Введение в java fx
Содержание:
- Введение
- Интерфейсы в механизме обратного вызова
- Упражнение 3: Добавление функциональности
- 7.2 Отделение «описания методов» от их реализации.
- Пример использования
- Tagging Interfaces
- Класс LinkedList
- Что такое функциональный интерфейс
- Declaring Interfaces
- 4.4 Mutable vs Immutable объекты
- Статические методы (static методы)
- What Are Interfaces in Java?
- Как наследуются default-методы
Введение
В предыдущих статьях я уже несколько раз упоминал наследование. Настало время написать подробную статью про эту вещь.
В Java класс может наследоваться от другого класса, получая его методы и поля, который в свою очередь может наследоваться от ещё одного класса и т. д. В Java нет множественного наследования классов. Один класс может наследоваться напрямую только от одного другого класса.
Класс, который наследуется от другого класса, называется подклассом (subclass), дочерним классом (child class), потомком или расширенным классом (extended class).
Класс, от которого наследуется дочерний класс, называется родительским классом (parent class), предком, суперклассом (superclass) или базовым классом (base class).
В самой вершине иерархии наследования находится класс
Object , от которого наследуются все классы, для которых не указан явно суперкласс. Таким образом все классы (кроме самого
Object ) напрямую или через какое-либо количество уровней наследования наследуются от класса
Object.
Идея наследования классов состоит в том, что когда вы хотите создать новый класс, например
Goblin , и уже существует какой-нибудь класс, который уже реализует часть функциональности, необходимой нашему классу, например
Monster , то вы можете указать этот класс в качестве родительского класса, унаследовав таким образом все его члены (поля, вложенные классы и методы экземпляров). Конструкторы не наследуются и не являются членами классов, но можно вызвать конструктор базового класса из конструктора дочернего класса.
Дочерний класс наследует все
public и
protected члены своего родителя независимо от пакета, в котором расположен родительский класс. Если дочерний и родительский класс находятся в одном пакете, то дочерний класс наследует также package-private члены своего родителя.
- Унаследованные поля можно использовать напрямую, как все другие поля.
- Можно объявить в дочернем классе поле с таким же именем, как и поле в родительском классе, тогда это поле скроет (hide) поле родительского класса (НЕ рекомендуется так делать).
- В дочернем классе можно объявлять поля, которых нет в родительском классе.
- Унаследованные методы можно использовать напрямую.
- Можно объявить метод экземпляров в дочернем классе с точно такой же сигнатурой, что и метод экземпляров в родительском классе, тогда этот метод переопределит (override) метод суперкласса.
- Можно объявить в дочернем классе статический метод с точно такой же сигнатурой, что и статический метод в родительском классе, тогда этот метод скроет (hide) метод родительского класса.
- В дочернем классе можно объявлять новые методы, которых нет в родительском классе.
- В дочернем классе можно объявить конструктор, который будет явно (с помощью ключевого слова
super ) или неявно вызывать конструктор базового класса.
Дочерний класс не наследует
private члены родительского класса, однако если в родительском классе есть
protected ,
public или package-private (для случая нахождения дочернего и родительского класса в одном пакете) методы для доступа к
private полям, то они могут использоваться дочерним классом.
Интерфейсы в механизме обратного вызова
Последнее обновление: 28.12.2015
Одним из распространенных способов использования интерфейсов в Java является создание обратного вызова. Суть обратного вызова состоит в том,
что мы создаем действия, которые вызываются при других действиях. То есть одни действия вызываются другими действиями. Стандартный пример — нажатие на кнопку.
Когда мы нажимаем на кнопку, мы производим действие, но в ответ на это нажатие запускаются другие действия. Например, нажатие на значок принтера
запускает печать документа на принтере и т.д.
Рассмотрим следующий пример:
public class EventsApp {
public static void main(String[] args) {
Button button = new Button(new ButtonClickHandler());
button.click();
button.click();
button.click();
}
}
class ButtonClickHandler implements EventHandler{
public void execute(){
System.out.println("Кнопка нажата!");
}
}
interface EventHandler{
void execute();
}
class Button{
EventHandler handler;
Button(EventHandler action){
this.handler=action;
}
public void click(){
handler.execute();
}
}
Итак, здесь у нас определен класс Button, который в конструкторе принимает объект интерфейса EventHandler и в методе click (имитация нажатия) вызывает
метод execute этого объекта.
Далее определяется реализация EventHandler в виде класса . И в основной программе объект этого класса передается в конструктор Button.
Таким образом, через конструктор мы устанавливаем обработчик нажатия кнопки. И при каждом вызове метода будет вызываться этот обработчик.
В итоге программа выведет на консоль следующий результат:
Кнопка нажата! Кнопка нажата! Кнопка нажата!
Но казалось бы, зачем нам выносить все действия в интерфейс, его реализовать, почему бы не написать проще сразу в классе Button:
class Button{
public void click(){
System.out.println("Кнопка нажата!");
}
}
Дело в том, что на момент определения класса нам не всегда бывают точно известны те действия, которые должны производиться. Особенно если класс Button
и класс основной программы находятся в разных пакетах, библиотеках и могут проектироваться разными разработчиками. К тому же у нас может быть несколько
кнопок — объектов Button и для каждого объекта надо определить свое действие. Например, изменим главный класс программы:
public class EventsApp {
public static void main(String[] args) {
Button tvButton = new Button(new EventHandler(){
private boolean on = false;
public void execute(){
if(on) {
System.out.println("Телевизор выключен..");
on=false;
}
else {
System.out.println("Телевизор включен!");
on=true;
}
}
});
Button printButton = new Button(new EventHandler(){
public void execute(){
System.out.println("Запущена печать на принтере...");
}
});
tvButton.click();
printButton.click();
tvButton.click();
}
}
Здесь у нас две кнопки — одна для включения-выключения телевизора, а другая для печати на принтере. Вместо того, чтобы создавать отдельные
классы, реализующие интерфейс EventHandler, здесь обработчики задаются в виде анонимных объектов, которые реализуют интерфейс EventHandler. Причем обработчик
кнопки телевизора хранит дополнительное состояние в виде логической переменной .
В итоге консоль выведет нам следующий результат:
Телевизор включен! Запущена печать на принтере... Телевизор выключен..
И в завершении надо сказать, что интерфейсы в данном качестве особенно широко используются в различных графических API — AWT, Swing, JavaFX,
где обработка событий объектов — элементов графического интерфейса особенно актуальна.
НазадВперед
Упражнение 3: Добавление функциональности
В этом упражнении будет добавлена необходимая функциональность к кнопкам «Add», «Clear» и «Exit». Поля и будут использоваться для ввода значений пользователем, а – для вывода результата работы программы. Создаваемая программа представляет собой простейший калькулятор. Итак, приступим!
Добавление функциональности к кнопке «Exit»
Для того чтобы кнопки стали функциональными, каждой из них необходимо присвоить обработчик событий, который будет отвечать за реагирование на события. В нашем случае требуется идентифицировать событие нажатия кнопки – путем щелчка мышью или с помощью клавиатуры. Поэтому будет использоваться интерфейс «ActionListener», предназначенный для обработки событий «ActionEvent».
- Щелкните правой кнопкой мыши кнопку «Exit». Во всплывающем меню выберите Events («События») > Action («Действие») > actionPerformed. Учтите, что меню содержит множество других событий, на которые может реагировать программа! При выборе события actionPerformed среда IDE автоматически добавит прослушиватель ActionListener к кнопке Exit («Выход») и создаст метод обработчика для обработки метода прослушивателя actionPerformed.
- В среде IDE автоматически открывается окно «Source Code», где отображается место вставки действия, которое должно выполняться кнопкой при ее нажатии (с помощью мыши или клавиатуры). Окно «Source Code» должно содержать следующие строки:
private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) { //TODO add your handling code here: } -
Теперь добавим код действия, которое должна выполнять кнопка «Exit». Замените строку TODO на . Готовый код кнопки «Exit» должен выглядеть следующим образом:
private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) { System.exit(0); }
Добавление функциональности к кнопке «Clear»
- Щелкните вкладку «Design» в верхней части рабочей области для возврата к экрану «Form Design».
- Щелкните правой кнопкой мыши кнопку «Clear» (). В появившемся меню выберите «Events > Action > actionPerformed».
- Нажатие кнопки «Clear» должно приводить к удалению всего текста из всех текстовых полей «jTextField». Для этого следует добавить код, аналогичный приведенному выше. Готовый исходный код должен выглядеть следующим образом:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt){ jTextField1.setText(""); jTextField2.setText(""); jTextField3.setText(""); }
Этот код удаляет текст из всех трех полей JTextField, оставляя их пустыми.
Добавление функциональности к кнопке «Add»
Кнопка «Add» должна выполнять три действия.
- Сначала она принимает данные, введенные пользователем в полях и , и преобразовывает их из типа «String» в тип «Float».
- Затем она выполнит сложение двух чисел.
- И, наконец, она преобразует сумму в тип String и поместит ее в .
Начнем!
- Щелкните вкладку «Design» в верхней части рабочей области для возврата к экрану «Form Design».
- Щелкните правой кнопкой мыши кнопку «Add» (). Во всплывающем меню выберите Events («События») > Action («Действие») > actionPerformed.
- Добавьте код действий, которые должна выполнять кнопка «Add». Готовый исходный код должен выглядеть следующим образом:
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt){ // First we define float variables. float num1, num2, result; // We have to parse the text to a type float. num1 = Float.parseFloat(jTextField1.getText()); num2 = Float.parseFloat(jTextField2.getText()); // Now we can perform the addition. result = num1+num2; // We will now pass the value of result to jTextField3. // At the same time, we are going to // change the value of result from a float to a string. jTextField3.setText(String.valueOf(result)); }
Теперь программа полностью готова, и можно приступить к ее сборке и выполнению.
7.2 Отделение «описания методов» от их реализации.
Раньше мы уже рассказывали, что если вы хотите разрешить вызывать методы своего класса из других классов, то их нужно пометить ключевым словом . Если же хотите, чтобы какие-то методы можно было вызывать только из этого же класса, их нужно помечать ключевым словом private. Другими словами, мы делим методы класса на две категории: «для всех» и «только для своих».
С помощью интерфейсов это деление можно усилить еще больше. Мы сделаем специальный «класс для всех», и второй «класс для своих», который унаследуем от первого. Вот как это примерно будет:
| Было | Стало |
|---|---|
Мы разбили наш класс на два: интерфейс и класс, унаследованный от интерфейса. И в чем тут преимущество?
Один и тот же интерфейс могут реализовывать (наследовать) различные классы. И у каждого может быть свое поведение. Так же, как и — это две различные реализации интерфейса .
Таким образом, мы скрываем не только различные реализации, но и сам класс, который ее содержит (везде в коде может фигурировать только интерфейс). Это позволяет очень гибко, прямо в процессе исполнения программы, подменять одни объекты на другие, меняя поведение объекта скрытно от всех классов, которые его используют.
Это очень мощная технология в сочетании с полиморфизмом. Сейчас далеко не очевидно, зачем так нужно делать. Вы сначала должны столкнуться с программами, состоящими из десятков или сотен классов, чтобы понять, что интерфейсы способны существенно упростить жизнь.
Пример использования
Допустим, у нас есть интерфейс Animal:
public interface Animal {
String move();
}
Есть классы Cat и Fish, реализующие интерфейс Animal:
public class Cat implements Animal {
@Override
public String move() {
return "run";
}
}
public class Fish implements Animal {
@Override
public String move() {
return "swim";
}
}
Мы хотим добавить в интерфейс Animal метод sleep(), при этом не реализовывать его в каждом классе, а реализовать непосредственно в интерфейсе. Классы же будут наследовать этот метод по умолчанию. Для этого наш метод надо обозначить как default:
public interface Animal {
String move();
default String sleep() {
return ("sleep");
}
}
Теперь этот метод унаследуют все животные:
@Test
public void whenCatSleep_thenOk() {
assertEquals("sleep", cat.sleep());
}
Впрочем, его можно и переопределить в каком-либо из классов, например в Fish:
public class Fish implements Animal {
@Override
public String move() {
return "swim";
}
@Override
public String sleep() {
return "fish sleeps";
}
}
Убедимся, что рыба спит по-своему:
@Test
public void whenFishSleep_thenOnItsOwn() {
assertEquals("fish sleeps", fish.sleep());
}
Tagging Interfaces
The most common use of extending interfaces occurs when the parent interface does not contain any methods. For example, the MouseListener interface in the java.awt.event package extended java.util.EventListener, which is defined as −
Example
package java.util;
public interface EventListener
{}
An interface with no methods in it is referred to as a tagging interface. There are two basic design purposes of tagging interfaces −
Creates a common parent − As with the EventListener interface, which is extended by dozens of other interfaces in the Java API, you can use a tagging interface to create a common parent among a group of interfaces. For example, when an interface extends EventListener, the JVM knows that this particular interface is going to be used in an event delegation scenario.
Adds a data type to a class − This situation is where the term, tagging comes from. A class that implements a tagging interface does not need to define any methods (since the interface does not have any), but the class becomes an interface type through polymorphism.
Previous Page
Print Page
Next Page
Класс LinkedList
Класс LinkedList реализует интерфейсы List, Deque. LinkedList – это двухсвязный список.
Конструкторы класса LinkedList:
- LinkedList()
- LinkedList(Collection<? extends Е> с)
Внутри класса LinkedList существует static inner класс Entry, с помощью которого создаются новые элементы:
Из LinkedList можно организовать стэк, очередь, или двойную очередь, со временем доступа O(1). На вставку и удаление из середины списка, получение элемента по индексу или значению потребуется линейное время O(n). Однако, на добавление и удаление из середины списка, используя ListIterator.add() и ListIterator.remove(), потребуется O(1). Позволяет добавлять любые значения в том числе и null.
Что такое функциональный интерфейс
Чтобы иметь возможность использовать лямбда выражения, необходим интерфейс:
Лямбда выражения не содержат информацию о том, какой функциональный интерфейс они реализуют.
Тип выражения выводится из контекста, в котором используется лямбда выражение. Этот тип называется целевой тип (target type).
Если лямбда выражение присваивается какому-то интерфейсу, лямбда выражение должно соответствовать синтаксису метода интерфейса.
Одно и то же лямбда выражение может использоваться с разными интерфейсами, если они имеют абстрактные методы, которые совместимы. Например:
Функциональный интерфейс (functional interface) – это интерфейс у которого только один абстрактный метод. Функциональный интерфейс может содержать любое количество методов по умолчанию (default) или статических методов. Например:
Еще один пример функционального интерфейса:
Функциональный интерфейс может содержать методы класса :
В Java 8 была введена аннотация , которая генерирует ошибку компиляции, если интерфейс не является функциональным:
Примеры функциональных интерфейсов: ,
Declaring Interfaces
The interface keyword is used to declare an interface. Here is a simple example to declare an interface −
Following is an example of an interface −
/* File name : NameOfInterface.java */
import java.lang.*;
// Any number of import statements
public interface NameOfInterface {
// Any number of final, static fields
// Any number of abstract method declarations\
}
Interfaces have the following properties −
-
An interface is implicitly abstract. You do not need to use the abstract keyword while declaring an interface.
-
Each method in an interface is also implicitly abstract, so the abstract keyword is not needed.
-
Methods in an interface are implicitly public.
4.4 Mutable vs Immutable объекты
Когда-то давно мы с вами изучали константы в Java и пришли к не очень утешительному выводу. Константы позволяют защитить переменные от изменений, но не в состоянии защитить от изменений объекты, на которые эти переменные ссылаются.
В ответ на эту проблему в Java придумали объекты-константы. Или, как их еще называют, immutable-объекты — неизменяемые объекты.
Кстати, вы даже знаете один такой класс, чьи объекты нельзя менять — . Объект класса остается неизменным все время после создания. И как же разработчики Java добились этого?
Во-первых, все переменные класса скрыты – объявлены .
Во-вторых, наследоваться от класса нельзя: он имеет модификатор в объявлении класса.
В-третьих, что самое интересное, все методы класса , которые по идее должны были менять существующий объект, не меняют его, а возвращают новый.
Например, метод делает все буквы строки большими (заглавными). Но вместо изменения объекта, у которого он вызван, этот метод возвращает новый объект типа , состоящий из заглавных букв:
Вот что будет в памяти после выполнения этого кода:
Так что смело передавайте ваши строки в любые методы: никто их не поменяет.
Статические методы (static методы)
Интерфейс может содержать статические методы, как и класс. Статические методы относятся к самому типу и вызываются через него.
Пример:
Monstr.java
Java
public interface Monstr {
boolean isSensitiveToSilver();
void logic(VisibleWorld visibleWorld);
static void logicForSensitiveToSilver(Monstr[] monstrs,
VisibleWorld visibleWorld) {
for (Monstr monstr : monstrs) {
if (monstr.isSensitiveToSilver()) {
monstr.logic(visibleWorld);
}
}
}
}
|
1 |
publicinterfaceMonstr{ booleanisSensitiveToSilver(); voidlogic(VisibleWorld visibleWorld); staticvoidlogicForSensitiveToSilver(Monstrmonstrs, VisibleWorld visibleWorld){ for(Monstr monstrmonstrs){ if(monstr.isSensitiveToSilver()){ monstr.logic(visibleWorld); } } } } |
Цикл статей «Учебник Java 8».
Следующая статья — «Java 8 наследование».
Предыдущая статья — «Java 8 вложенные классы и лямбда-выражения».
What Are Interfaces in Java?
In Java, an interface is an abstract type that contains a collection of methods and constant variables. It is one of the core concepts in Java and is used to achieve abstraction, polymorphism and multiple inheritances.
Let’s see a simple example of an interface in Java:
We can implement an interface in a Java class by using the implements keyword.
Next, let’s also create a Computer class that implements the Electronic interface we just created:
2.1. Rules for Creating Interfaces
In an interface, we’re allowed to use:
- constants variables
- abstract methods
- static methods
- default methods
We also should remember that:
- we can’t instantiate interfaces directly
- an interface can be empty, with no methods or variables in it
- we can’t use the final word in the interface definition, as it will result in a compiler error
- all interface declarations should have the public or default access modifier; the abstract modifier will be added automatically by the compiler
- an interface method can’t be private, protected, or final
- interface variables are public, static, and final by definition; we’re not allowed to change their visibility
Как наследуются default-методы
Возникает вопрос, какой метод унаследует класс, реализующий два интерфейса, если оба из них содержат default-методы с одинаковыми именами.
Например, есть второй интерфейс Man, который тоже содержит свой default метод sleep():
public interface Man {
default String sleep() {
return ("man sleeps");
}
}
И есть класс Kentavr, реализующий как интерфейс Man, так и Animal. Какой же метод sleep() унаследует Kentavr?
Чтобы не было неопределенности (и чтобы скомпилировался код), мы обязаны переопределить в Kentavr метод sleep(), причем можно просто вызвать в нем метод sleep() любого из интерфейсов – Man либо Animal, указав через точку и super, чей именно метод нужен:
public class Kentavr implements Man, Animal{
@Override
public String move() {
return "kentavr moves";
}
@Override
public String sleep() {
return Man.super.sleep();
}
}
Убедимся, что кентавр спит по-человечески:
@Test
public void whenKentavrSleep_thenSpecifyWhose() {
assertEquals("man sleeps", kentavr.sleep());
}
