V jazyku Java je abstraktná trieda deklarovaná kľúčovým slovom abstract. Môže mať abstraktné aj neabstraktné metódy (metódy s telami). Abstrakt je modifikátor Java použiteľný pre triedy a metódy v jazyku Java, ale nie pre Premenné . V tomto článku sa naučíme používať abstraktné triedy v Jave.
Čo je abstraktná trieda v jazyku Java?
Abstraktná trieda Java je trieda, ktorá nemôže byť iniciovaná sama osebe, musí byť podtriedená inou triedou, aby mohla využívať jej vlastnosti. Abstraktná trieda je deklarovaná pomocou kľúčového slova abstract v jej definícii triedy.
Ilustrácia abstraktnej triedy
abstract class Shape { int color; // An abstract function abstract void draw(); }> V Jave sú nasledujúce niektoré dôležité postrehy o abstraktných triedach sú nasledovné:
- Inštanciu abstraktnej triedy nie je možné vytvoriť.
- Konštruktéri sú povolené.
- Môžeme mať abstraktnú triedu bez akejkoľvek abstraktnej metódy.
- Môže existovať a konečná metóda v abstraktnej triede, ale žiadna abstraktná metóda v triede (abstraktná trieda) nemôže byť deklarovaná ako konečná alebo jednoduchšie konečná metóda nemôže byť sama osebe abstraktná, pretože spôsobí chybu: Nepovolená kombinácia modifikátorov: abstraktné a konečné
- V abstraktnej triede môžeme definovať statické metódy
- Môžeme použiť abstraktné kľúčové slovo na vyhlásenie triedy najvyššej úrovne (Outer class), ako aj vnútorné triedy ako abstraktné
- Ak trieda obsahuje minimálne jedna abstraktná metóda potom povinné by mali deklarovať triedu ako abstraktnú
- Ak Detská trieda nie je schopná zabezpečiť implementáciu všetkých abstraktných metód Rodičovská trieda potom by sme to mali vyhlásiť Detská trieda ako abstrakt takže trieda Child ďalšej úrovne by mala poskytovať implementáciu zostávajúcej abstraktnej metóde
Príklady Java Abstract Class
1. Príklad abstraktnej triedy, ktorá má abstraktnú metódu
Nižšie je uvedená implementácia vyššie uvedenej témy:
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();> >}> }> |
>
>Výkon
avinash 21 222.2>
2. Abstraktná trieda s konštruktorom, dátovým členom a metódami
Prvky abstraktnej triedy môžu mať
- údajový člen
- abstraktná metóda
- telo metódy (neabstraktná metóda)
- konštruktér
- metóda main().
Nižšie je uvedená implementácia vyššie uvedenej témy:
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();> >}> }> |
>
>Výkon
Learning Subject C , Java , C++ Preparing Right Now!>
Vlastnosti abstraktnej triedy
Rozoberme tieto pozorovania a zdôvodnime ich pomocou čistých programov Java nasledovne.
Pozorovanie 1
V Jave, rovnako ako v C++, nemožno vytvoriť inštanciu abstraktnej triedy, ale môžeme mať odkazy na abstraktný typ triedy. Je to znázornené nižšie prostredníctvom čistého programu Java.
Príklad
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();> >}> }> |
>
>Výkon
panel nástrojov rýchleho prístupu ms word
Derived fun() called>
Pozorovanie 2
Rovnako ako C++, an abstraktná trieda môže obsahovať konštruktérov v Jave. A konštruktor abstraktnej triedy sa zavolá, keď sa vytvorí inštancia zdedenej triedy. Je to znázornené v programe nižšie takto:
Príklad:
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();> >}> }> |
>
>Výkon
Base Constructor Called Derived Constructor Called Derived fun() called>
Pozorovanie 3
V Jave môžeme mať abstraktná trieda bez akejkoľvek abstraktnej metódy . To nám umožňuje vytvárať triedy, ktoré nemožno vytvárať inštancie, ale možno ich iba dediť . S pomocou čistého programu Java je to znázornené nižšie.
Príklad:
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();> >}> }> |
>
>Výkon
Function of Base class is called>
Pozorovanie 4
Abstraktné triedy môžu mať tiež Konečný metódy (metódy, ktoré nemožno prepísať)
Príklad:
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();> >}> >}> }> |
>
>Výkon
Base fun() called>
Pozorovanie 5
Pre žiadnu abstraktnú triedu java nie je dovolené vytvárať objekt, t. j. pre abstraktnú triedu nie je možná inštancia.
Java
// 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();> >}> }> |
java má ďalšie
>
>
Výkon:
Pozorovanie 6
Podobne ako rozhranie môžeme definovať statické metódy v abstraktnej triede že možno volať nezávisle bez objektu.
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();> >}> }> |
>
>Výkon
Geeks for Geeks>
Pozorovanie 7
Môžeme použiť abstraktné kľúčové slovo na deklarovanie tried najvyššej úrovne (Outer class), ako aj vnútorných tried ako abstraktných
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();> >}> }> |
>
>Výkon
Inside abstract method implementation>
Pozorovanie 8
Ak trieda obsahuje aspoň jednu abstraktnú metódu potom povinné, aby sme triedu deklarovali ako abstraktnú inak dostaneme chybu pri kompilácii ,Ak trieda obsahuje aspoň jednu abstraktnú metódu, implementácia pre túto triedu nie je úplná, a preto sa neodporúča vytvárať objekt, aby sa obmedzilo vytváranie objektov pre takéto čiastkové triedy používame abstraktné kľúčové slovo.
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();> >}> }> |
>
>Výkon
Hello>
Pozorovanie 9
Ak Dieťa trieda nie je schopná poskytnúť implementáciu všetkých abstraktných metód triedy Parent, potom by sme mali túto triedu Child vyhlásiť za abstraktnú, takže trieda Child ďalšej úrovne by mala poskytovať implementáciu zostávajúcej abstraktnej metóde.
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();> >}> }> |
>
>Výkon
Inside m1 Inside m2 Inside m3>
V C++, ak má trieda aspoň jednu čistá virtuálna funkcia , potom sa trieda stane abstraktnou. Na rozdiel od C++ v Jave sa na vytvorenie abstraktu triedy používa samostatné kľúčové slovo abstrakt.
Záver
Body, ktoré si treba zapamätať z tohto článku, sú uvedené nižšie:
- Abstraktná trieda je trieda, ktorá nemôže byť iniciovaná sama osebe, musí byť podtriedená inou triedou, aby mohla využívať jej vlastnosti.
- Abstraktnú triedu je možné vytvoriť pomocou abstraktných kľúčových slov.
- Môžeme mať abstraktnú triedu bez akejkoľvek abstraktnej metódy.
Časté otázky abstraktnej triedy
1. Čo je abstraktná trieda v Jave?
Abstraktná trieda v jazyku Java je trieda, ktorá nemôže byť iniciovaná samostatne, ale môže byť použitá ako podtrieda inou triedou.
2. Aký je účel abstraktnej triedy?
Hlavným účelom abstraktnej triedy je vytvoriť základnú triedu, z ktorej možno odvodiť mnoho ďalších tried.
3. Aká je hlavná výhoda abstraktnej triedy?
Abstraktná trieda poskytuje možnosti skrývania údajov v jazyku Java.
4. Prečo je abstraktná trieda rýchlejšia ako rozhranie?
Abstraktná trieda je rýchlejšia ako rozhranie, pretože rozhranie zahŕňa vyhľadávanie pred volaním akejkoľvek prepísanej metódy v jazyku Java, zatiaľ čo abstraktnú triedu možno použiť priamo.
Tiež si prečítajte
- Rozdiel medzi abstraktnou triedou a rozhraním v Jave
- Rozdiel medzi abstraktnou triedou a abstraktnými metódami
- Konštruktory v Java Abstract Class