45

45


Чтобы понять все сказанное до конца, рассмотрим ситуацию, где два интер­фейса тем или иным способом должны быть реализованы в классе. Вследствие гибкости интерфейсов возможен один из двух способов решения: отдельный одиночный класс или внутренний класс:
//: innerclasses/MultiInterfaces.java
// Два способа реализации нескольких интерфейсов.
interface А {}
interface В {}
class X implements А, В {}
class Y implements A { В makeBO {
// Безымянный внутренний класс: return new ВО {};
}
}
public class MultiInterfaces { static void takesA(A a) {} static void takesB(B b) {} public static void main(String[] args) { X x = new X(); Y у = new Y(); takesA(x);

takesA(y), takesB(x), takesB(y makeBO).
}
Конечно, выбор того или иного способа организации кода зависит от кон­кретной ситуации. Впрочем, сама решаемая вами задача должна подсказать, что для нее предпочтительно: один отдельный класс или внутренний класс. Но при отсутствии других ограничений оба подхода, использованные в рассмотренном примере, ничем не отличаются с точки зрения реализации. Оба они работают.
Но если вместо интерфейсов имеются реальные или абстрактные классы и новый класс должен как-то реализовать функциональность двух других, при­дется прибегнуть к внутренним классам:
//: innerclasses/MultiImplementation.java // При использовании реальных или абстрактных классов // "множественное наследование реализации" возможно // только с применением внутренних классов package innerclasses;
class D {} abstract class E {}
class Z extends D {
E makeEO { return new E() {}, }
}
public class MultiImplementation { static void takesD(D d) {} • static void takesE(E e) {} public static void main(String[] args) { Z z = new Z(); takesD(z); takesE(z.makeEO);
}
} ///:-
Если нет необходимости решать задачу «множественного наследования реа­лизации», скорее всего, вы без особого труда напишите программу, не прибегая к особенностям внутренних классов. Однако внутренние классы открывают пе­ред вами ряд дополнительных возможностей:
•       У внутреннего класса может существовать произвольное количество эк­земпляров, каждый из которых обладает собственной информацией со­стояния, не зависящей от состояния объекта внешнего класса.
•       Один внешний класс может содержать несколько внутренних классов, по-разному реализующих один и тот же интерфейс или наследующих от единого базового класса. Вскоре мы рассмотрим пример такой конст­рукции.
•       Место создания объекта внутреннего класса не привязано к месту и вре­мени создания объекта внешнего класса.
• Внутренний класс не использует тип отношений классов «является тем-то», способных вызвать недоразумения; он представляет собой от­дельную сущность.
Например, если бы в программе Sequence.java отсутствовали внутренние классы, пришлось бы заявить, что «класс Sequence есть класс Selector», и при этом ограничиться только одним объектом Selector для конкретного объекта Sequence. А вы можете с легкостью определить второй метод, reverseSelector(), создающий объект Selector для перебора элементов Sequence в обратном порядке. Такую гибкость обеспечивают только внутренние классы.
Замыкания и обратные вызовыЗамыканием(closure) называется вызываемый объект, который сохраняет ин­формацию о контексте, он был создан. Из этого определения видно, что внут­ренний класс является объектно-ориентированным замыканием, поскольку он не только содержит информацию об объекте внешнего класса («место созда­ния»), но к тому же располагает ссылкой на весь объект внешнего класса, с по­мощью которой он может манипулировать всеми членами этого объекта, в том числе и закрытыми (private).
При обсуждении того, стоит ли включать в Java некое подобие указателей, самым веским аргументом «за» была возможностьобратных вызовов(callback). В механизме обратного вызова некоторому стороннему объекту передается ин­формация, позволяющая ему затем обратиться с вызовом к объекту, который произвел изначальный вызов. Это очень мощная концепция программирова­ния, к которой мы еще вернемся. С другой стороны, при реализации обратного вызова на основе указателей вся ответственность за его правильное использо­вание возлагается на программиста. Как было показано ранее, язык Java ориен­тирован на безопасное программирование, поэтому указатели в него включены не были.
Замыкание, предоставляемое внутренним классом, — хорошее решение, го­раздо более гибкое и безопасное, чем указатель. Рассмотрим пример:
//: innerclasses/CalIbacks.java
// Использование внутренних классов
// для реализации обратных вызовов
package innerclasses;
import static net.mindview.util.Print.*;
interface Incrementable { void incrementO,
}
// Простая реализация интерфейса: class Call eel implements Incrementable { private int i = 0. public void incrementO { i++;
print(i);

class Mylncrement {
public void increment О { System, out. pri ntlnC'flpy гая операция") }; public static void f(MyIncrement mi) { mi.incrementО; }
}
// Если класс должен вызывать метод increment О // по-другому, необходимо использовать внутренний класс: class Callee2 extends Mylncrement { private int i = 0, private void increment О { super.increment(): i++;
print(i):
}
private class Closure implements Incrementable { public void increment О {
// Указывается метод внешнего класса;
// в противном случае возникает бесконечная рекурсия.
Са11ее2.this.increment();
}
}
Incrementable getCallbackReferenceO { return new ClosureO;



class Caller {
private Incrementable callbackReference;
Caller(Incrementable cbh) { callbackReference = cbh, }
void go() { callbackReference incrementO; }
}
public class Callbacks {
public static void main(String[] args) { Call eel cl = new CalleelO; Callee2 c2 = new Callee2(); Mylncrement.f(c2), Caller callerl = new Caller(cl); Caller caller2 = new Caller(c2.getCallbackReferenceO); callerl. goO; callerl.goO; caller2.go(); caller2.go();
}
} /* Output: Другая операция 1 1 2
Другая операция 2
Другая операция 3
*///:-

Этот пример также демонстрирует различия между реализацией интерфейса внешним или внутренним классом. Класс Calleel — наиболее очевидное реше­ние задачи с точки зрения программирования. Класс Callee2 наследует от класса Mylncrement, в котором уже есть метод increment(), выполняющий действие, ни­как не связанное с тем, что ожидает от него интерфейс Incrementable. Когда класс Mylncrement наследуется в Callee2, метод increment() нельзя переопреде­лить для использования в качестве метода интерфейса Incrementable, поэтому нам приходится предоставлять отдельную реализацию во внутреннем классе. Также отметьте, что создание внутреннего класса не затрагивает и не изменяет существующий интерфейс внешнего класса.
Все элементы, за исключением метода getCallbackReference(), в классе Callee2 являются закрытыми. Длялюбойсвязи с окружающим миром необходим ин­терфейс Incrementable. Здесь мы видим, как интерфейсы позволяют полностью отделить интерфейс от реализации.
Внутренний класс Closure просто реализует интерфейс Incrementable, предос­тавляя при этом связь с объектом Callee2 — но связь эта безопасна. Кто бы ни получил ссылку на Incrementable, он в состоянии вызвать только метод incre­mentO, и других возможностей у него нет (в отличие от указателя, с которым программист может вытворять все, что угодно).
Класс Caller получает ссылку на Incrementable в своем конструкторе (хотя пе­редача ссылки для обратного вызова может происходить в любое время), а по­сле этого использует ссылку для «обратного вызова» объекта Callee.
Главным достоинством обратного вызова является его гибкость — вы може­те динамически выбирать функции, выполняемые во время работы программы.
Внутренние классы и система управления
В качестве более реального пример использования внутренних классов мы рас­смотрим то, что я буду называть здесьсистемой управления(control frame­work).Каркас приложения(application framework) — это класс или набор классов, разработанных для решения определенного круга задач. При работе с каркаса­ми приложений обычно используется наследование от одного или нескольких классов, с переопределением некоторых методов. Код переопределенных мето­дов адаптирует типовое решение, предоставляемое каркасом приложения, к ва­шим конкретным потребностям. Система управления представляет собой опре­деленный тип каркаса приложения, основным движущим механизмом которого является обработка событий. Такие системы называютсясистемами, управляе­мыми по событиям(event-driven system). Одной из самых типичных задач в при­кладном программировании является создание графического интерфейса поль­зователя (GUI), всецело и полностью ориентированного на обработку событий.
Чтобы на наглядном примере увидеть, как с применением внутренних клас­сов достигается простота создания и использования библиотек, мы рассмотрим систему, ориентированную на обработку событий по их «готовности». Хотя в практическом смысле под «готовностью» может пониматься все, что угодно, в нашем случае она будет определяться по показаниям счетчика времени. Далее приводится общее описание управляющей системы, никак не зависящей от того, чем именно она управляет. Нужная информация предоставляется по­средством наследования, при реализации метода action().
Начнем с определения интерфейса, описывающего любое событие системы. Вместо интерфейса здесь используется абстрактный класс, поскольку по умол­чанию управление координируется по времени, а следовательно, присутствует частичная реализация:
//: innerclasses/control 1er/Event.java
// Общие для всякого управляющего события методы.
package innerclasses/controller;
public abstract class Event {
private long eventTime;
protected final long delayTime;
public Event(long delayTime) {
this.delayTime = delayTime; startO;
}
public void startO { // Позволяет перезапуск eventTime = System nanoTimeO + delayTime;
}
public boolean readyО {
return System.nanoTimeO >= eventTime;
}
public abstract void actionO; } ///:-
Конструктор просто запоминает время (от момента создания объекта), через которое должно выполняться событие Event, и после этого вызывает метод start(), который прибавляет к текущему времени интервал задержки, чтобы вы­числить время возникновения события. Метод start() отделен от конструктора, благодаря чему становится возможным «перезапуск» события после того, как его время уже истекло; таким образом, объект Event можно использовать много­кратно. Скажем, если вам понадобится повторяющееся событие, достаточно до­бавить вызов start() в метод action().
Метод ready() сообщает, что пора действовать — вызывать метод action(). Ко­нечно, метод ready() может быть переопределен любым производным классом, если событие Event активизируется не по времени, а по иному условию.
Следующий файл описывает саму систему управления, которая распоряжа­ется событиями и инициирует их. Объекты Event содержатся в контейнере List<Event>. На данный момент достаточно знать, что метод add() присоединяет объект Event к концу контейнера с типом List, метод size() возвращает количест­во элементов в контейнере, синтаксис foreach() осуществляет последовательную выборку элементов List, а метод remove() удаляет заданный элемент из контей­нера:

Report Page