34 Вопрос: В чем разница между интерфейсом и абстрактным классом?

вопрос создан в Thu, Feb 2, 2017 12:00 AM

В чем разница между интерфейсом и абстрактным классом?

    
1652
  1. Это очень распространенный вопрос интервью. Это удивительно, поскольку абстрактный класс редко используется в решениях по сравнению с другими вещами. Ваш вопрос помог мне Сафраз.
    2014-02-28 02: 34: 26Z
  2. Этот вопрос также может помочь понять концепцию интерфейсов stackoverflow.com/д /8531292/1055241
    2014-07-07 05: 28: 58Z
  3. Я удалил тег PHP из этого вопроса, поскольку почти ни один из ответов не зависит от языка, а сам вопрос не зависит от языка.
    2017-02-02 17: 41: 09Z
  4. в тот день в c ++ интерфейс представлял собой чистый абстрактный базовый класс со всеми реализациями метода = 0. Если один метод не был = 0, то он имеет реализация и абстрактная база больше не являются чистыми и больше не интерфейсом. Я думаю, что у VMT меньше косвенности, когда множественное наследование использует только чистые абстрактные основы, но я не помню, как они выглядят больше, слишком долго.
    2019-06-26 05: 59: 02Z
30 ответов                              30                         

Интерфейсы

Интерфейс - это контракт : человек, пишущий интерфейс, говорит: « эй, я принимаю вещи, выглядящие так », а человек, использующий интерфейс, говорит « Хорошо, класс, который я пишу, выглядит так ".

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

Например (псевдокод):

 
// I say all motor vehicles should look like this:
interface MotorVehicle
{
    void run();

    int getFuel();
}

// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{

    int fuel;

    void run()
    {
        print("Wrroooooooom");
    }


    int getFuel()
    {
        return this.fuel;
    }
}

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

Абстрактные классы

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

Абстрактные классы очень похожи на интерфейсы, но у них есть нечто большее: вы можете определить поведение для них. Это больше о человеке, который говорит: «Эти классы должны выглядеть так, и они имеют это общее, так что заполняйте пробелы!».

Например:

 
// I say all motor vehicles should look like this:
abstract class MotorVehicle
{

    int fuel;

    // They ALL have fuel, so lets implement this for everybody.
    int getFuel()
    {
         return this.fuel;
    }

    // That can be very different, force them to provide their
    // own implementation.
    abstract void run();
}

// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
    void run()
    {
        print("Wrroooooooom");
    }
}

Реализация

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

В Java это правило строго соблюдается, в то время как в PHP интерфейсы являются абстрактными классами без объявленного метода.

В Python абстрактные классы - это больше трюк программирования, который вы можете получить из модуля ABC, и на самом деле он использует метаклассы и, следовательно, классы. А интерфейсы в большей степени связаны с типизацией утки на этом языке, и это смесь соглашений и специальных методов, вызывающих дескрипторы (методы __method__).

Как обычно в программировании, есть теория, практика и практика на другом языке: -)

    
2139
2018-05-16 02: 56: 36Z
  1. Ключевым моментом об интерфейсах является не столько то, что они говорят о том, что делает класс, но позволяют объектам, которые могут Wizzle, стать полезными для кода, который нуждается в Wizzler. Обратите внимание, что во многих случаях ни тот, кто пишет то, что может сделать Wizzle, ни тот, кому нужен Wizzler, не будет тем, кто пишет интерфейс.
    2013-03-27 21: 28: 43Z
  2. Я не думаю, что потребление ресурсов процессора является важным моментом на интерфейсах.
    2013-09-11 21: 40: 12Z
  3. @ e-sat Можете ли вы объяснить свою точку зрения на загрузку процессора? Почему абстрактный класс как класс увеличивает загрузку ЦП? О каком поиске вы здесь говорите?
    2014-04-24 13: 18: 25Z
  4. @ e-sat В Java 8 вы можете определять методы по умолчанию в интерфейсах, что эквивалентно наличию неабстрактных методов в абстрактных классах. С этим добавлением я больше не вижу реальной разницы между абстрактными классами и интерфейсом, кроме того факта, что я должен использовать интерфейсы, потому что классы могут реализовывать несколько интерфейсов, но могут наследовать только один класс
    2015-10-31 01: 34: 34Z
  5. Я думаю, что сравнение между interface и class из Head First Java является ярким, что A class defines who you are, and an interface tells what roles you could play
    2016-07-11 06: 43: 00Z

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

  • Абстрактные классы могут иметь константы, члены, заглушки методов (методы без тела) и определенные методы , тогда как интерфейсы могут иметь только константы и заглушки методов .

  • Методы и члены абстрактного класса могут быть определены с любой видимостью , тогда как все методы интерфейса должны быть определены как public (они определены как общедоступные по умолчанию).

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

  • Аналогично, интерфейс, расширяющий другой интерфейс, не отвечает за реализацию методов из родительского интерфейса. Это связано с тем, что интерфейсы не могут определять какую-либо реализацию.

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

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

