it-swarm.com.de

Was ist eine Schnittstelle in Java?

Nur als Kontrapunkt zu dieser Frage : Was ist eine Schnittstelle in Java?

29
Imagist

Eine Schnittstelle ist eine spezielle Form einer abstrakten Klasse, die keine Methoden implementiert. In Java erstellen Sie eine Schnittstelle wie folgt:

interface Interface
{
    void interfaceMethod();
}

Da die Schnittstelle keine Methoden implementieren kann, ist davon auszugehen, dass die gesamte Sache einschließlich aller Methoden sowohl öffentlich als auch abstrakt ist (abstrakt in Java bedeutet "nicht von dieser Klasse implementiert"). Die Schnittstelle oben ist also identisch mit der Schnittstelle unten:

public interface Interface
{
    abstract public void interfaceMethod();
}

Um diese Schnittstelle zu verwenden, müssen Sie die Schnittstelle lediglich implementieren. Viele Klassen können eine Schnittstelle implementieren, und eine Klasse kann viele Schnittstellen implementieren:

interface InterfaceA
{
     void interfaceMethodA();
}

interface InterfaceB
{
    void interfaceMethodB();
}

public class ImplementingClassA
    implements InterfaceA, InterfaceB
{
    public void interfaceMethodA()
    {
        System.out.println("interfaceA, interfaceMethodA, implementation A");
    }

    public void interfaceMethodB()
    {
        System.out.println("interfaceB, interfaceMethodB, implementation A");
    }
}

public class ImplementingClassB
    implements InterfaceA, InterfaceB
{
    public void interfaceMethodA()
    {
         System.out.println("interfaceA, interfaceMethodA, implementation B");
    }

    public void interfaceMethodB()
    {
        System.out.println("interfaceB, interfaceMethodB, implementation B");
    }
}

Wenn Sie wollten, könnten Sie eine Methode wie folgt schreiben:

public void testInterfaces()
{
    ImplementingClassA u = new ImplementingClassA();
    ImplementingClassB v = new ImplementingClassB();
    InterfaceA w = new ImplementingClassA();
    InterfaceA x = new ImplementingClassB();
    InterfaceB y = new ImplementingClassA();
    InterfaceB z = new ImplementingClassB();

    u.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation A"
    u.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation A"
    v.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation B"
    v.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation B"
    w.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation A"
    x.interfaceMethodA();
    // prints "interfaceA, interfaceMethodA, implementation B"
    y.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation A"
    z.interfaceMethodB();
    // prints "interfaceB, interfaceMethodB, implementation B"
}

Sie könnten jedoch never Folgendes tun:

public void testInterfaces()
{
    InterfaceA y = new ImplementingClassA();
    InterfaceB z = new ImplementingClassB();

    y.interfaceMethodB(); // ERROR!
    z.interfaceMethodA(); // ERROR!
}

Der Grund, warum Sie dies nicht tun können, ist, dass y vom Typ interfaceA ist und es keine interfaceMethodB() in interfaceA gibt. Ebenso ist z vom Typ interfaceB und es gibt keine interfaceMethodA() in interfaceB.

Ich habe bereits erwähnt, dass Schnittstellen nur eine spezielle Form einer abstrakten Klasse sind. Um diesen Punkt zu veranschaulichen, sehen Sie sich den folgenden Code an.

interface Interface
{
    void abstractMethod();
}

abstract public class AbstractClass
{
    abstract public void abstractMethod();
}

Sie würden von diesen Klassen fast genauso erben:

public class InheritsFromInterface
    implements Interface
{
    public void abstractMethod() { System.out.println("abstractMethod()"); }
}

public class InteritsFromAbstractClass
    extends AbstractClass
{
    public void abstractMethod() { System.out.println("abstractMethod()"); }
}

Sie können sogar die Schnittstelle und die abstrakte Klasse wie folgt ändern:

interface Interface
{
    void abstractMethod();
}

abstract public class AbstractClass
    implements Interface
{
    abstract public void abstractMethod();
}

public class InheritsFromInterfaceAndAbstractClass
    extends AbstractClass implements Interface
{
    public void abstractMethod() { System.out.println("abstractMethod()"); }
}

