logo

TechCodeview

Classe astratta in Java

In Java, la classe astratta viene dichiarata con la parola chiave abstract. Può avere metodi sia astratti che non astratti (metodi con corpi). Un abstract è un modificatore Java applicabile a classi e metodi in Java ma non per le variabili . In questo articolo impareremo l'uso delle classi astratte in Java.

Cos'è la classe astratta in Java?

La classe astratta Java è una classe che non può essere avviata da sola, deve essere sottoclassata da un'altra classe per utilizzare le sue proprietà. Una classe astratta viene dichiarata utilizzando la parola chiave abstract nella sua definizione di classe.



Illustrazione della classe astratta 

abstract class Shape  {  int color;  // An abstract function  abstract void draw(); }>

In Java, i seguenti alcuni osservazioni importanti sulle classi astratte sono le seguenti:

  1. Non è possibile creare un'istanza di una classe astratta.
  2. Sono ammessi costruttori.
  3. Possiamo avere una classe astratta senza alcun metodo astratto.
  4. Può esserci un metodo finale nella classe astratta ma qualsiasi metodo astratto nella classe (classe astratta) non può essere dichiarato come finale o in termini più semplici il metodo finale non può essere astratto in quanto genererà un errore: Combinazione illegale di modificatori: astratto e finale
  5. Possiamo definire metodi statici in una classe astratta
  6. Possiamo usare il parola chiave astratta per aver dichiarato classi di livello superiore (classe esterna) e classi interne come astratto
  7. Se un classe contiene almeno un metodo astratto quindi obbligatorio dovrebbe dichiarare una classe come astratta
  8. Se la Classe bambini non è in grado di fornire l'implementazione a tutti i metodi astratti di Classe genitori allora dovremmo dichiararlo Classe infantile come astratta in modo che la classe Child di livello successivo fornisca l'implementazione al restante metodo astratto

Esempi di classe astratta Java

1. Esempio di classe astratta con metodo astratto

Di seguito è riportata l'implementazione dell'argomento precedente:

Giava








// 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();> >}> }> 

>

>

Produzione 

avinash 21 222.2>

2. Classe astratta con costruttore, membro dati e metodi

Elementi che la classe astratta può avere

  • membro dei dati
  • metodo astratto
  • corpo del metodo (metodo non astratto)
  • costruttore
  • metodo main().

Di seguito è riportata l'implementazione dell'argomento precedente:

Giava




// 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();> >}> }> 

>

>

Produzione 

Learning Subject C , Java , C++ Preparing Right Now!>

Proprietà della classe Abstract

Elaboriamo queste osservazioni e giustifichiamole con l'aiuto di programmi Java puliti come segue.

Osservazione 1

In Java, proprio come in C++, non è possibile creare un'istanza di una classe astratta, possiamo però avere riferimenti al tipo di classe astratta. È come mostrato di seguito tramite il programma Java pulito.

Esempio

Giava




// 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();> >}> }> 

>

>

Produzione

dialetto ibernato 
Derived fun() called>

Osservazione 2

Come C++, un classe astratta può contenere costruttori a Giava. E un costruttore di una classe astratta viene chiamato quando viene creata un'istanza di una classe ereditata. È come mostrato nel programma qui sotto come segue:

Esempio:

Giava




// 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();> >}> }> 

>

>

Produzione 

Base Constructor Called Derived Constructor Called Derived fun() called>

Osservazione 3

In Java, possiamo avere una classe astratta senza alcun metodo astratto . Questo ci permette di farlo creare classi che non possono essere istanziate ma possono solo essere ereditate . È come mostrato di seguito come segue con l'aiuto di un programma Java pulito.

Esempio:

Giava




// 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();> >}> }> 

>

>

Produzione 

Function of Base class is called>

Osservazione 4

Anche le classi astratte possono avere finale metodi (metodi che non possono essere sovrascritti)

Esempio:

Giava




// 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();> >}> >}> }> 

>

>

Produzione 

Base fun() called>

Osservazione 5

Per qualsiasi classe Java astratta non è consentito creare un oggetto, ovvero per una classe astratta non è possibile creare un'istanza di classe.

Giava




// 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();> >}> }> 

>

>

Produzione:

classe astratta

Osservazione 6

Simile all'interfaccia possiamo definire metodi statici in una classe astratta Quello può essere chiamato indipendentemente senza un oggetto.

Giava




// 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();> >}> }> 

>

>

Produzione 

Geeks for Geeks>

Osservazione 7

Possiamo usare il parola chiave astratta per dichiarare le classi di livello superiore (classe esterna) e le classi interne come astratte

Giava




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();> >}> }> 

>

>

Produzione 

Inside abstract method implementation>

Osservazione 8

Se un la classe contiene almeno un metodo astratto Poi obbligatorio dichiarare la classe come astratta altrimenti otterremo un errore in fase di compilazione: se una classe contiene almeno un metodo astratto, l'implementazione non è completa per quella classe e quindi non è consigliabile creare un oggetto in modo da limitare la creazione di oggetti per tali classi parziali noi usiamo parola chiave astratta.

Giava

nomi di città negli Stati Uniti




/*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();> >}> }> 

>

>

Produzione 

Hello>

Osservazione 9

Se la Bambino La classe Child non è in grado di fornire l'implementazione a tutti i metodi astratti della classe Parent, quindi dovremmo dichiarare la classe Child come astratta in modo che la classe Child di livello successivo debba fornire l'implementazione al metodo astratto rimanente.

Giava




// 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();> >}> }> 

>

>

Produzione 

Inside m1 Inside m2 Inside m3>

In C++, se una classe ne ha almeno uno pura funzione virtuale , allora la classe diventa astratta. A differenza di C++, in Java, per creare una classe astratta viene utilizzata una parola chiave abstract separata.

Conclusione

I punti da ricordare di questo articolo sono menzionati di seguito:

  • Una classe astratta è una classe che non può essere avviata da sola, deve essere sottoclassata da un'altra classe per utilizzare le sue proprietà.
  • Una classe astratta può essere creata utilizzando parole chiave astratte.
  • Possiamo avere una classe astratta senza alcun metodo astratto.

Domande frequenti sulla classe Abstract

1. Cos'è una classe astratta in Java?

Una classe astratta in Java è una classe che non può essere avviata da sola ma può essere utilizzata come sottoclasse da un'altra classe.

2. Qual è lo scopo della classe astratta?

Lo scopo principale della classe astratta è creare una classe base da cui possono derivare molte altre classi.

3. Qual è il vantaggio principale della classe astratta?

Una classe astratta fornisce le risorse di dati nascosti in Java.

4. Perché la classe astratta è più veloce dell'interfaccia?

Una classe astratta è più veloce di un'interfaccia perché l'interfaccia prevede una ricerca prima di chiamare qualsiasi metodo sovrascritto in Java mentre la classe astratta può essere utilizzata direttamente.

Inoltre, Leggi