Java, Periytys on tärkeä OOP:n (Object-Oriented Programming) pilari. Se on Java-mekanismi, jolla yksi luokka saa periä toisen luokan ominaisuudet (kentät ja menetelmät). Javalla Inheritance tarkoittaa uusien luokkien luomista olemassa olevien luokkien perusteella. Luokka, joka perii toisesta luokasta, voi käyttää uudelleen kyseisen luokan menetelmiä ja kenttiä. Lisäksi voit lisätä uusia kenttiä ja menetelmiä myös nykyiseen luokkaasi.

Miksi tarvitsemme Java-perinnön?

• Koodin uudelleenkäyttö: Superluokkaan kirjoitettu koodi on yhteinen kaikille alaluokille. Lapsiluokat voivat käyttää suoraan yläluokan koodia.
• Menetelmän ohittaminen: Menetelmän ohittaminen on saavutettavissa vain perinnön kautta. Se on yksi tavoista, joilla Java saavuttaa ajonaikaisen polymorfismin.
• Abstraktio: Abstraktin käsite, jossa meidän ei tarvitse antaa kaikkia yksityiskohtia, saavutetaan perinnön kautta. Abstraktio näyttää vain toiminnallisuuden käyttäjälle.

Java-perinnössä käytetyt tärkeät terminologiat

• Luokka: Luokka on joukko objekteja, joilla on yhteisiä ominaisuuksia/käyttäytymistä ja yhteisiä ominaisuuksia/attribuutteja. Luokka ei ole todellinen kokonaisuus. Se on vain malli tai suunnitelma tai prototyyppi, josta objektit luodaan.
• Superluokka/vanhempien luokka: Luokka, jonka ominaisuudet periytyvät, tunnetaan superluokkana (tai perusluokkana tai yläluokkana).
• Alaluokka/lapsiluokka: Luokka, joka perii toisen luokan, tunnetaan alaluokkana (tai johdettuna luokkana, laajennettu luokka tai aliluokka). Alaluokka voi lisätä omia kenttiä ja menetelmiä superluokan kenttien ja menetelmien lisäksi.
• Uudelleenkäytettävyys: Periytys tukee uudelleenkäytettävyyden käsitettä, eli kun haluamme luoda uuden luokan ja on jo luokka, joka sisältää osan haluamastamme koodista, voimme johtaa uuden luokkamme olemassa olevasta luokasta. Näin toimimalla käytämme uudelleen olemassa olevan luokan kenttiä ja menetelmiä.

Kuinka käyttää perintöä Javassa?

The laajentaa avainsanaa käytetään perintönä Javassa. Extens-avainsanan käyttäminen osoittaa, että olet johdettu olemassa olevasta luokasta. Toisin sanoen laajennus tarkoittaa lisääntynyttä toimivuutta.

kuinka tehdä uusiksi Photoshopissa

Syntaksi :

