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.
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:
Erfenis
Dus, wat is erfrecht?
- 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
Car
bovenliggende klasse en gebruik vervolgens het trefwoord extends om alle klassen voor specifieke typen auto's uit deCar
klasse af te leiden.
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 Truck
klasse 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 Car
bovenliggende 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 Car
klasse toegevoegd. Maar kijk naar de F1Car
klasse, 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 instanceof
operator retourneert true , aangezien we een Truck
object hebben en alle vrachtwagens auto's zijn. De Truck
klasse is afgeleid van de Car
klasse. Alle trucks worden gemaakt op basis van de gemeenschappelijke ouder, de Car
klasse. Kijk goed hoe de instanceof
operator 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 Car
klasse (en auto-objecten) is niet afgeleid van de Truck
klasse. Alle vrachtwagens zijn auto's, maar niet alle auto's zijn vrachtwagens. Car
objecten zijn niet gebaseerd op de Truck
klasse. 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 Object
klasse (ook al schrijft u niet "extends Object" - het is al geïmpliceerd). Hoe en wanneer zou dit nuttig zijn? De instanceof
operator wordt meestal gebruikt bij het overschrijven van de equals()
methode. Hier is bijvoorbeeld hoe de methode in de klas equals
wordt 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 String
met 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.
GO TO FULL VERSION