Java

Denken Sie jedoch immer daran, dass, wenn auch nur eine einzige Methode abstrakt ist, die gesamte Klasse als abstrakt deklariert werden muss. Eine einzige abstrakte Methode verdirbt den ganzen Haufen. Sie können jedoch auch nicht-abstrakte Methoden in eine abstrakte Klasse einfügen. Beispielsweise könnten Sie Methoden mit Implementierungen haben, die sich nicht von Autotyp zu Autotyp ändern sollten, wie getColor() oder setPrice(). Indem Sie nicht-abstrakte Methoden in eine abstrakte Klasse einfügen, geben Sie allen konkreten Unterklassen (konkret bedeutet nicht abstrakt) geerbte Methodenimplementierungen.

Zum Beispiel könnten Sie wollen, dass sowohl ein Ball als auch ein Reifen ein Aufprallverhalten haben, aber Ball und Reifen teilen keine Vererbungsbeziehung; Ball erweitert Toy, während Tire nur java.lang.Object erweitert. Indem Sie jedoch Ball und Tire zur Implementierung von Bounceable machen, sagen Sie, dass Ball und Tire als "Dinge, die hüpfen können" behandelt werden können, was in Java mit "Dinge, für die Sie die Methoden bounce() und setBounceFactor() aufrufen können" übersetzt wird.

Wenn Sie eine Schnittstelle erstellen, definieren Sie einen Vertrag darüber, was eine Klasse tun kann, ohne etwas darüber zu sagen, wie die Klasse es tun wird. Eine Schnittstelle ist ein Vertrag.

Sie könnten zum Beispiel eine Schnittstelle Bounceable schreiben, die besagt: "Dies ist die Schnittstelle Bounceable. Jede Klasse, die diese Schnittstelle implementiert, muss zustimmen, den Code für die Methoden bounce() und setBounceFactor() zu schreiben.

Ein Interface ist wie eine 100% abstrakte Klasse. Während aber eine abstrakte Klasse sowohl abstrakte als auch nicht-abstrakte Methoden definieren kann, kann eine Schnittstelle nur abstrakte Methoden haben.

1) Alle Methoden eines Interfaces sind public und abstrakt.

2) Alle in einer Schnittstelle definierten Variablen müssen öffentlich, statisch und final sein - mit anderen Worten, Schnittstellen können nur Konstanten deklarieren, keine Instanzvariablen.

3) Schnittstellenmethoden dürfen nicht statisch sein.

4)Da Schnittstellenmethoden abstrakt sind, können sie nicht als final, strictfp oder native gekennzeichnet werden

5) Eine Schnittstelle kann eine oder mehrere andere Schnittstellen erweitern.

6) Eine Schnittstelle muss mit dem Schlüsselwort interface deklariert werden.

Es ist erlaubt, Konstanten in eine Schnittstelle aufzunehmen. Auf diese Weise garantieren Sie, dass jede Klasse, die die Schnittstelle implementiert, Zugriff auf dieselbe Konstante hat.

Wenn Sie die Konstanten direkt in der Schnittstelle platzieren, hat jede Klasse, die die Schnittstelle implementiert, direkten Zugriff auf die Konstanten, so als ob die Klasse sie geerbt hätte.

Bei Schnittstellenkonstanten müssen Sie sich eine wichtige Regel merken. Sie müssen immer public static final sein (müssen das aber nicht extra deklarieren),.

WICHTIG: Schnittstellenkonstanten können nicht verändert werden. Das folgende würde nicht kompilieren:

interface Foo {

 int BAR = 42;

 void go();

}

class Zap implements Foo {

 public void go() {

 BAR = 27;

 }

}

Default oder Public

Punkt Operator 

class Zoo {

 public String coolMethod() {

 return "Wow baby";

 }

}

class Moo {

 public void useAZoo() {

 Zoo z = new Zoo();

 // If the preceding line compiles Moo has access

 // to the Zoo class

 // But... does it have access to the coolMethod()?

 System.out.println("A Zoo says, " + z.coolMethod());

 // The preceding line works because Moo can access the

 // public method

 }

}

Vererbung:

class Zoo {
 public String coolMethod() {
 return "Wow baby";
 }
}
class Moo extends Zoo {
 public void useMyCoolMethod() {
 // Does an instance of Moo inherit the coolMethod()?
 System.out.println("Moo says, " + this.coolMethod()); 
 // The preceding line works because Moo can inherit the 
 // public method
 // Can an instance of Moo invoke coolMethod() on an
 // instance of Zoo?
 Zoo z = new Zoo();
 System.out.println("Zoo says, " + z.coolMethod());
 // coolMethod() is public, so Moo can invoke it on a Zoo
 //reference 
 }
}

Wenn eine Methode oder eine Variable als öffentlich deklariert wird, bedeutet dies, dass alle anderen Klassen, unabhängig vom Paket, zu dem sie gehören, auf das Mitglied zugreifen können (vorausgesetzt, die Klasse selbst ist sichtbar)

Wenn eine Methode ohne den Punktoperator (.) aufgerufen wird (oder auf eine Variable zugegriffen wird), bedeutet dies, dass die Methode oder Variable zu der Klasse gehört, in der Sie den Code sehen. Es bedeutet auch, dass die Methode oder Variable implizit über die this-Referenz aufgerufen wird.

Nur Zugang in derselben Klasse

Ein privates Mitglied ist für jeden Code außerhalb seiner eigenen Klasse unsichtbar

Wenn ein Element als privat deklariert ist, kann eine Unterklasse es nicht erben.

Die Zugriffssteuerungsebenen "Protected" und der Standardzugriff sind fast identisch, allerdings mit einem entscheidenden Unterschied. Auf ein Standardmitglied kann nur zugegriffen werden, wenn die Klasse, die auf das Mitglied zugreift, zum selben Paket gehört, während auf ein geschütztes Mitglied (durch Vererbung) von einer Unterklasse zugegriffen werden kann, selbst wenn die Unterklasse in einem anderen Paket liegt.

Nein. Methode "testIt" hat Standardzugriff, nur Zugriff im selben Paket möglich.

Nein, können nicht über .-Referenz zugreifen aufgrund "Protected"

Für eine Unterklasse außerhalb des Pakets ist der Zugriff auf das geschützte Element nur durch Vererbung möglich.

Der Compiler gibt die gleiche Fehlermeldung aus, wie wenn ein Mitglied als privat deklariert wird. Die Unterklasse Child (in einem anderen Paket als die Oberklasse Parent) kann das Standardmitglied x der Oberklasse nicht sehen oder verwenden!