Java Encapsulation

Die Kapselung ist ein grundlegendes Prinzip der objektorientierten Programmierung (OOP) in Java, bei dem die Daten (Variablen) und die Methoden (Funktionen), die mit den Daten arbeiten, in einer einzigen Einheit, der so genannten Klasse, gebündelt werden. Sie schränkt den direkten Zugriff auf einige Komponenten eines Objekts ein und kann die versehentliche Änderung von Daten verhindern.

Zweck der Verkapselung

• Daten verstecken: Die Verkapselung ermöglicht es, die interne Darstellung eines Objekts nach außen hin zu verbergen. Nur die notwendigen Details werden über eine öffentliche Schnittstelle offengelegt.
• Erhöhte Flexibilität: Indem du den Zugriff auf die Felder einer Klasse kontrollierst, kannst du die interne Implementierung ändern, ohne den externen Code zu beeinflussen, der die Klasse verwendet.
• Verbesserte Wartbarkeit: Die Kapselung hilft bei der Pflege des Codes, indem sie die Felder privat hält und öffentliche Getter- und Setter-Methoden bereitstellt, um die Felder zu ändern und anzuzeigen.

Implementierung der Kapselung in Java

Um Kapselung in Java zu erreichen:

1. Deklariere die Klassenvariablen als private.
2. Biete public Getter- und Setter-Methoden an, um auf den Wert einer privaten Variable zuzugreifen und ihn zu aktualisieren.

Beispiel 1: Grundlegende Verkapselung

public class Student {
    private String name;
    private int age;

    // Getter method for name
    public String getName() {
        return name;
    }

    // Setter method for name
    public void setName(String name) {
        this.name = name;
    }

    // Getter method for age
    public int getAge() {
        return age;
    }

    // Setter method for age
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}
Bereitgestellt von

In diesem Beispiel hat die Klasse Student die privaten Felder name und age. Öffentliche Getter- und Setter-Methoden werden bereitgestellt, um auf diese Felder zuzugreifen und sie zu ändern. Der Setter für age enthält eine grundlegende Validierungsprüfung.

Beispiel 2: Verkapselung mit Validierung

public class BankAccount {
    private double balance;

    // Getter method for balance
    public double getBalance() {
        return balance;
    }

    // Setter method for balance with validation
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
}
Bereitgestellt von

Die Klasse BankAccount kapselt das Feld balance. Es bietet die Methoden deposit und withdraw, um den Saldo zu ändern und sicherzustellen, dass nur gültige Operationen durchgeführt werden.

Tipps und bewährte Praktiken

• Private Felder verwenden: Deklariere Klassenfelder immer als private, um sie vor externen Änderungen zu schützen.
• Biete Zugangsmethoden an: Verwende public Getter- und Setter-Methoden, um den Zugriff auf die Felder zu steuern. Dies ermöglicht eine Validierung und Flexibilität bei der Änderung der internen Implementierung.
• Validierungslogik: Implementiere eine Validierungslogik in Setter-Methoden, um sicherzustellen, dass der Objektstatus konsistent bleibt.
• Unveränderliche Klassen: Erwäge, Klassen unveränderlich zu machen (ohne Setter), wenn sich der Objektzustand nach der Erstellung nicht ändern soll. Das erhöht die Sicherheit und vereinfacht die gleichzeitige Programmierung.