Es gibt jedoch zwei Unterschiede zwischen Schnittstellen und abstrakten Klassen.

Der erste Unterschied ist, dass Schnittstellen keine Methoden implementieren können.

interface Interface
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}

Die obige Schnittstelle generiert einen Compiler-Fehler, da für implementedMethod() eine Implementierung vorliegt. Wenn Sie die Methode implementieren möchten, die Klasse jedoch nicht instanziieren können, müssen Sie dies folgendermaßen tun:

abstract public class AbstractClass
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}

Das ist keine sehr abstrakte Klasse, da keines seiner Mitglieder abstrakt ist, aber es ist legales Java.

Der andere Unterschied zwischen Schnittstellen und abstrakten Klassen besteht darin, dass eine Klasse von mehreren Schnittstellen erben kann, aber nur von einer abstrakten Klasse.

abstract public class AbstractClassA { }
abstract public class AbstractClassB { }
public class InheritsFromTwoAbstractClasses
    extends AbstractClassA, AbstractClassB
{ }

Der obige Code generiert einen Compiler-Fehler, nicht weil die Klassen alle leer sind, sondern weil InheritsFromTwoAbstractClasses versucht, von zwei abstrakten Klassen zu erben, was illegal ist. Folgendes ist absolut legal.

interface InterfaceA { }
interface InterfaceB { }
public class InheritsFromTwoInterfaces
    implements InterfaceA, InterfaceB
{ }    

Der erste Unterschied zwischen Schnittstellen und abstrakten Klassen ist der Grund für den zweiten Unterschied . Schauen Sie sich den folgenden Code an.

interface InterfaceA
{
    void method();
}

interface InterfaceB
{
    void method();
}

public class InheritsFromTwoInterfaces
    implements InterfaceA, InterfaceB
{
    void method() { System.out.println("method()"); }
}

Es gibt kein Problem mit dem obigen Code, da InterfaceA und InterfaceB nichts zu verbergen haben. Es ist leicht zu erkennen, dass ein Aufruf von method "method ()" druckt.

Sehen Sie sich nun den folgenden Code an:

abstract public class AbstractClassA
{
    void method() { System.out.println("Hello"); }
}

abstract public class AbstractClassB
{
    void method() { System.out.println("Goodbye"); }
}

public class InheritsFromTwoAbstractClasses
    extends AbstractClassA, AbstractClassB
{ }

Dies ist genau das gleiche wie in unserem anderen Beispiel, außer dass wir Methoden in abstrakten Klassen implementieren durften, und weil wir nicht bereits implementierte Methoden in einer erbenden Klasse implementieren mussten, haben wir dies nicht getan. Aber Sie haben vielleicht bemerkt, es gibt ein Problem. Was passiert, wenn wir new InheritsFromTwoAbstractClasses().method() aufrufen? Druckt es "Hallo" oder "Auf Wiedersehen"? Sie wissen es wahrscheinlich nicht und der Java-Compiler auch nicht. Eine andere Sprache, C++, erlaubte diese Art der Vererbung und löste diese Probleme auf eine Art und Weise, die oft sehr kompliziert war. Um diese Art von Problemen zu vermeiden, hat Java beschlossen, diese "Mehrfachvererbung" illegal zu machen.

Der Nachteil von Javas Lösung ist, dass Folgendes nicht getan werden kann:

abstract public class AbstractClassA
{
    void hi() { System.out.println("Hello"); }
}

abstract public class AbstractClassB
{
    void bye() { System.out.println("Goodbye"); }
}

public class InheritsFromTwoAbstractClasses
    extends AbstractClassA, AbstractClassB
{ }

AbstractClassA und AbstractClassB sind "Mixins" oder Klassen, die nicht instanziiert werden sollen, sondern fügen den Klassen, in die sie durch Vererbung "gemischt" werden, Funktionalität hinzu. Es ist offensichtlich kein Problem herauszufinden, was passiert, wenn Sie new InheritsFromTwoAbstractClasses().hi() oder new InheritsFromTwoAbstractClasses().bye() aufrufen. Dies ist jedoch nicht möglich, da Java dies nicht zulässt.

(Ich weiß, dass dies ein langer Post ist. Wenn Fehler dabei sind, lass es mich wissen und ich werde sie korrigieren.)

47
Imagist

Schnittstelle ist ein Vertrag. Ein einfaches Beispiel ist ein Mieter und Vermieter das sind die beiden Parteien und der Vertrag ist der Mietvertrag . Der Mietvertrag enthält verschiedene Klauseln, denen die Mieter folgen müssen. Ebenso handelt es sich bei Interface um einen Kontakt, der verschiedene Methoden (Deklaration) enthält, die die Partei implementieren muss (Methodenkörper bereitstellen). Hier ist Partei 1 die Klasse, die die Schnittstelle implementiert, und zweite Partei ist Client der Schnittstelle "und" Objekt der implementierenden Klasse ": Im Folgenden sind 3 Komponenten aufgeführt: (Erklärt anhand eines Beispiels)

Komponente 1] Schnittstelle: Der Vertrag

interface myInterface{

 public void myMethod();

 }

Komponente 2] Durchführungsklasse: Partnernummer 1

 class myClass implements myInterface {

 @Override

 public void myMethod() {

 System.out.println("in MyMethod");

 }

 }

Komponente 3] Kundencode: Parteiennummer 2

 Client.Java

 public class Client {

 public static void main(String[] args) {

 myInterface mi = new myClass();

 // Reference of Interface = Object of Implementing Class

 mi.myMethod(); // this will print in MyMethod

 }

 }
1
Shashank Bodkhe

Eine Schnittstelle ist ein klassenähnliches Konstrukt, das nur Konstanten und abstrakte Methoden enthält (Einführung in die Java-Programmierung, n.d.). Darüber hinaus kann es mehrere Schnittstellen erweitern, beispielsweise eine Superklasse. Java erlaubt nur eine einfache Vererbung für die Klassenerweiterung, aber mehrere Erweiterungen für die - Schnittstellen (Einführung in die Java-Programmierung, n.d.). Zum Beispiel

public class NewClass extends BaseClass
implements Interface1, ..., InterfaceN {
    ...
}

Zweitens können Schnittstellen verwendet werden, um das Verhalten von Objekten in einer Klasse anzugeben. Sie können jedoch keine abstrakten Methoden enthalten. Eine Schnittstelle kann auch andere Schnittstellen mit dem Schlüsselwort extend erben. 

public interface NewInterface extends Interface1, ... , InterfaceN {

}

Referenz

Einführung in die Java-Programmierung. Schnittstellen und Abstract-Klassen (n.d). Abgerufen am 10. März 2017 von https://viewer.gcu.edu/7NNUKW

0
FREDDYSMALLZ

Nach der neuesten Definition von Oracle lautet die Schnittstelle:

Es gibt eine Reihe von Situationen in der Softwareentwicklung, in denen es für unterschiedliche Gruppen von Programmierern wichtig ist, einem "Vertrag" zuzustimmen, der die Interaktion ihrer Software beschreibt . Jede Gruppe sollte in der Lage sein, ihren Code zu schreiben, ohne zu wissen, wie der Code der anderen Gruppe geschrieben ist. Im Allgemeinen sind Schnittstellen solche Verträge.

Stellen Sie sich zum Beispiel eine futuristische Gesellschaft vor, in der computergesteuerte Roboterautos Passagiere ohne menschlichen Bediener durch die Straßen der Stadt transportieren. Automobilhersteller schreiben eine Software (natürlich Java), die das Automobil bedient - anhalten, starten, beschleunigen, nach links abbiegen und so weiter. Eine andere Industriegruppe, Hersteller von elektronischen Leitinstrumenten, stellt Computersysteme her, die GPS-Positionsdaten (Global Positioning System) und drahtlose Übertragung von Verkehrsbedingungen empfangen und diese Informationen zum Fahren des Autos verwenden.

Die Autohersteller müssen eine branchenübliche Schnittstelle veröffentlichen, in der detailliert beschrieben wird, welche Methoden aufgerufen werden können, um das Auto in Bewegung zu versetzen (jedes Auto, von jedem Hersteller). Die Lenkungshersteller können dann Software schreiben, die die in der Schnittstelle beschriebenen Methoden aufruft, um das Auto zu steuern. Keiner der Industriekonzerne muss wissen, wie die Software des anderen Konzerns implementiert ist. Tatsächlich betrachtet jede Gruppe ihre Software als sehr proprietär und behält sich das Recht vor, sie jederzeit zu ändern, solange sie weiterhin an der veröffentlichten Oberfläche festhält.

