Реализует vs extends: Когда использовать? Какая разница?

Пожалуйста, объясните в удобном для понимания языке или ссылке на какую-то статью.

extends – это расширение classа.

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

Разница между интерфейсом и обычным classом заключается в том, что в интерфейсе вы не можете реализовать ни один из объявленных методов. Только class, который «реализует» интерфейс, может реализовать методы. С ++ эквивалент интерфейса был бы абстрактным classом (не ТОЧНО, тем не менее, но в значительной степени).

Также java не поддерживает множественное наследование для classов. Это решается с помощью нескольких интерфейсов.

  public interface ExampleInterface { public void doAction(); public String doThis(int number); } public class sub implements ExampleInterface { public void doAction() { //specify what must happen } public String doThis(int number) { //specfiy what must happen } } 

теперь расширяя class

  public class SuperClass { public int getNb() { //specify what must happen return 1; } public int getNb2() { //specify what must happen return 2; } } public class SubClass extends SuperClass { //you can override the implementation @Override public int getNb2() { return 3; } } 

в этом случае

  Subclass s = new SubClass(); s.getNb(); //returns 1 s.getNb2(); //returns 3 SuperClass sup = new SuperClass(); sup.getNb(); //returns 1 sup.getNb2(); //returns 2 

Я предлагаю вам сделать еще несколько исследований динамического связывания, polymorphismа и общего наследования в объектно-ориентированном программировании

Я замечаю, что у вас есть некоторые вопросы на C ++ в вашем профиле. Если вы понимаете концепцию множественного наследования от C ++ (ссылаясь на classы, которые наследуют характеристики от более чем одного другого classа), Java не позволяет этого, но у него есть interface ключевых слов, который похож на чистый виртуальный class в C ++ , Как упоминалось многими людьми, вы extend class (и можете только от одного), и вы implement интерфейс, но ваш class может реализовать столько интерфейсов, сколько вам захочется.

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

extends – это когда вы наследуете базовый class (т.е. расширяете его функциональность).

implements когда вы реализуете интерфейс .

Вот хорошее место для начала: Интерфейсы и Наследование .

class может только «реализовать» interface . Класс только «расширяет» class . Аналогично, interface может расширять другой interface .

class может распространять только один class . class может реализовывать несколько interface .

Если вместо этого вы больше заинтересованы в том, чтобы знать, когда использовать abstract class es и interface s, обратитесь к этому streamу: Interface vs Abstract Class (общий OO)

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

extends : производный class может распространять базовый class. Вы можете переопределить поведение установленного отношения. Производный class ” – это тип базового classа

реализует : вы выполняете контракт. Класс, реализующий интерфейс, имеет «возможность».

С выпуском java 8 интерфейс может иметь методы по умолчанию в интерфейсе, который обеспечивает реализацию в самом интерфейсе.

Обратитесь к этому вопросу за тем, когда использовать каждый из них:

Интерфейс против абстрактного classа (общий OO)

Пример для понимания вещей.

 public class ExtendsAndImplementsDemo{ public static void main(String args[]){ Dog dog = new Dog("Tiger",16); Cat cat = new Cat("July",20); System.out.println("Dog:"+dog); System.out.println("Cat:"+cat); dog.remember(); dog.protectOwner(); Learn dl = dog; dl.learn(); cat.remember(); cat.protectOwner(); Climb c = cat; c.climb(); Man man = new Man("Ravindra",40); System.out.println(man); Climb cm = man; cm.climb(); Think t = man; t.think(); Learn l = man; l.learn(); Apply a = man; a.apply(); } } abstract class Animal{ String name; int lifeExpentency; public Animal(String name,int lifeExpentency ){ this.name = name; this.lifeExpentency=lifeExpentency; } public void remember(){ System.out.println("Define your own remember"); } public void protectOwner(){ System.out.println("Define your own protectOwner"); } public String toString(){ return this.getClass().getSimpleName()+":"+name+":"+lifeExpentency; } } class Dog extends Animal implements Learn{ public Dog(String name,int age){ super(name,age); } public void remember(){ System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes"); } public void protectOwner(){ System.out.println(this.getClass().getSimpleName()+ " will protect owner"); } public void learn(){ System.out.println(this.getClass().getSimpleName()+ " can learn:"); } } class Cat extends Animal implements Climb { public Cat(String name,int age){ super(name,age); } public void remember(){ System.out.println(this.getClass().getSimpleName() + " can remember for 16 hours"); } public void protectOwner(){ System.out.println(this.getClass().getSimpleName()+ " won't protect owner"); } public void climb(){ System.out.println(this.getClass().getSimpleName()+ " can climb"); } } interface Climb{ public void climb(); } interface Think { public void think(); } interface Learn { public void learn(); } interface Apply{ public void apply(); } class Man implements Think,Learn,Apply,Climb{ String name; int age; public Man(String name,int age){ this.name = name; this.age = age; } public void think(){ System.out.println("I can think:"+this.getClass().getSimpleName()); } public void learn(){ System.out.println("I can learn:"+this.getClass().getSimpleName()); } public void apply(){ System.out.println("I can apply:"+this.getClass().getSimpleName()); } public void climb(){ System.out.println("I can climb:"+this.getClass().getSimpleName()); } public String toString(){ return "Man :"+name+":Age:"+age; } } 

вывод:

 Dog:Dog:Tiger:16 Cat:Cat:July:20 Dog can remember for 5 minutes Dog will protect owner Dog can learn: Cat can remember for 16 hours Cat won't protect owner Cat can climb Man :Ravindra:Age:40 I can climb:Man I can think:Man I can learn:Man I can apply:Man 

Важные моменты для понимания:

  1. Собака и кошка – животные, и они увеличили remember () и protectOwner (), разделив name,lifeExpentency от Animal
  2. Кошка может подняться (), но собака этого не делает. Собака может думать (), но Кота нет . Эти специфические возможности добавляются к Cat и Dog , реализуя эту возможность.
  3. Человек не животное, но он может Think,Learn,Apply,Climb

Пройдя эти примеры, вы можете понять, что

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

Интерфейс – это описание действий, которые может выполнять объект … например, когда вы переворачиваете переключатель освещения, свет загорается, вам все равно, как это делается. В объектно-ориентированном программировании интерфейс представляет собой описание всех функций, которые должен иметь объект для того, чтобы быть «X». Опять же, в качестве примера, все, что «ACTS LIKE» светло, должно иметь метод turn_on () и метод turn_off (). objective интерфейсов – позволить компьютеру обеспечивать соблюдение этих свойств и знать, что объект TYPE T (независимо от интерфейса) должен иметь функции, называемые X, Y, Z и т. Д.

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

  • A расширяет B:

    A и B – оба classа или оба интерфейса

  • A реализует B

    A – class, а B – интерфейс

  • Оставшийся случай, когда A является интерфейсом, а B – class, не является законным в Java.

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

Реализации : используется для реализации интерфейса (родительский class с сигнатурами функций, но не их определениями), определяя его в дочернем classе.

Существует одно особое условие: «Что, если я хочу, чтобы новый интерфейс был дочерним элементом существующего интерфейса?». В вышеуказанном условии дочерний интерфейс расширяет родительский интерфейс.

Реализаторы используются для интерфейсов, а extends используется для расширения classа.

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

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

Еще несколько примечаний:

интерфейс может расширить другой интерфейс.

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

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

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

Но когда мы расширяем что-либо, оно становится продолжением вашего classа. Вы можете изменить его, использовать его, использовать его повторно, и не обязательно возвращать те же значения, что и в суперclassе.

Оба ключевых слова используются при создании собственного нового classа на языке Java.

Разница: implements означает, что вы используете элементы интерфейса Java в своем classе. extends означает, что вы создаете подclass базового classа, который вы расширяете. Вы можете расширить только один class в своем дочернем classе, но вы можете реализовать столько интерфейсов, сколько хотите.

Для получения дополнительной информации см. Страницу документации oracle на интерфейсе .

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

В самых простых терминах extends используется для наследования classа, а утилиты используются для применения интерфейса в вашем classе

расширяет :

 public class Bicycle { //properties and methods } public class MountainBike extends Bicycle { //new properties and methods } 

реализует :

 public interface Relatable { //stuff you want to put } public class RectanglePlus implements Relatable { //your class code } 

если у вас все еще есть путаница, прочтите следующее: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html https://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html

Мы используем SubClass, который расширяет SuperClass только тогда, когда подclass хочет использовать некоторую функциональность (методы или переменные экземпляра), которая уже объявлена ​​в SuperClass , или если я хочу немного изменить функциональность SuperClass (переопределение метода). Но скажем, например, у меня есть class Animal ( SuperClass ) и class Dog ( SubClass ), и есть несколько методов, которые я определил в classе Animal, например. doEat (); , doSleep (); … и многое другое.

Теперь мой class Dog может просто расширить class Animal, если я хочу, чтобы моя собака использовала любой из методов, объявленных в classе Animal, я могу вызвать эти методы, просто создав объект Dog. Таким образом, я могу гарантировать, что у меня есть собака, которая может есть и спать, и делать все, что я хочу, чтобы собака сделала.

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

Но, скажем, кто-то пытается создать объект classа Animal. Вы можете сказать, как кошка спит, вы можете сказать, как собака ест, вы можете сказать, как пьет слон. Но это не имеет никакого смысла в создании объекта classа Animal. Потому что это шаблон, и мы не хотим никакого общего приема пищи.

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

Таким образом, интерфейс – это не что иное, как абстрактный class (чистый абстрактный class), который не содержит реализаций методов, а только определений (шаблонов). Итак, кто бы ни реализовал интерфейс, просто знает, что у них есть шаблоны doEat (); и doSleep (); но они должны определить свой собственный doEat (); и doSleep (); методов в соответствии с их потребностями.

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

Я поделюсь с вами fragmentом кода: вы попробуете его с различными наборами входов и посмотрите на результаты.

 class AnimalClass { public void doEat() { System.out.println("Animal Eating..."); } public void sleep() { System.out.println("Animal Sleeping..."); } } public class Dog extends AnimalClass implements AnimalInterface, Herbi{ public static void main(String[] args) { AnimalInterface a = new Dog(); Dog obj = new Dog(); obj.doEat(); a.eating(); obj.eating(); obj.herbiEating(); } public void doEat() { System.out.println("Dog eating..."); } @Override public void eating() { System.out.println("Eating through an interface..."); // TODO Auto-generated method stub } @Override public void herbiEating() { System.out.println("Herbi eating through an interface..."); // TODO Auto-generated method stub } } 

Определенные интерфейсы :

 public interface AnimalInterface { public void eating(); } interface Herbi { public void herbiEating(); } 

Как показано на рисунке ниже, class расширяет другой class, интерфейс расширяет другой интерфейс, но class реализует интерфейс. введите описание изображения здесь

Для получения дополнительной информации

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

Пример:

  1. Расширяет использование classа

    class Parent {

    }

    class Child extends Parent {

    }

  2. Расширяет использование интерфейса

    интерфейс Parent {

    }

    интерфейс Child extends Parent {

    }

  3. инвентарь

интерфейс A {

}

class B реализует A {

}

Сочетание расширений и орудий

 interface A{ } class B { } class C implements A,extends B{ } 
Interesting Posts
Давайте будем гением компьютера.