Интерфейсы interface

В статье рассматривается одно из свойств Java, как языка объектно-ориентированного программирования, вопрос использования интерфейса. Статья в большей степени ориентирована на философию Java, чем на практические рекомендации по программированию.

Первый вопрос, возникающий при знакомстве с Java, - Зачем нужны интерфейсы? Нельзя ли обойтись абстрактными классами? Может быть для маскировки отсутствия множественного наследования?

Привычные варианты ответа: класс вводит новый тип, класс обобщает и т.д.

Декларация типа

В Java новый тип можно определить спецификацией интерфейса. Любой java интерфейс (interface) может иметь много реализаций. Любой класс может реализовывать несколько интерфейсов.

В качестве примера создадим интерфейс INumber - тип, описывающий функции использования числовых значений. Ограничимся только операциями сложения и умножения.

/** ------------------------------------------------------------- 
 * INumber.java Декларация типа INumber
 *  ------------------------------------------------------------- 
 */
interface INumber
{
  public void     setValue (String s);
  public INumber  add      (INumber n);
  public INumber  mul      (INumber n);
  public String   toString ();
}

Реализация интерфейса, 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)
    {
        ArrayList<Object> ships = new ArrayList<Object>();
        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) методов неявно образует интерфейс данного класса. В силу этого наследование класса автоматически означает как наследование реализации, так и наследование интерфейса (типа). Очевидно, что наследование структуры данных и программного кода не определяет тип потомка. Например, абстрактные методы являются частью интерфейса и не являются частью реализации. Если бы можно было исключить их из наследования, то мы получили бы наследование реализации без сохранения типа.

Наверх
  Рейтинг@Mail.ru