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



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

15   578  

15 ответов:

extends на расширения класс.

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

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

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

 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
     }
 }

теперь расширение класса

 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

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

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

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

extends Это когда вы наследуете от базовый класс (т. е. расширение его функциональных возможностей).

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

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

A class может только "реализовать" an interface. Класс только "расширяет" a class. Аналогично,interface может быть продлен еще на interface.

A class может только продлить один другой class. А class может реализовать несколько interfaces.

если вместо этого вы больше заинтересованы в том, чтобы знать, когда использовать abstract classи interfaces, обратитесь к этой теме:интерфейс против абстрактного класса (общий OO)

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

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

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

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

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

интерфейс против абстрактного класса (общий 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

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

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

интерфейс-это описание действий, которые может выполнять объект... например, когда вы щелкаете выключателем, свет загорается, вам все равно, как, просто что он делает. В объектно-ориентированном программировании интерфейс-это описание всех функций, которые должен иметь объект, чтобы быть "X". Опять же, в качестве примера, все, что "действует как" свет, должно иметь метод turn_on() и метод turn_off (). Цель интерфейсов-позволить компьютеру применять эти свойства и чтобы знать, что объект типа T (независимо от интерфейса ) должен иметь функции,называемые X,Y, Z и т. д.

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

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

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

есть одно особое условие: "что делать, если я хочу, чтобы новый интерфейс был дочерний элемент существующего интерфейса?". В приведенном выше условии дочерний интерфейс extends Родительский интерфейс.

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

    A и B - оба класса или оба интерфейса

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

    a-это класс, А B-интерфейс

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

Implements используется для интерфейсов и extends используется для расширения класса.

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

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

еще несколько замечаний:

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

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

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

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

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

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

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

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

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

в самых простых терминах выходит используется для наследования от класс и осуществляет используется для применения интерфейс в свой класс

выходит:

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

мы используем:подкласс выходит суперкласса только когда подкласс хочет использовать некоторые функциональные возможности( методы или переменные экземпляра), которые уже объявлены в суперкласса, или если я хочу немного изменить функциональность суперкласса (переопределяющий метод). Но скажем, например у меня есть класс животных (суперкласса) и класс собаки (подкласс) и есть несколько методов, которые я определил в Класс животных, например. doEat ();,doSleep(); ... и многое другое.

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

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

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

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

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

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

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();

}

Как показано на рисунке ниже, класс расширяет другой класс, интерфейс расширяет другой интерфейс, но класс реализует интерфейс. enter image description here

дополнительные подробности

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

пример:

  1. расширяется с помощью класса

    родительский класс{

    }

    класс Child расширяет Parent{

    }

  2. распространяется через интерфейс

    Родительский интерфейс{

    }

    интерфейс Дочерний расширяет Родительский{

    }

  3. осуществляет

интерфейс{

}

класс B реализует{

}

сочетание extends и implements

interface A{

}

class B

{

}

class C implements A,extends B{

}

Comments

    No results found.