Java >> Java tutorial >  >> Tag >> extends

Implementer vs forlænger:Hvornår skal jeg bruge? Hvad er forskellen?

extends

extends er til forlængelse en klasse.

implements er til implementering en grænseflade

Forskellen mellem en grænseflade og en almindelig klasse er, at du i en grænseflade ikke kan implementere nogen af ​​de erklærede metoder. Kun den klasse, der "implementerer" grænsefladen, kan implementere metoderne. C++-ækvivalenten til en grænseflade ville være en abstrakt klasse (ikke PRÆCIS det samme, men stort set).

Java understøtter heller ikke multiple inheritance for klasser. Dette løses ved at bruge flere grænseflader.

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

udvider nu en klasse

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

i dette tilfælde

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

  SuperClass sup = new SuperClass();
  sup.getNb(); //returns 1
  sup.getNb2(); //returns 2

Bemærk også, at en @Override tag er ikke påkrævet for at implementere en grænseflade, da der ikke er noget i de originale grænseflademetoder der skal tilsidesættes

Jeg foreslår, at du gør noget mere forskning i dynamisk binding, polymorfi og generelt arv i objektorienteret programmering


Jeg bemærker, at du har nogle C++ spørgsmål i din profil. Hvis du forstår begrebet multiple-heritance fra C++ (der henviser til klasser, der arver karakteristika fra mere end én anden klasse), Java tillader ikke dette, men det har nøgleordet interface , hvilket er ligesom en ren virtuel klasse i C++. Som nævnt af mange mennesker, du extend en klasse (og du kan kun udvide fra én), og du implement en grænseflade -- men din klasse kan implementere så mange grænseflader, som du vil.

Dvs. disse nøgleord og reglerne for deres brug afgrænser mulighederne for multipel-arv i Java (du kan kun have én superklasse, men du kan implementere flere grænseflader).


Generelt implementerer bruges til at implementere en grænseflade og forlænger bruges til udvidelse af basisklasseadfærd eller abstrakt klasse.

forlænger :En afledt klasse kan udvide en basisklasse. Du kan omdefinere adfærden for en etableret relation. Afledt klasse "er en " basisklassetype

implementerer :Du er ved at implementere en kontrakt. Klassen, der implementerer grænsefladen "har en " kapacitet.

Med java 8-udgivelsen kan grænsefladen have standard metoder i grænsefladen, som giver implementering i selve grænsefladen.

Se dette spørgsmål for, hvornår du skal bruge hver af dem:

Interface vs abstrakt klasse (generel OO)

Eksempel til at forstå ting.

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

output:

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

Vigtige punkter at forstå:

  1. Hund og Kat er dyr og de udvidede remember () og protectOwner () ved at dele name,lifeExpentency fra Animal
  2. Kat kan klatre(), men hund kan ikke. Hund kan tænke(), men Cat gør det ikke . Disse specifikke egenskaber føjes til Cat og Dog ved at implementere denne evne.
  3. Mennesket er ikke et dyr, men det kan Think,Learn,Apply,Climb

Ved at gennemgå disse eksempler kan du forstå det

Ikke-relaterede klasser kan have funktioner gennem grænsefladen, men relaterede klasser tilsidesætter adfærd gennem udvidelse af basisklasser.


Java tag