Брюс Эккель - Философия Java3

private static long counter;

private final long id = counter++; public String toStringO { return "Waveform " + id. } } Hill- interfaces/filters/Filter java package interfaces filters,

public class Filter {

public String nameO {

return getClassO getSimpleName().

}

public Waveform process(Waveform input) { return input; } } III ~

// interfaces/filters/LowPass java package interfaces filters,

public class LowPass extends Filter { double cutoff;

public LowPass(double cutoff) { this.cutoff = cutoff; } public Waveform process(Waveform input) {

return input; II Фиктивная обработка

}

} Hill ■ i nterfaces/fi 1ters/Hi ghPass.java package interfaces.filters;

public class HighPass extends Filter { double cutoff;

public HighPass(double cutoff) { this.cutoff = cutoff; } public Waveform process(Waveform input) { return input. } } ///.-

// interfaces/filters/BandPass java package interfaces filters;

public class BandPass extends Filter { double lowCutoff. highCutoff; public BandPass(double lowCut. double highCut) { lowCutoff = lowCut; highCutoff = highCut;

}

public Waveform process(Waveform input) { return input; } } III-

Класс Filter содержит те же интерфейсные элементы, что и Processor, но, поскольку он не является производным от Processor (создатель класса Filter и не подозревал, что вы захотите использовать его как Processor), он не может использоваться с методом Apply.process(), хотя это выглядело бы вполне естественно. Логическая привязка между Apply.process() и Processor оказывается более сильной, чем реально необходимо, и это обстоятельство препятствует повторному использованию кода Apply.process(). Также обратите внимание, что входные и выходные данные относятся к типу Waveform.

Но, если преобразовать класс Processor в интерфейс, ограничения ослабляются и появляется возможность повторного использования Apply.process(). Обновленные версии Processor и Apply выглядят так:

//: interfaces/interfaceprocessor/Processor.java package interfaces interfaceprocessor;

public interface Processor { String nameO;

Object process(Object input), } ///-

//. interfaces/interfaceprocessor/Apply.java package i nterfaces.i nterfaceprocessor, import static net mindview.util.Print.*:

public class Apply {

public static void process(Processor p. Object s) { print ("Using Processor " + p.nameO): print(p.process(s)):

}

} ///:-

В первом варианте повторного использования кода клиентские программисты пишут свои классы с поддержкой интерфейса:

//: interfaces/interfaceprocessor/StringProcessor.java package i nterfaces.i nterfaceprocessor; import java.util.*;

public abstract class StringProcessor implements Processor! public String nameO {

return getClassO getSimpleNameO;

}

public abstract String process(Object input); public static String s =

