Objektorientierte Programmierung || Verkapselung

Wie wir alle wissen, ist die Kapselung eine der vier Säulen von OOPS und wir können damit die Daten ausblenden und einige Einschränkungen hinzufügen, um den Vorgang an der Instanzvariablen der Klassen auszuführen Dabei möchten wir sicherstellen, dass die Kapselung perfekt durchgeführt wurde.
Im Allgemeinen wurde uns gesagt, dass wir die zu erstellende Variable verbergen müssen, damit niemand sie ändern kann, außer der Klasse selbst, in der diese Variable definiert wurde. Um also auf diese Variable außerhalb der Klasse zuzugreifen (falls erforderlich), definieren wir die Getter- und Setter-Methode, damit wir die notwendigen Operationen im Zusammenhang mit diesem Instanz-Vairbale durchführen können.
Siehe den folgenden Java-Beispielcode::

// Class for a bank account Holder
public class BankAccountHolder {

    // Private fields to store account information
    private String accountNumber;
    private String accountHolderName;
    private double balance;

    // Public constructor to initialize a new BankAccount
    public BankAccount(String accountNumber, String accountHolderName, double initialBalance) throws Exception {
        setAccountNumber(accountNumber);
        setAccountHolderName(accountHolderName);
        setBalance(initialBalance);
    }

    // Public getter for accountNumber
    public String getAccountNumber() {
        return accountNumber;
    }

    // Private setter for accountNumber
    private void setAccountNumber(String accountNumber) throws Exception {
        if (accountNumber != null && !accountNumber.isEmpty()) {
            this.accountNumber = accountNumber;
        } else {
            throw new Exception("Invalid account number.");
        }
    }

    // Public getter for accountHolderName
    public String getAccountHolderName() {
        return accountHolderName;
    }

    // Public setter for accountHolderName
    public void setAccountHolderName(String accountHolderName) throws Exception {
        if (accountHolderName != null && !accountHolderName.isEmpty()) {
            this.accountHolderName = accountHolderName;
        } else {
            throw new Exception("Invalid account holder name.");
        }
    }

    // Public getter for balance
    public double getBalance() {
        return balance;
    }

    // Private setter for balance
    private void setBalance(double balance) throws Exception {
        if (balance >= 0) {
            this.balance = balance;
        } else {
            throw new Exception("Invalid initial balance.");
        }
    }
}

Im obigen Beispiel haben wir 3 Variablen als accountNumber, accountHolderName, balance als private Methode und wir haben die Getter und Setter für jede dieser 3 definiert, sodass bei Verwendung eine andere Klasse die verwenden möchte Instanzvariablen, die sie problemlos verwenden können.
Aber das ist noch nicht alles, wir nehmen an, wir wollen auch hier zwei weitere Methoden, damit wir auf dieses Konto ein- und auszahlen können.
Bitte beachten Sie, dass wir hier nicht die Sicherheit auf Anwendungsebene besprechen und davon ausgehen, dass unser Team bei der Autorisierung des Benutzers perfekte Arbeit geleistet hat.
Mit den beiden neuen Methoden werden wir also versuchen, bei der Durchführung der Abhebung und Einzahlung des Betrags den direkten Aufruf der Instanzvariablen „Balance“ zu vermeiden. Stattdessen aktualisieren wir dies mit der Setter-Methode, da die Setter-Methode sicherstellt, dass die Ausnahme ausgelöst wird, wenn eine der Regeln für die Instanzvariable verletzt.
Nachfolgend finden Sie den Code für Einzahlungs- und Auszahlungsmethoden, den wir in der BankAccountHolder-Klasse hinzufügen werden.

 public void deposit(double amount) throws Exception {
        if (amount > 0) 
            int finalBalance = this.getBalance() + amount;
            setBalance(finalBalance);
        } else {
            throw new Exception("Deposit amount must be positive.");
        }
    }

    // Public method to withdraw an amount from the account
    public void withdraw(double amount) throws Exception {
        if (amount > 0 && amount <= this.getBalance()) {
            int finalBalance = this.getBalance() - amount;
            setBalance(finalBalance);
        } else {
            throw new Exception("Invalid withdrawal amount.");
        }
    } 

Zusammenfassung: Wir werden versuchen, den Aufruf der Instanzvariablen auch direkt in der Klasse zu vermeiden, um die Sicherheitsstandards in unserem Code zu erfüllen.

Das obige ist der detaillierte Inhalt vonObjektorientierte Programmierung || Verkapselung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!