831
2016-11-20 14: 14: 29Z
  1. я думаю, что это лучший ответ, потому что он подчеркивает все ключевые различия. пример на самом деле не нужен.
    2011-07-10 18: 01: 03Z
  2. И обычно с помощью классов вы можете создать экземпляр объекта из него, в отличие от абстрактных классов, для которых создается экземпляр CANNOT.
    2013-07-09 20: 48: 50Z
  3. Я думал, что класс, реализующий интерфейс, должен определить все методы в интерфейсе?
    2013-12-27 12: 33: 57Z
  4. @ Jiazzyuser Если абстрактный класс реализует интерфейс, ему фактически не нужно определять методы интерфейса. Это требование может быть отложено до наследования /дочерних конкретных классов. Однако конкретный класс должен реализовывать все методы интерфейса, которые не реализованы его родительским классом. Я добавлю пример, чтобы проиллюстрировать этот момент.
    2014-01-28 20: 44: 14Z
  5. "При наследовании абстрактного класса дочерний класс должен определять абстрактные методы, тогда как интерфейс может расширять другой интерфейс, и методы не должны быть определены." - Это не труты. Так же, как интерфейс может расширять интерфейс без определения методов, абстрактный класс может наследовать абстрактный класс без определения методов.
    2014-03-10 17: 21: 41Z

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

 введите описание изображения здесь Взято из:

http://www.dotnetbull.com/2011/11 /разница между ними-абстрактным-классом-and.html

http: //www. dotnetbull.com/2011/11/what-is-abstract-class-in-c-net.html http://www.dotnetbull.com/2011 /11/what-is-interface-in-c-net.html р>     

131
2018-10-26 05: 55: 24Z
  1. Вам необходимо указать, к какому языку это относится («Абстрактный класс не поддерживает множественное наследование» далеко не универсально верно)
    2014-03-07 04: 16: 30Z
  2. Последнее сравнение сбивает с толку согласно таблице! Методы в интерфейсе не могут быть статическими, но переменные являются статическими. Final Реализованные методы в абстрактном классе могут быть статическими
    2014-03-09 04: 29: 24Z
  3. Опечатка это не Cunstructor .. Его конструктор ..
    2014-07-18 10: 57: 20Z
  4. Элемент интерфейса должен быть статическим финальным. Последнее утверждение неверно.
    2014-08-05 08: 21: 12Z
  5. Какой здесь целевой язык программирования? C #?
    2016-11-20 14: 26: 32Z

Объяснение можно найти здесь: http://www.developer.com/lang/php/article.php/3604111/PHP-5-OOP-Interfaces-Abstract-Classes-and-the-Adapter -Pattern.htm р>

  

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

     

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

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

    
78
2009-12-16 08: 24: 10Z
  1. Это самый правильный ответ,поскольку интерфейсы PHP отличаются от других языков тем, что интерфейсы PHP являются абстрактными классами, а интерфейсы других языков являются сигнатурами, которым должны соответствовать классы. Они ведут себя так же, пока нет ошибок.
    2009-12-16 08: 55: 05Z
  2. Правда, для PHP это действительно лучший ответ. Но из текстового блоба получить труднее, чем из простого фрагмента.
    2009-12-16 12: 15: 34Z
  3. Из предоставленных вами определений они выглядят одинаково, за исключением одной детали: интерфейс является на 100% абстрактным, тогда как абстрактный класс является частично абстрактным и может иметь некоторые реализации методов (возможно, все методы могут иметь реализации?).
    2014-08-23 04: 02: 05Z

Некоторые важные отличия:

В форме таблицы:

Разница

Как заявлено Джо из javapapers :

  

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

     

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

     

3.Члены Java-интерфейса по умолчанию общедоступны. Абстрактный класс Java может иметь обычные разновидности членов класса, такие как private,   защищены и т. д.

     

4.Java-интерфейс должен быть реализован с использованием ключевого слова «Implements»; Абстрактный класс Java должен быть расширен с помощью ключевого слова «extends».

     

5. Интерфейс может расширять только другой интерфейс Java, абстрактный класс может расширять другой класс Java и реализовывать несколько Java   интерфейсы.

     

6. Java-класс может реализовывать несколько интерфейсов, но он может расширять только один абстрактный класс.

     

