Einführung
Kapselung ist wie eine Tasche, die die Operationen und die mit einem Objekt verbundenen Daten zusammenfasst. Polymorphismus ist die Fähigkeit eines Objekts, viele Formen anzunehmen. In diesem Lab werden Sie sehen, wie sie aussehen.
Polymorphismus
Polymorphismus ist eine der OOP-Eigenschaften, die es uns ermöglichen, eine einzelne Aktion auf verschiedene Weise auszuführen. Polymorphismus, der während der Kompilierzeit aufgelöst wird, ist statischer Polymorphismus oder Kompilierzeit-Polymorphismus (Überladen gehört zu diesem Typ). Polymorphismus, der während der Laufzeit aufgelöst wird, wird Laufzeit-Polymorphismus genannt (Überschreiben gehört zu diesem Typ). Polymorphismus bietet auch die Eigenschaft eines Objekts, viele Formen anzunehmen. Ein sehr häufiger Gebrauch von Polymorphismus in der OOP besteht darin, dass eine Referenz auf die Elternklasse verwendet wird, um auf ein Objekt der Kindklasse zu verweisen. Jedes Java-Objekt, das mehr als einen IS-A-Test bestehen kann, gilt als polymorph. Eine Referenzvariable kann auf jedes Objekt ihres deklarierten Typs oder auf jedes Untertyp ihres deklarierten Typs verweisen. Eine Referenzvariable kann als Klassen-Typ oder als Schnittstellen-Typ deklariert werden. Der Fall der Vererbung ist eine Form von Polymorphismus, da es verschiedene Arten von Verhaltensweisen und Merkmalen von Tieren gibt. Hier stellen wir jedoch eine andere Form von Polymorphismus vor:
Beispiel:
Schreiben Sie folgenden Code in die Datei /home/labex/project/polymorphismTest.java:
// Wir deklarieren eine Schnittstelle life, sie hat einige Methoden, wir lassen sie hier weg.
interface life{}
// Und deklarieren eine Klasse, um Polymorphismus zu realisieren, den inneren Inhalt ignorieren wir für diesen Fall.
class Animal{}
// Wir deklarieren eine Human-Klasse, um die Klasse Animal und die life-Schnittstelle zu verwenden.
class Human extends Animal implements life{}
public class polymorphismTest{
public static void main(String[] args){
Human human = new Human(); // Instanziieren eines Human-Objekts
// Human hat eine direkte oder indirekte Vererbungszusammenhang mit Animal, Object
// Human implementiert die life-Schnittstelle, daher liefert der instanceof-Ausdruck true
System.out.println("human ist Instanz von Human? " + (human instanceof Human));
System.out.println("human ist Instanz von Animal? " + (human instanceof Animal));
System.out.println("human ist Instanz von life? " + (human instanceof life));
System.out.println("human ist Instanz von Object? " + (human instanceof Object));
}
}
Ausgabe:
Führen Sie die Datei polymorphismTest.java mit folgenden Befehlen aus:
javac /home/labex/project/polymorphismTest.java
java polymorphismTest
Sehen Sie sich die Ausgabe an:
human ist Instanz von Human? true
human ist Instanz von Animal? true
human ist Instanz von life? true
human ist Instanz von Object? true
Kapselung
Kapselung ist ein Begriff, der uns die Details eines Programms verbergen lässt. Andere Aufrufer müssen nur wissen, was ein Programm Ihnen geben kann, ohne zu wissen, wie es funktioniert. Die Kapselung vereinfacht die Entwicklung. Es ist ein Mechanismus, um Daten (Variablen) und Algorithmen (Methoden-Code) zu verpacken. Bei der Kapselung werden die Variablen einer Klasse von anderen Klassen versteckt und können nur über die Methoden der Klasse zugegriffen werden. Daher wird es auch als Datenversteckung bezeichnet. Normalerweise werden die Klassenvariablen als private deklariert und wir verwenden Getter/Setter-Methoden, um auf die Daten zuzugreifen und zu steuern. Wir definieren öffentliche Methoden, um nur Funktionalitäten für andere Klassen oder für die externe Verwendung bereitzustellen. Manchmal definieren wir private Methoden, die nur innerhalb der Klasse für bestimmte Zwecke verwendet werden. So verbergen wir die Details.
Beispiel:
Schreiben Sie folgenden Code in die Datei /home/labex/project/encapsulationTest.java:
class Person{
/*
* Es gibt zwei Member-Variablen in Person
* Sie sind privat, daher können sie nicht direkt außerhalb dieser Klasse zugegriffen werden.
*/
private String name;
private int age;
// leerer Konstruktor
public Person(){
}
// Konstruktor mit zwei Parametern
public Person(String name,int age){
this.name = name;
this.age = age;
}
// Verwenden Sie diese Methode, um den Namen-Wert zu erhalten
public String getName(){
return this.name;
}
// Verwenden Sie diese Methode, um den Namen-Wert zu setzen
public void setName(String name){
this.name = name;
}
// Verwenden Sie diese Methode, um den Alter-Wert zu erhalten
public int getAge(){
return this.age;
}
// Verwenden Sie diese Methode, um den Alter-Wert zu setzen
public void setAge(int age){
this.age = age;
}
}
public class encapsulationTest{
public static void main(String[] args){
Person p = new Person();
// Wir setzen den Namen und das Alter einer Person mit den setXXX()-Methoden
p.setName("Mike");
p.setAge(20);
// Wir erhalten den Namen und das Alter einer Person mit den getXXX()-Methoden
System.out.println("Name: " + p.getName() + ", Alter: " + p.getAge());
}
}
Ausgabe:
Führen Sie die Datei encapsulationTest.java mit folgenden Befehlen aus:
javac /home/labex/project/encapsulationTest.java
java encapsulationTest
Sehen Sie sich die Ausgabe an:
Name: Mike, Alter: 20
Zusammenfassung
Mit der Kapselung müssen wir nicht direkt auf die Objekt-Daten oder -Eigenschaften über object.XXX zugreifen, sondern verwenden einige Standardmethoden in Form von getXXX(), setXXX() und anderen Methoden, um dies zu tun. In der generischen Programmierung wird der Vorteil des Polymorphismus sichtbar, aber für jetzt sollten Sie sich nur daran erinnern, dass der Polymorphismus es einem Objekt ermöglicht, viele Formen anzunehmen.
