• Homepage
  • Articoli
  • Generale
  • Che cos'è una classe astratta e un metodo astratto in Java? Quando dovrei usarlo? Tutorial allegato

Che cos'è una classe astratta e un metodo astratto in Java? Quando dovrei usarlo? Tutorial allegato

Pubblicato: 2019-09-12
java-abstract-classe-tutorial-by-crunchify

Un paio di giorni fa ho scritto un articolo su Java Fundamental di base su Cos'è un'interfaccia in Java e come viene utilizzata? Questo tutorial è anche correlato al fondamentale Java di base “ Abstract Class and Abstract Method ”.

Che cos'è una classe astratta?

Iniziamo a capire prima la classe Abstract e poi esamineremo Esempio.

  • Una classe astratta è una classe dichiarata abstract
  • Le classi astratte non possono essere istanziate
  • Le classi astratte possono essere sottoclassi
  • Può includere o meno metodi astratti
  • Quando una classe astratta è subclassed , la sottoclasse di solito fornisce implementazioni per tutti i metodi astratti nella sua classe padre
  • Se la sottoclasse non fornisce implementazioni, anche la sottoclasse deve essere dichiarata abstract .

Questa è una basic Java Interview Question . Probabilmente la 1 st Java Interview Question che ricevi durante l'intervista.

Posso definire una classe astratta senza aggiungere un metodo astratto?

Certo che si. Dichiarare una classe astratta significa solo che non si consente che venga istanziata da sola. Non puoi avere un metodo astratto in una classe non astratta.

Che cos'è un metodo astratto?

  • Un abstract method è un metodo dichiarato senza un'implementazione.
  • Ha solo una firma del metodo.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package crunchify . com . tutorial ;
 
/**
* @author Crunchify.com
* Simple Abstract Class and Method Example with live result
*
*/
 
public abstract class CrunchifyExam {
 
public enum ExamStatus {
PASSED , FAILED
}
 
private String examTime ;
private ExamStatus status ;
 
public CrunchifyExam ( String examTime , ExamStatus status ) {
this . examTime = examTime ;
this . status = status ;
}
 
public String getExamTime ( ) {
return examTime ;
}
 
public void setExamTime ( String examTime ) {
this . examTime = examTime ;
}
 
public void setExamStatus ( ExamStatus status ) {
this . status = status ;
}
 
public ExamStatus getExamStatus ( ) {
return status ;
}
 
abstract public void checkResult ( ) ;
}

Cominciamo con un esempio. Descrizione del problema:

  1. Crea la classe CrunchifyExam.java , che ha un metodo astratto chiamato checkResult()
  2. Crea classe Crunchify1stSchoolExamResult.java , che estende la classe Abstract CrunchifyExam.java
  3. Crea la classe Crunchify2ndSchoolExamResult.java , che estende la classe astratta CrunchifyExam.java
  4. Ora entrambe le classi precedenti devono fornire l'implementazione per il metodo checkResult()
  5. Entrambe le scuole possono avere la propria procedure o number of checks per scoprire se l'utente è PASSED or FAILED , sono libere di avere la propria implementazione di checkResult()

Dopo aver esteso la classe CrunchifyExam in Crunchify1stSchoolExamResult.java , Eclipse ti chiederà di implementare i metodi astratti menzionati in CrunchifyExam.java

Implementa il metodo astratto - Crunchify Tutorial

Crunchify1 st SchoolExamResult.java

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package crunchify . com . tutorial ;
 
/**
* @author Crunchify.com
*/
 
public class Crunchify1stSchoolExamResult extends CrunchifyExam {
 
public Crunchify1stSchoolExamResult ( String examTime , ExamStatus status ) {
super ( examTime , status ) ;
// TODO Auto-generated constructor stub
}
 
@Override
public void checkResult ( ) {
String studentName = "Crunchify1" ;
String studentResult = "85%" ;
 
// School NO-1 will provide all their formula to find if user is passed or failed.
// After detailed calculation let's say student's grade is "PASSED".
 
System . out . println ( "Hey.. this is user " + studentName + " with grade " + studentResult + " - " + getExamStatus ( )
+ ", ExamTime: " + getExamTime ( ) ) ;
 
}
}

