Implements vs extends: kiedy używać? Co za różnica?

Zauważyłem, że masz kilka pytań w C++ w swoim profilu. Jeśli rozumiesz pojęcie dziedziczenia wielokrotnego z C++ (odnoszące się do klas, które dziedziczą cechy z więcej niż jednej innej klasy), Java na to nie pozwala, ale ma słowo kluczowe interface, które jest czymś w rodzaju czystej wirtualnej klasy w C++. Jak wspomniano przez wielu ludzi, ty extend klasy (i można rozszerzyć tylko z jednego), a Ty implement interfejs -- ale twoja klasa może zaimplementować tyle interfejsów, ile lubisz.

Tzn. te słowa kluczowe i zasady ich użycia określają możliwości dziedziczenia Wielokrotnego w Javie (możesz mieć tylko jedną super klasę, ale możesz zaimplementować wiele interfejsów).

Ogólnie implementuje używane do implementacji interfejsu i rozszerza używane do rozszerzenia klasy bazowej lub klasy abstract .

Extends : klasa pochodna może rozszerzyć klasę bazową. Możesz przedefiniować zachowanie ustalonej relacji. Klasa pochodna "jest" typ klasy bazowej

Implements : realizujesz umowę. Klasa implementująca interfejs "ma" możliwości.

W wydaniu java 8 interfejs może mieć domyślne metody w interfejsie, co zapewnia implementację w samym interfejsie.

Patrz na to pytanie, Kiedy używać każdego z nich:

Interfejs vs klasa abstrakcyjna (ogólne OO)

Przykład do zrozumienia rzeczy.

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

Wyjście:

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

Ważne punkty do zrozumienia:

1. pies i Kot są zwierzętami i rozszerzyły remember () i protectOwner () dzieląc name,lifeExpentency z Animal
2. kot może się wspinać (), ale pies nie. Pies może myśleć (), ale kot nie. Te specyficzne możliwości są dodawane do Cat i Dog poprzez implementację tej zdolności.
3. człowiek nie jest zwierzęciem, ale może Think,Learn,Apply,Climb

niepowiązane klasy mogą mieć możliwości poprzez interfejs, ale powiązane klasy nadpisują zachowanie poprzez rozszerzenie klas bazowych.

extends jest dla gdy dziedziczysz z klasy bazowej (tj. rozszerzając jej funkcjonalność).

implements jest dla implementacji interfejsu .

Tutaj jest dobre miejsce, aby zacząć: interfejsy i dziedziczenie.

A class może tylko "zaimplementować" an interface. A class only "extends" a class. Podobnie, an interface może rozszerzyć inne interface.

A class może rozszerzyć tylko jedną inną class. A class może zaimplementować kilka interface s.

Jeśli zamiast tego jesteś bardziej zainteresowany tym, kiedy używać abstract class es i interfaces, zapoznaj się z tym wątkiem: Interface vs Abstract Class (general oo)

Interfejs jest opisem działań, które obiekt może wykonać... na przykład, kiedy przełączysz przełącznik światła, światło się włącza, nie obchodzi cię jak, tylko to robi. W programowaniu obiektowym interfejs jest opisem wszystkich funkcji, które obiekt musi posiadać, aby być "X". Ponownie, jako przykład, wszystko, co "działa jak" światło, powinno mieć metodę turn_on() i metodę turn_off (). Celem interfejsów jest umożliwienie komputerowi wymuszenia tych właściwości i wiedzieć, że obiekt typu T (niezależnie od interfejsu) musi posiadać funkcje o nazwie X, Y, Z, itd.

Interfejs jest strukturą/składnią programowania, która pozwala komputerowi na wymuszenie pewnych właściwości na obiekcie (klasie). Na przykład, powiedzmy, że mamy klasę samochodu, klasę skutera i klasę Ciężarówki. Każda z tych trzech klas powinna mieć akcję start_engine (). Jak "silnik jest uruchamiany" dla każdego pojazdu jest pozostawione do każdej klasy, ale fakt, że muszą one mieć akcja start_engine jest domeną interfejsu .

