Instanceof at Inheritance sa Java

Hi! Sa nakaraang mga aralin, sa madaling sabi ay nakilala na natin ang konsepto ng mana. Ngayon, muli nating tatalakayin ang paksang ito, ngunit muli ay hindi masyadong malalim. Magkakaroon pa rin tayo ng mas detalyadong aralin tungkol dito sa hinaharap. Ngayon ay titingnan lang natin ang ilang praktikal na halimbawa at makikilala ang isang kawili-wiling operator sa Java.

Mana

Kaya, ano ang mana? Ang inheritance ay isang mekanismo ng programming (kabilang ang Java) na nagbibigay-daan sa iyong magdeklara ng bagong klase batay sa isang umiiral na. Ang nagmula na klase ay magkakaroon ng access sa mga field at pamamaraan ng parent class. Bakit natin ito kakailanganin? Buweno, isipin na kailangan mong lumikha ng ilang mga klase ng kotse sa isang programa: Truck, RaceCar, Sedan, Pickup, atbp. Bago pa man magsulat ng anumang code, alam mo nang sigurado na ang lahat ng mga klase na ito ay may maraming pagkakatulad: lahat ng mga kotse ay may isang modelo pangalan, taon ng paggawa, laki ng makina, maximum na bilis, atbp. (hindi sa banggitin ang katotohanan na lahat sila ay may mga gulong at iba pang mga bahagi sa karaniwan). Sa sitwasyong ito, maaari mong:

• Gawin ang mga field na ito sa bawat klase (idagdag ang mga ito sa bawat bagong klase ng kotse habang ginagawa mo ito)
• Dalhin ang mga field na karaniwan sa lahat ng sasakyan sa isang Carparent class, at pagkatapos ay gamitin ang keyword extends para makuha ang lahat ng klase para sa mga partikular na uri ng mga kotse mula sa Carklase.

Naturally, ang pangalawang pagpipilian 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, iniiwasan natin ang hindi kinakailangang pagdoble ng code (at dapat nating pagsikapan iyon kapag nagsusulat ng mga programa). Dagdag pa, mayroon kaming simple at nauunawaan na istraktura ng klase, na ang lahat ng mga field na karaniwan sa lahat ng mga kotse ay pinagsama-sama sa isang klase. Kung ang mga trak ay may mga espesyal na field na wala sa ibang mga sasakyan, maaari silang ideklara sa Truckklase. Ang parehong napupunta para sa mga pamamaraan. Ang lahat ng mga kotse ay may ilang karaniwang pag-uugali na maaaring ilarawan gamit ang mga pamamaraan, hal. simulan ang kotse, pabilisin/preno, atbp. Ang mga karaniwang pamamaraan na ito ay maaaring pagsama-samahin sa parent class, Carat ang bawat partikular na uri ng kotse ay maaaring tukuyin ang mga natatanging aksyon nito sa kanilang mga hinangong klase .

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

Idinagdag namin ang mga pamamaraan na karaniwan sa lahat ng mga kotse sa Carklase. Ngunit, tingnan ang F1Carklase, na kumakatawan sa "Formula 1" na mga race car. Ang mga pit stop (mga paghinto para sa agarang pagpapanatili ng kotse) ay ginagawa lamang sa mga karera, kaya idinagdag namin ang partikular na pagpapagana na ito sa nauugnay na nagmula na klase.

halimbawa ng operator

Sa Java, mayroong isang espesyal na operator, instanceof , para sa pagsuri upang makita kung ang isang bagay ay nilikha batay sa isang partikular na klase. Nagbabalik ito ng totoo o mali depende sa resulta ng tseke. Tingnan natin kung paano ito gumagana gamit ang mga klase sa aming halimbawa ng kotse:

public class Truck extends Car {

   public static void main(String[] args) {

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

Output: true Nagbabalik ang instanceofoperator ng true , dahil mayroon tayong Truckobject, at lahat ng trak ay mga kotse. Ang Truckklase ay hango sa Carklase. Ang lahat ng mga trak ay nilikha batay sa karaniwang magulang, ang Carklase. Tingnang mabuti kung paano instanceofginagamit ang operator. Isinulat mo ito nang walang tuldok, dahil isa itong operator, hindi isang paraan ("object instanceof Class”). Subukan natin ang ibang paraan:

public static void main(String[] args) {

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

Output: false Ang Carklase (at mga bagay ng kotse) ay hindi nagmula sa Truckklase. Ang lahat ng mga trak ay mga kotse, ngunit hindi lahat ng mga kotse ay mga trak. Carang mga bagay ay hindi batay sa Truckklase. 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: True Narito ang logic ay simple din: lahat ng mga klase sa Java, kabilang ang mga klase na iyong nilikha, ay bumaba mula sa Objectklase (kahit na hindi mo isinusulat ang "extends Object"—ito ay ipinahiwatig na). Paano at kailan ito magiging kapaki-pakinabang? Ang instanceofoperator ay kadalasang ginagamit kapag na-override ang equals()pamamaraan. Halimbawa, narito kung paano equalsipinapatupad ang pamamaraan sa Stringklase:

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 isang Stringsa naipasa na bagay, ang pamamaraan ay sumusubok upang makita kung ang bagay ay kahit isang string? Pagkatapos lamang nito sisimulan ang paghahambing ng mga katangian ng dalawang bagay. Kung ang pagsubok na ito ay hindi umiiral, anumang bagay na may halaga at haba na mga patlang ay maaaring maipasa sa pamamaraan at ihambing sa isang String, na magiging mali, siyempre.