Что такое интерфейс в Java?
Просто в качестве контрапункта к этому вопросу: что такое интерфейс в Java?
14 ответов
Интерфейс - это особая форма абстрактного класса, которая не реализует никаких методов. В 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()");
}
}
Приведенный выше интерфейс генерирует ошибку компилятора, потому что он имеет реализацию для 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
{ }
Это в точности то же самое, что и в нашем другом примере, за исключением того, что нам разрешено реализовывать методы в абстрактных классах, и мы не должны реализовывать уже реализованные методы в наследующем классе. Но вы могли заметить, есть проблема. Что происходит, когда мы звоним 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 не позволяет этого.
(Я знаю, что это длинный пост, поэтому, если в нем есть ошибки, пожалуйста, дайте мне знать, и я исправлю их.)
Интерфейс - это контракт. Простым примером являются Арендатор и Арендодатель, которые являются двумя сторонами, а договор - это Договор аренды. Договор аренды содержит различные условия, которым арендаторы должны следовать. Аналогично, Интерфейс - это контакт, который содержит различные методы (Декларации), которые Сторона должна реализовать (предоставить тела методов). Здесь первая сторона - это класс, который реализует интерфейс, а вторая сторона - Клиент, и способ использования и интерфейса имеет "Ссылку интерфейса "и" Объект класса реализации ": ниже представлены 3 компонента:(поясняется с помощью примера)
Компонент 1] Интерфейс: Контракт
interface myInterface{
public void myMethod();
}
Компонент 2] Реализация Класс: Партия № 1
class myClass implements myInterface {
@Override
public void myMethod() {
System.out.println("in MyMethod");
}
}
Компонент 3] Код клиента: Партия № 2
Client.java
public class Client {
public static void main(String[] args) {
myInterface mi = new myClass();
// Reference of Interface = Object of Implementing Class
mi.myMethod(); // this will print in MyMethod
}
}
Интерфейс в 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();
}
}
Интерфейс: служба системных требований.
Описание: Предположим, что клиенту нужна некоторая функциональность, например, интерфейс JDBC API, а также какой-то другой сервер Apache, Jetty, WebServer, все они предоставляют инструменты для этого. Таким образом, он ограничил документ требований, который поставщик услуг предоставил пользователю, который использует соединение для передачи данных с этими серверами Apache, Jetty, WebServer.
Согласно последнему определению Oracle, интерфейс - это:
В разработке программного обеспечения существует ряд ситуаций, когда разрозненным группам программистов важно согласиться на "контракт", в котором прописано, как их программное обеспечение взаимодействует. Каждая группа должна иметь возможность писать свой код, не зная, как пишется код другой группы. Вообще говоря, интерфейсы - это такие контракты.
Например, представьте себе футуристическое общество, в котором роботизированные автомобили с компьютерным управлением перевозят пассажиров по улицам города без оператора. Производители автомобилей пишут программное обеспечение (конечно, Java), которое управляет автомобилем - остановка, запуск, ускорение, поворот налево и так далее. Другая промышленная группа, производители электронных навигационных приборов, производят компьютерные системы, которые принимают данные о местоположении GPS (Global Positioning System) и беспроводную передачу условий движения, и используют эту информацию для управления автомобилем.
Производители автомобилей должны опубликовать стандартный для отрасли интерфейс, в котором подробно объясняется, какие методы можно использовать для приведения автомобиля в движение (любой автомобиль любого производителя). Затем производители могут написать программное обеспечение, которое вызывает методы, описанные в интерфейсе, для управления автомобилем. Ни одной промышленной группе не нужно знать, как внедряется программное обеспечение другой группы. Фактически, каждая группа считает свое программное обеспечение очень проприетарным и оставляет за собой право изменять его в любое время, пока оно продолжает придерживаться опубликованного интерфейса.
[...] Интерфейс - это ссылочный тип, аналогичный классу, который может содержать только константы, сигнатуры методов, методы по умолчанию, статические методы и вложенные типы. Тела метода существуют только для стандартных методов и статических методов. Интерфейсы не могут быть созданы - они могут быть реализованы только классами или расширены другими интерфейсами.
Наиболее популярное использование интерфейсов - это API (Application Programming Interface), которые распространены в коммерческих программных продуктах. Как правило, компания продает программный пакет, содержащий сложные методы, которые другая компания хочет использовать в своем программном продукте.
Примером может служить пакет методов цифровой обработки изображений, которые продаются компаниям, производящим графические программы для конечных пользователей.
Компания по обработке изображений пишет свои классы для реализации интерфейса, который публикует для своих клиентов. Затем графическая компания вызывает методы обработки изображений, используя сигнатуры и возвращаемые типы, определенные в интерфейсе. Хотя API компании по обработке изображений становится общедоступным (для ее клиентов), его реализация API держится в строжайшем секрете - фактически, он может пересмотреть реализацию на более позднем этапе, пока она продолжает реализовывать оригинальный интерфейс. что его клиенты полагались.
Проверьте, чтобы узнать больше об интерфейсах.
В дополнение к тому, что упоминали другие, и по нелогичному сравнению , это фреймворк для методов упаковки, чтобы их можно было хранить в переменных.
Таким образом, на лету вы можете приравнять переменную интерфейса к любому методу или набору методов, по крайней мере, в этом смысле, и хорошая причина, по которой вы обычно хотели бы это делать, - это избежать повторяющейся логики, которая определенно будет врагом прогресса в рамках Период полураспада вашего кода с любой скоростью затухания, будьте осторожны со сценарием ниже, рекомендуется на усмотрение пользователя.
СЦЕНАРИЙ
У вас есть игра сdrawSillyThings() метод в SoulAvengerкласс, который должен рисовать фреймы или спрайты. СейчасdrawSillyThings()есть список других методов, которые необходимо вызвать в другом, чтобы нарисовать метаморфизированного прославленного рейнджера душ после того, как пользователь убивает мрачного жнеца на уровне 5k, т.е.drawSillyThings() необходимо позвонить одному из inviteTheGrimReaper(), drawUpperCut(), drawTotalKO(), drawVictoryAndGlorifiedRanger(), drawDefeatAndMockery(), drawFightRecap() а также drawGameOver() всякий раз, когда во время игры возникают правильные ситуации, но все это может привести к нежелательной логике в drawSillyThings() что может замедлить игру, т.е.
public static class SoulAvenger{
public SoulAvenger(){
//constructor logic
}
private void loadLevel5k(){...}
private void dontAllowUserWinOnTime(){...}
private void loadGrimReaperFight(){...}
private void drawSillyThings(){
... //unaccounted game logic
while(fighting_in_level_5k){
while(soul_ranger_has_enough_lives){
if(game_state=fight)inviteTheGrimReaper();
else if(game_state=medium_blows)drawUpperCut();
else if(game_state=heavy_blows)drawTotalKO();
else if(game_state=lost)drawDefeatAndMockery();
else if(game_state=won)drawVictoryAndGlorifiedRanger();
else if(game_state=end)drawFightRecap();
}else drawGameOver();
}
}
}
Проблема здесь в том, что логические проверки, вложенные в цикл, должны выполняться каждый раз, пока душа-рейнджер еще жив, поскольку у вас может быть просто альтернативный класс, который гарантируетdrawSillyThings() не нужен game_state проверяться каждый раз, чтобы вызывать правильный метод, но для этого вам нужно как бы сохранить правильный метод в переменной, чтобы впоследствии вы могли variable = new method а также вроде variable.invoke(). Если бы это не было чем-то, посмотрите
public static class InterfaceTest{
public interface Method{
public void invoke();
}
public static void main(String[] args){
//lets create and store a method in a variable shall we
Method method_variable=new Method(){
@Override
public void invoke(){
//do something
}
};
//lets call or invoke the method from the variable in order to do something
method_variable.invoke();
//lets change the method to do something else
method_variable=new Method(){
@Override
public void invoke(){
//do something else
}
};
//lets do something else
method_variable.invoke();
}
}
Вероятно, это было то, что парни из oracle обнаружили в Java за несколько лет до того, как в сети появились слухи о том, что некоторые разработчики планируют массовый протест, но вернулись кSoulAvenger, когда происходит игровой процесс, вы определенно захотите, чтобы переменная была приравнена, чтобы дать правильный метод, который будет вызываться в drawSillyThings() чтобы вести дела глупо, поэтому
public static class SoulAvenger{
private interface SillyRunner{
public void run_things();
}
...//soul avenging variables
private SillyRunner silly_runner;
public SoulAvenger(int game_state){
//logic check is performed once instead of multiple times in a nested loop
if(game_state=medium_blows){
silly_runner=new SillyRunner(){
@Override
public void run_things(){
drawUpperCut();
}
};
}else if(game_state=heavy_blows){
silly_runner=new SillyRunner(){
@Override
public void run_things(){
drawTotalKO();
}
};
}else if(game_state=lost){
silly_runner=new SillyRunner(){
@Override
public void run_things(){
drawDefeatAndMockery();
}
};
}else if(game_state=won){
silly_runner=new SillyRunner(){
@Override
public void run_things(){
drawVictoryAndGlorifiedRanger();
}
};
}else if(game_state=fight){
silly_runner=new SillyRunner(){
@Override
public void run_things(){
drawFightRecap();
}
};
}
}
private void loadLevel5k(){
//an event triggered method to change how you run things to load level 5k
silly_runner=new SillyRunner(){
@Override
public void run_things(){
//level 5k logic
}
};
}
private void dontAllowUserWinOnTime(){
//an event triggered method to help user get annoyed and addicted to the game
silly_runner=new SillyRunner(){
@Override
public void run_things(){
drawDefeatAndMockery();
}
};
}
private void loadGrimReaperFight(){
//an event triggered method to send an invitation to the nearest grim-reaper
silly_runner=new SillyRunner(){
@Override
public void run_things(){
inviteTheGrimReaper();
}
};
}
private void drawSillyThings(){
...//unaccounted game logic
while(fighting_in_level_5k){
while(soul_ranger_has_enough_lives){
silly_runner.run_things();
}
}
}
}
Теперь drawSillyThings() не нужно выполнять никаких if логика во время рисования, потому что по мере запуска правильных событий silly_runner приравнивается к run_things() метод вызывает другой метод, таким образом используя переменную для хранения и вызова метода вроде как, хотя в реальном игровом мире (я на самом деле имею в виду в консоли) несколько потоков будут работать асинхронно, чтобы изменить переменные интерфейса для запуска другого фрагмента кода с тем же вызов.
Интерфейс в java - это особый тип абстрактного класса, интерфейс обеспечивает 100% абстракцию, но поскольку java вводит новые функции в java 8, значение всего интерфейса меняется. Интерфейсы используются для указания того, что следует делать. Но из-за новых возможностей теперь мы даем реализации методов в интерфейсе, которые изменили смысл интерфейса. В интерфейсе метод по умолчанию является общедоступным абстрактным
interface Bird{
void sound();
void eat();
}
Java не предоставляет функцию множественного наследования, что означает, что у класса нет двух родителей, но мы расширяем несколько интерфейсов в java.
Интерфейс - это план класса.
Существует одна концепция, называемая абстракция данных, согласно которой есть две категории: одна - абстрактный класс, а другая - интерфейс.
Абстрактный класс достигает только частичной абстракции, но интерфейс достигает полной абстракции.
В интерфейсе есть только абстрактные методы и конечные переменные. Вы можете расширять любое количество интерфейсов и реализовывать любое количество классов.
Если какой-либо класс реализует интерфейс, тогда класс должен также реализовывать абстрактные методы
Интерфейс не может быть создан.
interface A() {
void print()
}
Интерфейс - это классоподобная конструкция, которая содержит только константы и абстрактные методы (Введение в Java-программирование, nd). Более того, он может расширять несколько интерфейсов, например, суперкласс. Java допускает только одно наследование для расширения класса, но допускает несколько расширений для интерфейсов (Введение в программирование на Java, nd) Например,
public class NewClass extends BaseClass
implements Interface1, ..., InterfaceN {
...
}
Во-вторых, интерфейсы могут использоваться для определения поведения объектов в классе. Однако они не могут содержать абстрактные методы. Кроме того, интерфейс может наследовать другие интерфейсы, используя ключевое слово extends.
public interface NewInterface extends Interface1, ... , InterfaceN {
}
Ссылка
Введение в программирование на Java. Интерфейсы и абстрактные классы (nd). Получено 10 марта 2017 г. с https://viewer.gcu.edu/7NNUKW.
Что это
Интерфейс является ссылочным типом, как и класс. Это два основных ссылочных типа в Java.
Что это содержит
Интерфейс может содержать подмножество того, что может содержать обычный класс. Это включает в себя все, что staticи методы и переменные, и неstatic объявления методов. Не разрешается иметьstatic переменные.
Объявление метода отличается от обычного метода несколькими вещами; вот один в качестве примера:
[public] [abstract] ReturnType methodName();
Эти декларации могут быть помечены как public а также abstract, как представлено с [optional braces], В этом нет необходимости, так как это по умолчанию. private, protected, package-private (иначе ничего) и final Модификатор не допускается и помечается как ошибка компилятора. У них нет реализации, поэтому вместо фигурных скобок стоит точка с запятой.
Начиная с Java 8, они могут содержатьstatic методы с реализацией, они должны быть помечены default модификатор. Однако применяются те же ограничения, что и к другим модификаторам (добавив, что strictfp теперь действует и abstract больше не).
Для чего это полезно
Одно из его применений - использовать его как лицо для службы. Когда две стороны работают вместе, чтобы сформировать отношения типа "запросчик услуг" и "поставщик услуг", поставщик услуг предоставляет лицо службы (относительно того, как выглядит служба) в форме интерфейса.
Одной из концепций ООП является "Абстракция", что означает скрывать сложную работу систем и показывать только то, что необходимо для понимания системы. Это помогает визуализировать работу сложной системы. Это может быть достигнуто через интерфейс, где в каждом модуле визуализируется (и также реализован) работа через интерфейс другого модуля.
Этому вопросу 6 лет, и многое изменило определение интерфейса за эти годы.
Со страницы документации оракула (после выпуска Java 8):
В языке программирования Java интерфейс - это ссылочный тип, аналогичный классу, который может содержать только константы, сигнатуры методов, методы по умолчанию, статические методы и вложенные типы. Тела методов существуют только для стандартных методов и статических методов. Интерфейсы не могут быть созданы - они могут быть реализованы только классами или расширены другими интерфейсами.
Посмотрите на связанные вопросы SE для лучшего объяснения:
В общем, мы предпочитаем интерфейсы, когда есть еще две реализации, которые у нас есть. Где интерфейс выступает в качестве протокола.
Кодирование интерфейса, а не реализации. Кодирование интерфейса создает слабую пару.
Интерфейс является ссылочным типом в Java. Это похоже на класс. Это коллекция абстрактных методов. Класс реализует интерфейс, тем самым наследуя абстрактные методы интерфейса. Наряду с абстрактными методами интерфейс может также содержать константы, методы по умолчанию, статические методы и вложенные типы. для более подробной информации
Интерфейс - это договор между системой и внешней средой. В частности, для Java - контракт для класса (для определенного поведения), реализованный в форме, напоминающей чистый абстрактный класс.
Как и класс, интерфейс может иметь методы и переменные, но методы, объявленные в интерфейсе, по умолчанию являются абстрактными (только сигнатура метода, без тела).
- Интерфейсы определяют, что должен делать класс, а не как. Это план класса.
Интерфейс - это возможности, такие как Player может быть интерфейсом, и любой класс, реализующий Player, должен быть в состоянии (или должен реализовывать) move(). Таким образом, он определяет набор методов, которые класс должен реализовать.
Если класс реализует интерфейс и не предоставляет тела методов для всех функций, указанных в интерфейсе, тогда класс должен быть объявлен как абстрактный.
Интерфейсы используются для реализации абстракции. Поэтому возникает вопрос, зачем использовать интерфейсы, когда у нас есть абстрактные классы?
Причина в том, что абстрактные классы могут содержать неконечные переменные, тогда как переменные в интерфейсе являются конечными, общедоступными и статическими.
Новые функции, добавленные в интерфейсы в JDK 8
До JDK 8 интерфейс не мог определить реализацию. Теперь мы можем добавить реализацию по умолчанию для методов интерфейса. Эта реализация по умолчанию имеет специальное использование и не влияет на намерения за интерфейсами.
Предположим, нам нужно добавить новую функцию в существующий интерфейс. Очевидно, старый код не будет работать, так как классы не реализовали эти новые функции. Таким образом, с помощью реализации по умолчанию мы дадим тело по умолчанию для вновь добавленных функций. Тогда старые коды все равно будут работать.
- В JDK 8 теперь мы можем определять статические методы в интерфейсах, которые можно вызывать независимо без объекта. Примечание: эти методы не наследуются.