Instantie van en overerving in Java

Hoi! In voorgaande lessen hebben we al kort kennis gemaakt met het begrip overerving. Vandaag zullen we dit onderwerp opnieuw behandelen, maar opnieuw niet te diep. We zullen hier in de toekomst nog een meer gedetailleerde les over krijgen. Vandaag kijken we even naar enkele praktijkvoorbeelden en maken we kennis met een interessante operator in Java.

Erfenis

Dus, wat is erfrecht? Overerving is een programmeermechanisme (ook in Java) waarmee u een nieuwe klasse kunt declareren op basis van een bestaande. De afgeleide klasse krijgt dan toegang tot de velden en methoden van de bovenliggende klasse. Waarom zouden we dit nodig hebben? Stel je voor dat je verschillende autoklassen in een programma moet maken: Truck, RaceCar, Sedan, Pickup, enz. Zelfs voordat je een code schrijft, weet je zeker dat al deze klassen veel gemeen hebben: alle auto's hebben een model naam, bouwjaar, motorinhoud, maximumsnelheid, enz. (om nog maar te zwijgen van het feit dat ze allemaal wielen en andere onderdelen gemeen hebben). In deze situatie kunt u:

• Maak deze velden in elke klasse (voeg ze toe aan elke nieuwe autoklasse terwijl u deze aanmaakt)
• Breng de velden die alle auto's gemeen hebben naar een Carbovenliggende klasse en gebruik vervolgens het trefwoord extends om alle klassen voor specifieke typen auto's uit de Carklasse af te leiden.

Natuurlijk is de tweede optie veel handiger:

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

We vermijden op zijn minst de onnodige duplicatie van code (en daar moeten we altijd naar streven bij het schrijven van programma's). Bovendien hebben we een eenvoudige en begrijpelijke klassenstructuur, waarbij alle gebieden die voor alle auto's gelden, zijn geconsolideerd in één klasse. Als vrachtwagens speciale velden hebben die andere auto's niet hebben, kunnen ze in de Truckklasse worden verklaard. Hetzelfde geldt voor methoden. Alle auto's hebben bepaald gemeenschappelijk gedrag dat kan worden beschreven met methoden, bijv. de auto starten, gas geven/remmen, enz. Deze algemene methoden kunnen worden geconsolideerd in de Carbovenliggende klasse en elk specifiek type auto kan zijn unieke acties definiëren in hun afgeleide klassen .

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

We hebben de methoden die voor alle auto's gelden aan de Carklasse toegevoegd. Maar kijk naar de F1Carklasse, die "Formule 1" raceauto's vertegenwoordigt. Pitstops (stops voor dringend auto-onderhoud) worden alleen gedaan in races, dus hebben we deze specifieke functionaliteit toegevoegd aan de betreffende afgeleide klasse.

instantie van operator

In Java is er een speciale operator, instanceof , om te controleren of een object is gemaakt op basis van een bepaalde klasse. Het retourneert waar of onwaar , afhankelijk van het resultaat van de controle. Laten we eens kijken hoe het werkt met behulp van de klassen in ons autovoorbeeld:

public class Truck extends Car {

   public static void main(String[] args) {

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

Uitvoer: true De instanceofoperator retourneert true , aangezien we een Truckobject hebben en alle vrachtwagens auto's zijn. De Truckklasse is afgeleid van de Carklasse. Alle trucks worden gemaakt op basis van de gemeenschappelijke ouder, de Carklasse. Kijk goed hoe de instanceofoperator wordt gebruikt. Je schrijft het zonder punt, aangezien het een operator is, geen methode ("object instanceof Class"). Laten we het op een andere manier proberen:

public static void main(String[] args) {

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

Uitvoer: false De Carklasse (en auto-objecten) is niet afgeleid van de Truckklasse. Alle vrachtwagens zijn auto's, maar niet alle auto's zijn vrachtwagens. Carobjecten zijn niet gebaseerd op de Truckklasse. Nog een voorbeeld:

public static void main(String[] args) {

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

Uitvoer: True Ook hier is de logica eenvoudig: alle klassen in Java, inclusief klassen die u maakt, stammen af ​​van de Objectklasse (ook al schrijft u niet "extends Object" - het is al geïmpliceerd). Hoe en wanneer zou dit nuttig zijn? De instanceofoperator wordt meestal gebruikt bij het overschrijven van de equals()methode. Hier is bijvoorbeeld hoe de methode in de klas equalswordt geïmplementeerd :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;
}

Alvorens a te vergelijken Stringmet het doorgegeven object, test de methode of het object wel een string is? Pas dan begint het de eigenschappen van de twee objecten te vergelijken. Als deze test niet bestond, zou elk object met waarde- en lengtevelden aan de methode kunnen worden doorgegeven en vergeleken met een string, wat natuurlijk verkeerd zou zijn.