Getters og sættere

Hej! I tidligere forelæsninger har du allerede lært, hvordan du erklærer dine egne fuldgyldige klasser med metoder og felter. I dagens lektion vil vi tale om Getters og Settere i Java. Det er et seriøst fremskridt, godt gået! Men nu må jeg fortælle dig en ubehagelig sandhed. Vi har ikke erklæret vores klasser korrekt! Hvorfor? Ved første øjekast har følgende klasse ingen fejl:

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("Meow!");
   }
}

Men det gør den. Forestil dig, at du sidder på arbejde, og skriv denne Katteklasse for at repræsentere katte. Og så går du hjem. Mens du er væk, ankommer en anden programmør på arbejde. Han opretter sin egen hovedklasse , hvor han begynder at bruge den kat- klasse, du skrev.

public class Main {

   public static void main(String[] args) {

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

Det er lige meget, hvorfor han gjorde det, og hvordan det skete (måske er fyren træt eller har ikke fået nok søvn). Noget andet betyder noget: Vores nuværende Cat -klasse tillader, at felter tildeles helt vanvittige værdier. Som et resultat har programmet objekter med en ugyldig tilstand (såsom denne kat, der er -1000 år gammel). Så hvilken fejl lavede vi, da vi erklærede vores klasse? Vi afslørede vores klasses data. Felterne for navn, alder og vægt er offentlige. De kan tilgås hvor som helst i programmet: Du skal blot oprette et Cat- objekt, og enhver programmør har direkte adgang til sine data via prik- operatoren ( . ).

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

Her får vi direkte adgang til navnefeltet og indstiller dets værdi. Vi skal på en eller anden måde beskytte vores data mod upassende ekstern interferens. Hvad skal vi gøre for at gøre det? Først skal alle instansvariabler (felter) markeres med den private modifikator. Privat er den strengeste adgangsmodifikator i Java. Når du har gjort dette, vil felterne i Cat- klassen ikke være tilgængelige uden for klassen.

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("Meow!");
   }
}

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();
       cat.name = "";//error! The Cat class's name field is private!
   }
}

Compileren ser dette og genererer straks en fejl. Nu er markerne på en måde beskyttet. Men det viser sig, at vi måske har lukket for adgangen for stramt: Du kan ikke få en eksisterende kats vægt i programmet, selvom du har brug for det. Dette er heller ikke en mulighed. Som det er, er vores klasse stort set ubrugelig. Ideelt set skal vi tillade en form for begrænset adgang:

• Andre programmører bør være i stand til at oprette Cat- objekter
• De skal være i stand til at læse data fra eksisterende objekter (f.eks. få navnet eller alderen på en eksisterende kat)
• Det skal også være muligt at tildele feltværdier. Men ved at gøre det bør kun gyldige værdier tillades. Vores objekter skal beskyttes mod ugyldige værdier (f.eks. alder = -1000 osv.).

Det er en anstændig liste over krav! I virkeligheden opnås alt dette nemt med specielle metoder kaldet getters og settere. Disse navne kommer fra "get" (dvs. "metode til at få værdien af ​​et felt") og "sæt" (dvs. "metode til at indstille værdien af ​​et felt"). Lad os se, hvordan de ser ud i vores Cat- klasse :

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("Meow!");
   }

   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;
   }
}

Som du kan se, ser de ret simple ud :) Deres navne består ofte af "get"/"set" plus navnet på det relevante felt. For eksempel returnerer metoden getWeight() værdien af ​​vægtfeltet for det objekt, det kaldes på. Sådan ser det ud i et program:

public class Main {

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5, 4);
       String smudgeName = smudge.getName();
       int smudgeAge = smudge.getAge();
       int smudgeWeight = smudge.getWeight();

       System.out.println("Cat's name: " + smudgeName);
       System.out.println("Cat's age: " + smudgeAge);
       System.out.println("Cat's weight: " + smudgeWeight);
   }
}

Konsoludgang:

Cat's name: Smudge
Cat's age: 5
Cat's weight: 4

Nu kan en anden klasse ( Main ) få adgang til Cat- felterne, men kun gennem getters. Bemærk, at getters har public access modifier, dvs. de er tilgængelige overalt i programmet. Men hvad med at tildele værdier? Det er hvad seter-metoder er til

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