"If she weighs the same as a duck, she's made of wood"; public static void main(String[] args) { Apply, process (new UpcaseO, s); Apply, process (new DowncaseO, s); Apply, process (new SplitterO. s);

class Upcase extends StringProcessor {

public String process(Object input) { II Ковариантный возвращаемый тип return ((String)input) .toUpperCaseO;

class Downcase extends StringProcessor { public String process(Object input) {

return ((String)input).toLowerCase();

class Splitter extends StringProcessor {

public String process(Object input) {

return Arrays.toString(((String)input).split(" ")).

}

} /* Output

Используем Processor Upcase

IF SHE WEIGHS THE SAME AS A DUCK, SHE'S MADE OF WOOD Используем Processor Downcase if she weighs the same as a duck, she's made of wood Используем Processor Splitter

[If. she. weighs, the. same. as. a. duck., she's, made. of. wood] *///:-

Впрочем, довольно часто модификация тех классов, которые вы собираетесь использовать, невозможна. Например, в примере с электронными фильтрами библиотека была получена из внешнего источника. В таких ситуациях применяется паттерн «адаптер»: вы пишете код, который получает имеющийся интерфейс, и создаете тот интерфейс, который вам нужен:

//: interfaces/interfaceprocessor/FilterProcessor java package interfaces interfaceprocessor, import interfaces.filters.*;

class FilterAdapter implements Processor { Filter filter.

public FilterAdapter(Filter filter) { this.filter = filter.

}

public String nameO { return filter.nameO; } public Waveform process(Object input) {

return filter.process((Waveform)input).

}

}

public class FilterProcessor {

public static void main(String[] args) { Waveform w = new Waveform(); -

Apply process(new FilterAdapter(new LowPass(l.O)), w); Apply.process(new FilterAdapter(new HighPass(2.0)). w); Apply.process(

new FilterAdapter(new BandPass(3.0. 4 0)). w);

}

} /* Output.

Используем Processor LowPass Waveform 0

Используем Processor HighPass Waveform 0

Используем Processor BandPass

Waveform 0 *///.-

Конструктор FilterAdapter получает исходный интерфейс (Filter) и создает объект с требуемым интерфейсом Processor. Также обратите внимание на применение делегирования в классе FilterAdapter.

Отделение интерфейса от реализации позволяет применять интерфейс к разным реализациям, а следовательно, расширяет возможности повторного использования кода.

«Множественное наследование» в Java

Так как интерфейс по определению не имеет реализации (то есть не обладает памятью для хранения данных), нет ничего, что могло бы помешать совмещению нескольких интерфейсов. Это очень полезная возможность, так как в некоторых ситуациях требуется выразить утверждение: «Икс является и А, и Б, и В одновременно». В С++ подобное совмещение интерфейсов нескольких классов называется множественным наследованием , и оно имеет ряд очень неприятных аспектов, поскольку каждый класс может иметь свою реализацию. В Java можно добиться аналогичного эффекта, но, поскольку реализацией обладает всего один класс, проблемы, возникающие при совмещении нескольких интерфейсов в С++, в Java принципиально невозможны:

При наследовании базовый класс вовсе не обязан быть абстрактным или «реальным» (без абстрактных методов). Если наследование действительно осуществляется не от интерфейса, то среди прямых «предков» класс может быть только один — все остальные должны быть интерфейсами. Имена интерфейсов перечисляются вслед за ключевым словом implements и разделяются запятыми. Интерфейсов может быть сколько угодно, причем к ним можно проводить восходящее преобразование. Следующий пример показывает, как создать новый класс на основе реального класса и нескольких интерфейсов:

//: interfaces/Adventure java

// Использование нескольких интерфейсов.

interface CanFight { void fightO,

}

interface CanSwim { void swimO,

}

interface CanFly { void fly().

}

class ActionCharacter {

public void fightO {}

}

class Hero extends ActionCharacter

implements CanFight, CanSwim, CanFly { public void swimO {}

public void fly() {}

}

public class Adventure {

public static void t(CanFight x) { x fightO; } public static void u(CanSwim x) { x swimO, } public static void v(CanFly x) { x fly(); } public static void w(ActionCharacter x) { x.fightO. } public static void main(String[] args) { Hero h = new HeroO;

t(h), // Используем объект в качестве типа CanFight u(h). // Используем объект в качестве типа CanSwim v(h). // Используем объект в качестве типа CanFly w(h), // Используем объект в качестве ActionCharacter

}

} ///-

Мы видим, что класс Него сочетает реальный класс ActionCharacter с интерфейсами CanFight, CanSwim и CanFly. При объединении реального класса с интерфейсами на первом месте должен стоять реальный класс, а за ним следуют интерфейсы (иначе компилятор выдаст ошибку).

Заметьте, что объявление метода fight() в интерфейсе CanFight совпадает с тем, что имеется в классе ActionCharacter, и поэтому в классе Него нет определения метода fight(). Интерфейсы можно расширять, но при этом получается другой интерфейс. Необходимым условием для создания объектов нового типа является наличие всех определений. Хотя класс Него не имеет явного определения метода fight(), это определение существует в классе ActionCharacter, что и делает возможным создание объектов класса Него.

Класс Adventure содержит четыре метода, которые принимают в качестве аргументов разнообразные интерфейсы и реальный класс. Созданный объект Него передается всем этим методам, а это значит, что выполняется восходящее преобразование объекта к каждому интерфейсу по очереди. Система интерфейсов Java спроектирована так, что она нормально работает без особых усилий со стороны программиста.