class DerivedClass extends BaseClass  {   //methods and fields  }>

Esimerkki Java-perinnöstä

Esimerkki: Alla olevassa esimerkissä luokka Bicycle on perusluokka, luokka MountainBike on johdettu luokka, joka laajentaa Bicycle-luokkaa ja luokka Test on kuljettajaluokka ohjelman suorittamista varten.

// Java program to illustrate the // concept of inheritance // base class class Bicycle {  // the Bicycle class has two fields  public int gear;  public int speed;  // the Bicycle class has one constructor  public Bicycle(int gear, int speed)  {  this.gear = gear;  this.speed = speed;  }  // the Bicycle class has three methods  public void applyBrake(int decrement)  {  speed -= decrement;  }  public void speedUp(int increment)  {  speed += increment;  }  // toString() method to print info of Bicycle  public String toString()  {  return ('No of gears are ' + gear + '
'  + 'speed of bicycle is ' + speed);  } } // derived class class MountainBike extends Bicycle {  // the MountainBike subclass adds one more field  public int seatHeight;  // the MountainBike subclass has one constructor  public MountainBike(int gear, int speed,  int startHeight)  {  // invoking base-class(Bicycle) constructor  super(gear, speed);  seatHeight = startHeight;  }  // the MountainBike subclass adds one more method  public void setHeight(int newValue)  {  seatHeight = newValue;  }  // overriding toString() method  // of Bicycle to print more info  @Override public String toString()  {  return (super.toString() + '
seat height is '  + seatHeight);  } } // driver class public class Test {  public static void main(String args[])  {  MountainBike mb = new MountainBike(3, 100, 25);  System.out.println(mb.toString());  } }>

No of gears are 3 speed of bicycle is 100 seat height is 25>

Yllä olevassa ohjelmassa, kun MountainBike-luokan objekti luodaan, kopio kaikista superluokan menetelmistä ja kentistä hankkii muistin tässä objektissa. Siksi aliluokan objektia käyttämällä pääsemme käsiksi myös superluokan jäseniin.

Huomaa, että periytymisen aikana luodaan vain alaluokan objekti, ei yliluokkaa. Katso lisätietoja Perittyjen luokan Java-objektien luominen .

Esimerkki 2: Alla olevassa esimerkissä luokka Työntekijä on perusluokka, luokka Engineer on johdettu luokka, joka laajentaa Työntekijä-luokkaa ja luokka Testi on kuljettajaluokka ohjelman suorittamista varten.

// Java Program to illustrate Inheritance (concise) import java.io.*; // Base or Super Class class Employee {  int salary = 60000; } // Inherited or Sub Class class Engineer extends Employee {  int benefits = 10000; } // Driver Class class Gfg {  public static void main(String args[])  {  Engineer E1 = new Engineer();  System.out.println('Salary : ' + E1.salary  + '
Benefits : ' + E1.benefits);  } }>

Salary : 60000 Benefits : 10000>

Havainnollistava kuva ohjelmasta:

leksikografisesti

Käytännössä perintö ja polymorfismi käytetään yhdessä Javassa nopean suorituskyvyn ja koodin luettavuuden saavuttamiseksi.

Java-perintötyypit

Alla on erityyppisiä perintöjä, joita Java tukee.

1. Yksittäinen perintö
2. Monitasoinen perintö
3. Hierarkkinen perintö
4. Moniperintö
5. Hybridiperintö

1. Yksittäinen perintö

Yksittäisessä perinnössä alaluokka johdetaan vain yhdestä superluokasta. Se perii yhden vanhemman luokan ominaisuudet ja käyttäytymisen. Joskus sitä kutsutaan myös yksinkertaiseksi perinnöksi. Alla olevassa kuvassa 'A' on vanhempiluokka ja 'B' on lapsiluokka. Luokka 'B' perii kaikki luokan 'A' ominaisuudet.

Yksittäinen perintö

// Java program to illustrate the // concept of single inheritance import java.io.*; import java.lang.*; import java.util.*; // Parent class class One {  public void print_geek()  {  System.out.println('Geeks');  } } class Two extends One {  public void print_for() { System.out.println('for'); } } // Driver class public class Main {  // Main function  public static void main(String[] args)  {  Two g = new Two();  g.print_geek();  g.print_for();  g.print_geek();  } }>

Geeks for Geeks>

2. Monitasoinen perintö

Monitasoperinnössä johdettu luokka perii perusluokan, ja johdettu luokka toimii myös muiden luokkien perusluokkana. Alla olevassa kuvassa luokka A toimii perusluokkana johdetulle luokalle B, joka puolestaan ​​toimii perusluokkana johdetulle luokalle C. Javassa luokka ei voi käyttää suoraan isovanhempien jäseniä .

Monitasoinen perintö

// Importing required libraries import java.io.*; import java.lang.*; import java.util.*; // Parent class One class One {  // Method to print 'Geeks'  public void print_geek() {  System.out.println('Geeks');  } } // Child class Two inherits from class One class Two extends One {  // Method to print 'for'  public void print_for() {  System.out.println('for');  } } // Child class Three inherits from class Two class Three extends Two {  // Method to print 'Geeks'  public void print_lastgeek() {  System.out.println('Geeks');  } } // Driver class public class Main {  public static void main(String[] args) {  // Creating an object of class Three  Three g = new Three();    // Calling method from class One  g.print_geek();    // Calling method from class Two  g.print_for();    // Calling method from class Three  g.print_lastgeek();  } }>

Geeks for Geeks>

3. Hierarkkinen perintö

Hierarkkisessa perinnössä yksi luokka toimii yliluokkana (perusluokka) useammalle kuin yhdelle alaluokalle. Alla olevassa kuvassa luokka A toimii perusluokkana johdetuille luokille B, C ja D.

// Java program to illustrate the // concept of Hierarchical inheritance class A {  public void print_A() { System.out.println('Class A'); } } class B extends A {  public void print_B() { System.out.println('Class B'); } } class C extends A {  public void print_C() { System.out.println('Class C'); } } class D extends A {  public void print_D() { System.out.println('Class D'); } } // Driver Class public class Test {  public static void main(String[] args)  {  B obj_B = new B();  obj_B.print_A();  obj_B.print_B();  C obj_C = new C();  obj_C.print_A();  obj_C.print_C();  D obj_D = new D();  obj_D.print_A();  obj_D.print_D();  } }>

Class A Class B Class A Class C Class A Class D>

4. Moniperintö ( käyttöliittymien kautta)

Sisään Useita perintöjä , yhdellä luokalla voi olla useampi kuin yksi superluokka ja se voi periä ominaisuuksia kaikilta yläluokilta. Huomaa, että Java tekee ei tuki useita perintöjä luokkien kanssa. Javassa voimme saavuttaa useita perintöjä vain kautta Liitännät . Alla olevassa kuvassa luokka C on johdettu liitännöistä A ja B.

Moniperintö

// Java program to illustrate the // concept of Multiple inheritance import java.io.*; import java.lang.*; import java.util.*; interface One {  public void print_geek(); } interface Two {  public void print_for(); } interface Three extends One, Two {  public void print_geek(); } class Child implements Three {  @Override public void print_geek()  {  System.out.println('Geeks');  }  public void print_for() { System.out.println('for'); } } // Drived class public class Main {  public static void main(String[] args)  {  Child c = new Child();  c.print_geek();  c.print_for();  c.print_geek();  } }>

Geeks for Geeks>

5. Hybridiperintö

Se on sekoitus kahdesta tai useammasta edellä mainitusta perinnöstä. Koska Java ei tue useita perintöjä luokkien kanssa, usean periytymisen sisältävä hybridiperintö ei myöskään ole mahdollista luokkien kanssa. Javassa voimme saavuttaa hybridiperinnön vain kautta Liitännät jos haluamme sisällyttää usean periytymisen hybridiperinnön toteuttamiseen.
On kuitenkin tärkeää huomata, että hybridiperintö ei välttämättä edellytä yksinomaan moniperinnön käyttöä. Se voidaan saavuttaa yhdistämällä monitasoinen periytyminen ja hierarkkinen periytyminen luokkien kanssa, hierarkkinen ja yksittäinen periytyminen luokkien kanssa. Siksi on todellakin mahdollista toteuttaa hybridiperintö käyttämällä luokkia yksinään ilman usean perinnön tyyppiä.

Hybridiperintö

merkkijono kokonaisluvuksi

Java on eräänlainen suhde

IS-A on tapa sanoa: Tämä objekti on objektin tyyppi. Katsotaanpa, kuinka laajennus-avainsanaa käytetään periytymisen saavuttamiseen.

public class SolarSystem { } public class Earth extends SolarSystem { } public class Mars extends SolarSystem { } public class Moon extends Earth { }>

Nyt, edellä olevan esimerkin perusteella, oliokeskeisillä termeillä seuraavat ovat totta: -

• SolarSystem on Earth-luokan huippuluokka.
• SolarSystem on Mars-luokan huippuluokka.
• Maa ja Mars ovat SolarSystem-luokan alaluokkia.
• Kuu on sekä Earth- että SolarSystem-luokkien alaluokka.

class SolarSystem { } class Earth extends SolarSystem { } class Mars extends SolarSystem { } public class Moon extends Earth {  public static void main(String args[])  {  SolarSystem s = new SolarSystem();  Earth e = new Earth();  Mars m = new Mars();  System.out.println(s instanceof SolarSystem);  System.out.println(e instanceof Earth);  System.out.println(m instanceof SolarSystem);  } }>

true true true>

Mitä alaluokassa voidaan tehdä?

Alaluokissa voimme periä jäseniä sellaisenaan, korvata ne, piilottaa ne tai täydentää niitä uusilla jäsenillä:

• Perittyjä kenttiä voidaan käyttää suoraan, kuten mitä tahansa muita kenttiä.
• Voimme ilmoittaa alaluokassa uusia kenttiä, jotka eivät ole superluokassa.
• Perittyjä menetelmiä voidaan käyttää suoraan sellaisenaan.
• Voimme kirjoittaa uuden ilmentymä menetelmä alaluokassa, jolla on sama allekirjoitus kuin superluokan ylivoimainen se (kuten yllä olevassa esimerkissä, toString() menetelmä on ohitettu).
• Voimme kirjoittaa uuden staattinen menetelmä alaluokassa, jolla on sama allekirjoitus kuin superluokan piilossa se.
• Voimme ilmoittaa alaluokassa uusia menetelmiä, jotka eivät ole superluokassa.
• Voimme kirjoittaa aliluokkakonstruktorin, joka kutsuu superluokan rakentajan joko implisiittisesti tai käyttämällä avainsanaa super .

Javan perinnön edut:

1. Koodin uudelleenkäytettävyys: Periytys mahdollistaa koodin uudelleenkäytön ja vähentää kirjoitettavan koodin määrää. Alaluokka voi käyttää uudelleen superluokan ominaisuuksia ja menetelmiä, mikä vähentää koodin päällekkäisyyttä.
2. Abstraktio: Periytys mahdollistaa abstraktien luokkien luomisen, jotka määrittävät yhteisen rajapinnan toisiinsa liittyvien luokkien ryhmälle. Tämä edistää abstraktiota ja kapselointia, mikä tekee koodista helpompi ylläpitää ja laajentaa.
3. Luokkahierarkia: Periytys mahdollistaa luokkahierarkian luomisen, jota voidaan käyttää reaalimaailman kohteiden ja niiden suhteiden mallintamiseen.
4. Polymorfismi: Perinnöllisyys mahdollistaa polymorfismin, joka on objektin kyky ottaa useita muotoja. Alaluokat voivat ohittaa superluokan menetelmät, jolloin ne voivat muuttaa käyttäytymistään eri tavoin.

Java-perinnön haitat:

1. Monimutkaisuus: Periytys voi tehdä koodista monimutkaisempaa ja vaikeampaa ymmärtää. Tämä pätee erityisesti, jos perintöhierarkia on syvä tai jos käytetään useita perintöjä.
2. Tiukka kytkentä: Periytys luo tiukan kytkennän superluokan ja alaluokan välille, mikä vaikeuttaa muutosten tekemistä yläluokkaan vaikuttamatta alaluokkaan.

Johtopäätös

Tarkastellaanpa joitain artikkelin tärkeitä kohtia, jotka mainitaan alla:

• Oletussuperluokka : Paitsi Esine luokka, jolla ei ole superluokkaa, jokaisella luokalla on yksi ja vain yksi suora superluokka (yksittäinen perintö). Muun eksplisiittisen superluokan puuttuessa jokainen luokka on implisiittisesti Object-luokan alaluokka.
• Superluokka voi olla vain yksi: Yläluokalla voi olla mikä tahansa määrä alaluokkia. Mutta alaluokalla voi olla vain yksi superluokka. Tämä johtuu siitä, että Java ei tue useita perintöjä luokkien kanssa. Vaikka Java tukee useita perintöjä, sillä on rajapintoja.
• Perityt rakentajat: Alaluokka perii kaikki jäsenet (kentät, menetelmät ja sisäkkäiset luokat) superluokasta. Konstruktorit eivät ole jäseniä, joten alaluokat eivät peri niitä, mutta alaluokasta voidaan kutsua superluokan konstruktori.
• Yksityinen jäsenperintö: Alaluokka ei peri yläluokkansa yksityisiä jäseniä. Jos superluokassa on kuitenkin julkisia tai suojattuja menetelmiä (kuten getterit ja setterit) yksityisiin kenttiin pääsemiseksi, alaluokka voi myös käyttää niitä.

Usein kysytyt kysymykset perinnössä

1. Mikä on Inheritance Java?

Periytys on OOP-käsite, jossa yksi luokka perii toiselta luokalta, joka voi käyttää uudelleen emoluokan menetelmiä ja kenttiä.

2. Mitkä ovat 4 perintötyyppiä Javassa?

On yksi, monitasoinen, monitasoinen, hierarkkinen ja hybridi

3. Mitä hyötyä on laajentaa avainsanasta?

Extend-avainsanaa käytetään luokan perimiseen toiseen.

4. Mikä on esimerkki perinnöstä Javassa?

Alla mainitaan todellinen esimerkki Java-perinnöstä:

pandan kääntöpiste

Harkitse ajoneuvoryhmää. Sinun on luotava luokat linja-autoille, henkilöautoille ja kuorma-autoille. Metodit fuelAmount(), kapasiteetti(), applyBrakes() ovat samat kaikille kolmelle luokalle.

Käytetyt referenssit:

1. Head First Java: Kathy Sierra ja Bert Bates
2. Java: Herbert Schildtin opas aloittelijoille
3. Java: Herbert Schildtin täydellinen viite
4. Tehokas Java, kirjoittanut Joshua Bloch
5. Java: Hyvät osat, kirjoittanut Jim Waldo.