Interface en tant que type en Java?

Prenons l'exemple suivant:

Serializable s = new ArrayList();

En Java, c'est un code valide, même si Serializable est une interface, car ArrayList implémente Serializable. Donc, dans ce cas, nous traitons s comme une variable de type Serializable.

Supposons maintenant que nous suivions le code ci-dessus avec ce qui suit:

s = "String object";

Ceci est également valable carString met également en œuvre Serializable. Puisque nous avons déclaré s comme type Serializable, il peut pointer vers tout objet qui implémente cette interface.

Les Objets peuvent avoir plusieurs types de

Considérez l'extrait de code suivant:

public class MyClass extends ParentClass implements Interface1, Interface2 {    
    //some code    
}

Cette classe peut être utilisée à différents endroits comme suit:

MyClass m1 = new MyClass();
ParentClass p = new MyClass();
Interface1 i1 = new MyClass();
Interface2 i2 = new MyClass();

La variable est déclarée comme étant le type d'une interface, sa valeur peut référencer n'importe quel objet instancié à partir de n'importe quelle classe qui implémente l'interface.

Considérons les deux dernières lignes de l'extrait de code précédent, une variable de type Interface1 peut référencer n'importe quel objet qui implémente cette interface, donc, si nous avons une autre classe implémente Interface1, disons MyClass2, alors

Interface1 i1 = new MyClass();
Interface1 i2 = new MyClasss2();
i1 = i2;
i1 = new MyClass2();

Toutes les affectations précédentes sont valides car MyClass et MyClass2 implémentent Interface1

class Ball extends Rubber implements Jumping, Rolling, Squeezing {
   public void jump(){}
   public void roll(){}
   public void squeeze(){}
}

Ball b = new Ball();
Jumping j = new Ball();
j.jump();

Les déclarations que vous citez (d'où?) sont vrais mais trompeurs-les objets ont déjà plusieurs types sans interfaces.

Par exemple "bimmelim" de type String, mais il a aussi le type Object. Les interfaces ne changent pas cela, sauf que "bimmelim" aussi a le type Serializable, CharSequence et d'autres.

En Fait, il est peut-être discutable de savoir si on doit dire que "bimmelim" "a" le type Object, mais certainement une référence à tenir dans un Object variable.

Si une variable est déclarée type d'interface ... par exemple

CharSequence x ;

... sa valeur peut faire référence à une String telle que "bimmelim", ou il pourrait être un StringBuffer, qui est un autre type qui implémente CharSequence.

String implémente plusieurs interfaces, il a donc plusieurs types:

String s = "A String";
Comparable<String> comp = s;
CharSequece cs = s;
Serializable ser = s;

L'interface CharSequence est implémentée par plusieurs classes, donc une référence CharSequence peut contenir toutes sortes d'objets:

CharSequence cs = "A String";
cs = new StringBuilder();
cs = new Segment();

Les objets peuvent avoir plusieurs types

Exemple:

public class Foo implements Runnable, Callable<Integer> {
  public void run() {}
  public Integer call() {return 1;}
}

Foo foo = new Foo();
Runnable r = foo;
Callable<Integer> c = foo;

Exemple:

Si une variable est déclarée comme étant le type d'une interface, sa valeur peut référencer n'importe quel objet instancié à partir de n'importe quelle classe qui implémente l'interface

Runnable r = new Foo();
r = Thread.currentThread();   //Thread implements Runnable

Exemple très basique -

List<String> list1=new ArrayList<String>();

Puisque, ArrayList implémente List, nous pouvons donc utiliser la variable d'interface List, c'est-à-dire list1, pour faire référence à l'objet créé par Arraylist.

Que ce qui suit est une affectation correcte:

class AClass implements AInterface {
}


AInterface var = new AClass();

Considérez les définitions de classe et d'interface suivantes:

public class A { }

public class B extends A implements I { }

public interface I { }

Les déclarations suivantes sont toutes légales:

A first = new A();
B second = new B();
A third = new B();
I fourth = new B();

Parce que B implémente I et étend A, il peut être utilisé comme valeur partout où un "I" ou un "A" est attendu.

Prenez le Collection interface à partir des bibliothèques Java standard à titre d'exemple. Toute variable déclarée de type Collection peut alors se voir attribuer un objet d'une classe qui implémente l'interface Collection, par exemple ArrayList, Stack, ... voir le document lié pour plus d'exemples.