Javassa abstrakti luokka ilmoitetaan abstraktilla avainsanalla. Siinä voi olla sekä abstrakteja että ei-abstrakteja menetelmiä (menetelmiä, joissa on kappaleita). Tiivistelmä on Java-muokkaus, joka soveltuu Java-luokille ja menetelmille, mutta ei muuttujia varten . Tässä artikkelissa opimme käyttämään abstrakteja luokkia Javassa.
Mikä on Abstract Class Javassa?
Abstrakti Java-luokka on luokka, jota ei voida käynnistää itsestään, vaan se on alaluokitettava toisen luokan toimesta voidakseen käyttää sen ominaisuuksia. Abstrakti luokka ilmoitetaan käyttämällä abstraktia avainsanaa sen luokkamäärityksessä.
Kuva abstraktista luokasta
abstract class Shape { int color; // An abstract function abstract void draw(); }> Javassa seuraavat joitain tärkeitä havaintoja abstrakteista luokista ovat seuraavat:
- Abstraktin luokan esiintymää ei voida luoda.
- Rakentajat ovat sallittuja.
- Meillä voi olla abstrakti luokka ilman abstraktia menetelmää.
- Siellä voi olla a lopullinen menetelmä abstraktissa luokassa, mutta mitä tahansa abstraktia menetelmää luokassa (abstrakti luokka) ei voida julistaa lopulliseksi tai yksinkertaisemmin sanottuna lopullinen menetelmä ei voi olla abstrakti itse, koska se antaa virheen: Laiton modifiointien yhdistelmä: abstrakti ja lopullinen
- Voimme määritellä staattiset menetelmät abstraktissa luokassa
- Voimme käyttää abstrakti avainsana julistamista varten huippuluokan luokat (Ulkoluokka) sekä sisäluokat abstraktina
- Jos luokkaa sisältää ainakin yksi abstrakti menetelmä silloin pakollisen tulisi julistaa luokka abstraktiksi
- Jos Lapsiluokka ei pysty toteuttamaan kaikkia abstrakteja menetelmiä Vanhempien luokka sitten meidän pitäisi julistaa se Lapsiluokka abstraktina niin, että seuraavan tason lapsiluokan tulisi toteuttaa jäljellä oleva abstrakti menetelmä
Esimerkkejä Java Abstract Classista
1. Esimerkki abstraktista luokasta, jossa on abstrakti menetelmä
Alla on yllä olevan aiheen toteutus:
Java
// Abstract class> abstract> class> Sunstar {> >abstract> void> printInfo();> }> // Abstraction performed using extends> class> Employee>extends> Sunstar {> >void> printInfo()> >{> >String name =>'avinash'>;> >int> age =>21>;> >float> salary =>222>.2F;> >System.out.println(name);> >System.out.println(age);> >System.out.println(salary);> >}> }> // Base class> class> Base {> >public> static> void> main(String args[])> >{> >Sunstar s =>new> Employee();> >s.printInfo();> >}> }> |
>
>Lähtö
avinash 21 222.2>
2. Abstrakti luokka, jossa on konstruktori, datajäsen ja menetelmät
Abstraktissa luokassa voi olla elementtejä
- datajäsen
- abstrakti menetelmä
- menetelmän runko (ei-abstrakti menetelmä)
- rakentaja
- main() -menetelmä.
Alla on yllä olevan aiheen toteutus:
Java
// Java Program to implement Abstract Class> // having constructor, data member, and methods> import> java.io.*;> abstract> class> Subject {> >Subject() {> >System.out.println(>'Learning Subject'>);> >}> > >abstract> void> syllabus();> > >void> Learn(){> >System.out.println(>'Preparing Right Now!'>);> >}> }> class> IT>extends> Subject {> >void> syllabus(){> >System.out.println(>'C , Java , C++'>);> >}> }> class> GFG {> >public> static> void> main(String[] args) {> >Subject x=>new> IT();> > >x.syllabus();> >x.Learn();> >}> }> |
>
>Lähtö
Learning Subject C , Java , C++ Preparing Right Now!>
Abstraktiluokan ominaisuudet
Tarkastellaanpa näitä havaintoja ja perustellaan ne puhtaiden java-ohjelmien avulla seuraavasti.
Havainto 1
Javassa, aivan kuten C++:ssa ei voida luoda abstraktin luokan esiintymää, meillä voi kuitenkin olla viittauksia abstraktiin luokkatyyppiin. Se näkyy alla puhtaan Java-ohjelman kautta.
Esimerkki
Java
// Java Program to Illustrate> // that an instance of Abstract> // Class can not be created> // Class 1> // Abstract class> abstract> class> Base {> >abstract> void> fun();> }> // Class 2> class> Derived>extends> Base {> >void> fun()> >{> >System.out.println(>'Derived fun() called'>);> >}> }> // Class 3> // Main class> class> Main {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Uncommenting the following line will cause> >// compiler error as the line tries to create an> >// instance of abstract class. Base b = new Base();> >// We can have references of Base type.> >Base b =>new> Derived();> >b.fun();> >}> }> |
>
>Lähtö
muurahainen vs maven
Derived fun() called>
Havainto 2
Kuten C++, an abstrakti luokka voi sisältää rakentajat Javassa. Ja abstraktin luokan konstruktoria kutsutaan, kun luodaan perityn luokan esiintymä. Se näkyy alla olevassa ohjelmassa seuraavasti:
Esimerkki:
Java
// Java Program to Illustrate Abstract Class> // Can contain Constructors> // Class 1> // Abstract class> abstract> class> Base {> >// Constructor of class 1> >Base()> >{> >// Print statement> >System.out.println(>'Base Constructor Called'>);> >}> >// Abstract method inside class1> >abstract> void> fun();> }> // Class 2> class> Derived>extends> Base {> >// Constructor of class2> >Derived()> >{> >System.out.println(>'Derived Constructor Called'>);> >}> >// Method of class2> >void> fun()> >{> >System.out.println(>'Derived fun() called'>);> >}> }> // Class 3> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating object of class 2> >// inside main() method> >Derived d =>new> Derived();> >d.fun();> >}> }> |
>
>Lähtö
Base Constructor Called Derived Constructor Called Derived fun() called>
Havainto 3
Javalla meillä voi olla abstrakti luokka ilman abstraktia menetelmää . Tämä antaa meille mahdollisuuden luoda luokkia, joita ei voida instantoida, mutta jotka voidaan vain periä . Se näkyy alla seuraavasti puhtaan java-ohjelman avulla.
Esimerkki:
Java
// Java Program to illustrate Abstract class> // Without any abstract method> // Class 1> // An abstract class without any abstract method> abstract> class> Base {> >// Demo method. This is not an abstract method.> >void> fun()> >{> >// Print message if class 1 function is called> >System.out.println(> >'Function of Base class is called'>);> >}> }> // Class 2> class> Derived>extends> Base {> >// This class only inherits the Base class methods and> >// properties> }> // Class 3> class> Main {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating object of class 2> >Derived d =>new> Derived();> >// Calling function defined in class 1 inside main()> >// with object of class 2 inside main() method> >d.fun();> >}> }> |
>
>Lähtö
Function of Base class is called>
Havainto 4
Abstrakteilla luokilla voi olla myös lopullinen menetelmiä (menetelmiä, joita ei voi ohittaa)
Esimerkki:
Java
// Java Program to Illustrate Abstract classes> // Can also have Final Methods> // Class 1> // Abstract class> abstract> class> Base {> >final> void> fun()> >{> >System.out.println(>'Base fun() called'>);> >}> }> // Class 2> class> Derived>extends> Base {> > }> // Class 3> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >{> >// Creating object of abstract class> >Base b =>new> Derived();> >// Calling method on object created above> >// inside main method> >b.fun();> >}> >}> }> |
>
>Lähtö
Base fun() called>
Havainto 5
Abstraktille java-luokalle emme saa luoda objektia, eli abstraktille luokalle ilmentäminen ei ole mahdollista.
Java
javascript monirivinen merkkijono
// Java Program to Illustrate Abstract Class> // Main class> // An abstract class> abstract> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Trying to create an object> >GFG gfg =>new> GFG();> >}> }> |
>
>
Lähtö:
Havainto 6
Samanlainen kuin käyttöliittymä voimme määritellä staattisia menetelmiä abstraktissa luokassa että voidaan kutsua itsenäisesti ilman objektia.
Java
// Java Program to Illustrate> // Static Methods in Abstract> // Class Can be called Independently> // Class 1> // Abstract class> abstract> class> Helper {> >// Abstract method> >static> void> demofun()> >{> >// Print statement> >System.out.println(>'Geeks for Geeks'>);> >}> }> // Class 2> // Main class extending Helper class> public> class> GFG>extends> Helper {> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Calling method inside main()> >// as defined in above class> >Helper.demofun();> >}> }> |
>
>Lähtö
Geeks for Geeks>
Havainto 7
Voimme käyttää abstrakti avainsana ylimmän tason luokkien (Ulkoluokka) sekä sisäluokkien julistamiseen abstrakteiksi
Java
import> java.io.*;> abstract> class> B {> >// declaring inner class as abstract with abstract> >// method> >abstract> class> C {> >abstract> void> myAbstractMethod();> >}> }> class> D>extends> B {> >class> E>extends> C {> >// implementing the abstract method> >void> myAbstractMethod()> >{> >System.out.println(> >'Inside abstract method implementation'>);> >}> >}> }> public> class> Main {> >public> static> void> main(String args[])> >{> >// Instantiating the outer class> >D outer =>new> D();> >// Instantiating the inner class> >D.E inner = outer.>new> E();> >inner.myAbstractMethod();> >}> }> |
>
>Lähtö
Inside abstract method implementation>
Havainto 8
Jos luokka sisältää ainakin yhden abstraktin menetelmän sitten pakollista, että meidän pitäisi julistaa luokka abstraktiksi muuten saamme käännösaikavirheen, jos luokka sisältää ainakin yhden abstraktin menetelmän, toteutus ei ole valmis kyseiselle luokalle, joten ei ole suositeltavaa luoda objektia, jotta objektin luomista rajoitetaan tällaisille osittaisille luokille käytämme abstrakti avainsana.
Java
/*package whatever //do not write package name here */> import> java.io.*;> // here if we remove the abstract> // keyword then we will get compile> // time error due to abstract method> abstract> class> Demo {> >abstract> void> m1();> }> class> Child>extends> Demo {> >public> void> m1()> >{> >System.out.print(>'Hello'>);> >}> }> class> GFG {> >public> static> void> main(String[] args)> >{> >Child c =>new> Child();> >c.m1();> >}> }> |
>
>Lähtö
Hello>
Havainto 9
Jos Lapsi luokka ei pysty tarjoamaan toteutusta kaikille Parent-luokan abstrakteille menetelmille, niin meidän pitäisi julistaa tämä lapsiluokka abstraktiksi, jotta seuraavan tason Child-luokan tulisi tarjota toteutus jäljellä olevalle abstraktille menetelmälle.
Java
// Java Program to demonstrate> // Observation> import> java.io.*;> abstract> class> Demo {> >abstract> void> m1();> >abstract> void> m2();> >abstract> void> m3();> }> abstract> class> FirstChild>extends> Demo {> >public> void> m1() {> >System.out.println(>'Inside m1'>);> >}> }> class> SecondChild>extends> FirstChild {> >public> void> m2() {> >System.out.println(>'Inside m2'>);> >}> >public> void> m3() {> >System.out.println(>'Inside m3'>);> >}> }> class> GFG {> >public> static> void> main(String[] args)> >{> >// if we remove the abstract keyword from FirstChild> >// Class and uncommented below obj creation for> >// FirstChild then it will throw> >// compile time error as did't override all the> >// abstract methods> >// FirstChild f=new FirstChild();> >// f.m1();> >SecondChild s =>new> SecondChild();> >s.m1();> >s.m2();> >s.m3();> >}> }> |
>
>Lähtö
Inside m1 Inside m2 Inside m3>
C++:ssa, jos luokassa on vähintään yksi puhdas virtuaalinen toiminto , silloin luokasta tulee abstrakti. Toisin kuin C++, Javassa luokan abstraktin tekemiseen käytetään erillistä avainsanaa abstract.
Johtopäätös
Tästä artikkelista muistettavat seikat on mainittu alla:
- Abstrakti luokka on luokka, jota ei voida aloittaa itsestään, vaan se on alaluokitettava toisen luokan toimesta käyttääkseen sen ominaisuuksia.
- Abstrakti luokka voidaan luoda käyttämällä abstrakteja avainsanoja.
- Meillä voi olla abstrakti luokka ilman abstraktia menetelmää.
Abstract-luokan usein kysytyt kysymykset
1. Mikä on abstrakti luokka Javassa?
Abstrakti luokka Javassa on luokka, jota ei voida aloittaa yksinään, mutta jota toinen luokka voi käyttää alaluokkana.
2. Mikä on abstraktin luokan tarkoitus?
Abstraktin luokan päätarkoitus on luoda perusluokka, josta voidaan johtaa monia muita luokkia.
3. Mikä on abstraktin luokan tärkein etu?
Abstrakti luokka tarjoaa tiedon piilottamisen Javassa.
4. Miksi abstrakti luokka on nopeampi kuin käyttöliittymä?
Abstrakti luokka on nopeampi kuin käyttöliittymä, koska käyttöliittymä sisältää haun ennen ohitetun menetelmän kutsumista Javassa, kun taas abstraktia luokkaa voidaan käyttää suoraan.
Myös Lue
- Ero abstraktin luokan ja käyttöliittymän välillä Javassa
- Ero abstraktin luokan ja abstraktien menetelmien välillä
- Rakentajat Java Abstract Classissa