Сфера полезности интерфейса в Java

Question

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

Является ли это только использованием / областью действия интерфейса в Java? Только для этого они ввели концепцию интерфейса или я что-то упустил? Пожалуйста, помогите мне в понимании использования интерфейсов, с примерами. (Не о том, как использовать или создавать интерфейсы, а о том, как они помогают программистам).

Спасибо.

Answer 1

Вот где я понял их использование, когда впервые прочитал о них:

Скажем, что вы получаете портативный проигрыватель дисков в качестве подарка.Когда вы пытаетесь управлять плеером, ничего не происходит - игрок требует батарей.Какие аккумуляторы подходят к плееру?К счастью, на задней панели плеера находится спецификация, This player requires two AA batteries.'' With this information, you can obtain the correctly sized components (the batteries) and fit them into the player. The completed сборка '' работает.

Спецификация аккумуляторов проигрывателя дисков служила нескольким полезным целям:

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

Answer 2

Я приведу вам пример.

У вас есть класс автомобиля

    class Car{
        start(){
            //code
        }
        stop(){
            //code
        }
    }

И вам нужен суперкар, который должен отскакивать (но функция Bounceable принадлежит мячу / резине)

Здесь ваш суперкарможет реализовывать прыжковые

    public interface Bounceable{

        bounce();
    }

Теперь у вас есть автомобиль Super Car, который может прыгать.

    class SuperCar extends Car implements Bounceable{
        //My Super Car will bounce.
    }

Answer 3

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

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

Итак, если, например, все наблюдатели реализуют следующий интерфейс:

public interface Observer
{
 notify();
}

Субъект может без каких-либо знаний о своих наблюдателях сделать что-то вроде этого:

public class MySubject...
{
  List<Observer> observers;

  .....



  public void notifyAll()
  {
      for (Observer observer : observers)
      {
         observer.notify();
      }
  }
}

Как видите, класс MySubject не имеет никаких знаний окак Observer реализует метод notify, что его действительно волнует, так это то, что он реализует его.Это позволяет создавать разных наблюдателей, которые по-разному реализуют свой собственный класс notify, не требуя каких-либо изменений в классе MySubject.

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

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

Answer 4

Класс может реализовывать множество интерфейсов и, следовательно, может предоставлять различные «дескрипторы» для рассматриваемого класса.Вот как классы считаются полиморфными (они могут иметь много форм в зависимости от того, как вы на них ссылаетесь).

Ознакомьтесь с документацией по Java-учебнику по этому вопросу.Вот несколько полезных примеров:

• http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html
• http://docs.oracle.com/javase/tutorial/java/IandI/interfaceAsType.html
• http://docs.oracle.com/javase/tutorial/collections/interfaces/index.html

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

Answer 5

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

Например, если вы собираетесь реализовать класс Queue, который реализует интерфейс List, интерфейс List потребует, например, реализации метода add и метода remove.

interface List {

    public void add(Object o);

    public void remove(Object o);

}

Если ваша очередь реализует интерфейс List, вы должны реализовать собственную версию методов add и remove. Основным преимуществом использования интерфейса является то, что вы можете поменять один тип с другим. Например:

 // this function returns an ArrayList
 List genericList = (ArrayList) getAnArrayList();  

OR

 // this function returns the Queue you implemented
 List myQueue = (MyQueue) getAQueue(); 

Реализуя свой класс в качестве интерфейса, вы можете объявить свои переменные, используя более общий тип, чем если бы вы использовали конкретный тип. Я считаю, что это действительно полезно для объекта EJB или объекта передачи данных, где один класс обслуживания может использовать ArrayList, а другой может выиграть от использования HashSet. В моем компоненте я могу использовать объявление интерфейса и позволить каждому классу службы определить, какой конкретный тип он хочет использовать, приведя переменную к конкретному типу.

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

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

Answer 6

Java не допускает множественное наследование.

Их проектное решение заключалось в реализации интерфейсов.

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

Answer 7

Это классический пример, но все равно. Например, вы хотите написать игру, в которой должны быть круги, квадраты, треугольники и другие фигуры. Вы не знаете, какая фигура появится в следующий раз, поэтому вы должны написать интерфейс с именем скажем Shape с абстрактным методом draw и Triangle, Circle, Square классы, которые реализуют ваш Shape интерфейс. После этого вам все равно, какая форма будет дальше. Вы можете дать своему методу drawNext(Shape s) экземпляр Shape и вызвать метод draw для этого. Он будет работать для всех типов, которые реализуют Shape.

public void drawNext(Shape s)
{
     s.draw(); //this will call draw() method of Square if you call drawNext(new Square()) and draw() method of Triangle in case drawNext(new Triangle()) and so on..
}

Если вы не используете этот интерфейс, вы должны написать другой метод для всех типов объектов, которые можно перемещать (drawSquare(Square s), drawCircle(Circle c) и т.д ...)

Это одна из областей применения интерфейсов.

Answer 8

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

Однако это не единственное использование / область применения интерфейса. Это определение интерфейса.

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

Часто в вашем программировании вы можете предоставить один (или несколько) конкретных классов; но интерфейс - это сигнал того, что это точка планируемой расширяемости. Чтобы вернуться к моему примеру с классом «Телефон», я мог бы написать в классе «Телефон».

(assume that listeners is a Collection of TelephoneListener)

public void addListener(TelephoneListener listener) {
  listeners.add(listener);
}

private void simulateCall() {
  for (TelephoneListener listener : listeners) {
    listener.onRing();
  }
}

сигнализация TelephoneListeners, которые даже не написали (пока), что зазвонил телефон.

На самом деле речь идет не просто об имитации множественного наследования, хотя те, кто пришел из C ++, идентифицируют его как средство «решения» множественного наследования. Речь идет о спецификации контракта для будущих классов для реализации. Многократное наследование в C ++ смешивает контракт с реализацией (и, таким образом, вы рискуете получить страшный ромбовидный паттерн).

Answer 9

Небольшая история помогает:

Объектная модель в java является в значительной степени упрощенной версией C ++. Это страдало от "проблемы с бриллиантами", когда она сталкивалась с множественным наследованием.

В Java, хотя 1 класс может расширять только 1 базовый класс, он может реализовывать несколько интерфейсов. Когда 2 или более методов в этих реализованных интерфейсах имеют одинаковую сигнатуру (имя, номер параметра и типы), программист будет осознавать это И в худшем случае (если он забудет реализовать методы), их поведение будет по умолчанию возвращать ноль или ничего не делать (это то, что IDE делает для вас в любом случае). При множественном наследовании вам всегда следует помнить, что не нужно переопределять методы базовых классов.

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

Answer 10

interface s имеют решающее значение в Java, потому что не имеет множественного наследования . Если вы хотите, чтобы ваш класс был Iterable, но вы также хотите реализовать определенную логику, вы не можете наследовать от 2 классов, поэтому вам придется использовать interface.

Итак, если вам нужно, чтобы класс реализовал более 1 логики [что не редкость], вы не можете использовать только abstract классы, вам придется использовать interface s