Что такое интерфейс в Java?

Интерфейс - это особая форма абстрактного класса, которая не реализует никаких методов. В Java вы создаете интерфейс, подобный этому:

interface Interface
{
    void interfaceMethod();
}

Поскольку интерфейс не может реализовывать какие-либо методы, подразумевается, что все, включая все методы, являются как общедоступными, так и абстрактными (абстрактное в терминах Java означает «не реализовано с помощью этот класс"). Таким образом, интерфейс выше идентичен интерфейсу ниже:

public interface Interface
{
    abstract public void interfaceMethod();
}

Чтобы использовать этот интерфейс, вам просто нужно реализовать интерфейс. Многие классы могут реализовывать интерфейс, а класс может реализовывать множество интерфейсов:

interface InterfaceA
{
     void interfaceMethodA();
}

interface InterfaceB
{
    void interfaceMethodB();
}

public class ImplementingClassA
    implements InterfaceA, InterfaceB
{
    public void interfaceMethodA()
    {
        System.out.println("interfaceA, interfaceMethodA, implementation A");
    }

    public void interfaceMethodB()
    {
        System.out.println("interfaceB, interfaceMethodB, implementation A");
    }
}

public class ImplementingClassB
    implements InterfaceA, InterfaceB
{
    public void interfaceMethodA()
    {
         System.out.println("interfaceA, interfaceMethodA, implementation B");
    }

    public void interfaceMethodB()
    {
        System.out.println("interfaceB, interfaceMethodB, implementation B");
    }
}

Теперь, если вы хотите, вы можете написать такой метод:

public void testInterfaces()
{
    ImplementingClassA u = new ImplementingClassA();
    ImplementingClassB v = new ImplementingClassB();
    InterfaceA w = new ImplementingClassA();
    InterfaceA x = new ImplementingClassB();
    InterfaceB y = new ImplementingClassA();
    InterfaceB z = new ImplementingClassB();

    u.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation A"
    u.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation A"
    v.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation B"
    v.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation B"
    w.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation A"
    x.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation B"
    y.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation A"
    z.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation B"
}

Однако вы можете никогда не делать следующее:

public void testInterfaces()
{
    InterfaceA y = new ImplementingClassA();
    InterfaceB z = new ImplementingClassB();

    y.interfaceMethodB(); // ERROR!
    z.interfaceMethodA(); // ERROR!
}

] Причина, по которой вы не можете этого сделать, заключается в том, что y имеет тип interfaceA , и нет interfaceMethodB () в interfaceA . Аналогично, z относится к типу interfaceB , и нет interfaceMethodA () в interfaceB .

Я упоминал ранее, что интерфейсы являются просто особая форма абстрактного класса. Чтобы проиллюстрировать эту точку зрения, взгляните на следующий код.

interface Interface
{
    void abstractMethod();
}

abstract public class AbstractClass
{
    abstract public void abstractMethod();
}

Вы могли бы наследовать от этих классов почти таким же образом:

public class InheritsFromInterface
    implements Interface
{
    public void abstractMethod() { System.out.println("abstractMethod()"); }
}

public class InteritsFromAbstractClass
    extends AbstractClass
{
    public void abstractMethod() { System.out.println("abstractMethod()"); }
}

Фактически, вы могли бы даже изменить интерфейс и абстрактный класс следующим образом:

interface Interface
{
    void abstractMethod();
}

abstract public class AbstractClass
    implements Interface
{
    abstract public void abstractMethod();
}

public class InheritsFromInterfaceAndAbstractClass
    extends AbstractClass implements Interface
{
    public void abstractMethod() { System.out.println("abstractMethod()"); }
}

Однако, есть два различия между интерфейсами и абстрактными классами.

Первое отличие состоит в том, что интерфейсы не могут реализовывать методы.

interface Interface
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}

Интерфейс выше генерирует ошибку компилятора, потому что он имеет реализацию для implementationMethod () . Если вы хотите реализовать метод, но не можете создать экземпляр класса, вам придется сделать это следующим образом:

abstract public class AbstractClass
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}

Это не так уж и много абстрактного класса, потому что ни один из его членов не является абстрактным, но это законная Java.

Другое различие между интерфейсами и абстрактными классами состоит в том, что класс может наследовать от нескольких интерфейсов, но может наследовать только от одного абстрактного класса.

abstract public class AbstractClassA { }
abstract public class AbstractClassB { }
public class InheritsFromTwoAbstractClasses
    extends AbstractClassA, AbstractClassB
{ }

Приведенный выше код генерирует ошибку компилятора не потому, что все классы пусты, а потому, что InheritsFromTwoAbstractClasses пытается наследовать от двух абстрактных классов, что является недопустимым. Следующее является совершенно законным.

interface InterfaceA { }
interface InterfaceB { }
public class InheritsFromTwoInterfaces
    implements InterfaceA, InterfaceB
{ }    

Первое различие между интерфейсами и абстрактными классами является причиной второго различия . Взгляните на следующий код.

interface InterfaceA
{
    void method();
}

interface InterfaceB
{
    void method();
}

public class InheritsFromTwoInterfaces
    implements InterfaceA, InterfaceB
{
    void method() { System.out.println("method()"); }
}

Вот ' Нет проблем с приведенным выше кодом, потому что InterfaceA и InterfaceB не имеют ничего, что нужно скрывать. Легко сказать, что при вызове метода будет выведено «method ()».

Теперь посмотрим на следующий код:

abstract public class AbstractClassA
{
    void method() { System.out.println("Hello"); }
}

abstract public class AbstractClassB
{
    void method() { System.out.println("Goodbye"); }
}

public class InheritsFromTwoAbstractClasses
    extends AbstractClassA, AbstractClassB
{ }

Это точно так же, как и в нашем другом примере, за исключением того, что мы Нам разрешено реализовывать методы в абстрактных классах, и поскольку нам не нужно реализовывать уже реализованные методы в наследующем классе, мы этого не сделали. Но вы могли заметить, что есть проблема. Что происходит, когда мы вызываем new InheritsFromTwoAbstractClasses (). Method () ? Он печатает «Привет» или «До свидания»? Вы, вероятно, не знаете, и компилятор Java тоже. Другой язык, C ++ допускал такой вид наследования, и они решали эти проблемы зачастую очень сложными способами. Чтобы избежать такого рода проблем, Java решила сделать это «множественное наследование» незаконным.

Обратной стороной решения Java является невозможность выполнения следующего:

abstract public class AbstractClassA
{
    void hi() { System.out.println("Hello"); }
}

abstract public class AbstractClassB
{
    void bye() { System.out.println("Goodbye"); }
}

public class InheritsFromTwoAbstractClasses
    extends AbstractClassA, AbstractClassB
{ }

AbstractClassA и AbstractClassB являются «миксинами» или классами, которые не предназначены для создания экземпляров, но добавляют функциональность классам, в которые они «смешиваются» посредством наследования. Очевидно, нет проблем с выяснением того, что произойдет, если вы вызовете new InheritsFromTwoAbstractClasses (). Hi () или new InheritsFromTwoAbstractClasses (). Bye () , но вы не можете этого сделать, потому что Java не позволяет это.

(Я знаю, что это длинный пост,