étend la classe et implémente l'interface dans Java

interface Bouncable{ } 
interface Colorable extends Bouncable{ } 
class Super implements Colorable{ } 
class Sub extends Super implements Colorable {} //Ok (case -1)

Mais,

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

Pourquoi cas-2 montrant erreur de compilation { expected. Pourquoi ?? Bien que, cas-1 s'exécute sans erreur.

source d'informationauteur Ravi

extends devrait aller de l'avant implements:

class Sub extends Super implements Colorable {}

2

J'ai un exemple pour montrer pourquoi s'étend précède met en œuvre dans la déclaration de classe,

inerface :
```
public interface IParent {
    void getName();
    void getAddress();
    void getMobileNumber();
}
```
classe abstraite :
```
public abstract class Parent {
    public abstract void getAge();
    public void getName(){
        System.out.print("the parent name");
    }
}
```
Enfant de la classe :
```
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.
    }
}
```
Si vous l'observez, il en est de même de la méthode getName() dans l'interface et dans la classe abstraite, où dans la classe abstraite la méthode de la mise en œuvre.

Lorsque vous essayez de mettre en œuvre, alors il est obligatoire pour une classe de remplacer toutes les méthodes abstraites de l'interface, puis nous essayons d'étendre la classe abstraite qui a déjà a un de la mise en œuvre de la méthode getName().

lorsque vous créez une instance d'une classe Enfant et a appelé la méthode getName ()
```
Child child = new Child();
child.getName();
```
Il y aura un conflit pour un enfant d'appeler la méthode de la mise en œuvre comme il y aura deux de mise en œuvre pour la même méthode getName().

Pour éviter ce conflit, ils l'ont rendu obligatoire pour étendre première et de mettre en œuvre une interface plus tard.

donc, si une classe abstraite est la même méthode que dans une interface et si la classe abstraite a mis en œuvre la méthode déjà à l'époque pour un enfant de la classe il n'est pas nécessaire de remplacer la méthode
1

C'est parce que d'une spécification dans JLS. Et il y a un certain ordre des éléments lorsque vous essayez de déclarer une classe en Java:
- Les modificateurs comme publicprivateetc.
- Le nom de la classe, avec la première lettre en majuscule par la convention.
- Le nom de la classe parent (super-classe), le cas échéant, précédé par
  le mot-clé extends. Une classe ne peut étendre (sous-classe) d'un
  parent.
- Une liste séparée par des virgules des interfaces implémentées par la classe, si
  tout, précédé par le mot-clé implements. Une classe peut implémenter
  plus d'une interface.
- Le corps de la classe, entouré par des accolades, { }.
Référence:

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

La syntaxe pour la définition de la classe à JLS Syntaxe de la Page est
```
NormalClassDeclaration: 
    class Identifier [TypeParameters] [extends Type] [implements TypeList] ClassBody
```
Je pense que pour simplifier la syntaxe des règles qu'ils n'ont pas interchangeables.

Pour faire interchangeables, vous avez probablement besoin de quelque chose comme:
```
NormalClassDeclaration: 
    class Identifier [TypeParameters] [ExtendsImplements] ClassBody

ExtendsImplements:
    [extends Type] [implements TypeList] | [implements TypeList] [extends Type]
```
Ou même pire, vous risquez de été de déclarer Extends et Implements afin d'utiliser OR.

Je suppose qu'il n'est pas si important que ça vaut la encombrer les règles d'analyse.
0

Que vous avez à faire comme ça. Vous pouvez étend une seule classe, mais vous pouvez implémenter plusieurs interfaces par des virgules séparément. il serait plus clair d'avoir l'étendre d'abord avant de le mettre en œuvre
```
class Sub extends Super implements Colorable
```
0

Il y a une règle en java si vous souhaitez implémenter une interface et d'étendre une classe, nous devons étendre une classe d'abord, puis nous mettons en œuvre une interface
```
interface A{}
class super{}

class sub extends super implements A {}
```
Lorsque le compilateur Java tourne une classe en bytecode, il faut d'abord regarder à un parent de la classe. C'est parce que le sous-jacent de la mise en œuvre de classes est de pointer vers le bytecode de la classe parent - qui détient les méthodes et les champs. Puis il ajoute dans les pointeurs vers le code de l'enfant des fonctions de classe - dont certains sont obligatoires de par la 'implémente ce mot-clé.

Parce que la classe parent doit être compilable, c'est plus facile si le compilateur sait à l'avance ce qu'est la classe. En outre, vous pouvez étendre une classe unique, mais de mettre en place un nombre quelconque d'interfaces. Le temps de compilation grimpe si le mot-clé extends peut être mêlés parmi plusieurs met en œuvre des instructions. Les compilateurs voulu manquer aussi vite que possible pour diminuer les dev de temps, donc ce choix est logique. En outre, il vous aide à penser clairement sur la classe pour la même raison.

Vous devez vous connecter pour publier un commentaire.