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

Question

Как контрапункт this question: что такое интерфейс в Java?

Answer 1

Интерфейс представляет собой особый вид абстрактного класса, который не реализует никаких методов. В 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 и THER e нет 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()"); 
    } 
} 

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

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 напечатает «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 
{ } 

Это точно так же, как наш другой пример, за исключением того, что, поскольку мы позволили реализовать методы в абстрактные классы, мы сделали, и потому, что мы не» t должны реализовать уже реализованные методы в наследующем классе, мы этого не сделали. Но вы, возможно, заметили, что есть проблема. Что происходит, когда мы вызываем new InheritsFromTwoAbstractClasses().method()? Печатает ли «Hello» или «Goodbye»? Вероятно, вы этого не знаете, и компилятор 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 не разрешает это.

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

Answer 2

Интерфейс в Java является проектом класса. Он имеет только статические константы и абстрактные методы. Интерфейс в java - это механизм, позволяющий полностью абстрагироваться. Могут существовать только абстрактные методы в интерфейсе java, а не в методе. Он используется для достижения полной абстракции и множественного наследования в Java. Интерфейс представляет собой набор абстрактных методов. Класс реализует интерфейс, тем самым наследуя абстрактные методы интерфейса. Интерфейс не является классом. Написание интерфейса аналогично написанию класса, но это два разных понятия. Класс описывает атрибуты и поведение объекта. Интерфейс содержит поведение (абстрактные методы), которое реализует класс. Если класс, реализующий интерфейс, является абстрактным, все методы интерфейса должны быть определены в классе. Поскольку множественное наследование не разрешено в java, интерфейс является всего лишь способом реализации множественного наследования. Вот пример для понимания интерфейс

interface Printable{ 
void print(); 
} 

interface Showable{ 
void print(); 
} 

class testinterface1 implements Printable,Showable{ 

public void print(){System.out.println("Hello");} 

public static void main(String args[]){ 
testinterface1 obj = new testinterface1(); 
obj.print(); 
} 
} 

Answer 3

Интерфейс является светокопия класса.

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

Аннотация Класс достигает лишь частичной абстракции, но интерфейс достигает полной абстракции.

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

Если какой-либо класс реализует интерфейс, то класс должен реализовывать абстрактные методы слишком

интерфейс не может быть реализован.

interface A() { 
    void print() 
} 

Answer 4

Этот вопрос составляет 6 лет, и многие вещи изменили определение интерфейса на протяжении многих лет.

От оракула documentation страницы (пост Java-8 выпуск):

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

Посмотрите на смежные вопросы SE для лучшего объяснения:

Is there more to an interface than having the correct methods

What is the difference between an interface and abstract class?

Answer 5

как класс, интерфейс может иметь методы и переменные, но методы, объявленные в интерфейсе по умолчанию abstract (только подпись метода, без тела).

• Интерфейсы определяют, что должен делать класс, а не как. Это проект класса .

• Интерфейс о возможностях, таких как Игрок, может быть интерфейсом , и любой реализующий класс Player должен иметь возможность (или должен реализовать) move(). Поэтому он задает набор методов, которые должен реализовать класс .

• Если класс реализует интерфейс и не предоставляет метод тел для всех функций, указанных в интерфейсе, то класс должен быть объявлен абстрактным.

Интерфейсы используются для реализации абстракции. Итак, возникает вопрос, зачем использовать интерфейсы, когда у нас есть абстрактные классы?

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

Новые возможности были добавлены в интерфейсах в JDK 8

1. До JDK 8, интерфейс не может определить реализацию. Мы можем добавить стандартную реализацию для методов интерфейса. Эта реализация по умолчанию имеет специальное применение и не влияет на намерение за интерфейсами.

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

2. В JDK 8 теперь мы можем определить статические методы в интерфейсах, которые можно вызывать независимо без объекта. Примечание: эти методы не наследуются.

Answer 6

Что это
интерфейс является ссылочным типом, так же, как класса есть. Это два основных типа ссылок в Java.

Что он содержит
интерфейс может содержать подмножество, что нормальный класс может содержать. Это включает в себя все, что есть static, как методы, так и переменные, а также объявления типа static. Нельзя иметь переменные не static.
Декларация о методе отличается от обычного метода несколькими вещами; вот один как пример:

[public] [abstract] ReturnType methodName(); 

Эти заявления могут быть помечены как public и abstract, как представлено с [optional braces]. Это не обязательно, поскольку это значение по умолчанию. private, protected, package-private (aka. Nothing) и модификатор final не разрешены и помечены как ошибка компилятора. Они не реализуются, поэтому вместо фигурных скобок есть точка с запятой.

На Java 8, они могут держать Непро- static Методы с реализацию, они должны быть помечены модификатором default. Тем не менее применяются те же ограничения, что и для других модификаторов (добавив, что strictfp теперь действителен и abstract больше не существует).

Что это полезно для
Один из его использования для того, чтобы использоваться в качестве лица для службы.Когда две стороны работают вместе, чтобы сформировать запрос-провайдер &, поставщик услуг предоставляет лицо услуги (в отношении того, как выглядит служба) в виде интерфейса.
Одной из концепций ООП является «Абстракция», что означает скрыть сложную работу систем и показать только то, что необходимо для понимания системы. Это помогает визуализировать работу сложной системы. Это может быть достигнуто за счет интерфейса, где в каждом модуле визуализируется (а также реализован) для работы через интерфейс другого модуля

Answer 7

В общем, мы предпочитаем интерфейсы, когда есть два больше реализаций у нас есть. Где Интерфейс действует как протокол.

Кодирование по интерфейсу, а не реализациям Кодирование интерфейса обеспечивает свободную пару.

Интерфейс является ссылочным типом в Java. Он похож на класс. Это коллекция абстрактных методов. Класс реализует интерфейс, тем самым наследуя абстрактные методы интерфейса. Наряду с абстрактными методами интерфейс может также содержать константы, методы по умолчанию, статические методы и вложенные типы. для более details

Answer 8

Интерфейс представляет собой классную конструкцию, содержащую только константы и абстрактные методы (Введение в java-программирование, n.d.). Более того, он может распространять более одного интерфейса, например, надкласс. Java позволяет только одиночное наследование для расширения класса, но позволяет несколько расширений для интерфейсов (Введение в программирование на Java, Н.О.) Например,

public class NewClass extends BaseClass 
implements Interface1, ..., InterfaceN { 
    ... 
} 

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

public interface NewInterface extends Interface1, ... , InterfaceN { 

} 

Ссылка

Введение в Java программирования. Интерфейсы и абстрактные классы (n.d). Получено 10 марта 2017 года с https://viewer.gcu.edu/7NNUKW