Som du kan se, er de også simple. Vi kalder setName() -metoden på et Cat- objekt, sender en streng som et argument, og strengen tildeles til objektets navnefelt.

public class Main {

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5, 4);

       System.out.println("Cat's original name: " + smudge.getName());
       smudge.setName("Mr. Smudge");
       System.out.println("Cat's new name: " + smudge.getName());
   }
}

Her bruger vi både gettere og settere. Først bruger vi en getter til at få og vise kattens oprindelige navn. Derefter bruger vi en setter til at tildele et nyt navn ("Mr. Smudge"). Og så bruger vi getteren igen for at få navnet (for at tjekke om det virkelig har ændret sig). Konsoludgang:

Cat's original name: Smudge
Cat's new name: Mr. Smudge

Så hvad er forskellen? Vi kan stadig tildele ugyldige værdier til felter, selvom vi har sættere:

public class Main {

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5, 4);
       smudge.setAge(-1000);

       System.out.println("Smudge's age: " + smudge.getAge());
   }
}

Konsoludgang:

Smudge's age: -1000 years

Forskellen er, at en setter er en fuldgyldig metode. Og i modsætning til et felt, lader en metode dig skrive den verifikationslogik, der er nødvendig for at forhindre uacceptable værdier. For eksempel kan du nemt forhindre et negativt tal i at blive tildelt som en alder:

public void setAge(int age) {
   if (age >= 0) {
       this.age = age;
   } else {
       System.out.println("Error! Age can't be negative!");
   }
}

Og nu fungerer vores kode korrekt!

public class Main {

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5, 4);
       smudge.setAge(-1000);

       System.out.println("Smudge's age: " + smudge.getAge());
   }
}

Konsoludgang:

Error! Age can't be negative!
Smudge's age: 5 years

Inde i sætteren oprettede vi en begrænsning, der beskyttede os mod forsøget på at indstille ugyldige data. Smudges alder blev ikke ændret. Du bør altid oprette getters og settere. Selvom der ikke er nogen begrænsninger for, hvilke værdier dine felter kan tage, vil disse hjælpemetoder ikke skade. Forestil dig følgende situation: du og dine kolleger skriver et program sammen. Du opretter en Cat- klasse med offentlige felter. Alle programmører bruger dem, som de vil. Og så en skønne dag indser du: "Crap, før eller siden kan nogen ved et uheld tildele vægten et negativt tal! Vi skal oprette sættere og gøre alle felterne private!" Du gør netop det og bryder med det samme al den kode, som dine kolleger har skrevet. De'Kattemarker direkte.

cat.name = "Behemoth";

Og nu er felterne private, og compileren udsender en masse fejl!

cat.name = "Behemoth";//error! The Cat class's name field is private!

I dette tilfælde ville det være bedre at skjule felterne og oprette getter og settere helt fra begyndelsen. Alle dine kolleger ville have brugt dem. Og hvis du for sent indså, at du på en eller anden måde skulle begrænse feltværdierne, kunne du bare have skrevet checken inde i sætteren. Og ingens kode ville blive brudt. Selvfølgelig, hvis du ønsker, at adgang til et felt bare skal være "read only", kan du kun oprette en getter til det. Kun metoder bør være tilgængelige eksternt (dvs. uden for din klasse). Data skal skjules. Vi kunne sammenligne med en mobiltelefon. Forestil dig, at du i stedet for den sædvanlige lukkede mobiltelefon fik en telefon med åbent etui, med alle mulige udragende ledninger, kredsløb osv. Men telefonen virker: hvis du prøver rigtig meget og prikker i kredsløbene, kan du endda blive kunne foretage et opkald. Men dig' I stedet giver producenten dig en grænseflade: brugeren indtaster blot de korrekte cifre, trykker på den grønne opkaldsknap, og opkaldet begynder. Hun er ligeglad med, hvad der sker indeni med kredsløbene og ledningerne, eller hvordan de får deres arbejde gjort. I dette eksempel begrænser virksomheden adgangen til telefonens "inside" (data) og blotlægger kun en grænseflade (metoder). Som et resultat får brugeren, hvad hun ønskede (evnen til at foretage et opkald) og vil bestemt ikke ødelægge noget indeni. For at styrke det, du har lært, foreslår vi, at du ser en videolektion fra vores Java-kursus