Jak pokazano na rysunku poniżej, Klasa rozszerza inną klasę, interfejs rozszerza inny interfejs, ale klasa implementuje interfejs.

Więcej szczegóły

Extends : jest to używane do pobierania atrybutów klasy nadrzędnej do klasy bazowej i może zawierać już zdefiniowane metody, które mogą być nadpisane w klasie podrzędnej.

Narzędzia : jest to używane do implementacji interfejsu (klasy nadrzędnej z tylko podpisami funkcji, ale nie ich definicjami) poprzez zdefiniowanie go w klasie potomnej.

Jest jeden specjalny warunek: "co zrobić, jeśli chcę, aby nowy interfejs był potomkiem istniejącego interfejsu?". W powyższy warunek, interfejs potomny rozszerza interfejs rodzica.

Oba słowa kluczowe są używane podczas tworzenia własnej nowej klasy w języku Java.

Różnica: implements oznacza, że używasz elementów interfejsu Java w swojej klasie. extends oznacza, że tworzysz podklasę klasy bazowej, którą rozszerzasz. Możesz rozszerzyć tylko jedną klasę w klasie potomnej, ale możesz zaimplementować tyle interfejsów, ile chcesz.

• A rozszerza B:

  A i B to obie klasy lub oba interfejsy

• A B

  A jest klasą, A B interfejsem

• Pozostały przypadek, w którym A jest interfejsem, A B klasą, nie jest legalny w Javie.

Implements jest używany dla interfejsów, a extends jest używany do rozszerzenia klasy.

Żeby było jaśniej,interfejs jest jak dźwięk-interfejs-model, który trzeba zastosować,naśladować, wraz ze swoimi pomysłami do niego.

Extend jest używany dla klas,tutaj rozszerzasz coś, co już istnieje, dodając do niego więcej funkcjonalności.

Jeszcze kilka uwag:

Interfejs może rozszerzyć inny interfejs.

I kiedy trzeba wybrać pomiędzy implementacją interfejsu lub rozszerzeniem klasy dla określonego scenariusza, przejdź do implementacji interfejsu. Ponieważ klasa może zaimplementować wiele interfejsów, ale rozszerzyć tylko jedną klasę.

W najprostszych terminach extends jest używany do dziedziczenia z klasy i implementuje jest używany do stosowania interfejsu w twojej klasie

Extends :

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
}

Jeśli nadal masz zamieszanie przeczytaj to: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html https://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html

Używamy podklasy extends SuperClass tylko wtedy, gdy podklasa chce używać pewnych funkcjonalności (metod lub zmiennych instancji), które są już zadeklarowane w SuperClass , lub jeśli chcę nieznacznie zmodyfikować funkcjonalność SuperClass (nadpisywanie metod). Ale powiedzmy, że mam klasę zwierząt (SuperClass ) i klasę Psów ( SubClass ) i jest kilka metod, które zdefiniowałem w klasie zwierząt np. doEat (); , doSleep ();... i wiele innych.

Teraz moja klasa psów może po prostu rozszerzyć klasę zwierząt, jeśli chcę, aby mój pies użył którejkolwiek z metod zadeklarowanych w klasie zwierząt mogę wywołać te metody po prostu tworząc obiekt psa. Więc w ten sposób mogę zagwarantować, że mam psa, który może jeść, spać i robić to, co chcę, aby pies robił.

Więc zamiast tego, wolę zrobić abstrakcyjną klasę, której nikt nie może utworzyć, ale może być używany jako szablon dla innych klasy.

Podsumowując, interfejs jest niczym innym jak klasą abstrakcyjną (czystą klasą abstrakcyjną), która nie zawiera implementacji metod, a jedynie definicje(szablony). Więc ktokolwiek implementuje interfejs, wie, że ma szablony doEat (); i doSleep (); ale musi zdefiniować swoje własne metody doeat (); i doSleep (); zgodnie z ich potrzebami.