7.Интерфейс абсолютно абстрактный и не может быть создан; Абстрактный класс Java также не может быть создан, но может быть вызван, если   main () существует.

     

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

    
38
2013-10-14 19: 53: 02Z
  1. Я отредактировал ваш ответ, чтобы обеспечить правильную атрибуцию. Вы не можете просто оставить ссылку внизу вашего ответа. Вы должны также процитировать весь язык, который был скопирован из другого источника. Кроме того, если эта таблица была взята откуда-то, вы должны четко указать, откуда она.
    2013-10-14 19: 54: 22Z
  2. Пожалуйста, укажите также и для C ++ ... хотя в C ++ нет ключевого слова "interface" как такового, но его также часто спрашивают в Qn regd C ++.
    2014-06-18 04: 52: 58Z
  3. @ cbinder: в c ++ нет ключевого слова 'interface'. Чтобы узнать разницу в c ++, см. 1. tutorialspoint.com/cplusplus/cpp_interfaces.htm 2. tutorialspoint.com/cplusplus/cpp_interfaces.htm
    2014-06-18 09: 34: 43Z
  4. @ MageshBabu Возможно, определение функции в классе, содержащем чисто виртуальную функцию, делает ее абстрактным классом, а не интерфейсом
    2014-06-19 09: 52: 09Z
  5. В Java 8 различия теперь меньше. Проверьте обновленные различия здесь: journaldev.com/1607 /... а>
    2014-07-15 17: 28: 26Z

Я не хочу выделять различия, о которых уже говорилось во многих ответах (в отношении общедоступных статических модификаторов final для переменных в интерфейсе и поддержки защищенных, закрытых методов в абстрактных классах)

Проще говоря, я хотел бы сказать:

интерфейс: реализовать контракт несколькими несвязанными объектами

абстрактный класс: для реализации одинакового или разного поведения среди нескольких связанных объектов

Из документации Oracle

Рассмотрите возможность использования абстрактных классов if:

  1. Вы хотите поделиться кодом между несколькими тесно связанными классами.
  2. Вы ожидаете, что классы, расширяющие ваш абстрактный класс, имеют много общих методов или полей или требуют модификаторов доступа, отличных от public (например, protected и private).
  3. Вы хотите объявить нестатические или не финальные поля.

рассмотрите возможность использования интерфейсов if:

  1. Вы ожидаете, что несвязанные классы будут реализовывать ваш интерфейс. Например, многие несвязанные объекты могут реализовать интерфейс Serializable.
  2. Вы хотите указать поведение определенного типа данных, но не беспокоитесь о том, кто реализует его поведение.
  3. Вы хотите воспользоваться множественным наследованием типа.

абстрактный класс устанавливает отношение «является» с конкретными классами. Интерфейс предоставляет возможность «имеет» для классов.

Если вы ищете Java в качестве языка программирования, вот еще несколько обновлений:

Java 8 в некоторой степени сократил разрыв между классами interface и abstract, предоставив функцию метода default. Интерфейс не имеет реализации для метода больше не является допустимым.

Обратитесь к этой документации страницу для получения дополнительной информации.

Посмотрите на этот вопрос SE, чтобы примеры кода были лучше понятны.

Как мне объяснить разницу между интерфейсом и абстрактным классом?

    
37
2017-05-23 12: 34: 53Z

Суть в том, что:

  • Аннотация является объектно-ориентированной . Он предлагает основные данные, которые должен иметь «объект», и /или функции, которые он должен выполнять. Он касается основных характеристик объекта: что у него есть и что он может сделать. Следовательно, объекты, которые наследуются от одного и того же абстрактного класса, имеют общие характеристики (обобщение).
  • Интерфейс ориентирован на функциональность . Он определяет функциональные возможности, которые должен иметь объект. Независимо от того, что это за объект, пока он может выполнять эти функции, которые определены в интерфейсе, это нормально. Это игнорирует все остальное. Объект /класс может содержать несколько (групп) функциональных возможностей; следовательно, класс может реализовать несколько интерфейсов.
29
2016-06-30 17: 48: 12Z
  1. Спасибо, теперь мы получаем что-то с хорошим ответом высокого уровня. Забавно, насколько глубоко в комментарии вы должны зайти, чтобы найти более понятный ответ.
    2017-01-16 22: 51: 02Z
  2. Другие ответы слишком технические. Это приближается к тому, что я считаю «правильным» ответом. Весь смысл ООП заключается в семантике, и то, являются ли открытые методы получения закрытыми вложенными классами посредством дорогостоящих поисков ЦП, здесь в значительной степени не имеет значения
    2017-03-06 21: 41: 22Z

