Leitfaden zum Beherrschen der Kapselung in Java für Anfänger

Verkapselung ist der Prozess, bei dem Daten zu einer einzigen Einheit zusammengefasst werden und nicht durch unbefugten Code oder Benutzer abgerufen werden können. Stellen Sie sich die Kapselung wie eine Tüte Chips im Supermarkt vor. Sie können sich die Tüte Chips ansehen, aber solange Sie nicht bezahlt haben, dürfen Sie sie nicht öffnen, um die darin enthaltenen Chips zu essen.

Der Schutz von Computerdaten ist ein Dauerthema. Schließlich müssen Sie bereit sein, einige Informationen preiszugeben, beispielsweise Ihre Krankenakten in einer Arztpraxis. Sie möchten natürlich niemals, dass diese Informationen von externen Stellen gehackt werden. Aber auch innerhalb eines Unternehmens oder einer Organisation möchten Sie, dass möglichst wenige Personen – nur diejenigen, die es wissen müssen – Zugriff auf diese Daten haben.

Was genau ist Datenkapselung in Java? Wie funktioniert es und wann sollten Sie es verwenden? Im Folgenden gehen wir auf die Grundlagen ein, damit Sie Ihre Daten bestmöglich schützen können.

Schnelle Navigation
Was ist Datenkapselung in Java?Verwendung der Datenkapselung in JavaÜberprüfung der Datenkapselung3 häufige DatenkapselungsfehlerDie Variable ist weniger eingeschränkt als im Getter & SetterGetter enthält die zurückgegebene ObjektreferenzSetter enthält zugewiesene ObjektreferenzRessourcen zur Datenkapselung

Was ist Datenkapselung in Java?

Java-Logo

Datenkapselung ist ein Konzept der objektorientierten Programmierung (OOP) zum Schutz von Daten. Dies geschieht durch die Kombination der Variablen (Daten) und des Codes (Methoden) in einem Paket. Nach der Kapselung ist auf alle Variablen kein Zugriff mehr möglich, es sei denn, es werden Methoden verwendet, die dieser Klasse zugeordnet sind. Dieser Vorgang wird auch als Data Hiding bezeichnet.