[...] Eine Schnittstelle ist ein Referenztyp, ähnlich einer Klasse, der nur Konstanten, Methodensignaturen, Standardmethoden, statische Methoden und verschachtelte Typen enthalten kann. Methodenkörper existieren nur für Standardmethoden und statische Methoden. Schnittstellen können nicht instanziiert werden - sie können nur von Klassen implementiert oder durch andere Schnittstellen erweitert werden.

Die am weitesten verbreitete Verwendung von Schnittstellen sind APIs (Application Programming Interface), die in kommerziellen Softwareprodukten üblich sind. In der Regel verkauft ein Unternehmen ein Softwarepaket, das komplexe Methoden enthält, die ein anderes Unternehmen in seinem eigenen Softwareprodukt verwenden möchte.

Ein Beispiel könnte ein Paket digitaler Bildverarbeitungsverfahren sein, die an Unternehmen verkauft werden, die Endbenutzer-Grafikprogramme herstellen.

Das Bildverarbeitungsunternehmen schreibt seine Klassen, um eine Schnittstelle zu implementieren, die es seinen Kunden zugänglich macht. Die Grafikfirma ruft dann die Bildverarbeitungsmethoden unter Verwendung der in der Schnittstelle definierten Signaturen und Rückgabetypen auf. Während die API des Bildverarbeitungsunternehmens (für seine Kunden) veröffentlicht wird, wird die Implementierung der API streng geheim gehalten. Tatsächlich wird die Implementierung möglicherweise zu einem späteren Zeitpunkt überarbeitet, solange die ursprüngliche Schnittstelle weiterhin implementiert wird darauf haben sich seine Kunden verlassen.

Check out to Weitere Informationen zu Schnittstellen .

0
Johnny

Diese Frage ist 6 Jahre alt und viele Dinge haben die Definition der Schnittstelle im Laufe der Jahre verändert. 

Von Oracle Dokumentation Seite (nach Java 8 Release):

In der Java-Programmiersprache ist eine Schnittstelle ein Referenztyp, der einer Klasse ähnelt und nurKonstanten, Methodensignaturen, Standardmethoden, statische Methoden und geschachtelte Typen enthalten kann . Methodentexte sind nur für Standardmethoden und statische Methoden vorhanden. Schnittstellen können nicht instanziiert werden. Sie können nur von Klassen implementiert oder von anderen Schnittstellen erweitert werden.

Sehen Sie sich verwandte SE-Fragen zur besseren Erklärung an:

Gibt es mehr an einer Schnittstelle als die richtigen Methoden

Was ist der Unterschied zwischen einer Schnittstelle und einer abstrakten Klasse?

0
Ravindra babu

Was es ist
Ein interface ist ein Referenztyp, genau wie ein class is. Dies sind die zwei Hauptreferenztypen in Java.

Was es enthält
Ein interface kann eine Teilmenge dessen enthalten, was eine normale Klasse enthalten kann. Dies beinhaltet alles, was static ist, sowohl Methoden als auch Variablen, und Nicht-static Methodendeklarationen. Es dürfen nicht -static -Variablen vorhanden sein.
Eine Deklaration einer Methode unterscheidet sich in einigen Punkten von einer normalen Methode. Hier ist ein Beispiel:

[public] [abstract] ReturnType methodName();

Diese Deklarationen können als public und abstract markiert werden, wie mit [optional braces] dargestellt. Es ist nicht erforderlich, da dies die Standardeinstellung ist. private, protected, package-private (aka nichts) und der Modifizierer final sind nicht zulässig und werden als Compiler-Fehler markiert. Sie haben keine Implementierung, daher gibt es ein Semikolon anstelle von geschweiften Klammern.

