Objektorientierte Programmierkonzepte in Java

1. Übersicht

In diesem Artikel werden wir uns mit objektorientierten Programmierkonzepten (OOP) in Java befassen. Wir werden Klassen, Objekte, Abstraktion, Kapselung, Vererbung und Polymorphismus diskutieren .

2. Klassen

Klassen sind der Ausgangspunkt aller Objekte, und wir können sie als Vorlage zum Erstellen von Objekten betrachten. Eine Klasse enthält normalerweise Mitgliedsfelder, Mitgliedsmethoden und eine spezielle Konstruktormethode.

Wir werden den Konstruktor verwenden, um Objekte der Klasse zu erstellen:

public class Car { // member fields private String type; private String model; private String color; private int speed; // constructor public Car(String type, String model, String color) { this.type = type; this.model = model; this.color = color; } // member methods public int increaseSpeed(int increment) { this.speed = this.speed + increment; return this.speed; } // ... }

Beachten Sie, dass eine Klasse mehr als einen Konstruktor haben kann. Wir können mehr über die Klassen in unserem Klassenartikel lesen.

3. Objekte

Objekte werden aus Klassen erstellt und als Instanzen der Klasse bezeichnet. Wir erstellen Objekte aus Klassen mit ihren Konstruktoren:

Car veyron = new Car("Bugatti", "Veyron", "crimson"); Car corvette = new Car("Chevrolet", "Corvette", "black"); 

Hier haben wir zwei Instanzen der Klasse Car erstellt. Lesen Sie mehr darüber in unserem Objektartikel.

4. Abstraktion

Abstraktion verbirgt die Komplexität der Implementierung und macht einfachere Schnittstellen sichtbar.

Wenn wir an einen typischen Computer denken, kann man nur die externe Schnittstelle sehen, die für die Interaktion mit ihm am wichtigsten ist, während interne Chips und Schaltkreise vor dem Benutzer verborgen sind.

In OOP bedeutet Abstraktion, dass die komplexen Implementierungsdetails eines Programms ausgeblendet werden und nur die API verfügbar gemacht wird, die für die Verwendung der Implementierung erforderlich ist. In Java erreichen wir die Abstraktion mithilfe von Schnittstellen und abstrakten Klassen.

Weitere Informationen zur Abstraktion finden Sie in unseren Artikeln zu abstrakten Klassen und Schnittstellen.

5. Kapselung

Durch die Kapselung wird der Status oder die interne Darstellung eines Objekts vor dem Benutzer einer API verborgen und öffentlich zugängliche Methoden bereitgestellt, die für den Lese- / Schreibzugriff an das Objekt gebunden sind. Auf diese Weise können bestimmte Informationen ausgeblendet und der Zugriff auf die interne Implementierung gesteuert werden.

Beispielsweise sind Mitgliedsfelder in einer Klasse vor anderen Klassen verborgen und können mit den Mitgliedsmethoden aufgerufen werden. Eine Möglichkeit, dies zu tun, besteht darin, alle Datenfelder privat und nur mit den Methoden für öffentliche Mitglieder zugänglich zu machen :

public class Car { // ... private int speed; public int getSpeed() { return color; } public void setSpeed(int speed) { this.speed = speed; } // ... }

Hier wird die Feldgeschwindigkeit verkapselt die Verwendung von privaten Zugriffsmodifizierer und kann nur zugegriffen werden , um die Verwendung von öffentlichen getSpeed () und setSpeed () Methoden. Weitere Informationen zu Zugriffsmodifikatoren finden Sie in unserem Artikel zu Zugriffsmodifikatoren.

6. Vererbung

Vererbung ist der Mechanismus, mit dem eine Klasse alle Eigenschaften einer anderen Klasse durch Erben der Klasse abrufen kann. Wir nennen die erbende Klasse eine untergeordnete Klasse und die geerbte Klasse als Oberklasse oder übergeordnete Klasse.

In Java erweitern wir dazu die übergeordnete Klasse. Somit erhält die untergeordnete Klasse alle Eigenschaften vom übergeordneten Element:

public class Car extends Vehicle { //... }

Wenn wir eine Klasse erweitern, bilden wir eine IS-A-Beziehung. Das Auto IS-A Fahrzeug . Es hat also alle Eigenschaften eines Fahrzeugs .

Wir können die Frage stellen, warum wir Vererbung brauchen ? Um dies zu beantworten, betrachten wir einen Fahrzeughersteller, der verschiedene Fahrzeugtypen wie Autos, Busse, Straßenbahnen und Lastwagen herstellt.

Um die Arbeit zu vereinfachen, können wir die gemeinsamen Merkmale und Eigenschaften aller Fahrzeugtypen in einem Modul (einer Klasse im Fall von Java) bündeln. Und wir können einzelne Typen diese Eigenschaften erben und wiederverwenden lassen:

public class Vehicle { private int wheels; private String model; public void start() { // the process of starting the vehicle } public void stop() { // process to stop the vehicle } public void honk() { // produces a default honk } }

Der Fahrzeugtyp Auto erbt nun von der übergeordneten Fahrzeugklasse :

public class Car extends Vehicle { private int numberOfGears; public void openDoors() { // process to open the doors } }

Java unterstützt Einzelvererbung und Mehrebenenvererbung. Dies bedeutet, dass eine Klasse nicht direkt von mehr als einer Klasse ausgehen kann, sondern eine Hierarchie verwenden kann:

public class ArmoredCar extends Car { private boolean bulletProofWindows; public void remoteStartCar() { // this vehicle can be started by using a remote control } }

Hier ist die ArmouredCar erstreckt Auto und Auto erstreckt Fahrzeug . So ArmouredCar erben Eigenschaften von beiden Autos und Fahrzeug .

Während wir von der übergeordneten Klasse erben, kann ein Entwickler auch eine Methodenimplementierung von der übergeordneten Klasse überschreiben. Dies wird als Methodenüberschreibung bezeichnet.

In unserem obigen Beispiel für die Fahrzeugklasse gibt es die honk () -Methode. Die Car- Klasse, die die Vehicle- Klasse erweitert, kann diese Methode überschreiben und so implementieren, wie sie das Hupen erzeugen soll:

public class Car extends Vehicle { //... @Override public void honk() { // produces car-specific honk } }

Beachten Sie, dass dies auch als Laufzeitpolymorphismus bezeichnet wird, wie im nächsten Abschnitt erläutert. Weitere Informationen zur Vererbung finden Sie in unseren Artikeln zur Java-Vererbung sowie zur Vererbung und Komposition.

7. Polymorphismus

Polymorphismus ist die Fähigkeit einer OOP-Sprache, Daten je nach Art der Eingabe unterschiedlich zu verarbeiten. In Java kann dies derselbe Methodenname sein, der unterschiedliche Methodensignaturen hat und unterschiedliche Funktionen ausführt:

public class TextFile extends GenericFile { //... public String read() { return this.getContent() .toString(); } public String read(int limit) { return this.getContent() .toString() .substring(0, limit); } public String read(int start, int stop) { return this.getContent() .toString() .substring(start, stop); } }

In diesem Beispiel sehen wir, dass die Methode read () drei verschiedene Formen mit unterschiedlichen Funktionen hat. Diese Art von Polymorphismus ist statischer Polymorphismus oder Polymorphismus zur Kompilierungszeit und wird auch als Methodenüberladung bezeichnet.

Es gibt auch Laufzeit- oder dynamischen Polymorphismus, bei dem die untergeordnete Klasse die Methode des übergeordneten Elements überschreibt :

public class GenericFile { private String name; //... public String getFileInfo() { return "Generic File Impl"; } }

Eine untergeordnete Klasse kann die GenericFile- Klasse erweitern und die Methode getFileInfo () überschreiben :

public class ImageFile extends GenericFile { private int height; private int width; //... getters and setters public String getFileInfo() { return "Image File Impl"; } }

Weitere Informationen zum Polymorphismus finden Sie in unserem Artikel über Polymorphismus in Java.

8. Fazit

In diesem Artikel haben wir die grundlegenden Konzepte von OOP mit Java kennengelernt.

Die Codebeispiele in diesem Artikel sind auf Github verfügbar.