Interface en tant que type en Java?
À Partir De Les Tutoriels Java :
En Java, une classe peut hériter d'une seule classe mais elle peut implémenter plus d'une interface. Par conséquent, les objets peuvent avoir plusieurs types : le type de leur propre classe et les types de toutes les interfaces ils mettent en œuvre. Cela signifie que si une variable est déclarée comme étant d'une interface, sa valeur peut référencer n'importe quel objet qui est instancié à partir de n'importe quelle classe qui implémente interface .
Quelqu'un peut-il me fournir un pseudo type de base pour cela. Je ne comprenais pas les lignes audacieuses.
11 réponses
Déclarons deux interfaces et une classe qui les implémente toutes les deux:
interface I1 { }
interface I2 { }
class C implements I1, I2 { }
les objets peuvent avoir plusieurs types de
Dans le code suivant, il peut être vu que d'un C exemple le type de C ainsi que I1 et I2:
C c = new C();
boolean isC = (c instanceof C); //true
boolean isI1 = (c instanceof I1); //true
boolean isI2 = (c instanceof I2); //true
Maintenant, déclarons une classe B qui implémente également I1:
class B implements I1 { }
si une variable est déclarée comme étant le type d'une interface, sa valeur peut référencer n'importe quel objet qui est instanciés à partir de n'importe quelle classe qui implémente l'interface.
, Si nous déclarons une variable de type I1, nous pouvons la fixer à une instance de C, puis réaffecter à une instance de B:
I1 i1 = new C();
i1 = new B();
, Nous pouvons également réaffecter à une instance de D, où D étend C:
i1 = new D();
...
class D extends C { }
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 {[5] } 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 valide car String implémente également Serializable. Puisque nous avons déclaré {[5] } comme type Serializable, Il peut pointer vers n'importe quel objet qui implémente cette interface.
Les Objets peuvent avoir plusieurs types de
Considérez l'extrait 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érez les deux dernières lignes de l'extrait 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 nous devrions dire cela "bimmelim" "A" le type Object, mais certainement une référence à celui-ci s'intégrera 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, donc il a 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 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 n'importe où un "I" ou un "A" est attendu.
Prenez le Collection interface 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.