Rozszerzasz tylko wtedy, gdy chcesz ponownie użyć jakiejś części SuperClass (ale pamiętaj, że zawsze możesz nadpisać metody swojej SuperClass zgodnie z potrzebami) i zaimplementować, gdy chcesz szablony i chcesz je zdefiniować samodzielnie (zgodnie z potrzebami).

Podzielę się z Tobą fragmentem kodu: wypróbuj go z różnymi zestawami wejść i spójrz na wyniki.

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
    
}


}

Zdefiniowane Interfejsy :

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}

Gdy podklasa rozszerza klasę, pozwala jej dziedziczyć (ponownie używać) i nadpisywać kod zdefiniowany w supertype. Gdy klasa implementuje interfejs, pozwala obiektowi utworzonemu z klasy na użycie w dowolnym kontekście, który oczekuje wartości interfejsu.

Prawdziwym haczykiem jest to, że podczas gdy wdrażamy cokolwiek, oznacza to po prostu, że używamy tych metod tak, jak jest. Nie ma możliwości zmiany ich wartości i typów zwrotnych.

Ale kiedy jesteśmy Rozszerzanie czegokolwiek wtedy staje się przedłużeniem twojej klasy. Możesz go zmienić, użyć, ponownie użyć użyj go i niekoniecznie musi zwracać te same wartości, co w superclass.

klasy i interfejsy są obie Kontrakty. Dostarczają one metod i właściwości innych części aplikacji opiera się na.

Definiujesz Interfejs , gdy nie jesteś zainteresowany szczegółami realizacji niniejszej umowy. Jedyną rzeczą, o którą należy dbać, jest to, że kontrakt (interfejs) istnieje.

W tym przypadku pozostawiasz to klasie, która implementuje interfejs, aby dbać o szczegóły, jak jest kontrakt spełniony. Tylko klasy mogą implementować interfejsy.

Extends jest używany, gdy chcesz zastąpić szczegóły istniejącej umowy. W ten sposób zastępujesz jeden sposób realizacji umowy innym sposobem. Klasy mogą rozszerzać inne klasy, A interfejsy mogą rozszerzać inne Interfejsy.

Extends jest używany, gdy chcesz mieć atrybuty nadrzędnej klasy / interfejsu w swojej klasie / interfejsie potomnym, a implements jest używany, gdy chcesz mieć atrybuty interfejsu w swojej klasie.

Przykład:

1. Extends using class

   Rodzic Klasy {

   }

   Class Child extends Parent {

   }

2. Extends using interface

   Rodzic Interfejsu {

   }

   Interface Child extends Rodzic {

   }

3. Narzędzia

Interfejs A {

}

Klasa B implementuje a {

}

połączenie rozszerzeń i implementacji

interface A{

}

class B

{

}

class C implements A,extends B{

}

Extends

• Klasa rozszerza tylko jedną klasę
• interfejs rozszerza jeden lub więcej interfejsów

Implements

• klasa implementuje jeden lub więcej interfejsów
• interfejsy "nie mogą" niczego implementować

Klasy abstrakcyjne również działają jak klasy, z rozszerzeniami i implementacjami

Te dwa słowa kluczowe są bezpośrednio połączone dziedziczeniem jest to podstawowa koncepcja OOP. Kiedy dziedziczymy jakąś klasę do innej klasy, możemy użyć extends , ale kiedy chcemy dziedziczyć niektóre interfejsy do naszej klasy, nie możemy używać extends, powinniśmy użyć implements i możemy użyć extends do dziedziczenia interfejsu z innego interfejsu.

W Javie Klasa (sub class) rozszerza inną klasę(Super class) i może nadpisywać metody zdefiniowane w super class.

While implements jest używane, gdy Klasa stara się zadeklarować metody zdefiniowane w interfejsie, którego ta klasa rozszerza.