Kan een normale klasse meerdere interfaces implementeren?

Ik weet dat meerdere overervingen tussen interfaces mogelijk zijn, bijvoorbeeld:

public interface C extends A,B {...} //Where A, B and C are Interfaces

Maar is het mogelijk om een gewone klasse te erven van meerdere interfaces zoals deze:

public class A implements C,D {...} //Where A is a Class and C and D are interfaces

Antwoord 1, autoriteit 100%

Een Java-klasse kan slechts één bovenliggende klasse uitbreiden. Meervoudige overerving (extends) is niet toegestaan. Interfaces zijn echter geen klassen, en een klasse kan meer dan één interface implementeren.

De bovenliggende interfaces worden gedeclareerd in een door komma’s gescheiden lijst, na het trefwoord implements.

Concluderend, ja, het is mogelijk om het volgende te doen:

public class A implements C,D {...}

Antwoord 2, autoriteit 8%

publieke klasse A implementeert C,D {…} geldig

dit is de manier om meervoudige overerving in java te implementeren

Antwoord 3, autoriteit 7%

In één woord: ja.
In feite implementeren veel klassen in de JDK meerdere interfaces. Bijvoorbeeld, ArrayListimplementeert List, RandomAccess, Cloneableen Serializable.

Antwoord 4, autoriteit 6%

Ja, een klasse kan meerdere interfaces implementeren. Elke interface biedt een contract voor een bepaald soort gedrag. Ik voeg een gedetailleerd klassendiagram en shell-interfaces en klassen bij.

Ceremonieel voorbeeld:

public interface Mammal {
    void move();
    boolean possessIntelligence();
}

public interface Animal extends Mammal {
    void liveInJungle();
}

public interface Human extends Mammal, TwoLeggedMammal, Omnivore, Hunter {
    void liveInCivilization();
}

public interface Carnivore {
    void eatMeat();
}

public interface Herbivore {
    void eatPlant();
}

public interface Omnivore extends Carnivore, Herbivore {
    void eatBothMeatAndPlant();
}

public interface FourLeggedMammal {
    void moveWithFourLegs();
}

public interface TwoLeggedMammal {
    void moveWithTwoLegs();
}

public interface Hunter {
    void huntForFood();
}

public class Kangaroo implements Animal, Herbivore, TwoLeggedMammal {
    @Override
    public void liveInJungle() {
        System.out.println("I live in Outback country");
    }
    @Override
    public void move() {
        moveWithTwoLegs();
    }
    @Override
    public void moveWithTwoLegs() {
        System.out.println("I like to jump");
    }
    @Override
    public void eat() {
        eatPlant();
    }
    @Override
    public void eatPlant() {
        System.out.println("I like this grass");
    }
    @Override
    public boolean possessIntelligence() {
        return false;
    }
}

public class Lion implements Animal, FourLeggedMammal, Hunter, Carnivore {
    @Override
    public void liveInJungle() {
        System.out.println("I am king of the jungle!");
    }
    @Override
    public void move() {
        moveWithFourLegs();
    }
    @Override
    public void moveWithFourLegs() {
        System.out.println("I like to run sometimes.");
    }
    @Override
    public void eat() {
        eatMeat();
    }
    @Override
    public void eatMeat() {
        System.out.println("I like deer meat");
    }
    @Override
    public boolean possessIntelligence() {
        return false;
    }
    @Override
    public void huntForFood() {
        System.out.println("My females hunt often");
    }
}

public class Teacher implements Human {
    @Override
    public void liveInCivilization() {
        System.out.println("I live in an apartment");
    }
    @Override
    public void moveWithTwoLegs() {
        System.out.println("I wear shoes and walk with two legs one in front of the other");
    }
    @Override
    public void move() {
        moveWithTwoLegs();
    }
    @Override
    public boolean possessIntelligence() {
        return true;
    }
    @Override
    public void huntForFood() {
        System.out.println("My ancestors used to but now I mostly rely on cattle");
    }
    @Override
    public void eat() {
        eatBothMeatAndPlant();
    }
    @Override
    public void eatBothMeatAndPlant() {
        eatPlant();
        eatMeat();
    }
    @Override
    public void eatMeat() {
        System.out.println("I like this bacon");
    }
    @Override
    public void eatPlant() {
        System.out.println("I like this broccoli");
    }
}

Antwoord 5, Autoriteit 3%

Natuurlijk … Bijna alle klassen implementeren verschillende interfaces. Op elke pagina van Java-documentatie op Oracle heeft u een subsectie met de naam “Alle geïmplementeerde interfaces”.

Hier een voorbeeld van de DateKlasse.

Antwoord 6, Autoriteit 3%

Het is waar dat een Java-klasse meerdere interfaces tegelijkertijd kan implementeren, maar er is een vangst hier.
Als u in een klasse probeert u twee JAVA-interfaces te implementeren, die methoden met dezelfde handtekening bevatten, maar diffruent retourtype, krijgt u in dat geval een compilatiefout.

interface One
{
    int m1();
}
interface Two
{
    float m1();
}
public class MyClass implements One, Two{
    int m1() {}
    float m1() {}
    public static void main(String... args) {
    }
}

Uitgang:

prog.java:14: error: method m1() is already defined in class MyClass
    public float m1() {}
                 ^
prog.java:11: error: MyClass is not abstract and does not override abstract method m1() in Two
public class MyClass implements One, Two{
       ^
prog.java:13: error: m1() in MyClass cannot implement m1() in Two
    public int m1() {}
               ^
  return type int is not compatible with float
3 errors

Antwoord 7, autoriteit 2%

Ja, dat is mogelijk. Dit is de addertje onder het gras: java ondersteunt geen meervoudige overerving, d.w.z. klasse kan niet meer dan één klasse uitbreiden. Class kan echter meerdere interfaces implementeren.

Antwoord 8

Een interface kan andere interfaces uitbreiden. Ook kan een interface geen andere interface implementeren.
Als het op een klasse aankomt, kan deze een andere klasse uitbreiden en een willekeurig aantal interfaces implementeren.

class A extends B implements C,D{...}