Я строю здание из 300 этажей

План здания интерфейс

  • Например, сервлет (I)

Здание построено до 200 этажей - частично завершено --- аннотация

  • Частичная реализация, например, универсальный и HTTP-сервлет

Строительство здания завершено - бетон

  • Полная реализация, например, собственного сервлета

Интерфейс

  • Мы ничего не знаем о реализации, только требования. Мы можем перейти на интерфейс.
  • По умолчанию каждый метод является публичным и абстрактным
  • Это 100% чистый абстрактный класс
  • Если мы объявляем открытый, мы не можем объявить закрытый и защищенный
  • Если мы объявляем абстрактный, мы не можем объявить final, static, synchronized, strictfp и native
  • У каждого интерфейса есть public, static и final
  • Сериализация и переходные процессы не применимы, потому что мы не можем создать экземпляр для в интерфейсе
  • Энергонезависимый, потому что он окончательный
  • Каждая переменная является статической
  • Когда мы объявляем переменную внутри интерфейса, нам нужно инициализировать переменные при объявлении
  • Экземпляр и статический блок запрещены

Абстрактный р>

  • Частичная реализация
  • У него есть абстрактный метод. Кроме того, он использует бетон
  • Нет ограничений для модификаторов методов абстрактного класса
  • Нет ограничений для модификаторов переменных абстрактного класса
  • Мы не можем объявить другие модификаторы, кроме абстрактных
  • Нет ограничений на инициализацию переменных

Взято с сайта DurgaJobs

    
24
2018-04-01 09: 35: 05Z
  1. Абстрактный класс может иметь конструктор
    2017-07-26 08: 33: 32Z
  2. Я полностью не согласен с этим мнением. План представляет собой совершенно другую концепцию «интерфейса». План больше похож на статическую модель или спецификацию проекта для конкретной реализации. Он ближе к «классу», так как проект может быть создан несколько раз через его конструктор, но даже это не достаточно близко, так как «класс» также содержит спецификацию того, как построить (ctor), и средства для выполнения так. Интерфейс как концепция предназначен для представления некоторого поведения, такого как нагрев /охлаждение, которое может применяться к различным вещам, например, к зданиям, печам и т. Д.
    2017-09-18 07: 48: 39Z

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

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

    
23
2016-11-20 14: 21: 38Z

Давайте снова поработаем над этим вопросом:

Первое, что вам нужно знать, это то, что 1/1 и 1 * 1 дают одинаковые результаты, но это не значит, что умножение и деление одинаковы. Очевидно, у них хорошие отношения, но учтите, что вы оба разные.

Я укажу на основные отличия, а остальное уже объяснили:

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

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

    
18
2016-11-20 14: 18: 24Z
  1. Хороший ответ, но математическая метафора бесполезна и заставляет меня тратить примерно эквивалентное количество времени на ее чтение при написании этогокомментарий. Теперь умножьте это на всех остальных людей, которые читали этот вопрос.
    2017-01-16 22: 49: 23Z
  2. "математическая метафора бесполезна", почему вы так думаете?
    2017-03-16 17: 01: 47Z

Это довольно просто на самом деле.

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

Таким образом, интерфейс может только "объявлять" и не определять поведение, которое должен иметь класс.

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

А обычный класс позволяет вам только определять, а не объявлять поведение /действия, которые должен иметь класс.

Последнее,

В Java вы можете реализовать несколько интерфейсов, но вы можете расширить только один (абстрактный класс или класс) ...

Это означает, что наследование определенного поведения ограничено разрешением только одного для класса ... т. е. если вы хотите, чтобы класс, инкапсулирующий поведение из классов A, B и C, вам нужно было бы сделать следующее: класс A расширяет B, класс C расширяет A ... это немного о способе множественного наследования ...

Интерфейсы, с другой стороны, вы могли бы просто сделать: интерфейс C реализует A, B

Таким образом, по сути, Java поддерживает множественное наследование только в «объявленном поведении», то есть в интерфейсах, и только одиночное наследование с определенным поведением ... если только вы не выполните описанный мной способ ...

Надеюсь, это имеет смысл.

    
12
2017-03-17 22: 31: 14Z

Неверное сравнение интерфейса с абстрактным классом. Вместо этого должно быть два других сравнения: 1) интерфейс против класса и 2) абстрактный и окончательный класс .

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

Интерфейс - это контракт между двумя объектами. Например, я почтальон, а ты посылка для доставки. Я ожидаю, что вы знаете свой адрес доставки. Когда кто-то дает мне посылку, он должен знать ее адрес доставки:

 
interface Package {
  String address();
}

