Интерфейсы interface
В статье рассматривается одно из свойств Java, как языка объектно-ориентированного программирования, вопрос использования интерфейса. Статья в большей степени ориентирована на философию Java, чем на практические рекомендации по программированию.
Первый вопрос, возникающий при знакомстве с Java, — Зачем нужны интерфейсы? Нельзя ли обойтись абстрактными классами? Может быть для маскировки отсутствия множественного наследования?
Привычные варианты ответа: класс вводит новый тип, класс обобщает и т.д.
Декларация типа
В Java новый тип можно определить спецификацией интерфейса. Любой java интерфейс (interface) может иметь много реализаций. Любой класс может реализовывать несколько интерфейсов.
В качестве примера создадим интерфейс INumber — тип, описывающий функции использования числовых значений. Ограничимся только операциями сложения и умножения.
/** ————————————————————- * INumber.java Декларация типа INumber * ————————————————————- */ interface INumber
Реализация интерфейса, implements
Пример реализации интерфейса INumber при описании класса целочисленных значений :
class IntNumber implements INumber < int i; public IntNumber() <>public IntNumber(int v) < this.i = v; >public IntNumber(String v) < this.i = toInt(v); >public Integer toInt (String value) < int l = value.indexOf('.'); if (l >0) value = value.substring(0, l); return (new Integer(value)).intValue(); > @Override public void setValue(String s) < i = toInt (s); >@Override public INumber add(INumber n) < i += toInt (n.toString()); return this; >@Override public INumber mul(INumber n) < i *= toInt (n.toString()); return this; >@Override public String toString() < return Integer.toString(i); >> В классе IntNumber реализованы (переопределены) методы интерфейса с использованием аннотации Override.
Пример использования интерфейса INumber :
public class TestINumber < public void calculation(INumber n1, INumber n2, INumber n3) < INumber i2; i2 = n2; /* Если закомментировать предыдущую строку, то компилятор выдаст ошибку: * variable in2 might not have been initialized */ System.out.println("i2 = " + xx.toString()); System.out.println("n1 = " + n1.toString()); System.out.println("n2 = " + n2.toString()); System.out.println("n3 = " + n3.toString()); System.out.println("(n1 + n2) * n3 = " + n1.add(n2).mul(n3).toString()); n1.setValue("21"); System.out.println("(n2 + n1) * n3 = " + n2.add(n1).mul(n3).toString()); n2.setValue("37.6"); System.out.println("n1 * (n2 + n3) = " + n1.mul(n2.add(n3)).toString()); n1.setValue("21"); n2.setValue("37.6"); System.out.println("n3 * (n1 + n2) = " + n3.mul(n1.add(n2)).toString()); >public static void main(String args[]) < TestINumber tin = new TestINumber(); INumber in1 = new IntNumber("21"), in2 = new IntNumber("37.6"), in3 = new IntNumber(1); tin.calculation(in1, in2, in3); >> В результате выполнения примера «TestINumber» в консоль будет выведен следующий текст :
i2 = 37 n1 = 21 n2 = 37 n3 = 1 (n1 + n2) * n3 = 58 (n2 + n1) * n3 = 58 n1 * (n2 + n3) = 798 n3 * (n1 + n2) = 58
Из приведенного примера видно :
- Интерфейс позволяет объявить тип. В приведенном примере объявляются переменные и параметры типа INumber, описываются действия над ними. Компиляция выполняется без ошибок.
- Реализация типа передается через объект. Объекты n1, n2 и n3 передаются в метод calculation через параметры. Таким образом компилятор информируется, что объекты проинициализированы где-то за пределами данного модуля. Этого достаточно и классы пока не нужны.
Добавим вариант реализации интерфейса при создании класса вещественного числа :
/** ------------------------------------------------------------- * DblNumber.java Реализация типа INumber через double. * ------------------------------------------------------------- */ class DblNumber implements INumber < double d; public DblNumber(double ip) < d = ip; >public void setValue(String s) < d = (new Double(s)).doubleValue(); >public INumber add(INumber n) < d += (new Double(n.toString())).doubleValue(); return this; >public INumber mul(INumber n) < d *= (new Double(n.toString())).doubleValue(); return this; >public String toString() < return (new Double(d)).toString(); >>
Протестируем классы, реализующие интерфейс INumber :
/** ------------------------------------------------------------- * TestNumber.java Тестирование ингтерфейса INumber. * ------------------------------------------------------------- */ public class TestNumber < public static void main(String[] args) < INumber i1 = new IntNumber(22 ); INumber i2 = new DblNumber(11.2); INumber i3 = new DblNumber(3.4 ); new TestINumber().calculation(i1, i2, i3); >>
Результат выполнения тестовой программы:
i2 = 11.2 n1 = 22 n2 = 11.2 n3 = 3.4 (n1 + n2) * n3 = 99 (n2 + n1) * n3 = 109.48 n1 * (n2 + n3) = 861 n3 * (n1 + n2) = 197.2
Следует обратить внимание, что реализация передается через объект. Класс нужен для порождения объекта, несущего реализацию. Но не обязательно, как увидим позднее. Интересно отметить, что результат операции над INumber зависит от последовательности использования переменных. Эффект возникает потому, что в спецификации типа мы опустили важные для чисел свойства: точность и диапазон допустимых значений. В результате они неявно берутся из базового типа, использованного при реализации.
Реализация интерфейса
В предыдущем примере мы видели, что реализация передается через объект. Следовательно, в объекте упакована вся необходимая информация по реализации интерфейса. Если поведение определяется интерфейсом, а реализация упакована в объекте, то зачем нужен класс? — Классы нужны для наследования реализации и повторного использования кода. Если повторное использование объекта не требуется, то и описание в виде класса не нужно.
В следующем примере класс используется только для запуска приложения. Логика программы реализована на трех интерфейсах без использования классов!
/** ------------------------------------------------------------- * TestAnimal.java Образец бесклассовой реализации интерфейса * ------------------------------------------------------------- */ import java.util.ArrayList; interface Animal < void giveSignals(); void goHome(); String getTitle(); String getNick(); >interface Command < void exeCommand(Animal an); >interface Ranch < void add(Animal an); void visitAll(Command cmd); >public class TestAnimal < public static void main(String[] args) < Ranch myRanch = new Ranch() < private ArrayList ranchAnimals = new ArrayList(); public void add(Animal a) < ranchAnimals.add(a); >public void visitAll(Command cmd) < for(int i = 0; i < ranchAnimals.size(); i++) cmd.exeCommand((Animal)ranchAnimals.get(i)); >>; // end of new Ranch() // add animals myRanch.add(new Animal() // dog < public void giveSignals() < System.out.println("Гав-гав"); >public void goHome() < System.out.println("Бежит в будку"); >public String getTitle() < return new String("собака"); >public String getNick() < return new String("Блэк"); >>); // end of add new Animal dog myRanch.add(new Animal() // sheep < public void giveSignals() < System.out.println("Бе-е"); >public void goHome() < System.out.println("Идет в загон"); >public String getTitle() < return new String("овца"); >public String getNick() < return new String(""); >>); // end of add new Animal sheep myRanch.add(new Animal() // another sheep < public void giveSignals() < System.out.println("Бе-е"); >public void goHome() < System.out.println("Идет в загон"); >public String getTitle() < return new String("овца"); >public String getNick() < return new String(""); >>); // end of add new Animal another sheep // gives signals System.out.println("\n ------- Все подали голос -------\n"); myRanch.visitAll(new Command() < public void exeCommand(Animal a) < System.out.print(a.getTitle()+" "+a.getNick() + " говорит: "); a.giveSignals(); >>); // go to Home System.out.println("\n------- Все домой! -------\n"); myRanch.visitAll(new Command() < public void exeCommand(Animal a) < System.out.print(a.getTitle()+" "+a.getNick() + " идет домой: "); a.goHome(); >>); > > Использование класса Sheep позволило бы сократить текст программы. Никаких других преимуществ введение этого класса не дает. Для остальных объектов определение соответствующих классов не дает ничего. Результат выполнения программы :
------- Все подали голос ------- собака Блэк говорит: Гав-гав овца говорит: Бе-е овца говорит: Бе-е ------- Все домой! ------- собака Блэк идет домой: Бежит в будку овца идет домой: Идет в загон овца идет домой: Идет в загон
Анонимный класс
Можно сказать, что в приведенном выше примере использованы анонимные классы, и мы будем правы.
Но что такое анонимный класс? В спецификации Java сказано: декларация анонимного класса автоматически извлекается компилятором из выражения создания экземпляра класса. Анонимный класс является подклассом существующего класса или реализации интерфейса, и анонимный класс не имеет имени.
Обычно, для того, чтобы создать объект, необходимо сначала декларировать класс. С анонимным классом все наоборот — сначала описывается экземпляр, а потом под него подгоняется класс. Можно сказать, что анонимный класс нужен для того, чтобы узаконить существование созданного объекта. То есть, в данном случае класс — это техническое средство для упаковки реализации; небольшой, относительно автономный кусочек программы (данные + код).
Но если этот кусочек необходимо повторить, то тогда имеет смысл сделать его доступным из разных частей программы. Таким образом, класс нужен только для повторного использования. Кроме того, в большой программе выделение кода в классы улучшает ее читаемость.
Наследование интерфейса, полиморфизм
Наследование типа и полиморфизм обеспечиваются наследованием интерфейса. Пример :
/** ------------------------------------------------------------- * TestShips.java Наследование интерфейсов и полиморфизм * ------------------------------------------------------------- */ import java.util.ArrayList; interface Ship < void runTo(String s); >interface WarShip extends Ship < void bombard(); >interface Transport extends Ship < void loadTroops(int n); void landTroops(); >public class TestShips < public static void main(String[] args) < ArrayListships = new ArrayList(); for(int i = 0; i < 3; i++) ships.add(new Transport() < private int troopers; public void runTo(String s) < System.out.println("Транспорт направляется в "+s+"."); >public void loadTroops(int n) < troopers = n; >public void landTroops() < System.out.println((new Integer(troopers)).toString() + " отрядов десантировано."); >>); for(int i = 0; i < 2; i++) ships.add(new WarShip() < public void runTo(String s) < System.out.println("Корабль направляется в " + s + "."); >public void bombard() < System.out.println("Корабль бомбардирует цель."); >>); for(int i = 0; i < 3; i++) ((Transport)ships.get(i)).loadTroops(i+5); for(int i = 0; i < ships.size(); i++) ((Ship)ships.get(i)).runTo("Вражий Порт"); for(int i = 0; i < 3; i++) ((Transport)ships.get(i)).landTroops(); for(int i = 3; i < ships.size(); i++) ((WarShip)ships.get(i)).bombard(); >> Результат выполнения программы:
Транспорт направляется в Вражий Порт. Транспорт направляется в Вражий Порт. Транспорт направляется в Вражий Порт. Корабль направляется в Вражий Порт. Корабль направляется в Вражий Порт. 5 отрядов десантировано. 6 отрядов десантировано. 7 отрядов десантировано. Корабль бомбардирует цель. Корабль бомбардирует цель.
Таким образом, концепция интерфейсов добавляет полиморфизму второе измерение :
- Иерархический полиморфизм в стиле C++, основанный на приведении к базовому типу классов и/или интерфейсов (см. TestShips);
- Полиморфизм экземпляров, основанный на разных реализациях одного и того же интерфейса (см. INumber).
Наследование имеет два аспекта:
- «быть похожим на» — наследование типа, поведения;
- «быть устроенным как» — наследование реализации.
Наследование реализации не означает наследование типа! В практике это не встречается, потому что и в С++ и в Java невозможно наследование реализации без наследования интерфейса. В C++ интерфейс и класс неотделимы друг от друга. В Java интерфейс от класса отделить можно, но класс от интерфейса — нельзя.
В С++ и в Java совокупность общедоступных (public) методов неявно образует интерфейс данного класса. В силу этого наследование класса автоматически означает как наследование реализации, так и наследование интерфейса (типа). Очевидно, что наследование структуры данных и программного кода не определяет тип потомка. Например, абстрактные методы являются частью интерфейса и не являются частью реализации. Если бы можно было исключить их из наследования, то мы получили бы наследование реализации без сохранения типа.
Implementing an Interface
To declare a class that implements an interface, you include an implements clause in the class declaration. Your class can implement more than one interface, so the implements keyword is followed by a comma-separated list of the interfaces implemented by the class. By convention, the implements clause follows the extends clause, if there is one.
A Sample Interface, Relatable
Consider an interface that defines how to compare the size of objects.
public interface Relatable < // this (object calling isLargerThan) // and other must be instances of // the same class returns 1, 0, -1 // if this is greater than, // equal to, or less than other public int isLargerThan(Relatable other); >
If you want to be able to compare the size of similar objects, no matter what they are, the class that instantiates them should implement Relatable .
Any class can implement Relatable if there is some way to compare the relative «size» of objects instantiated from the class. For strings, it could be number of characters; for books, it could be number of pages; for students, it could be weight; and so forth. For planar geometric objects, area would be a good choice (see the RectanglePlus class that follows), while volume would work for three-dimensional geometric objects. All such classes can implement the isLargerThan() method.
If you know that a class implements Relatable , then you know that you can compare the size of the objects instantiated from that class.
Implementing the Relatable Interface
Here is the Rectangle class that was presented in the Creating Objects section, rewritten to implement Relatable .
public class RectanglePlus implements Relatable < public int width = 0; public int height = 0; public Point origin; // four constructors public RectanglePlus() < origin = new Point(0, 0); >public RectanglePlus(Point p) < origin = p; >public RectanglePlus(int w, int h) < origin = new Point(0, 0); width = w; height = h; >public RectanglePlus(Point p, int w, int h) < origin = p; width = w; height = h; >// a method for moving the rectangle public void move(int x, int y) < origin.x = x; origin.y = y; >// a method for computing // the area of the rectangle public int getArea() < return width * height; >// a method required to implement // the Relatable interface public int isLargerThan(Relatable other) < RectanglePlus otherRect = (RectanglePlus)other; if (this.getArea() < otherRect.getArea()) return -1; else if (this.getArea() >otherRect.getArea()) return 1; else return 0; > >
Because RectanglePlus implements Relatable , the size of any two RectanglePlus objects can be compared.
Note: The isLargerThan method, as defined in the Relatable interface, takes an object of type Relatable . The line of code, shown in bold in the previous example, casts other to a RectanglePlus instance. Type casting tells the compiler what the object really is. Invoking getArea directly on the other instance ( other.getArea() ) would fail to compile because the compiler does not understand that other is actually an instance of RectanglePlus .