Die Durchführung der Datenkapselung erfolgt in drei Schritten:

  • Legen Sie Klassenvariablen als privat fest.
  • Definieren Sie die Getter-Methode, die die zu lesenden Variablendaten abruft.
  • Definieren Sie die Setter-Methode, mit der Daten geändert werden können oder nicht.
  • Die Kapselung bietet eine Reihe von Vorteilen:

    • Flexibilität: Klassenvariablen können einfach auf schreibgeschützt oder schreibgeschützt eingestellt werden. Außerdem können Sie die Datentypen einschränken, die in ein Feld eingegeben werden können. Sie können auch Ereignisse auslösen, wenn Daten geändert werden.
    • Ausblenden von Daten: Benutzer können nicht auf variable Daten zugreifen, es sei denn, sie verwenden die vordefinierte Getter-Methode.
    • Daten pflegen: Der gekapselte Anwendungscode ist in diskrete Einheiten – Setter, Getter, Methoden, Klassen usw. – segmentiert, was bedeutet, dass Sie mit einer einzelnen Einheit arbeiten können, ohne die Leistung anderer zu beeinträchtigen.
    • Daten wiederverwenden: Gekapselte Daten können an mehreren Stellen in der Anwendungsprogrammierschnittstelle (API) oder sogar über mehrere APIs hinweg wiederverwendet werden.

    Verwendung der Datenkapselung in Java

    Wie oben erwähnt, ist die Datenkapselung ein dreistufiger Prozess. Zunächst legen Sie Klassenvariablen als privat fest. Zweitens definieren Sie die Getter-Methoden für den Zugriff auf diese variablen Daten. Schließlich bestimmen definierte Setter-Methoden, ob diese Daten geändert werden können.

    Schauen wir uns zum Beispiel den folgenden Beispielcode für die Datenkapselung an:

    öffentliche Klasse SampleEncap {

    private String idNumber;

    privater String-Name;

    privates Int-Alter;

    öffentlicher String getIdNumber() {

    idNumber zurückgeben;

    }

    öffentlicher String getName() {

    Rückgabename;

    }

    public int getAge() {

    Rückkehralter;

    }

    public void setIdNumber(String newIdNumber) {

    idNumber = newIdNumber;

    }

    public void setName(String newName) {

    name = neuerName;

    }

    public void setIdAge(int newAge) {

    newAge = newAge;

    }

    }

    Wie Sie beim Betrachten des Codes oben sehen werden, besteht er aus drei Abschnitten:

    • Die Variablendaten „idNum“, „Name“ und „Alter“ werden auf „privat“ gesetzt
    • Getter-Regeln ermöglichen die Anzeige der Daten
    • Setter-Regeln machen diese Daten schreibgeschützt

    Überprüfung der Datenkapselung

    Nachdem Sie Ihre Datenkapselungsmethoden eingerichtet haben, müssen Sie den Code überprüfen, um sicherzustellen, dass er korrekt ausgeführt wird. Geben Sie zunächst die zu überprüfenden Variablendaten ein und generieren Sie dann eine Ausgabe gemäß diesem Beispielcode:

    öffentliche Klasse TestSampleEncap

    {

    public static void main (String[] args)

    {

    obj.setIdNumber(0419);

    obj.setName(„Justin“);

    obj.setAge(34);

    System.out.println(„Kunden-ID-Nummer: “ + obj.getIdNumber());

    System.out.println(„Kundenname: “ + obj.getName());

    System.out.println(„Kundenalter: “ + obj.getAge());

    }

    }

    Wie Sie sehen, besteht dieser Code aus zwei grundlegenden Komponenten: Eingabe der Kundeninformationen, die nach Abschluss der Ausführung über die Systemausgabe überprüft werden sollen. In diesem Fall sollten wir die folgenden Ausgabeergebnisse haben:

    Kunden-ID-Nummer: 0419

    Kundenname: Justin

    Alter des Kunden: 34

    3 häufige Datenkapselungsfehler

    Obwohl das Definieren und Verwenden von Gettern und Settern relativ einfach ist, sollten Sie auf diese drei häufigen Fehler achten. Jeder von ihnen zeigt, wie selbst das kleinste Codierungsproblem verhindern kann, dass Ihre Daten wie beabsichtigt verborgen bleiben.

    Die Variable ist weniger eingeschränkt als im Getter & Setter

    Schauen Sie sich genau an, was hier passiert:

    public String idNumber;

    public void setIdNumber(String id) {

    this.idNumber = id;

    }

    öffentlicher String getIdNumber() {

    gib diese.idNumber zurück.

    }

    Obwohl Setter und Getter korrekt eingerichtet sind, ist dies ein strittiger Punkt, da die anfängliche idNumber-Zeichenfolge in der ersten Zeile als öffentlich definiert wurde. Auf variable Daten kann jetzt direkt mit dem Punktoperator (.) zugegriffen werden. Um dieses Problem zu vermeiden, sollte die erste Codezeile umgeschrieben werden, um einen Modifikator für eingeschränkten Zugriff zu integrieren:

    private String idNumber;

    Getter enthält die zurückgegebene Objektreferenz

    Schauen wir uns nun diesen Getter an, um die Noten eines Schülers in einer Klasse anzuzeigen:

    privat int[] Noten;

    öffentlich int[] Noten bekommen() {

    return this.grades;

    }

    Dann verwenden wir diesen Code, um ein Array mit den darin enthaltenen Noten zu erstellen:

    int[] myGrades = {80, 50, 70, 90, 85};

    setGrades(myGrades);

    displayGrades();

    int[] copyGrades = getGrades();

    copyGrades[1] = 1;

    displayGrades();

    Das Problem besteht darin, dass die folgenden nicht übereinstimmenden Ergebnisse generiert werden:

    80 50 70 90 85

    80 1 70 90 85

    Das Problem liegt in Zeile 5 des Getter-Codes, da diese Methode wie definiert die Referenz der internen Variablen grades direkt zurückgibt. Dies hat zur Folge, dass auch externer Code auf diese Referenz zugreifen und Änderungen am Objekt vornehmen kann.

    Geben Sie die Referenz nicht direkt im Getter zurück. Geben Sie stattdessen eine Objektkopie zurück. Auf diese Weise kann externer Code immer nur auf eine Kopie zugreifen, nicht auf das eigentliche interne Objekt selbst. Schreiben Sie den Getter also folgendermaßen um:

    öffentlich int[] Noten bekommen() {

    int[] copy = new int[this.grades.length];

    System.arraycopy(this.grades, 0, copy, 0, copy.length);

    Rückgabeexemplar;

    }

    Unsere Daten sind jetzt tatsächlich gekapselt und für unbefugten Code unzugänglich.

    Setter enthält zugewiesene Objektreferenz

    Hier ist ein weiteres Problem, das es wert ist, diskutiert zu werden. Schauen Sie sich zunächst diesen Setter-Code für ein Notenbuch an:

    privat int[] Noten;

    public void setGrades(int[] grd) {

    this.grades = grd;

    }

    So weit, so gut, oder? Der folgende Code veranschaulicht jedoch das Problem, auf das wir letztendlich stoßen:

    int[] myGrades = {80, 50, 70, 90, 85};

    setGrades(myGrades);

    displayGrades();

    meine Noten[1] = 1;

    displayGrades();

    Das Problem tritt schließlich mit diesem Code zur Anzeige der Noten auf:

    public void displayGrades() {

    for (int i = 0; i < this.grades.length; i++) {

    System.out.print(this.grades[i] + “ „);

    }

    System.out.println();

    }

    Im Moment sind die von den Zeilen 2 und 3 oben erzeugten Werte dieselben:

    80 50 70 90 85

    Allerdings gibt es ein Problem mit Zeile 4, wenn wir sie wie folgt umschreiben, wodurch das zweite Element im Array geändert wird:

    meine Noten[1] = 1;

    Wenn wir nun den Code zur Anzeige von Noten erneut ausführen, schauen wir uns an, was mit der zweiten Zahl im Array passiert:

    80 1 70 90 85

    Die Note hat sich von 50 auf 1 geändert. Sicher, das scheint etwas kompliziert zu sein, aber das Problem liegt darin, dass Daten außerhalb der zuvor definierten Parameter des Setters manipuliert wurden. Schauen wir uns noch einmal die Methode zum Festlegen von Noten an:

    public void setGrades(int[] grd) {

    this.grades = grd;

    }

    Hier liegt das Problem: Die Variable „notes“ wird direkt dem Parametervariablenraster der Methode zugewiesen. Das Ergebnis ist, dass beide Variablen auf dasselbe Objekt verweisen: das myGrades-Array. Alle an diesen Notenvariablen oder der myGrades-Variablen vorgenommenen Änderungen wirken sich auf dasselbe Objekt aus.

    Die Lösung besteht darin, Elemente einzeln aus dem Array „grd“ in das Array „grades“ zu kopieren. Ihr aktualisierter Setter-Code sollte wie folgt aussehen:

    public void setGrades(int[] grd) {

    this.grades = new int[grd.length];

    System.arraycopy(grd, 0, this.grades, 0, grd.length);

    }

    Die resultierende Ausgabe aus den Zeilen 2 und 3 des Anzeigecodes ist nun konsistent als myGrades[1] = 1; hat keinen Einfluss mehr auf die Array-Qualitäten:

    80 50 70 90 85

    80 50 70 90 85

    Denken Sie daran: Wenn Sie eine Objektreferenz an einen Setter übergeben, kopieren Sie die Referenz anschließend nicht in die interne Variable. Kopieren Sie stattdessen Elemente von einem Array in ein anderes, indem Sie die Methode System.arraycopy() verwenden.

    Ressourcen zur Datenkapselung

    Der erste Ort, an dem Sie mehr über die Datenkapselung in Java erfahren können, ist bei Oracle Java Entwickler-Kit (JDK) Wissensdatenbank. Sie können für jede JDK-Release-Version auf eine Vielzahl unterschiedlicher Ressourcen zugreifen – API-Dokumentation, Videos und herunterladbare Bücher.

    Darüber hinaus sollten Sie sich umsehen Kapselung in Java-OOPs. In diesem ausführlichen Tutorial wird anhand von Videos und Screenshots erläutert, wie Kapselung und Datenverbergung in Java funktionieren. Außerdem gibt es einen interessanten Abschnitt darüber, wie das Verstecken von Daten beispielsweise Bankkonten vor Hackern schützen kann.

    Während die Vor- und Nachteile der Datenkapselung und ihrer Getter und Setter zunächst etwas überwältigend sein können, ist es wichtig, dass Sie diese Methoden effektiv in Ihre Java-Programmierung integrieren. Schließlich geht es nicht nur darum, Daten vor dem Zugriff oder der Manipulation durch externe Hacker zu schützen. Außerdem müssen Sie den Zugriff auf die Personen beschränken, die damit arbeiten müssen.

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen