Getter und Setter

Hallo! In früheren Vorlesungen haben Sie bereits gelernt, wie Sie eigene, vollwertige Kurse mit Fachgebieten und Methoden erstellen. Das ist ein ernsthafter Fortschritt, gut gemacht! Aber jetzt muss ich Ihnen eine unangenehme Wahrheit sagen. Wir haben unsere Klassen nicht ganz richtig erstellt! Warum? Auf den ersten Blick gibt es in dieser Klasse keine Fehler:

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Miau!");
   }
}

Tatsächlich gibt es das. Stellen Sie sich vor, Sie hätten bei der Arbeit eine Klasse wie diese geschrieben Cat, in der es um Katzen geht. Und er ging nach Hause. Während Ihrer Abwesenheit kam ein anderer Programmierer zur Arbeit, erstellte seine eigene Klasse Mainund begann, die von Ihnen geschriebene Klasse zu verwenden Cat.

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();
       cat.name = "";
       cat.age = -1000;
       cat.weight = 0;
   }
}

Es spielt keine Rolle, warum er es getan hat oder wie es passiert ist: Vielleicht war die Person müde oder hat nicht genug geschlafen. Noch etwas ist wichtig: Mit unserer aktuellen Klasse Catkönnen Sie Feldern verrückte Werte zuweisen. Dadurch enthält das Programm Objekte mit einem falschen Zustand, wie zum Beispiel diese Katze mit einem Alter von -1000 Jahren. Welchen Fehler haben wir letztendlich gemacht? Als wir die Klasse erstellt haben, haben wir ihre Daten offengelegt. Die Felder nameund agesind weightgemeinfrei. Auf sie kann überall im Programm zugegriffen werden: Erstellen Sie einfach ein Objekt Cat– und schon hat jeder Programmierer Zugriff auf seine Daten direkt über den „ .“ -Operator

Cat cat = new Cat();
cat.name = "";

Hier greifen wir direkt auf das Feld zu nameund legen seinen Wert fest. Wir müssen unsere Daten irgendwie vor falschen Eingriffen von außen schützen. Was wird dafür benötigt? Zunächst müssen alle Instanzvariablen (Felder) mit einem Modifikator gekennzeichnet werden private. Private ist der strengste Zugriffsmodifikator in Java. CatWenn Sie es verwenden, sind die Felder der Klasse außerhalb der Klasse nicht zugänglich.

public class Cat {

   private String name;
   private int age;
   private int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Miau!");
   }
}

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();
       cat.name = "";//Fehler! Das Namensfeld in der Cat-Klasse hat privaten Zugriff!
   }
}

Der Compiler erkennt dies und erzeugt sofort einen Fehler. Jetzt scheinen die Felder geschützt zu sein. Es stellt sich jedoch heraus, dass der Zugang zu ihnen „fest“ verschlossen ist: Das Programm kann bei Bedarf nicht einmal das Gewicht einer vorhandenen Katze erreichen. Auch das ist keine Option: In dieser Form ist unsere Klasse praktisch nicht nutzbar. Im Idealfall müssen wir einen eingeschränkten Zugriff auf die Daten zulassen:

• Andere Programmierer sollten in der Lage sein, Objekte zu erstellenCat
• Sie sollten in der Lage sein, Daten von bereits vorhandenen Objekten zu lesen (z. B. den Namen oder das Alter einer bereits vorhandenen Katze abzurufen).
• Es sollte auch möglich sein, Feldwerte zuzuweisen. Aber gleichzeitig - nur richtige Werte. Unsere Objekte müssen vor falschen Objekten geschützt werden (kein „Alter = -1000 Jahre“ und dergleichen).

Die Liste der Anforderungen ist in Ordnung! Tatsächlich lässt sich all dies jedoch leicht mit speziellen Methoden erreichen – Getter und Setter . Der Name kommt aus dem Englischen „ get “ – „ empfangen “ (d. h. „Methode zum Abrufen des Werts eines Felds“) und set – „ set “ (d. h. „Methode zum Festlegen des Werts eines Felds“). Sehen wir uns am Beispiel unserer Klasse an, wie sie aussehen Cat:

public class Cat {

   private String name;
   private int age;
   private int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Miau!");
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       this.age = age;
   }

   public int getWeight() {
       return weight;
   }

   public void setWeight(int weight) {
       this.weight = weight;
   }
}

Wie Sie sehen, ist alles ganz einfach :) Ihre Namen bestehen meist aus dem Wort get/set + dem Namen des Feldes, für das sie verantwortlich sind. Beispielsweise gibt eine Methode getWeight()den Feldwert weightdes Objekts zurück, für das sie aufgerufen wurde. So sieht es im Programm aus:

public class Main {

   public static void main(String[] args) {

       Cat barsik = new Cat(„Barsik“, 5, 4);
       String barsikName = barsik.getName();
       int barsikAge = barsik.getAge();
       int barsikWeight = barsik.getWeight();

       System.out.println(„Katzenname:“ + barsikName);
       System.out.println(„Alter der Katze:“ + barsikAge);
       System.out.println(„Gewicht der Katze:“ + barsikWeight);
   }
}

Konsolenausgabe:

Name кота: Барсик
Возраст кота: 5
Вес кота: 4

MainNun gibt es von einer anderen Klasse ( ) Zugriff auf die Felder Cat, allerdings nur über Getter . Bitte beachten Sie, dass Getter über einen Zugriffsmodifikator verfügen public, was bedeutet, dass sie von überall im Programm aus zugänglich sind. Wie wäre es mit der Zuweisung von Werten? Verantwortlich hierfür sind Setter- Methoden

public void setName(String name) {
   this.name = name;
}

Auch ihre Arbeit ist, wie Sie sehen, einfach. Wir rufen eine Methode setName()für ein Objekt auf Cat, übergeben ihr einen String als Argument und dieser String wird einem Feld nameunseres Objekts zugewiesen.

public class Main {

   public static void main(String[] args) {

       Cat barsik = new Cat(„Barsik“, 5, 4);

       System.out.println(„Der ursprüngliche Name der Katze ist“ + barsik.getName());
       barsik.setName("Basilikum");
       System.out.println(„Der neue Name der Katze –“ + barsik.getName());
   }
}

Hier haben wir sowohl Getter als auch Setter verwendet. Zuerst haben wir mit einem Getter den ursprünglichen Namen der Katze empfangen und an die Konsole ausgegeben. Dann namewurde seinem Feld mithilfe eines Setters ein neuer Wert zugewiesen – „Vasily“. Und dann haben wir mit einem Getter den Namen erneut abgerufen, um zu überprüfen, ob er sich wirklich geändert hat. Konsolenausgabe:

Изначальное Name кота — Барсик
Новое Name кота — Васoderй

Es scheint, was ist der Unterschied? Wir können Objektfeldern auch falsche Werte zuweisen, selbst wenn wir Setter haben:

public class Main {

   public static void main(String[] args) {

       Cat barsik = new Cat(„Barsik“, 5, 4);
       barsik.setAge(-1000);

       System.out.println(„Zeitalter von Barsik –“ + barsik.getAge() + " Jahre");
   }
}

Konsolenausgabe:

Возраст Барсика — -1000 лет

Der Unterschied besteht darin, dass ein Setter eine vollwertige Methode ist . Und in einer Methode können Sie im Gegensatz zu einem Feld die Verifizierungslogik einfügen, die Sie benötigen, um inakzeptable Werte zu verhindern. Sie können beispielsweise die Zuweisung einer negativen Zahl als Alter ganz einfach deaktivieren:

public void setAge(int age) {
   if (age >= 0) {
       this.age = age;
   } else {
       System.out.println(„Fehler! Alter darf nicht negativ sein!“);
   }
}

Und jetzt funktioniert unser Code korrekt!

public class Main {

   public static void main(String[] args) {

       Cat barsik = new Cat(„Barsik“, 5, 4);
       barsik.setAge(-1000);

       System.out.println(„Zeitalter von Barsik –“ + barsik.getAge() + " Jahre");
   }
}

Konsolenausgabe:

Ошибка! Возраст не может быть отрицательным числом!
Возраст Барсика — 5 лет

Es gibt eine Einschränkung innerhalb des Setters, die vor Versuchen schützt, falsche Daten festzulegen. Barsiks Alter blieb unverändert. Getter und Setter sollten immer erstellt werden. Auch wenn Ihre Felder keine Einschränkungen hinsichtlich der möglichen Werte haben, können sie keinen Schaden anrichten. Stellen Sie sich eine Situation vor: Sie und Ihre Kollegen schreiben gemeinsam ein Programm. Sie haben eine Klasse Catmit öffentlichen Feldern erstellt und alle Programmierer verwenden sie nach Belieben. Und dann dämmert es Ihnen eines schönen Tages: „Verdammt, früher oder später könnte jemand versehentlich einer Variablen eine negative Zahl zuweisen weight!“ Wir müssen Setter erstellen und alle Felder privat machen!“ Sie erstellen sie und der gesamte von Ihren Kollegen geschriebene Code geht sofort kaputt. Schließlich hatten sie bereits eine Menge Code geschrieben, in dem sie Catdirekt auf die Felder zugegriffen haben.

cat.name = "Nilpferd";

Und jetzt sind die Felder privat geworden und der Compiler produziert eine Menge Fehler!

cat.name = "Nilpferd";//Fehler! Das Namensfeld der Cat-Klasse hat privaten Zugriff!

In einer solchen Situation wäre es besser, die Felder auszublenden und von Anfang an Getter-Setter zu erstellen . Alle Ihre Kollegen würden sie verwenden, und wenn Ihnen spät klar wurde, dass Sie die Feldwerte begrenzen müssen, fügten Sie einfach ein Häkchen in den Setter ein. Und niemand würde den bereits geschriebenen Code brechen. Wenn Sie nur Lesezugriff auf ein bestimmtes Feld wünschen, können Sie natürlich einen Getter dafür erstellen. „Outside“, also außerhalb Ihrer Klasse, sollten nur Methoden zur Verfügung stehen. Die Daten müssen ausgeblendet sein. Eine Analogie lässt sich mit einem Mobiltelefon ziehen. Stellen Sie sich vor, dass Sie anstelle eines normalen eingeschalteten Mobiltelefons ein Telefon mit offenem Gehäuse erhalten, in dem sich alle Kabel, Schaltkreise usw. befinden. ragt heraus. Das Telefon funktioniert: Wenn Sie sich anstrengen und mit den Diagrammen herumspielen, können Sie vielleicht sogar einen Anruf tätigen. Aber du wirst es wahrscheinlich einfach kaputt machen. Stattdessen stellt Ihnen der Hersteller eine Schnittstelle zur Verfügung: Der Kunde wählt einfach die gewünschten Nummern, drückt mit dem Hörer die grüne Taste und schon beginnt das Gespräch. Und es ist ihm egal, was im Inneren mit den Schaltkreisen und Leitungen vor sich geht und wie sie ihre Aufgabe erfüllen. In diesem Beispiel hat das Unternehmen nur begrenzten Zugriff auf die „Interna“ (Daten) des Telefons und lässt nur die Schnittstelle (Methoden) außen vor. Dadurch erhält der Kunde, was er wollte (einen Anruf tätigen) und wird mit Sicherheit nichts kaputt machen.