Класс - это группа объектов, которые подчиняются договору. Например, я ящик из группы "Ящик" и подчиняюсь договору, требуемому Почтальоном. В то же время я подчиняюсь другим контрактам:

 
class Box implements Package, Property {
  @Override
  String address() {
    return "5th Street, New York, NY";
  }
  @Override
  Human owner() {
    // this method is part of another contract
  }
}

Аннотация против финала

Абстрактный класс - это группа незавершенных объектов. Их нельзя использовать, потому что они пропускают некоторые части. Например, я являюсь абстрактной коробкой, поддерживающей GPS - я знаю, как проверить свое положение на карте:

 
abstract class GpsBox implements Package {
  @Override
  public abstract String address();
  protected Coordinates whereAmI() {
    // connect to GPS and return my current position
  }
}

Этот класс, если он унаследован /расширен другим классом, может быть очень полезным. Но само по себе - это бесполезно, так как не может иметь объектов. Абстрактные классы могут быть элементами построения конечных классов.

Final class - это группа законченных объектов, которые можно использовать, но нельзя изменить. Они точно знают, как работать и что делать. Например, я ящик, который всегда идет по адресу, указанному при его создании:

 
final class DirectBox implements Package {
  private final String to;
  public DirectBox(String addr) {
    this.to = addr;
  }
  @Override
  public String address() {
    return this.to;
  }
}

В большинстве языков, таких как Java или C ++, просто класс может быть ни абстрактным, ни окончательным. Такой класс может быть унаследован и может быть создан. Я не думаю, что это строго соответствует объектно-ориентированной парадигме.

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

    
11
2014-07-24 21: 57: 49Z

Разница лишь в том, что один может участвовать в множественном наследовании, а другой - нет.

Определение интерфейса со временем изменилось. Как вы думаете, интерфейс имеет только объявления методов и является просто контрактами? А как насчет статических конечных переменных и определений по умолчанию после Java 8?

Интерфейсы были введены в Java из-за проблемы с алмазом с множественным наследованием, и это что они на самом деле намерены сделать.

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

См. Почему Java допускает статические конечные переменные в интерфейсах, когда они предназначены только для контрактов? .

    
8
2016-12-05 16: 44: 22Z
  1. Хотя это важное отличие, это не единственное отличие.
    2019-02-07 20: 38: 36Z

Вкратце различия следующие:

Синтаксические различия между интерфейсом и абстрактным классом :

  1. Методы и члены абстрактного класса могут иметь любую видимость. Все методы интерфейса должны быть общедоступными . //Больше не выполняется в Java 9
  2. Конкретный дочерний класс класса Abstract должен определять все абстрактные методы. У дочернего класса Abstract могут быть абстрактные методы. интерфейс , расширяющий другой интерфейс, не должен обеспечивать реализацию по умолчанию для методов, унаследованных от родительского интерфейса.
  3. Дочерний класс может расширять только один класс. интерфейс может расширять несколько интерфейсов. Класс может реализовывать несколько интерфейсов.
  4. Дочерний класс может определять абстрактные методы с такой же или менее ограничительной видимостью, тогда как класс, реализующий интерфейс , должен определять все методы интерфейса как общедоступные.
  5. Абстрактные классы могут иметь конструкторы, но не интерфейсы .
  6. Интерфейсы из Java 9 имеют частные статические методы.

В интерфейсах сейчас:

public static - поддерживается
public abstract - поддерживается
public default - поддерживается
private static - поддерживается
private abstract - ошибка компиляции
private default - ошибка компиляции
private - поддерживается

    
8
2017-10-27 05: 18: 44Z

Интерфейс: поверните (поверните налево, поверните направо).

Абстрактный класс: Колесо.

Класс: рулевое колесо, происходит от колеса, показывает поворот интерфейса

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

    
7
2017-03-06 21: 46: 53Z

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

Следующие примеры демонстрируют это.

Абстрактный класс в Java:

 
abstract class animals
{
    // They all love to eat. So let's implement them for everybody
    void eat()
    {
        System.out.println("Eating...");
    }
    // The make different sounds. They will provide their own implementation.
    abstract void sound();
}

class dog extends animals
{
    void sound()
    {
        System.out.println("Woof Woof");
    }
}

class cat extends animals
{
    void sound()
    {
        System.out.println("Meoww");
    }
}

Ниже приведена реализация интерфейса в Java:

 
interface Shape
{
    void display();
    double area();
}

class Rectangle implements Shape 
{
    int length, width;
    Rectangle(int length, int width)
    {
        this.length = length;
        this.width = width;
    }
    @Override
    public void display() 
    {
        System.out.println("****\n* *\n* *\n****"); 
    }
    @Override
    public double area() 
    {
        return (double)(length*width);
    }
} 

