verlengt de klasse en implementeren interface in Java

Maar,

class Sub implements Colorable extends Super {} // error (case -2)

Waarom Case-2 Compilatiefout met { expected. Waarom ?? Hoewel, case-1 voert zonder fouten uit.

Antwoord 1, Autoriteit 100%

extendsMoet gaan vóór implements:

class Sub extends Super implements Colorable {}

Antwoord 2, Autoriteit 13%

Ik heb een voorbeeld om te laten zien waarom uitreiken voorafgaand aan werktuigen in klassenaangifte,

INERFACE:

public interface IParent {
    void getName();
    void getAddress();
    void getMobileNumber();
}

Abstracte klasse:

public abstract class Parent {
    public abstract void getAge();
    public void getName(){
        System.out.print("the parent name");
    }
}

Kinderklasse:

public class Child extends Parent implements IParent {
    @Override
    public void getAddress() {
       System.out.print(" Child class overrides the Parent class getAddress()");
    }
    @Override
    public void getMobileNumber() {
        System.out.print(" Child class overrides the Parent class getMobileNumber()");
    }
    @Override
    public void getAge() {
        //To change body of implemented methods use File | Settings | File Templates.
    }
}

Als u opmerkt, is er dezelfde methode getname () in beide interface en in abstracte klas, waar in abstracte klasse de methode de implementatie heeft.

Wanneer u probeert te implementeren, is het verplicht voor een klas om alle abstracte methoden van een interface te negeren en dan proberen we de abstracte klasse die al een implementatie heeft verlengd voor de methode getname () uit te breiden.

Wanneer u een exemplaar van een kindklasse maakt en de methode getname () als

wordt genoemd

Child child = new Child();
child.getName();

Er zal een conflict voor een kind om te bellen welke methode-implementatie, omdat er twee implementatie voor dezelfde methode is getname ().

Om dit conflict te voorkomen, hebben ze het verplicht om eerst uit te breiden en een interface uit te voeren.

Dus als een abstracte klasse dezelfde methode heeft als in een interface en als abstracte klasse de methode al heeft geïmplementeerd voor een kindklasse, is het niet nodig om die methode

te overschrijven

Antwoord 3, Autoriteit 5%

Er is een regel in Java als u een interface wilt implementeren en een klasse uitbreiden We moeten eerst een klasse uitbreiden, dan implementeren we een interface

interface A{}
class super{}
class sub extends super implements A {}

Wanneer de Java-compiler een klasse verandert in ByTecode, moet het eerst naar een oudercategorie kijken. Dat komt omdat de onderliggende implementatie van de lessen is om te wijzen op de bypecode van de ouderklasse – die de relevante methoden en velden bevat. Dan voegt het in aanwijzingen toe aan de Code van de Functies van de Kindklasse – waarvan sommige worden verplicht door het trefwoord ‘Implementing’.

Omdat de bovenliggende klasse moet worden samengesteld, is het gemakkelijker als de compiler op de voorkant weet wat die klasse is. Verder kunt u slechts één klasse uitstrekken, maar een willekeurig aantal interfaces implementeren. De compilatietijd klimt als het uitreikende sleutelwoord kan worden vermengd onder elk aantal werktuiginstructies. Compilers willen zo snel mogelijk falen om de dev-tijd te verlagen, dus deze keuze is logisch. Verder helpt het je om dezelfde reden over de klas te denken.

Antwoord 4, Autoriteit 2%

Dit komt door een specificatie in JLS . En er is een bepaalde volgorde van elementen wanneer u probeert een klasse in Java te declareren:

• modifiers zoals public, private, enz.
• De klassaam, met de initiële brief geactiveerd door Conventie.
• De naam van de ouder van de klasse (Superclass), indien aanwezig, voorafgegaan door
  Het sleutelwoord extends. Een klasse kan alleen (subclass) er één uitstrekken
  ouder.
• een door komma’s gescheiden lijst van interfaces geïmplementeerd door de klas, als
  Elke, voorafgegaan door het trefwoord implements. Een klasse kan implementeren
  meer dan één interface.
• Het klasse lichaam, omgeven door beugels, { }.

Referentie:

http://docs.oracle.com/javase/tutorial/ java / javaoo / classdecl.html

Antwoord 5, Autoriteit 2%

De syntaxis voor klassedfinitie op JLS SYNTAX PAGINa is

NormalClassDeclaration: 
    class Identifier [TypeParameters] [extends Type] [implements TypeList] ClassBody

Ik denk dat voor het vereenvoudigen van de syntaxisregels die zij het niet uitwisselbaar hebben gemaakt.

Voor het uitwisselen van uitwisselbaar heb je waarschijnlijk iets nodig als:

NormalClassDeclaration: 
    class Identifier [TypeParameters] [ExtendsImplements] ClassBody
ExtendsImplements:
    [extends Type] [implements TypeList] | [implements TypeList] [extends Type]

Of zelfs het ergst, u bent geëist om te declareren extendsen Implementsom ORte gebruiken.

Ik denk dat het niet zo belangrijk is dat het de moeite waard zal zijn om de parserende regels te rommelen.

Antwoord 6

je moet zo doen. U kunt slechts één klasse verlengen, maar u kunt meerdere interfaces per komma apart implementeren. Het zou meer lezer zijn die de uitstrekkende eerst vóór het implementeren

hebben

class Sub extends Super implements Colorable