Type abstrait de Données et de l'Interface

What is the difference between Abstract data type and Interface.

1. Les Variables déclarées dans une interface Java est par défaut final. Un
   classe abstraite peut contenir des non-final variables.
2. Les membres d'une interface Java sont publics par défaut. Java abstrait
   classe peut avoir l'habitude des saveurs de membres de la classe comme privé,
   la protection, etc..
   cochez cette lien pour info

Essayer de penser comme ça:

• Interface Java est un type, qui se résume à une ensemble de signatures de méthode. N'importe quel type, prêt à être référencé en tant que l'interface doit fournir à la mise en œuvre de ces signatures. En réalité, il n'y a pas de comportement de contrat. Votre application peut ne rien faire et à toujours être "mise en œuvre" une interface.

• Java classe abstraite est un type, avec partiellement spécifié comportement dont la mise en œuvre interne pour une raison quelconque doit être spécifié dans son héritière. Cette classe n'ont de comportement, qui peut être redéfini/spécifiées dans ses héritiers.

• ADT est un ensemble de comportements attendus. Vous supposez qu'après l'appel de adt.remove(element) vous appelez adt.get(element) et de recevoir des null.

La réponse à votre question est: juste une interface n'est pas assez pour être un outil ADT.

• Tout, que correctement implémente votre interface MyListADT<T> est un outil ADT. Son comportement extérieur doit respecter le guide pratique du concept. Cela signifie que, pour être considéré comme de l'ADT, votre type doit effectuer la mise en œuvre, qui résulte soit dans la classe abstraite ou une classe normale. Par exemple: java.util.List<T> est une interface pour un ADT, mais java.util.ArrayList<T> et java.util.LinkedList<T> sont en fait ADTs, parce que leur comportement ne sont conformes à l'ADT concept.

Conformément à la [wiki] http://en.wikipedia.org/wiki/Abstract_data_type

En informatique, un type abstrait de données (ADT) est un modèle mathématique pour une certaine classe de structures de données qui ont un comportement similaire; ou pour certains types de données d'un ou de plusieurs langages de programmation qui ont les mêmes sémantique. Un type abstrait de données est définie indirectement, uniquement par les opérations qui peuvent être réalisées et en mathématique des contraintes sur les effets (et éventuellement le coût) de ces opérations.

Pour le langage de programmation Java

vous pouvez prendre Java la Liste de l'interface comme un exemple. L'interface ne définit pas explicitement les comportements à tous, car il n'existe pas de Liste concrète de la classe. L'interface définit un ensemble de méthodes que d'autres classes (par exemple, ArrayList et LinkedList) doit mettre en œuvre pour être considérée comme une Liste.

mais la ligne de fond est que c'est un concept

Plus de dégagement.
La syntaxe et des exemples

syntaxe de la classe abstraite

public abstract class MyAbstractClass  
{  
    //code  
    public abstract void method();      
} 

exemple de classe abstraite

public abstract class Animal  
{  
    abstract void walk();      
}  

public class Dog extends Animal  
{  
    void walk()  
    {  
         //Implementation is done here  
    }  
}  

---

syntaxe de l'interface

public interface NameOfInterface
{
   //Any number of final, static fields
   //Any number of abstract method declarations\
}

exemple de l'interface

interface Animal {

   public void eat();
   public void travel();
}

la mise en œuvre de l'interface

public class MammalInt implements Animal{

   public void eat(){
      System.out.println("Mammal eats");
   }

   public void travel(){
      System.out.println("Mammal travels");
   } 

   public int noOfLegs(){
      return 0;
   }

   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

l'extension de l'interface

//Filename: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

//Filename: Football.java
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

//Filename: Hockey.java

public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

prolongement de plusieurs interfaces

public interface Hockey extends Sports, Event

s'étend et met en œuvre les Deux

interface A can extends interface B 
class A can extends class B         
class A implements interface A   
class A extends class B implements interface A