W Javie klasa abstrakcyjna jest deklarowana za pomocą słowa kluczowego streszczenie. Może mieć zarówno metody abstrakcyjne, jak i nieabstrakcyjne (metody z ciałami). Streszczenie to modyfikator Java mający zastosowanie do klas i metod w Javie, ale nie dla zmiennych . W tym artykule nauczymy się korzystać z klas abstrakcyjnych w Javie.
Co to jest klasa abstrakcyjna w Javie?
Klasa abstrakcyjna języka Java to klasa, której nie można samodzielnie zainicjować; aby móc korzystać z jej właściwości, musi zostać podklasowana przez inną klasę. Klasę abstrakcyjną deklaruje się za pomocą słowa kluczowego streszczenie w jej definicji klasy.
Ilustracja klasy abstrakcyjnej
abstract class Shape { int color; // An abstract function abstract void draw(); }> W Javie poniższe niektóre ważne obserwacje dotyczące klas abstrakcyjnych są następujące:
- Nie można utworzyć instancji klasy abstrakcyjnej.
- Konstruktorzy są dozwoleni.
- Możemy mieć klasę abstrakcyjną bez żadnej metody abstrakcyjnej.
- Może być metoda ostateczna w klasie abstrakcyjnej, ale żadna metoda abstrakcyjna w klasie (klasa abstrakcyjna) nie może zostać zadeklarowana jako ostateczna lub, mówiąc prościej, ostateczna metoda nie może sama w sobie być abstrakcyjna, ponieważ spowoduje to błąd: Niedozwolona kombinacja modyfikatorów: abstrakcyjnego i końcowego
- Metody statyczne możemy zdefiniować w klasie abstrakcyjnej
- Możemy skorzystać z abstrakcyjne słowo kluczowe za zadeklarowanie klasy najwyższego poziomu (klasa zewnętrzna), a także klasy wewnętrzne jako abstrakcyjne
- Jeśli klasa zawiera przynajmniej jedna abstrakcyjna metoda wówczas obowiązkowo należy zadeklarować klasę jako abstrakcyjną
- Jeśli Klasa dziecka nie jest w stanie zapewnić implementacji wszystkich abstrakcyjnych metod Klasa rodzicielska wtedy powinniśmy to ogłosić Klasa podrzędna jako abstrakcyjna tak aby klasa Child następnego poziomu zapewniła implementację pozostałej metody abstrakcyjnej
Przykłady klas abstrakcyjnych Java
1. Przykład klasy abstrakcyjnej, która posiada metodę abstrakcyjną
Poniżej realizacja powyższego tematu:
Jawa
// 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();> >}> }> |
>
>Wyjście
avinash 21 222.2>
2. Klasa abstrakcyjna posiadająca konstruktor, element danych i metody
Elementy, które może posiadać klasa abstrakcyjna
- członek danych
- metoda abstrakcyjna
- treść metody (metoda nieabstrakcyjna)
- konstruktor
- metoda main().
Poniżej realizacja powyższego tematu:
Jawa
// 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();> >}> }> |
>
>Wyjście
Learning Subject C , Java , C++ Preparing Right Now!>
Właściwości klasy Abstrakcyjnej
Rozwińmy te obserwacje i uzasadnijmy je za pomocą czystych programów Java w następujący sposób.
Obserwacja 1
W Javie, podobnie jak w C++, nie można utworzyć instancji klasy abstrakcyjnej, możemy jednak mieć odniesienia do typu klasy abstrakcyjnej. Jest to pokazane poniżej w czystym programie Java.
Przykład
Jawa
// 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();> >}> }> |
>
>Wyjście
centos kontra rhel
Derived fun() called>
Obserwacja 2
Podobnie jak C++, np klasa abstrakcyjna może zawierać konstruktorzy w Jawie. Konstruktor klasy abstrakcyjnej jest wywoływany, gdy tworzona jest instancja klasy dziedziczonej. Wygląda to tak jak na poniższym programie:
Przykład:
Jawa
// 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();> >}> }> |
>
>Wyjście
Base Constructor Called Derived Constructor Called Derived fun() called>
Obserwacja 3
W Javie możemy mieć klasa abstrakcyjna bez żadnej metody abstrakcyjnej . To nam na to pozwala tworzyć klasy, których nie można utworzyć, a które można jedynie dziedziczyć . Jest to pokazane poniżej w następujący sposób przy pomocy czystego programu Java.
Przykład:
Jawa
// 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();> >}> }> |
>
>Wyjście
Function of Base class is called>
Obserwacja 4
Klasy abstrakcyjne mogą również mieć finał metody (metody, których nie można zastąpić)
Przykład:
Jawa
// 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();> >}> >}> }> |
>
>Wyjście
Base fun() called>
Obserwacja 5
Dla żadnej abstrakcyjnej klasy Java nie wolno nam tworzyć obiektu, tzn. dla instancji klasy abstrakcyjnej nie jest możliwe.
Jawa
// 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();> >}> }> |
>
>
Wyjście:
Obserwacja 6
Podobny do interfejsu możemy zdefiniować metody statyczne w klasie abstrakcyjnej To można wywołać niezależnie bez obiektu.
Jawa
// 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();> >}> }> |
>
>Wyjście
Geeks for Geeks>
Obserwacja 7
Możemy skorzystać z abstrakcyjne słowo kluczowe do deklarowania klas najwyższego poziomu (klasa zewnętrzna), a także klas wewnętrznych jako abstrakcyjnych
Jawa
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();> >}> }> |
>
>Wyjście
Inside abstract method implementation>
Obserwacja 8
Jeśli klasa zawiera co najmniej jedną metodę abstrakcyjną Następnie obowiązkowe, że powinniśmy zadeklarować klasę jako abstrakcyjną w przeciwnym razie otrzymamy błąd kompilacji. Jeśli klasa zawiera co najmniej jedną metodę abstrakcyjną, wówczas implementacja dla tej klasy nie została ukończona i dlatego nie zaleca się tworzenia obiektu, aby ograniczyć tworzenie obiektów dla takich klas częściowych Używamy abstrakcyjne słowo kluczowe.
Jawa
/*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();> >}> }> |
>
>Wyjście
Hello>
Obserwacja 9
Jeśli Dziecko class nie jest w stanie zapewnić implementacji wszystkich abstrakcyjnych metod klasy Parent, powinniśmy zadeklarować tę klasę Child jako abstrakcyjną, tak aby klasa Child następnego poziomu zapewniła implementację pozostałej metody abstrakcyjnej.
Jawa
wyrównywanie obrazów w CSS
// 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();> >}> }> |
>
>Wyjście
Inside m1 Inside m2 Inside m3>
W C++, jeśli klasa ma co najmniej jedną czysta funkcja wirtualna , wtedy klasa staje się abstrakcyjna. W przeciwieństwie do C++, w Javie do utworzenia streszczenia klasy używa się osobnego streszczenia słowa kluczowego.
Wniosek
Punkty do zapamiętania z tego artykułu są wymienione poniżej:
- Klasa abstrakcyjna to klasa, której nie można samodzielnie zainicjować; aby móc korzystać z jej właściwości, musi zostać podklasowana przez inną klasę.
- Klasę abstrakcyjną można utworzyć za pomocą abstrakcyjnych słów kluczowych.
- Możemy mieć klasę abstrakcyjną bez żadnej metody abstrakcyjnej.
Często zadawane pytania dotyczące klasy abstrakcyjnej
1. Co to jest klasa abstrakcyjna w Javie?
Klasa abstrakcyjna w Javie to klasa, która nie może zostać zainicjowana samodzielnie, ale może zostać użyta jako podklasa przez inną klasę.
2. Jaki jest cel klasy abstrakcyjnej?
Głównym celem klasy abstrakcyjnej jest utworzenie klasy bazowej, z której można wyprowadzić wiele innych klas.
3. Jaka jest główna zaleta klasy abstrakcyjnej?
Klasa abstrakcyjna zapewnia możliwość ukrywania danych w Javie.
4. Dlaczego klasa abstrakcyjna jest szybsza niż interfejs?
Klasa abstrakcyjna jest szybsza niż interfejs, ponieważ interfejs wymaga wyszukiwania przed wywołaniem jakiejkolwiek przesłoniętej metody w Javie, podczas gdy klasy abstrakcyjnej można użyć bezpośrednio.
Przeczytaj także
- Różnica między klasą abstrakcyjną a interfejsem w Javie
- Różnica między klasą abstrakcyjną a metodami abstrakcyjnymi
- Konstruktory w klasie abstrakcyjnej Java