la mise en œuvre de l'interface d'une classe: la classe de l'interface à l'interface

salut je suis un débutant dans ce domaine et im essayant de mettre en place une classe à une interface. L'interface s'étend une autre interface. Im faire une classe avec des méthodes d'exécution à travers une liste et interférer avec elle, les deux interfaces sont en dehors de cette.

Les deux interfaces sont dans chaque son fichier séparé, mais tout est dans le même paquet, de l'espoir, c'est la droite.

Im obtenir les erreurs suivantes:

De la classe doublelinkedlist: interface expected here

À partir de l'interface: doublelinkedlist.A is already defined in doublelinkedlist, interface expected here

À partir de l'interface B: doublelinkedlist.B is already defined in doublelinkedlist

Code de classe:

package doublelinkedlist;

import java.util.*;

public class Doublelinkedlist<T> implements A<T>
{

Code de l'interface d'Un: (en fichier séparé appelé A.java )

package doublelinkedlist;

import java.util.Iterator;


public class A<T> { //am I supposed to have a class here? or just have the interface?

  public interface A<T> extends B<T> 
  {

Code de l'interface B: (en fichier séparé appelé B.java )

package doublelinkedlist;

public class B<T> {

  public interface B<T> extends Iterable<T> 
  {

Il n'y a pas de code pour les deux interfaces de la classe, alors je ne comprends pas pourquoi j'obtiens un message d'erreur indiquant que son déjà défini. Quelqu'un a un idée?

Une interface ne peut pas s'étendre à partir d'une classe, juste de l'autre des interfaces. Une classe ne peut pas s'étendre à partir d'une interface, juste à partir d'une seule non-classe finale. Une classe peut implémenter une ou plusieurs interfaces.
vous pouvez déclarer intérieure interfaces et des classes à l'intérieur d'une classe, il n'y a rien de mal à cela.

OriginalL'auteur comodeque | 2013-10-15

interface java

7

interface expected here indique que le compilateur s'attend à une interface après implements, où vous avez donné une classe (depuis la déclaration de class A<T> est venu en premier).

doublelinkedlist.A is already defined in doublelinkedlist, interface expected here est levée, car vous avez une classe nommée et une interface à l'intérieur le nom de la classe A, ils ne peuvent pas tous les deux ont le même nom (même avec B)

Alors que vous pouvez techniquement disposent d'une interface à l'intérieur d'une classe, ce n'est pas vraiment le meilleur design (depuis les interfaces ont été destinés à l'abstrait, ou de se cacher, loin les détails de la sous-classes, ils sont généralement plus visible), alors essayez d'éviter de faire, sauf si vous avez une bonne raison 🙂

C'est probablement ce que vous cherchez:

Doublelinkedlist.java:
```
package doublelinkedlist;

import java.util.*;

public class Doublelinkedlist<T> implements A<T>
{...}
```
A.java:
```
package doublelinkedlist;

import java.util.Iterator;

public interface A<T> extends B<T> 
{...}
```
B.java:
```
package doublelinkedlist;

public interface B<T> extends Iterable<T> 
{...}
```
Plus de lecture sur les interfaces:
http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html

OriginalL'auteur Klazen108
0
```
public class A<T> { //am I supposed to have a class here? or just have the interface?

public interface A<T> extends B<T> 
{
```
C'est ambiguë. Est l'interface ou de la classe?

Seules les interfaces peuvent être "mis en œuvre". Vous ne pouvez pas mettre en œuvre une classe.

Donc je suppose que votre question est fait par le changement de ces dans:

Fichier DoubleLinkedList.java:
```
public class Doublelinkedlist<T> implements A<T>
{
 //... blah blah
}
```
-> Le classe implémente l'interface d'Un

Fichier A.java:
```
public interface A<T> extends B<T> 
{
   //...
}
```
-> L'interface étend de l'interface B

Fichier B.java:
```
public interface B<T> extends Iterable<T> 
{
   //...
}
```
-> L'interface étend l'interface Itérable

OriginalL'auteur Fildor

public interface Entity{

public int getId();
public void setId(int id);
public int getHealth();
public void setHealth(int health);
}

public class Tank implements Entity{

//without implementing the methods mentioned in Entity you will immediately see a red line //under "Tank" in your IDE saying un-implemented methods. 
}
public class Tank implements Entity{
private int id;
private int health;

public Tank(){..}
public int getId(){
return id;
}
public void setId(int id){
this.id = id;
}
public int getHealth(){
return health;
}
public void setHealth(int health){
this.health = health;
}
}

une interface est un contrat entre la classe qui implémente l'interface, c'est à dire "HÉ, VOUS, vous avez signé pour m'utiliser, afin de mieux vous prenez ces méthodes et de les définir correctement".

Une interface n'décrire la méthode d'en-têtes, mais pas réellement de tout contenu, il est laissé à la classe qui implémente l'interface.

de plus, comprendre les éléments suivants
l'héritage - permet à une classe d'hériter les attributs et les méthodes de sa classe mère, mais le même enfant de la classe ne peut hériter directement à partir de 2 classes parent, vous pouvez cependant avoir un enfant de la classe hérite d'une classe parent qui hérite d'une autre classe qui implémente une interface.
voici un exemple

 public interface Entity{
    ...
    }
    public Soldier implements Entity{
    //implements the entity interface,
    //and defines the methods
    }
    public SwordsMan extends Soldiers{
    //this class inherits the methods and attributes of soldier
    //which had also implemented the methods from entity

}

Vous avez également mentionné en train de s'étendre à une interface sur une interface les interfaces sont conçues avec pas mis en œuvre des méthodes, si vous souhaitez utiliser deux interfaces vous sont les meilleurs pour ce faire:

public class Aircraft implements Engine, Entity{
//this class then has to implements all methods from Engine and Entity
}

OriginalL'auteur tommy knocker

Vous devez vous connecter pour publier un commentaire.