Instanță și moștenire în Java

Bună! În lecțiile anterioare, ne-am familiarizat deja pe scurt cu conceptul de moștenire. Astăzi, vom aborda din nou acest subiect, dar din nou nu prea profund. Vom avea în continuare o lecție mai detaliată despre asta în viitor. Astăzi vom arunca o privire rapidă la câteva exemple practice și ne vom familiariza cu un operator interesant în Java.

Moştenire

Deci, ce este moștenirea? Moștenirea este un mecanism de programare (inclusiv în Java) care vă permite să declarați o nouă clasă pe baza uneia existente. Clasa derivată obține apoi acces la câmpurile și metodele clasei părinte. De ce am avea nevoie de asta? Ei bine, imaginați-vă că trebuie să creați mai multe clase de mașini într-un program: Camion, RaceCar, Sedan, Pickup etc. Chiar înainte de a scrie orice cod, știți sigur că toate aceste clase au multe în comun: toate mașinile au un model denumire, an de fabricatie, marime motor, turatie maxima etc.(sa nu mai vorbim de faptul ca toate au in comun roti si alte piese). În această situație, puteți:

• Creați aceste câmpuri în fiecare clasă (adăugându-le la fiecare clasă nouă de mașini pe măsură ce o creați)
• Aduceți câmpurile comune tuturor mașinilor într-o Carclasă părinte, apoi utilizați cuvântul cheie extinde pentru a deriva toate clasele pentru anumite tipuri de mașini din Carclasă.

Desigur, a doua opțiune este mult mai convenabilă:

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

Cel puțin, evităm duplicarea inutilă a codului (și ar trebui să ne străduim întotdeauna pentru asta atunci când scriem programe). În plus, avem o structură de clasă simplă și ușor de înțeles, cu toate domeniile comune tuturor mașinilor consolidate într-o singură clasă. Dacă camioanele au câmpuri speciale pe care alte mașini nu le au, acestea pot fi declarate în Truckclasă. Același lucru este valabil și pentru metode. Toate mașinile au un anumit comportament comun care poate fi descris cu metode, de exemplu, pornirea mașinii, accelerarea/frânarea, etc. Aceste metode comune pot fi consolidate în clasa părinte Carși fiecare tip specific de mașină își poate defini acțiunile unice în clasele lor derivate .

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

Am adăugat în clasă metodele comune tuturor mașinilor Car. Dar, uită-te la F1Carclasa, care reprezintă mașini de curse „Formula 1”. Opririle la boxe (opriri pentru întreținerea urgentă a mașinii) se fac doar în curse, așa că am adăugat această funcționalitate specifică la clasa derivată relevantă.

instanță de operator

În Java, există un operator special, instanceof , pentru a verifica dacă un obiect a fost creat pe baza unei anumite clase. Returnează adevărat sau fals în funcție de rezultatul verificării. Să vedem cum funcționează folosind clasele din exemplul nostru de mașină:

public class Truck extends Car {

   public static void main(String[] args) {

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

Ieșire: true Operatorul instanceofreturnează true , deoarece avem un Truckobiect și toate camioanele sunt mașini. Clasa Truckeste derivată din Carclasă. Toate camioanele sunt create pe baza părintelui comun, Carclasa. Priviți cu atenție cum instanceofeste utilizat operatorul. Îl scrii fără punct, deoarece este un operator, nu o metodă („obiect instanceof Class”). Să încercăm un alt mod:

public static void main(String[] args) {

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

Ieșire: false Clasa Car(și obiectele mașini) nu derivă din Truckclasă. Toate camioanele sunt mașini, dar nu toate mașinile sunt camioane. Carobiectele nu se bazează pe Truckclasă. Inca un exemplu:

public static void main(String[] args) {

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

Ieșire: Adevărat Și aici logica este simplă: toate clasele în Java, inclusiv clasele pe care le creați, descind din clasă Object(chiar dacă nu scrieți „extends Object” – este deja implicit). Cum și când ar fi util acest lucru? Operatorul instanceofeste cel mai frecvent utilizat atunci când treceți peste equals()metoda. De exemplu, iată cum equalseste implementată metoda în Stringclasă:

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

Înainte de a compara a Stringcu obiectul trecut, metoda testează pentru a vedea dacă obiectul este chiar un șir? Abia atunci începe să compare proprietățile celor două obiecte. Dacă acest test nu ar exista, orice obiect cu câmpuri de valoare și lungime ar putea fi transmis metodei și comparat cu un String, ceea ce ar fi greșit, desigur.