In diesem Beitrag untersuchen wir die vier Grundpfeiler der objektorientierten Programmierung (OOP) in Java. Diese Grundprinzipien tragen dazu bei, den Code modular, wiederverwendbar und wartbar zu strukturieren. Dieser Beitrag dient als Einführung. In den kommenden Beiträgen geht es mit differenzierten Diskussionen und Beispielen tiefer auf die einzelnen Konzepte ein.
Um es leichter zu merken, verwenden Sie das Akronym „A PIE“: Abstraction, Polymorphism, Inheritance , und EEinkapselung.
Was bedeutet es, objektorientiert zu sein?
Java wird oft als objektorientierte Sprache beschrieben, ist aber nicht zu 100 % objektorientiert. Warum? Während sich die meisten Elemente in Java um Objekte drehen (wie Klassen, Objekte und Methoden), verwendet es auch primitive Typen (wie int, boolean und double), die keine Objekte.
Die Beibehaltung primitiver Typen in Java war eine bewusste Designentscheidung. Hier ist der Grund:
-
Speichereffizienz: Primitive Typen beanspruchen weniger Speicher im Vergleich zu ihren Objektgegenstücken (wie Integer oder Boolean).
-
Leistungssteigerung: Operationen an Grundelementen sind schneller, da sie den Aufwand für die Objekterstellung und Referenzverwaltung vermeiden.
-
Komfort: Primitive Typen machen den Code in einfachen Fällen sauberer, insbesondere beim Umgang mit arithmetischen und logischen Operationen.
Kurz gesagt:
Java schafft ein Gleichgewicht, indem es Grundelemente für Leistung und Speichereffizienz bereitstellt und gleichzeitig Wrapper-Klassen (wie Integer) anbietet, wenn Sie diese Werte als Objekte behandeln müssen.
1.
Abstraktion: Unnötige Details verbergen
Abstraktion bedeutet,
die interne Logik zu verbergen und dem Benutzer nur die wesentlichen Merkmale offenzulegen. Es ermöglicht dem Benutzer, auf hohem Niveau mit einem Objekt zu interagieren, ohne sich Gedanken über die zugrundeliegende Komplexität machen zu müssen. Stellen Sie sich das wie die Verwendung eines Geldautomaten vor – Sie müssen lediglich den abzuhebenden Betrag eingeben, ohne zu wissen, wie der Geldautomat mit Ihrer Bank interagiert, um die Transaktion abzuwickeln.
In Java tragen
abstrakte Klassen und Schnittstellen zur Abstraktion bei, indem sie wesentliche Methoden definieren und die internen Details entweder den untergeordneten Klassen oder innerhalb der übergeordneten Klasse überlassen aber für den Benutzer verborgen.
Beispiel:
abstract class Payment {
// A method with concrete logic, hidden from the user.
private void authenticate() {
System.out.println("Authenticating payment...");
}
// Abstract method that child classes must implement.
abstract void processPayment(double amount);
// Public method exposing only the necessary details.
public void makePayment(double amount) {
authenticate(); // Hidden complexity
processPayment(amount); // Exposed to child classes
System.out.println("Payment completed.");
}
}
// Concrete class implementing the abstract method.
class CreditCardPayment extends Payment {
@Override
void processPayment(double amount) {
System.out.println("Processing credit card payment of ₹" + amount);
}
}
public class TestAbstraction {
public static void main(String[] args) {
Payment payment = new CreditCardPayment(); // Polymorphism in action.
payment.makePayment(1000.00); // Only high-level interaction.
}
}
Nach dem Login kopieren
Nach dem Login kopieren
Nach dem Login kopieren
Erläuterung:
2. Polymorphismus: Gleiche Aktion, unterschiedliche Formen
Polymorphismus ermöglicht es einem Objekt, sich in verschiedenen Situationen unterschiedlich zu verhalten. Java unterstützt zwei Arten von Polymorphismus:
1. Polymorphismus zur Kompilierungszeit (Methodenüberladung): Wird erreicht, indem mehrere Methoden mit demselben Namen, aber unterschiedlichen Parametern definiert werden.
Beispiel:
abstract class Payment {
// A method with concrete logic, hidden from the user.
private void authenticate() {
System.out.println("Authenticating payment...");
}
// Abstract method that child classes must implement.
abstract void processPayment(double amount);
// Public method exposing only the necessary details.
public void makePayment(double amount) {
authenticate(); // Hidden complexity
processPayment(amount); // Exposed to child classes
System.out.println("Payment completed.");
}
}
// Concrete class implementing the abstract method.
class CreditCardPayment extends Payment {
@Override
void processPayment(double amount) {
System.out.println("Processing credit card payment of ₹" + amount);
}
}
public class TestAbstraction {
public static void main(String[] args) {
Payment payment = new CreditCardPayment(); // Polymorphism in action.
payment.makePayment(1000.00); // Only high-level interaction.
}
}
Nach dem Login kopieren
Nach dem Login kopieren
Nach dem Login kopieren
2. Laufzeitpolymorphismus (Methodenüberschreibung): Wird erreicht, wenn eine Unterklasse ihre spezifische Implementierung einer in der übergeordneten Klasse deklarierten Methode bereitstellt.
Beispiel:
class Calculator {
// Compile-time polymorphism (Overloading)
int add(int a, int b) {
return a + b;
}
int add(int a, int b, int c) {
return a + b + c;
}
public static void main(String[] args) {
Calculator calc = new Calculator();
System.out.println(calc.add(2, 3)); // Output: 5
System.out.println(calc.add(2, 3, 4)); // Output: 9
}
}
Nach dem Login kopieren
Erläuterung:
Kompilierungszeit-Polymorphismus wird durch Überladen der add()-Methode demonstriert, während Laufzeit-Polymorphismus durch Überschreiben der sound()-Methode gezeigt wird.
Die sound()-Methode verhält sich je nach Objekttyp unterschiedlich. Obwohl animal vom Typ Animal ist, wird zur Laufzeit die überschriebene Methode in Dog ausgeführt.
3. Vererbung: Wiederverwendbarkeit von Code durch Eltern-Kind-Beziehung
Vererbung ermöglicht einer Klasse (untergeordneten Klasse), die Eigenschaften und das Verhalten einer anderen Klasse (übergeordneten Klasse) wiederzuverwenden. Dies fördert die Wiederverwendbarkeit von Code und stellt eine IS-A-Beziehung zwischen Klassen her. Java unterstützt keine Mehrfachvererbung durch Klassen, um Mehrdeutigkeiten zu vermeiden, lässt sie jedoch über Schnittstellen zu.
Beispiel:
class Animal {
void sound() {
System.out.println("Animals make sounds.");
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("Dog barks.");
}
}
public class TestPolymorphism {
public static void main(String[] args) {
Animal animal = new Dog(); // Runtime polymorphism
animal.sound(); // Output: Dog barks
}
}
Nach dem Login kopieren
Erläuterung:
In diesem Beispiel:
Hund erbt von Tier, was bedeutet, dass der Hund sowohl fressen als auch bellen kann.
Dies demonstriert die Code-Wiederverwendung – wir mussten die eat()-Methode für die Dog-Klasse nicht neu schreiben.
4. Kapselung: Daten durch Zugriffskontrolle schützen
Kapselung bedeutet das Bündeln der Daten (Felder) und der Methoden, die sie manipulieren, in einer einzigen Einheit (Klasse). Es gewährleistet auch das Datenverbergen, indem Felder privat gemacht und verfügbar gemacht werden durch Getter und Setter.
Beispiel:
abstract class Payment {
// A method with concrete logic, hidden from the user.
private void authenticate() {
System.out.println("Authenticating payment...");
}
// Abstract method that child classes must implement.
abstract void processPayment(double amount);
// Public method exposing only the necessary details.
public void makePayment(double amount) {
authenticate(); // Hidden complexity
processPayment(amount); // Exposed to child classes
System.out.println("Payment completed.");
}
}
// Concrete class implementing the abstract method.
class CreditCardPayment extends Payment {
@Override
void processPayment(double amount) {
System.out.println("Processing credit card payment of ₹" + amount);
}
}
public class TestAbstraction {
public static void main(String[] args) {
Payment payment = new CreditCardPayment(); // Polymorphism in action.
payment.makePayment(1000.00); // Only high-level interaction.
}
}
Nach dem Login kopieren
Nach dem Login kopieren
Nach dem Login kopieren
Erläuterung:
Das Namensfeld ist privat, d. h. es kann nicht direkt von außerhalb der Klasse darauf zugegriffen werden.
Der Zugriff erfolgt über öffentliche Getter und Setter, wodurch das Datenverbergen erzwungen wird.
Abschluss
Javas OOP-Prinzipien – Abstraktion, Polymorphismus, Vererbung und Kapselung – bilden die Grundlage für das Schreiben von modularem, wartbarem und effizientem Code. Mit diesen Konzepten sind Sie besser darauf vorbereitet, komplexe Systeme zu entwerfen und zu verstehen.
In den kommenden Beiträgen werden wir uns mit differenzierteren Beispielen, Best Practices und auf Interviews ausgerichteten Tipps eingehender mit jedem dieser Prinzipien befassen. Bleiben Sie dran!
Verwandte Beiträge
Viel Spaß beim Programmieren!
Das obige ist der detaillierte Inhalt vonOOP in Java knacken: Ein Kuchen, von dem Sie ein Stück haben wollen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