Crunchify2 nd SchoolExamResult.java

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package crunchify . com . tutorial ;
 
import java . text . DateFormat ;
import java . text . SimpleDateFormat ;
import java . util . Date ;
 
/**
* @author Crunchify.com
*/
 
public class Crunchify2ndSchoolExamResult extends CrunchifyExam {
 
public Crunchify2ndSchoolExamResult ( String examTime , ExamStatus status ) {
super ( examTime , status ) ;
}
 
@Override
public void checkResult ( ) {
String studentName = "Crunchify2" ;
String studentResult = "45%" ;
 
// School NO-2 will provide all their formula to find if user is passed or failed.
// After detailed calculation let's say student's grade is "FAILED".
log ( "Hey.. this is user " + studentName + " with grade " + studentResult + " - " + getExamStatus ( ) + ", ExamTime: "
+ getExamTime ( ) ) ;
 
}
 
public static void main ( String args [ ] ) {
DateFormat dateFormat = new SimpleDateFormat ( "yyyy/MM/dd HH:mm:ss" ) ;
 
// 1st School's checkResult()
Date date = new Date ( ) ;
String examTime = dateFormat . format ( date ) ;
 
log ( "Initializing 1st School object at time " + examTime ) ;
// We are setting up time and Result for 1st School
Crunchify1stSchoolExamResult object = new Crunchify1stSchoolExamResult ( examTime , ExamStatus . PASSED ) ;
object . checkResult ( ) ;
 
// Let's wait 5 seconds wait to see time difference in console log
try {
Thread . sleep ( 5000 ) ;
} catch ( InterruptedException e ) {
e . printStackTrace ( ) ;
}
 
// 2nd School's checkResult()
date = new Date ( ) ;
examTime = dateFormat . format ( date ) ;
 
log ( "\nInitializing 2nd School object at time " + examTime ) ;
// We are setting up time and Result for 2nd School
Crunchify2ndSchoolExamResult object2 = new Crunchify2ndSchoolExamResult ( examTime , ExamStatus . FAILED ) ;
object2 . checkResult ( ) ;
}
 
// Simple log method
private static void log ( String value ) {
System . out . println ( value ) ;
}
}

Risultato console Eclipse:

Basta fare clic con il pulsante destro del mouse su Crunchify2ndSchoolExamResult.java ed eseguire come Java Application per vedere il risultato di seguito.

1
2
3
4
5
Initializing 1st School object at time 2016 / 11 / 30 14 : 24 : 37
Hey . . this is user Crunchify1 with grade 85 % - PASSED ExamTime : 2016 / 11 / 30 14 : 24 : 37
 
Initializing 2nd School object at time 2016 / 11 / 30 14 : 24 : 42
Hey . . this is user Crunchify2 with grade 45 % - FAILED ExamTime : 2016 / 11 / 30 14 : 24 : 42

Ora potresti avere una domanda

Perché non posso usare l'interfaccia qui invece di avere Abstract Method e Class astratti e avere CrunchifyExam come interfaccia?

Bene, Sure you could , ma dovresti anche implementare i getExamTime (), setExamTime (), getExamTime (), setExamTime ().

Utilizzando classi astratte, puoi ereditare l'implementazione di altri metodi (non astratti). Non puoi farlo con le interfacce: un'interfaccia cannot provide alcuna implementazione di metodo.

È possibile creare una classe astratta e finale in Java?

  • L'astratto e il finale sono il concetto che si escludono a vicenda.
  • Quindi la risposta è NO, non possiamo rendere una classe astratta o un metodo finale in Java.
  • La classe finale è una classe completa e non può essere ulteriormente estesa.
  • La classe astratta è chiamata classe incompleta e può essere estesa solo da un'altra classe concreta e devi implementare tutti i metodi astratti.
  • Inoltre, non c'è modo e non è possibile avere un metodo astratto in una classe finale.

È possibile ereditare da più classi astratte in Java?

  • Java non supporta l'ereditarietà multipla.
  • In Java possiamo estendere solo una singola classe.
  • In Java possiamo implementare Interfacce da molte fonti.