Instanceof és öröklődés a Java nyelven

Szia! Az előző leckékben már röviden megismerkedtünk az öröklődés fogalmával. Ma újra érintjük ezt a témát, de nem túl mélyen. A jövőben még lesz egy részletesebb leckénk erről. Ma csak egy gyors pillantást vetünk néhány gyakorlati példára, és megismerkedünk egy érdekes Java operátorral.

Öröklés

Szóval, mi az öröklés? Az öröklődés egy programozási mechanizmus (beleértve a Java nyelvet is), amely lehetővé teszi egy új osztály deklarálását egy meglévő osztály alapján. A származtatott osztály ezután hozzáfér a szülőosztály mezőihez és metódusaihoz. Miért lenne erre szükségünk? Nos, képzelje el, hogy egy programban több autóosztályt kell létrehoznia: teherautó, versenyautó, szedán, pickup stb. Még mielőtt kódot írna, biztosan tudja, hogy ezekben az osztályokban sok a közös: minden autónak van egy modellje. név, gyártási év, motor méret, maximális fordulatszám, stb (nem beszélve arról, hogy mindegyikben közös a kerekek és egyéb alkatrészek). Ebben a helyzetben a következőket teheti:

• Hozza létre ezeket a mezőket minden osztályban (minden egyes új autóosztályhoz a létrehozás során adja hozzá őket)
• Hozza be az összes autóra jellemző mezőket egy szülőosztályba Car, majd használja az expands kulcsszót , hogy az adott autótípushoz tartozó összes osztályt az Carosztályból származtassa.

Természetesen a második lehetőség sokkal kényelmesebb:

public class Car {

   private String model;
   private int maxSpeed;
   private int yearOfManufacture;

   public Car(String model, int maxSpeed, int yearOfManufacture) {
       this.model = model;
       this.maxSpeed = maxSpeed;
       this.yearOfManufacture = yearOfManufacture;
   }
}

public class Truck extends Car {

   public Truck(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

public class Sedan extends Car {
   public Sedan(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

Minimálisan kerüljük a felesleges kódkettőzést (és programíráskor mindig erre kell törekednünk). Ráadásul egyszerű és érthető osztálystruktúrával rendelkezünk, amelyben minden autóban közös mezők egy osztályba vannak vonva. Ha a teherautóknak van olyan speciális mezője, amivel más autók nem rendelkeznek, akkor az osztályba bejelenthető Truck. Ugyanez vonatkozik a módszerekre is. Minden autónak van bizonyos közös viselkedése, ami leírható metódusokkal, pl. az autó indítása, gyorsítás/fékezés, stb. Ezek a közös metódusok a szülőosztályba konszolidálhatók, Carés minden egyes autótípus meghatározhatja egyedi műveleteit a származtatott osztályaiban. .

public class Car {

   public void gas() {
       // Accelerate
   }

   public void brake() {
       // Brake
   }
}


public class F1Car extends Car {

   public void pitStop() {
      
       // Only race cars make pit stops
   }

   public static void main(String[] args) {
      
       F1Car formula1Car = new F1Car();
       formula1Car.gas();
       formula1Car.pitStop();
       formula1Car.brake();
   }
}

Hozzáadtuk az osztályhoz az összes autóra jellemző metódusokat Car. De nézd meg az F1Carosztályt, amely a "Forma-1" versenyautókat képviseli. A boxkiállások (a sürgős autókarbantartás miatti megállások) csak versenyeken történnek, ezért ezt a funkciót hozzáadtuk a megfelelő származtatott osztályhoz.

operátor példánya

A Java-ban van egy speciális operátor, az instanceof , amellyel ellenőrizhető, hogy egy objektum egy adott osztály alapján készült-e. Igaz vagy hamis értéket ad vissza az ellenőrzés eredményétől függően. Nézzük meg, hogyan működik az autópéldánk osztályaival:

public class Truck extends Car {

   public static void main(String[] args) {

       Truck truck = new Truck();
       System.out.println(truck instanceof Car);
   }
}

Kimenet: true Az instanceofoperátor true értéket ad vissza , mivel van egy Trucktárgyunk, és minden teherautó személyautó. Az Truckosztály az osztályból származik Car. Minden teherautó a közös szülő, az osztály alapján jön létre Car. Nézze meg alaposan az instanceofoperátor használatát. Pont nélkül írod, mivel ez egy operátor, nem pedig metódus ("Object instance of Class"). Próbálkozzunk más módon:

public static void main(String[] args) {

   Car car = new Car();
   System.out.println(car instanceof Truck);
}

Kimenet: false Az Carosztály (és az autóobjektumok) nem az osztályból származnak Truck. Minden teherautó személyautó, de nem minden személygépkocsi teherautó. Caraz objektumok nem az osztályon alapulnak Truck. Még egy példa:

public static void main(String[] args) {

   Car car = new Car();
   Truck truck = new Truck();
   System.out.println(car instanceof Object && truck instanceof Object);
}

Kimenet: Igaz Itt is egyszerű a logika: a Java-ban minden osztály, beleértve az Ön által létrehozott osztályokat is, az osztálytól származik Object(annak ellenére, hogy nem írja be, hogy "extends Object" - ez már sejtett). Hogyan és mikor lenne ez hasznos? Az instanceofoperátort leggyakrabban a equals()metódus felülbírálásakor használják. Például a következőképpen equalsvalósul meg a metódus az osztályban String:

public boolean equals(Object anObject) {
   if (this == anObject) {
       return true;
   }
   if (anObject instanceof String) {
       String anotherString = (String) anObject;
       int n = value.length;
       if (n == anotherString.value.length) {
           char v1[] = value;
           char v2[] = anotherString.value;
           int i = 0;
           while (n-- != 0) {
               if (v1[i] != v2[i])
                       return false;
               i++;
           }
           return true;
       }
   }
   return false;
}

Mielőtt összehasonlítaná az a-t Stringaz átadott objektummal, a metódus megvizsgálja, hogy az objektum egy karakterlánc-e? Csak ezután kezdi el összehasonlítani a két objektum tulajdonságait. Ha ez a teszt nem létezne, bármely érték- és hosszmezővel rendelkező objektumot át lehetne adni a metódusnak, és összehasonlítani lehetne egy karakterlánccal, ami természetesen hibás lenne.