39
При описании методов в интерфейсе вы можете явно объявить их открытыми (public), хотя они являются таковыми даже без спецификатора. Однако при реализации интерфейса его методыдолжныбыть объявлены как public. В противном случае будет использоваться доступ в пределах пакета, а это приведет к уменьшению уровня доступа во время наследования, что запрещается компилятором Java.
Все сказанное можно увидеть в следующем примере с объектами Instrument. Заметьте, что каждый метод интерфейса ограничивается простым объявлением; ничего большего компилятор не" разрешит. Вдобавок ни один из методов интерфейса Instrument не объявлен со спецификатором public, но все методы автоматически являются открытыми:
// interfaces/music5/Music5.java
// Интерфейсы.
package interfaces.music5;
import polymorphism.music.Note;
import static net.mindview.util.Print.*;
interface Instrument {
// Константа времени компиляции:
int VALUE = 5; // является и static, и final
// Определения методов недопустимы:
void play(Note n); // Автоматически объявлен как public
void adjustO;
}
class Wind implements Instrument { public void play(Note n) {
print(this + ".playO " + n);
}
public String toStringO { return "Wind"; } public void adjustO { print(this + ".adjustO"); }
}
class Percussion implements Instrument { public void play(Note n) {
print(this + ".playO " + n),
}
public String toStringO { return "Percussion"; } public void adjustO { print(this + " adjustO"); }
}
class Stringed implements Instrument { public void play(Note n) {
print(this + ".playO " + n);
}
public String toStringO { return "Stringed"; } public void adjustO { print(this + ".adjustO"); }
}
class Brass extends Wind {
public String toStringO { return "Brass"; }
}
class Woodwind extends Wind {
public String toStringO { return "Woodwind"; }
}
public class Music5 {
// Работа метода не зависит от фактического типа объекта. // поэтому типы, добавленные в систему, будут работать правильно: static void tune(Instrument i) { // .
i.play(Note.MIDDLE_C);
}
static void tuneAll(Instruments e) { for(Instrument i : e) tune(i);
}
public static void main(String[] args) {
// Восходящее преобразование при добавлении в массив. Instrument!!] orchestra = { new WindO. new PercussionO. new StringedO, new BrassO. new WoodwindО
}.
tuneAll(orchestra),
}
} /* Output: Wind.pi ayО MIDDLE_C Percussion.playO MIDDLE_C Stringed.pi ayО MIDDLE_C Brass.pi ayО MIDDLE_C Woodwind pi ayО MIDDLE_C */// ~
В этой версии присутствует еще одно изменение: метод what() был заменен на toString(). Так как метод toString() входит в корневой класс Object, его присутствие в интерфейсе не обязательно.
Остальной код работает так же, как прежде. Неважно, проводите ли вы преобразование к «обычному» классу с именем Instrument, к абстрактному классу с именем Instrument или к интерфейсу с именем Instrument — действие будет одинаковым. В методе tune() ничто не указывает на то, является класс Instrument «обычным» или абстрактным, или это вообще не класс, а интерфейс.
Отделение интерфейса от реализации
В любой ситуации, когда метод работает с классом вместо интерфейса, вы ограничены использованием этого класса или его субклассов. Если метод должен быть применен к классу, не входящему в эту иерархию, — значит, вам не повезло. Интерфейсы в значительной мере ослабляют это ограничение. В результате код становится более универсальным, пригодным для повторного использования.
Представьте, что у нас имеется класс Processor с методами name() и process(). Последний получает входные данные, изменяет их и выдает результат. Базовый класс расширяется для создания разных специализированных типов Processor. В следующем примере производные типы изменяют объекты String (обратите внимание: ковариантными могут быть возвращаемые значения, но не типы аргументов):
//• interfaces/classprocessor/Apply.java package interfaces classprocessor; import java.util.*;
import static net.mindview.util.Print.*;
class Processor {
public String nameО {
return getClass().getSimpleName();
}
Object process(Object input) { return input; }
class Upcase extends Processor {
String process(Object input) { // Ковариантный возвращаемый тип return ((String)input) toUpperCase(),
class Downcase extends Processor { String process(Object input) {
return ((String)input) toLowerCase(),
class Splitter extends Processor { String process(Object input) {
// Аргумент splitO используется для разбиения строки return Arrays toString(((String)input) splitC ")),
public class Apply {
public static void process(Processor p. Object s) { print ("Используем Processor " + p nameO), print(p.process(s));
}
public static String s =
"Disagreement with beliefs is by definition incorrect"; public static void main(String[] args) { process(new UpcaseO, s); process(new Downcase(), s); process(new SplitterO, s),
}
} /* Output:
Используем Processor Upcase
DISAGREEMENT WITH BELIEFS IS BY DEFINITION INCORRECT Используем Processor Downcase disagreement with beliefs is by definition incorrect Используем Processor Splitter
[Disagreement, with, beliefs, is, by, definition, incorrect] *///-
Метод Apply.process() получает любую разновидность Processor, применяет ее к Object, а затем выводит результат. Метод split() является частью класса String. Он получает объект String, разбивает его на несколько фрагментов по ограничителям, определяемым переданным аргументом, и возвращает String[]. Здесь он используется как более компактный способ создания массива String.
Теперь предположим, что вы обнаружили некое семейство электронных фильтров, которые тоже было бы уместно использовать с методом Apply. process():
// interfaces/filters/Waveform java package interfaces.filters.
public class Waveform {
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.
Отделение интерфейса от реализации позволяет применять интерфейс к разным реализациям, а следовательно, расширяет возможности повторного использования кода.