class Circle implements Shape 
{
    double pi = 3.14;
    int radius;
    Circle(int radius)
    {
        this.radius = radius;
    }
    @Override
    public void display() 
    {
        System.out.println("O"); // :P
    }
    @Override
    public double area() 
    { 
        return (double)((pi*radius*radius)/2);
    }
}

Несколько важных ключевых моментов в двух словах:

  1. Переменные, объявленные в интерфейсе Java, по умолчанию являются окончательными. Абстрактные классы могут иметь неконечные переменные.

  2. Переменные, объявленные в интерфейсе Java, по умолчанию являются статическими. Абстрактные классы могут иметь нестатические переменные.

  3. Члены интерфейса Java по умолчанию являются публичными. Абстрактный класс Java может иметь обычные разновидности членов класса, такие как private, protected и т. Д.

6
2018-11-29 18: 17: 50Z

На самом деле это не ответ на исходный вопрос, но как только вы получите ответ на разницу между ними, вы введете дилемму «когда использовать»: Когда использовать интерфейсы или абстрактные классы? Когда использовать оба?

Я ограничил знание ООП, но видение интерфейсов как эквивалента прилагательного в грамматике до сих пор работало для меня (поправьте меня, если этот метод фальшивый!). Например, имена интерфейсов похожи на атрибуты или возможности, которые вы можете дать классу, и у класса может быть много из них: ISerializable, ICountable, IList, ICacheable, IHappy, ...

    
4
2017-05-23 12: 02: 57Z

Наследование используется для двух целей:

  • Разрешить объекту рассматривать элементы данных родительского типа и реализации методов как свои собственные.

  • Разрешить использование ссылки на объекты одного типа кодом, который ожидает ссылку на объект супертипа.

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

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

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

    
3
2013-09-03 16: 09: 55Z

Ключевые моменты:

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

Преимущество:

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

найти подробности здесь ... http: //pradeepatkari.wordpress. ком /2014/11/20 /интерфейс-и-абстрактный класс-в-с-ой / р>     

3
2014-12-05 10: 00: 14Z

Самый короткий способ подвести итог: interface:

  1. Полностью абстрактный, кроме методов default и static; хотя он имеет определения (сигнатуры методов + реализации) для методов default и static, он имеет только объявления (сигнатуры методов) для других методов.
  2. тематический списокБолее слабые правила, чем классы (класс может реализовывать несколько interface с, а interface может наследоваться от нескольких interface с). Все переменные неявно постоянны, независимо от того, указано ли оно как public static final или нет. Все члены неявно public, независимо от того, указаны они как таковые или нет.
  3. Обычно используется как гарантия того, что реализующий класс будет иметь указанные функции и /или будет совместим с любым другим классом, который реализует тот же интерфейс.

Между тем, класс abstract:

  1. В любом месте, от полностью абстрактного до полностью реализованного, с тенденцией иметь один или несколько abstract методов. Может содержать как объявления, так и определения, причем объявления помечены как abstract.
  2. Полноценный класс и подчиняется правилам, которые управляют другими классами (может наследоваться только от одного класса), при условии, что он не может быть создан (поскольку нет гарантии, что он полностью реализован). Может иметь непостоянные переменные-члены. Может реализовывать управление доступом членов, ограничивая участников как protected, private или закрытый пакет (не указан).
  3. Обычно используется, чтобы предоставить столько реализации, сколько может совместно использовать несколько подклассов, либо предоставить столько реализации, сколько может предоставить программист.

Или, если мы хотим свести все это к одному предложению: interface - это то, что реализующий класс имеет , а abstract - это то, что подкласс является . р>     

3
2016-01-28 21: 58: 45Z

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

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

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

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

Чтобы прочитать подробно, посетите разница между абстрактным классом и интерфейсом

    
3
2016-06-30 16: 27: 45Z

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

    
3
2016-12-15 17: 47: 09Z

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

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

    
3
2017-06-28 10: 49: 48Z
  1. Поскольку вы ответили на него только что, ваш ответ не учитывает ключевое слово default в Java 8, с помощью которого вы также можете определять конкретные методы в интерфейсах.
    2017-06-28 11: 19: 58Z
  2. Как я уже сказал, это должен был быть «простой, но ясный ответ» для кого-то на этапе изучения того, в чем разница. Для кого-то подобного это не полезно знать об такого рода исключениях, это только очень сбивает с толку.
    2019-02-12 11:30:49Z

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

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

Некоторые другие случаи использования интерфейса.

