Интерфейсы
Java предоставляет программисту еще одно средство, родственное классам, - интерфейсы. Интерфейс - это набор абстрактных методов, которые не содержат никакого кода. По своему предназначению интерфейсы похожи на абстрактные классы, хотя между ними имеются некоторые существенные различия. Так, например, интерфейсы, в отличие от абстрактных классов, могут быть только public или private. Методы, описанные внутри интерфейсов, всегда доступны (public) и абстрактны (abstract). Данные, декларированные в интерфейсе, изначально имеют атрибуты final, public и static, т. е. неизменяемы. Иногда это удобно, а иногда накладывает серьезные ограничения на применение интерфейсов. Но тут уж ничего не поделаешь - таковы правила языка.
Интерфейсы дают возможность программисту описывать наборы методов, которые должен реализовать класс. К примеру, стандартный интерфейс для создания многопоточных приложений Runnable задается следующим образом:
shape[0].Draw(); // Вызывает Point.Draw();
shape[1].Draw(); // Вызывает Circle.Draw();
shape[2].Draw(); // Вызывает Square.Draw();
Данное описание устанавливает прототип для метода Run, необходимого для запуска нового потока выполнения.
Для того чтобы использовать интерфейсы, от них должен быть унаследован класс, который реализует все шаблоны абстрактных методов, определенных в интерфейсе. Это можно сделать, использовав ключевое слово implements. Так, описание класса потока может выглядеть следующим образом:
public NewThread implements Runnable
{
public void run()
{
// Здесь запускается новый поток
// выполнения
}
}
Обратите внимание: ключевое слово implements (реализует) стоит в том месте, где обычно располагается ключевое слово extends, описывающее отношение наследования. Но встречаются и случаи, когда какой-нибудь класс наследует методы другого класса и одновременно реализует какой-нибудь интерфейс:
public class MyApplet
extends Applet implements Runnable
После такого упрощенного введения позволю себе описать понятия и синтаксис интерфейсов снова, но уже более формально. Итак, как уже было сказано, интерфейс - это набор описаний методов без реализации и констант. Такое средство может понадобиться для организации наследования из любого места иерархии. Описав, к примеру, интерфейс CustomLook с методом CustomPaint для создания элементов интерфейса с новым внешним видом, мы можем создавать по-новому выглядящие элементы на базе стандартных. При этом можно с одинаковым успехом создать на базе интерфейса CustomLook новый вид кнопки или новую строку ввода, и при этом не имеет значения, что кнопка и строка ввода располагаются в разных местах иерархии классов. Главное то, что их объединяет, - необходимость реализовать собственный метод CustomPaint для нестандартного отображения элемента. В связи с этим отметим следующие случаи применения интерфейсов:
Интерфейсы описываются по такой схеме:
public interface CustomLook
{
public abstract void NotifyStartPaint();
public abstract void CustomPaint ();
}
После того как интерфейс декларирован, его имя можно использовать наряду со стандартными типами и классами. Возвращаясь к примеру создания элементов пользовательского интерфейса с новым внешним видом, можно сказать, что вы имеете право создавать переменные типа CustomLook. Возникает интересная возможность: вы можете хранить в массиве элементов CustomLook любые классы, унаследованные от него (полиморфизм), и передавать эти классы в качестве параметра типа CustomLook, иначе говоря, приводить их к типу базового интерфейса, не теряя при этом их особенностей. И все это можно проделывать для классов, никак не связанных в рамках иерархии. Разве такое возможно в Си++?
Для облегчения понимания рассмотрим простой пример - создание элементов пользовательского интерфейса нестандартного вида. Сначала уточним задачу. Имеются несколько стандартных элементов интерфейса пользователя: кнопка (OldButton), строка ввода (OldInputLine) и пункт меню (OldMenuItem). Все эти элементы унаследованы от разных классов, никак не связанных между собой. Требуется создать на базе указанных выше элементов новые, отличающиеся по внешнему виду. Для этого нам потребуется, чтобы каждый новый элемент установил метод, отслеживающий начало рисования элемента на экране NotifyStartPaint, и новый метод рисования своего интерфейса CustomPaint. Оформим все новые требования как интерфейс CustomLook:
public interface CustomLook
{
public abstract void NotifyStartPaint();
public abstract void CustomPaint ();
}
На базе интерфейса CustomLook и старых элементов мы создаем новые элементы: кнопку (NewButton), строку ввода (NewInputLine) и пункт меню (NewMenuItem). Вот окончательный вариант каркаса программы:
public class NewButton
extends OldButton implements CustomLook
{
public void NotifyStartPaint()
{
// Код для перехвата начала рисования
}
public void CustomPaint ();
}
{
// Код для рисования кнопки нового
// внешнего вида
}
}
public class NewInputLine
extends OldInputLine implements CustomLook
{
public void NotifyStartPaint()
{
// Код для перехвата начала рисования
}
public void CustomPaint ();
}
{
// Код для рисования строки ввода
// нового внешнего вида
}
}
public class NewMenuItem
extends OldMenuItem implements CustomLook
{
public void NotifyStartPaint()
{
// Код для перехвата начала рисования
}
public void CustomPaint ();
}
{
// Код для рисования пункта меню нового
// внешнего вида
}
}
Таким образом, мы получили новые классы, как и раньше, не связанные между собой, но имеющие одинаковую функциональность. Их можно сохранить в массиве элементов типа CustomLook, несмотря на то, что все они имеют разных предков.
Кратко напомним ключевые моменты использования интерфейсов:
