variabele van interfacetype

Ik leer Java, ik zag de volgende beschrijving betrekking hebben op interface in een boek:

Wanneer een variabele wordt verklaard als van een interfacetype, is dit eenvoudig   betekent dat het object naar verwachting die interface heeft geïmplementeerd.

What does it mean? If I define an interface:

public interface Myinterface{

   void method_one(); 
   int method_two();
}

Vervolgens verklaar ik dat een variabele van een interfacetype is, bijvoorbeeld:

Myinterface foo = new Myinterface();
  • Hoe de interface wordt geïmplementeerd ??
  • Onder welke omstandigheden zou ik een interfacetypevariabele moeten definiëren?

Ik raak helemaal in de war door de beschrijving van het boek ...

10

3 antwoord

U kunt een interface niet instantiëren, dat wil zeggen u kunt het niet doen

MyInterface foo = new MyInterface();//Compile-time error.

What you can do is instantiate a class that implements the interface. That is, given a class MyClass

public class MyClass implements MyInterface {
 //...

  @Override
  void method_one() {
   //...
  }
  @Override
  int method_two() {
   //...
  }
}

je kunt het instantiëren en een verwijzing naar het in je variabele als volgt plaatsen:

MyInterface foo = new MyClass();

If you had another class implementing MyInterface

class MyClass2 implements MyInterface {
 //...
}

u kunt ook een verwijzing naar de instantie van deze klasse vervangen door uw variabele:

MyInterface foo = new MyClass2();

Dit is waar de kracht van interfaces ligt: ​​ze definiëren typen , niet een bepaalde implementatie en laten je verwijzen naar elke implementatie van een bepaald type.

Het is een zeer goede programmeermethode om klassen interfaces te laten implementeren en deze te gebruiken om naar instanties van deze klassen te verwijzen. Deze praktijk vergemakkelijkt een grote mate van flexibiliteit en hergebruik.

Therefore, you should use interface type arguments and variables whenever it is conceivable that different implementations may be passed into the method you're implementing. For example, if you're working with a HashSet instance, you should use a variable of type Set to refer to it (class HashSet implements interface Set).

15
toegevoegd
Bedankt, zowel jij als Macmade geven me een duidelijke uitleg.
toegevoegd de auteur Mellon, de bron

U kunt een interface niet instantiëren. Maar u kunt uw variabele typen met de interfacenaam:

Myinterface foo = new MyObject();

Ervan uitgaande dat MyObject werkt MyInterface .

It may be useful when acquiring objects from an external source, for instance.
In such a case, you don't know (and don't care) about the real type of the object.

U hoeft alleen te weten en ervoor te zorgen dat het een bepaalde interface implementeert, zodat u interface-methoden op het object kunt aanroepen.

Ervan uitgaande dat je de volgende variabele hebt:

Myinterface foo;

And two classes (Foo and Bar), both implementing MyInterface.
You will then be able to assign the foo variables with instances of both Foo and Bar.

Hetzelfde geldt natuurlijk voor argumenten voor methoden.

4
toegevoegd
Zojuist toegevoegd:)
toegevoegd de auteur Macmade, de bron
Graag gedaan : )
toegevoegd de auteur Macmade, de bron
Bedankt, kunt u ook mijn tweede vraag beantwoorden, onder welke omstandigheden moet ik dit doen? Waarom doet het zo? Wat is het voordeel?
toegevoegd de auteur Mellon, de bron
Bedankt, zowel jij als Adam geven me een heel duidelijke uitleg :)
toegevoegd de auteur Mellon, de bron

U instantiat geen interface. Je maakt klassen die de interface implementeren , om ze te instantiëren, maar naar de interface te verwijzen (in tegenstelling tot de implementatieklasse).

Hierdoor blijft uw code implementatie-neutraal, vergelijkbaar met het gebruik van een lijst verwijzing, maar een ArrayList -implementatie.

In combinatie met afhankelijkheidsinjectie maakt het testen en uitbreidbaarheid veel eenvoudiger.

1
toegevoegd