Arv i Java forklart

Arv

Java-arv refererer til evnen til en Java-klasse til inheritegenskapene fra en annen klasse. Tenk på det som et barn som arver eiendommer fra foreldrene sine, konseptet er veldig likt det. På Java lingo kalles det også utvide -ing en klasse.

Noen enkle ting å huske:

  • Klassen som utvider eller arver kalles en underklasse
  • Klassen som utvides eller arves kalles en superklasse

Dermed gir arv Java den kule muligheten til å bruke kode på nytt, eller dele kode mellom klassene!

La oss beskrive det med det klassiske eksemplet på en Vehicleklasse og en Carklasse:

public class Vehicle { public void start() { // starting the engine } public void stop() { // stopping the engine } } public class Car extends Vehicle { int numberOfSeats = 4; public int getNumberOfSeats() { return numberOfSeats; } }

Her kan vi se Carklassen arver egenskapene til Vehicleklassen. Så vi trenger ikke å skrive den samme koden for metodene start()og stop()for det Car, ettersom disse egenskapene er tilgjengelige fra den overordnede eller superklassen. Derfor vil objekter opprettet fra Carklassen også ha disse egenskapene!

Car tesla = new Car(); tesla.start(); tesla.stop();

Kjør kode

Men har foreldreklassen barnets metoder? Nei, det gjør det ikke.

Derfor, når du trenger å dele noen felles kode mellom flere klasser, er det alltid bra å ha en overordnet klasse, og deretter utvide den klassen når det er nødvendig! Reduserer antall linjer med kode, gjør koden modulær og forenkler testing.

Hva kan arves?

  • Alt protectedog publicfelt og metoder fra foreldre

Hva kan ikke arves?

  • private felt og metoder
  • Konstruktører. Selv om underklassekonstruktøren ringe superklassekonstruktøren hvis den er definert (Mer om det senere!)
  • Flere klasser. Java støtter bare en enkelt arv , det vil si at du bare kan arve en klasse om gangen.
  • Enger. Individuelle felt i en klasse kan ikke overstyres av underklassen.

Type Casting & Reference

I Java er det mulig å referere til en underklasse som en forekomst av superklassen. Det kalles polymorfisme i objektorientert programmering (OOP), evnen til et objekt å ta på seg mange former. For eksempel Carkan klasseobjektet refereres til som en Vehicleklasseinstans som dette:

Vehicle car = new Car();

Selv om det motsatte ikke er mulig:

Car car = new Vehicle(); // ERROR

Kjør kode

Siden du kan referere til en Java-underklasse som en superklasse-forekomst, kan du enkelt kaste en forekomst av et underklasseobjekt til en superklasse-forekomst. Det er mulig å kaste et superklasseobjekt til en underklassetype, men bare hvis objektet virkelig er en forekomst av underklassen . Så husk dette:

Car car = new Car(); Vehicle vehicle = car; // upcasting Car car2 = (Car)vechile; //downcasting Bike bike = new Bike(); // say Bike is also a subclass of Vehicle Vehicle v = bike; // upcasting, no problem here. Car car3 = (Car)bike; // Compilation Error : as bike is NOT a instance of Car

Kjør kode

Nå vet du hvordan du deler kode gjennom et foreldre-barn forhold. Men hva om du ikke liker implementeringen av en bestemt metode i barneklassen og vil skrive en ny for den? Hva gjør du da?

Overstyr det!

Java lar deg overstyre eller omdefinere metodene som er definert i superklassen. For eksempel har Carklassen din en annen implementering start()enn foreldren Vehicle, så du gjør dette:

public class Vehicle { public void start() { System.out.println("Vehicle start code"); } } public class Car extends Vehicle { public void start() { System.out.println("Car start code"); } } Car car = new Car(); car.start(); // "Car start code"

Kjør kode

So, it’s pretty simple to override methods in the subclass. Although, there is a catch. Only that superclass method with the exact same method signature as the subclass method will be overriden. That means the subclass method definition must have the exact same name, same number and type of parameters, and in the exact same sequence. Thus, public void start(String key) would not override public void start().

Notes :

  • You cannot override private methods of the superclass. (Quite obvious, isn’t it?)
  • What if the method of superclass which you are overriding in the subclass suddenly gets obliterated or methods changed? It would fail in runtime! So Java provides you a nifty annotation @Override which you can place over the subclass method, which will warn the compiler of those incidents!

Annotations in Java is a good coding practice, but they are not a necessity. The compiler is smart enough to figure out overriding on its own though. Unlike other OOP languages, Annotations in Java it doesn’t necessarily modify the method or add extra functionality.

How to call super class methods?

Funny you ask about it! Just use the keyword super :

public class Vehicle() { public void start() { System.out.println("Vehicle start code"); } } public class Car extends Vehicle { public void run() { super.start(); } } Car car = new Car(); car.run(); // "Vehicle start code"

Run Code

N.B. : Although you can call the parent method by using a super call, you cannot go up the inheritance hierarchy with chained super calls.

How to know the type of a class?

Using the instanceof keyword. Having lots of classes and subclasses it would be a little confusing to know which class is a subclass of which one in runtime. So, we can use instanceof to determine whether an object is an instance of a class, an instance of a subclass, or an instance of an interface.

Car car = new Car(); boolean flag = car instanceof Vehicle; // true in this case!

Constructors & Inheritance

As mentioned earlier, constructors cannot be directly inherited by a subclass. Although, a subclass is required to call its parent’s constructor as the first operation in its own constructor. How? You guessed it, using super :

public class Vehicle { public Vehicle() { // constructor } public void start() { System.out.println("Vehicle start code"); } } public class Car extends Vehicle { public Car() { super(); } public void run() { super.start(); } }

Run Code

Husk at hvis superklassen ikke har noen konstruktører definert, trenger du ikke å kalle det eksplisitt i underklassen. Java håndterer det internt for deg! Påkallelse til superkonstruktør gjøres i tilfelle superklassen skal kalles sammen med en hvilken som helst annen konstruktør enn standardkonstruktøren .

Hvis ingen andre konstruktører er definert, påkaller Java standard superklassekonstruktøren ( selv om den ikke er definert eksplisitt ).

Gratulerer, nå vet du alt om arv! Les mer om avanserte måter å arve ting på i Abstrakte klasser og grensesnitt!