V Javě je abstraktní třída deklarována klíčovým slovem abstract. Může mít jak abstraktní, tak neabstraktní metody (metody s těly). Abstrakt je modifikátor Java použitelný pro třídy a metody v jazyce Java, ale ne pro proměnné . V tomto článku se naučíme používat abstraktní třídy v Javě.
Co je abstraktní třída v Javě?
Abstraktní třída Java je třída, která nemůže být iniciována sama o sobě, musí být podtříděna jinou třídou, aby mohla využívat její vlastnosti. Abstraktní třída je deklarována pomocí klíčového slova abstract v její definici třídy.
Ilustrace abstraktní třídy
abstract class Shape { int color; // An abstract function abstract void draw(); }> V Javě následující některé důležitá pozorování o abstraktních třídách jsou následující:
- Instanci abstraktní třídy nelze vytvořit.
- Konstruktéři jsou povoleni.
- Můžeme mít abstraktní třídu bez jakékoli abstraktní metody.
- Může být a konečná metoda v abstraktní třídě, ale žádná abstraktní metoda ve třídě (abstraktní třída) nemůže být deklarována jako konečná nebo jednodušeji konečná metoda nemůže být sama o sobě abstraktní, protože způsobí chybu: Nepovolená kombinace modifikátorů: abstraktní a konečná
- Můžeme definovat statické metody v abstraktní třídě
- Můžeme použít abstraktní klíčové slovo pro vyhlášení třídy nejvyšší úrovně (Outer class) i vnitřní třídy jako abstraktní
- Pokud třída obsahuje minimálně jedna abstraktní metoda pak povinný by měl deklarovat třídu jako abstraktní
- Pokud Třída dětí není schopen zajistit implementaci všech abstraktních metod Rodičovská třída pak bychom to měli prohlásit Třída dítěte jako abstraktní takže třída Child další úrovně by měla poskytovat implementaci zbývající abstraktní metody
Příklady Java Abstract Class
1. Příklad abstraktní třídy, která má abstraktní metodu
Níže je implementace výše uvedeného tématu:
Jáva
// 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ýstup
avinash 21 222.2>
2. Abstraktní třída s konstruktorem, datovým členem a metodami
Prvky abstraktní třídy mohou mít
- datový člen
- abstraktní metoda
- tělo metody (neabstraktní metoda)
- konstruktér
- metoda main().
Níže je implementace výše uvedeného tématu:
Jáva
// 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ýstup
Learning Subject C , Java , C++ Preparing Right Now!>
Vlastnosti abstraktní třídy
Pojďme si tato pozorování rozvést a zdůvodnit je pomocí čistých java programů následovně.
Pozorování 1
V Javě, stejně jako v C++, nelze vytvořit instanci abstraktní třídy, ale můžeme mít odkazy na abstraktní typ třídy. Je to, jak je uvedeno níže, prostřednictvím čistého programu Java.
Příklad
Jáva
// 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ýstup
java objektová rovnost
Derived fun() called>
Pozorování 2
Stejně jako C++, an abstraktní třída může obsahovat konstruktéři v Javě. A konstruktor abstraktní třídy je volán, když je vytvořena instance zděděné třídy. V níže uvedeném programu je to zobrazeno následovně:
Příklad:
Jáva
// 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ýstup
Base Constructor Called Derived Constructor Called Derived fun() called>
Pozorování 3
V Javě můžeme mít abstraktní třída bez jakékoli abstraktní metody . To nám umožňuje vytvářet třídy, které nelze konkretizovat, ale lze je pouze zdědit . Je to, jak je uvedeno níže, s pomocí čistého programu Java.
Příklad:
Jáva
// 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ýstup
Function of Base class is called>
Pozorování 4
Abstraktní třídy mohou mít také finále metody (metody, které nelze přepsat)
Příklad:
Jáva
// 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ýstup
Base fun() called>
Pozorování 5
Pro žádnou abstraktní třídu Java nesmíme vytvářet objekt, tj. pro abstraktní třídu není konkretizace možná.
Jáva
// 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();> >}> }> |
>
>
Výstup:
Pozorování 6
Podobné rozhraní můžeme definovat statické metody v abstraktní třídě že lze volat nezávisle bez objektu.
Jáva
// 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ýstup
Geeks for Geeks>
Pozorování 7
Můžeme použít abstraktní klíčové slovo pro deklarování tříd nejvyšší úrovně (Outer class) i vnitřních tříd jako abstraktní
Jáva
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ýstup
Inside abstract method implementation>
Pozorování 8
Pokud třída obsahuje alespoň jednu abstraktní metodu pak povinné, že bychom měli třídu deklarovat jako abstraktní jinak dostaneme chybu při kompilaci ,Pokud třída obsahuje alespoň jednu abstraktní metodu, pak implementace pro tuto třídu není úplná, a proto se nedoporučuje vytvářet objekt, aby se omezilo vytváření objektů pro takové dílčí třídy. používáme abstraktní klíčové slovo.
Jáva
/*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ýstup
Hello>
Pozorování 9
Pokud Dítě třída není schopna zajistit implementaci všech abstraktních metod třídy Parent, pak bychom měli tuto třídu Child prohlásit za abstraktní, takže třída Child další úrovně by měla poskytovat implementaci zbývající abstraktní metodě.
Jáva
// 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();> >}> }> |
>
>
Verilog vždyVýstup
Inside m1 Inside m2 Inside m3>
V C++, pokud má třída alespoň jeden čistě virtuální funkce , pak se třída stane abstraktní. Na rozdíl od C++ se v Javě používá k vytvoření abstrakt třídy samostatné klíčové slovo abstrakt.
Závěr
Body, které je třeba si zapamatovat z tohoto článku, jsou uvedeny níže:
- Abstraktní třída je třída, která nemůže být iniciována sama o sobě, musí být podtřídou jinou třídou, aby mohla používat její vlastnosti.
- Abstraktní třídu lze vytvořit pomocí abstraktních klíčových slov.
- Můžeme mít abstraktní třídu bez jakékoli abstraktní metody.
Nejčastější dotazy abstraktní třídy
1. Co je abstraktní třída v Javě?
Abstraktní třída v Javě je třída, která nemůže být iniciována sama o sobě, ale může být použita jako podtřída jinou třídou.
2. Jaký je účel abstraktní třídy?
Hlavním účelem abstraktní třídy je vytvořit základní třídu, ze které lze odvodit mnoho dalších tříd.
3. Jaká je hlavní výhoda abstraktní třídy?
Abstraktní třída poskytuje možnosti skrytí dat v Javě.
4. Proč je abstraktní třída rychlejší než rozhraní?
Abstraktní třída je rychlejší než rozhraní, protože rozhraní zahrnuje vyhledávání před voláním jakékoli přepsané metody v Javě, zatímco abstraktní třídu lze použít přímo.
Také Číst
- Rozdíl mezi abstraktní třídou a rozhraním v Javě
- Rozdíl mezi abstraktní třídou a abstraktními metodami
- Konstruktory v Java Abstract Class