Связь между двумя внешними объектами (сторонняя интеграция в нашем приложении) осуществляется через интерфейс , здесь интерфейс работает как договор.

Abstract Class: Abstract, это ключевое слово, и когда мы используем это ключевое слово перед любым классом, оно становится абстрактным классом. В основном оно используется, когда нам нужно определить шаблон, а также некоторые значения по умолчанию. функциональность объекта, за которым следуют все подклассы, и таким образом он удаляет избыточный код и еще один случай использования, когда мы можем использовать абстрактный класс , например, мы не хотим, чтобы другие классы могли напрямую создавать экземпляры объект класса, только производные классы могут использовать функциональность.

Пример абстрактного класса:

 
 public abstract class DesireCar
  {

 //It is an abstract method that defines the prototype.
     public abstract void Color();

  // It is a default implementation of a Wheel method as all the desire cars have the same no. of wheels.   
 // and hence no need to define this in all the sub classes in this way it saves the code duplicasy     

  public void Wheel() {          

               Console.WriteLine("Car has four wheel");
                }
           }


    **Here is the sub classes:**

     public class DesireCar1 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red color Desire car");
            }
        }

        public class DesireCar2 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red white Desire car");
            }
        }

Пример интерфейса:

 
  public interface IShape
        {
          // Defines the prototype(template) 
            void Draw();
        }


  // All the sub classes follow the same template but implementation can be different.

    public class Circle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Circle");
        }
    }

    public class Rectangle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Rectangle");
        }
    }
    
3
2017-08-18 05: 56: 01Z

Вы можете найти четкую разницу между интерфейсом и абстрактным классом.

Интерфейс

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

Абстрактный класс

  • Абстрактный класс содержит абстрактные и неабстрактные методы.

  • Не заставляет пользователей реализовывать все методы при наследовании абстрактный класс.

  • Содержит все виды переменных, включая примитивные и не примитивные

  • Объявление с использованием абстрактного ключевого слова.

  • Методы и члены абстрактного класса могут быть определены с любым видимость.

  • Дочерний класс может расширять только один класс (абстрактный или конкретный).

3
2017-08-24 14: 05: 09Z

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

Интерфейсы и абстрактные классы, хотя и кажутся с технической точки зрения схожими, имеют совершенно разные значения и цели.

Резюме

  1. Интерфейс определяет контракт , который некоторая реализация выполнит для вас .

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

Альтернативная сводка

  1. Интерфейс предназначен для определения общедоступных API
  2. Абстрактный класс предназначен для внутреннего использования и для определения SPI

О важности сокрытия деталей реализации

Конкретный класс выполняет реальную работу очень специфическим образом. Например, ArrayList использует непрерывную область памяти для компактного хранения списка объектов, который предлагает быстрый произвольный доступ, итерации и изменения на месте, но ужасен при вставках, удалениях и иногда даже добавлениях; Между тем, LinkedList использует двойные узлы для хранения списка объектов, которыйead предлагает быструю итерацию, изменения на месте и вставку /удаление /добавление, но ужасен при произвольном доступе. Эти два типа списков оптимизированы для разных вариантов использования, и очень важно, как вы собираетесь их использовать. Когда вы пытаетесь выжать производительность из списка, с которым вы интенсивно взаимодействуете, и когда выбор типа списка зависит от вас, вы должны тщательно выбрать, какой экземпляр вы создаете.

С другой стороны, пользователям высокого уровня списка на самом деле все равно, как он реализован на самом деле, и они должны быть изолированы от этих деталей. Давайте представим, что Java не предоставляла интерфейс List, а имела только конкретный класс List, который на самом деле и есть LinkedList прямо сейчас. Все Java-разработчики адаптировали бы свой код к деталям реализации: избегайте произвольного доступа, добавьте кэш для ускорения доступа или просто переопределите ArrayList самостоятельно, хотя это было бы несовместимо со всем другим кодом, который фактически работает только с List , Это было бы ужасно ... Но теперь представьте, что мастера Java на самом деле понимают, что связанный список ужасен для большинства реальных случаев использования, и решили переключиться на список массивов для своего единственного доступного класса List. Это повлияет на производительность каждой Java-программы в мире, и люди не будут этому рады. И главный виновник в том, что детали реализации были доступны, и разработчики предположили, что эти детали являются постоянным контрактом, на который они могут положиться. Вот почему важно скрывать детали реализации и определять только абстрактный контракт. Это цель интерфейса: определить, какие входные данные принимает метод и какой ожидаемый результат, не подвергая всех смелости, которая побудит программистов настроить свой код, чтобы соответствовать внутренним деталям, которые могут измениться при любом будущем обновлении . р>