Ab Java 8 halten sie can non -static-Methoden with eine Implementierung. Diese müssen mit dem Modifizierer default gekennzeichnet werden. Es gelten jedoch die gleichen Einschränkungen wie für die anderen Modifikatoren (das Hinzufügen von strictfp ist jetzt gültig und abstract ist nicht mehr gültig.

Wofür ist es nützlich
Eine seiner Anwendungen ist, dass es als Gesicht für eine Dienstleistung verwendet wird. Wenn zwei Parteien zusammenarbeiten, um eine Art Service-Requester- und Service-Provider-Beziehung zu bilden, stellt der Service-Provider das Gesicht des Services (wie der Service aussieht) in Form einer Schnittstelle bereit.
Eines der OOP-Konzepte ist "Abstraktion", was bedeutet, komplexe Funktionen der Systeme zu verbergen und nur das zu zeigen, was zum Verständnis des Systems notwendig ist. Dies hilft bei der Visualisierung der Funktionsweise eines komplexen Systems. Dies kann durch Schnittstelle erreicht werden, wobei in jedem Modul visualisiert (und auch implementiert) wird, um durch die Schnittstelle eines anderen Moduls zu arbeiten

0
S R Chaitanya

Schnittstelle ist der Bauplan einer Klasse. 

Es gibt ein Konzept von oop mit dem Namen Data Abstraction, wobei zwei Kategorien vorhanden sind: eine ist abstrakte Klasse und die andere ist Schnittstelle.

Die abstrakte Klasse erzielt nur eine teilweise Abstraktion, die Schnittstelle jedoch eine vollständige Abstraktion.

In der Schnittstelle gibt es nur abstrakte Methoden und abschließende Variablen. Sie können eine beliebige Anzahl von Schnittstellen erweitern und Sie können eine beliebige Anzahl von Klassen implementieren.

Wenn eine Klasse das Interface implementiert, muss die Klasse auch die abstrakten Methoden implementieren

Schnittstelle kann nicht instanziiert werden.

interface A() {
    void print()
}
0
Revathi Bala

Eine Schnittstelle in Java ist ein Entwurf einer Klasse. Es hat nur statische Konstanten und abstrakte Methoden. Die Schnittstelle in Java ist ein Mechanismus, um eine vollständige Abstraktion zu erreichen. Es können nur abstrakte Methoden in der Java-Schnittstelle vorhanden sein, nicht der Methodenkörper. Es wird verwendet, um eine vollständige Abstraktion und Mehrfachvererbung in Java zu erreichen. Eine Schnittstelle ist eine Sammlung abstrakter Methoden. Eine Klasse implementiert eine Schnittstelle und erbt dadurch die abstrakten Methoden der Schnittstelle. Eine Schnittstelle ist keine Klasse. Das Schreiben einer Schnittstelle ähnelt dem Schreiben einer Klasse, es gibt jedoch zwei verschiedene Konzepte. Eine Klasse beschreibt die Attribute und das Verhalten eines Objekts. Eine Schnittstelle enthält Verhalten (abstrakte Methoden), die eine Klasse implementiert. Wenn die Klasse, die die Schnittstelle implementiert, abstrakt ist, müssen alle Methoden der Schnittstelle in der Klasse definiert werden. In Java ist Mehrfachvererbung nicht zulässig Die Schnittstelle ist also nur eine Möglichkeit, die Mehrfachvererbung zu implementieren. Hier ist ein Beispiel zum Verständnis der Schnittstelle

interface Printable{  
void print();  
}  

interface Showable{  
void print();  
}  

class testinterface1 implements Printable,Showable{  

public void print(){System.out.println("Hello");}  

public static void main(String args[]){  
testinterface1 obj = new testinterface1();  
obj.print();  
 }  
}
0
Ketan G

Im Allgemeinen bevorzugen wir Schnittstellen, wenn zwei weitere Implementierungen vorhanden sind. Wobei Interface als Protokoll fungiert.

Codierung an Schnittstelle, keine Implementierungen Codierung an Schnittstelle macht lose Koppelungen. 

Eine Schnittstelle ist ein Referenztyp in Java . Es ist der Klasse ähnlich. Es ist eine Sammlung abstrakter Methoden. Eine Klasse implementiert eine Schnittstelle und erbt damit die abstrakten Methoden der Schnittstelle. Neben abstrakten Methoden kann eine Schnittstelle auch Konstanten, Standardmethoden, statische Methoden und verschachtelte Typen enthalten. für mehr Details

0
Premraj