instanceof at inheritance basics

Kamusta! Sa mga nakaraang lektura, ilang beses na nating nakatagpo ang konsepto ng mana. Ngayon ay tatalakayin din natin ang paksang ito, ngunit hindi rin masyadong malalim. Magkakaroon ng isang detalyadong lecture tungkol dito sa ibang pagkakataon, ngunit ngayon ay titingnan lang natin ang mga praktikal na halimbawa at makikilala ang isang kawili-wiling operator sa Java.

Manang Java

Kaya, ano nga ba ang mana? Ang inheritance ay isang mekanismo sa programming, kabilang ang Java, na nagbibigay-daan sa iyong ilarawan ang isang bagong klase batay sa isang umiiral na. Ang descendant class ay magkakaroon ng access sa mga field at pamamaraan ng parent class. Bakit maaaring kailanganin ito? Well, halimbawa, isipin na kailangan mong lumikha ng ilang mga klase ng mga kotse sa programa: Truck, Racing, Sedan, Pickup, atbp. Kahit na hindi nagsisimulang magsulat ng code, alam mong sigurado na ang mga klase na ito ay may maraming pagkakatulad: lahat ng mga kotse ay may pangalan ng modelo, taon ng paggawa, laki ng makina, maximum na bilis, atbp. (not to mention the fact na lahat sila ay may mga gulong at iba pang bahagi). Sa ganoong sitwasyon, maaari mong:

• Gawin ang mga field na ito sa bawat klase at idagdag ang mga ito sa mga bagong klase ng kotse kapag ginawa ang mga ito
• Ilipat ang mga field na karaniwan sa lahat ng machine sa parent class Car, at lahat ng klase ng mga partikular na uri ng machine ay nagmamana mula sa Carpaggamit ng word extends .

Ang pangalawang pagpipilian, siyempre, ay mas maginhawa:

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

Sa pinakamababa, naiwasan natin ang hindi kinakailangang pagdoble ng code, at ito ay isang bagay na dapat nating laging pagsikapan kapag nagsusulat ng mga programa. Bilang karagdagan, mayroon kaming simple at nauunawaan na istraktura ng klase: ang mga field na karaniwan sa lahat ng makina ay inilalagay sa isang klase. Kung, halimbawa, ang mga trak ay may ilang partikular na field na wala sa ibang mga sasakyan, maaari silang ideklara sa klase Truck. Ang parehong napupunta para sa mga pamamaraan. Ang lahat ng mga kotse ay may ilang karaniwang pag-uugali na maaaring ilarawan: simulan ang kotse, gas/preno, atbp. Ang mga pangkalahatang pamamaraan na ito ay maaaring ilagay sa isang pangkalahatang klase Car, at ang partikular na pag-uugali ng bawat partikular na uri ay maaaring ilarawan sa mga descendant na klase.

public class Car {

   public void gas() {
       //...gas
   }

   public void brake() {
       //...brake
   }
}


public class F1Car extends Car {

   public void pitStop() {

       //...only racing cars make pit stops
   }

   public static void main(String[] args) {

       F1Car formula1Car = new F1Car();
       formula1Car.gas();
       formula1Car.pitStop();
       formula1Car.brake();
   }
}

Inilipat namin ang mga karaniwang pamamaraan ng lahat ng mga kotse sa klase Car. Ngunit sa kahalili na klase F1Car, na naglalarawan sa Formula 1 na karera ng mga kotse - mga pit stop (humihinto para sa agarang pagpapanatili ng kotse), na ginagawa lamang sa karera at nakikilala sa pamamagitan ng tiyak na pag-uugali.

Java instanceof operator

Upang suriin kung ang isang bagay ay nilikha batay sa isang klase, mayroong isang espesyal na operator sa Java - instanceof. Ibinabalik nito ang halaga truekung totoo ang pagsubok, o falsekung mali ang resulta. Tingnan natin kung paano ito gumagana gamit ang aming mga klase ng kotse bilang isang halimbawa:

public class Truck extends Car {

   public static void main(String[] args) {

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

Output: true Ang tseke gamit ang operator instanceofay ibinalik true, dahil mayroon kaming isang bagay ng klase Truck, at lahat ng mga trak ay mga kotse. Ang klase Truckay isang inapo ng klase Car, samakatuwid, ang lahat ng mga trak ay nilikha batay sa isang karaniwang magulang - isang kotse. Bigyang-pansin ang operator instanceof: ito ay nakasulat nang walang tuldok, dahil ito ay isang operator, hindi isang pamamaraan ("object instanceof Class"). Subukan natin ito sa ibang paraan:

public static void main(String[] args) {

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

Output: false Ang klase Carat, nang naaayon, ang object nito ay hindi nagmula sa klase Truck.Lahat ng trak ay mga kotse, ngunit hindi lahat ng sasakyan ay mga trak. Ang mga bagay Caray hindi nilikha batay sa klase Truck. Isa pang halimbawa:

public static void main(String[] args) {

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

Output: Totoo Ang lohika dito ay simple din: lahat ng mga klase sa Java, kabilang ang mga nilikha mo, ay nagmula sa isang klase Object(bagaman hindi ka sumulat ng extends Object sa kanila - ang mekanismong ito ay implicit sa kanila). Bakit ito maaaring maging kapaki-pakinabang at sa ilalim ng anong mga pangyayari? Ang pinakakaraniwang paggamit ng operator instanceofay bilang isang paraan ng override equals(). Halimbawa, narito kung paano ipinatupad ang pamamaraan equalssa klase 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;
}

Bago ihambing ang string sa naipasa na bagay, sinusuri ng pamamaraan: ang naipasa ba ay talagang isang string? At saka lamang siya nagsimulang ihambing ang mga katangian ng dalawang bagay. Kung wala ang tseke na ito, maaari mong ipasa ang anumang bagay na may halaga at haba na mga patlang sa pamamaraan at ihambing ito sa isang string, na, siyempre, ay magiging mali.