Абстрактный класс находится посередине между интерфейсами и конкретными классами. Предполагается, что реализации помогают использовать общий или скучный код. Например, AbstractCollection предоставляет базовые реализации для isEmpty на основе размера, равного 0, contains в качестве итерации и сравнения, addAll в качестве повторного add и так далее. Это позволяет реализациям сосредоточиться на важнейших частях, которые различают их: как на самом деле хранить и извлекать данные.

API против SPI

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

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

Разница между API и SPI незначительна, но важна: для API основное внимание уделяется тому, кто его использует , а для SPI основное внимание уделяется тому, кто реализует это.

Добавить методы в API легко, все существующие пользователи API все равно будут компилироваться. Добавить методы в SPI сложно, поскольку каждый поставщик услуг (конкретная реализация) должен будет внедрить новые методы. Если для определения SPI используются интерфейсы, поставщик должен будет выпускать новую версию при каждом изменении контракта SPI. Если вместо этого используются абстрактные классы, новые методы могут быть определены либо в терминах существующих абстрактных методов, либо в виде пустых заглушек throw not implemented exception, что по крайней мере позволит более старой версии реализации службы по-прежнему компилироваться и запускаться.

Примечание по Java 8 и методам по умолчанию

Хотя в Java 8 были введены методы по умолчанию для интерфейсов, что делает грань между интерфейсами и абстрактными классами еще более размытой, это было сделано не для того, чтобы реализации могли повторно использовать код, а чтобы было проще изменять интерфейсы, которые служат как API, так и как SPI (или неправильно используются для определения SPI вместо абстрактных классов).

Какой использовать?

  1. Предполагается, что вещь публично используется в других частях кода или в другом внешнем коде? Добавьте интерфейс, чтобы скрыть подробности реализации от публичного абстрактного контракта, который является общим поведением вещи.
  2. Является ли вещь чем-то, что должно иметь несколько реализаций с большим количеством общего кода? Сделайте и интерфейс и абстрактную, неполную реализацию.
  3. Будет ли когда-нибудь только одна реализация, и никто другой не будет ее использовать? Просто сделайте это конкретным классом.
    1. "когда-либо"долгое время вы могли бы поиграть в это безопасно и все равно добавить интерфейс поверх него.

Следствие: обратное часто делается неправильно: при использовании вещь всегда старайтесь использовать самый универсальный класс /интерфейс, который вам действительно нужен. Другими словами, не объявляйте ваши переменные как ArrayList theList = new ArrayList(), если только у вас на самом деле нет сильной зависимости от того, что он является списком array , и никакие другие типы списков не обрезают его для вас. Вместо этого используйте List theList = new ArrayList или даже Collection theCollection = new ArrayList, если факт, что это список, а не какой-либо другой тип коллекции, на самом деле не имеет значения.

    
2
2016-06-19 09: 02: 34Z

Абстрактный класс - это класс, объект которого не может быть создан, или класс, который не может быть создан. Абстрактный метод делает класс абстрактным. Абстрактный класс должен быть унаследован, чтобы переопределить методы, объявленные в абстрактном классе. Нет ограничений на спецификаторы доступа. Абстрактный класс может содержать конструктор и другие конкретные (не abstarct методы) методы, но интерфейс не может иметь.

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

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

    
2
2016-09-20 19: 19: 45Z

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

Но в абстрактном классе должен быть абстрактный метод только с определением, но другие методы также могут быть в абстрактном классе с реализацией ...

    
1
2016-11-20 14: 25: 09Z

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

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

Интерфейс

имеет широкий спектр абстракций, а не абстрактный класс. Вы можете увидеть это в передаче аргументов. посмотрите этот пример:

 введите описание изображения здесь

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

    
1
2018-10-29 07: 11: 53Z

Простое, но эффективное объяснение абстрактного класса и интерфейса на php.net :

  

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

     

Интерфейс - это всегда соглашение или обещание. Когда класс говорит: «Я реализую интерфейс Y», он говорит: «Я обещаю иметь те же общедоступные методы, которые есть у любого объекта с интерфейсом Y».

     

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

     

Абстрактный класс является основой для другого объекта. Когда класс говорит «Я расширяю абстрактный класс Y», он говорит: «Я использую некоторые методы или свойства, уже определенные в этом другом классе с именем Y».

     

Итак, рассмотрим следующий PHP:

 
<?php
class X implements Y { } // this is saying that "X" agrees to speak language "Y" with your code.

class X extends Y { } // this is saying that "X" is going to complete the partial class "Y".
?>
     

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

     

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

     

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

    
1
2018-12-07 07: 03: 58Z
источник размещен Вот