Una classe astratta è una classe che non può essere istanziata. Una classe astratta viene utilizzata creando una sottoclasse ereditaria che può essere istanziata. Una classe astratta fa alcune cose per la sottoclasse ereditaria:
- Definire metodi che possono essere utilizzati dalla sottoclasse ereditaria.
- Definire metodi astratti che la sottoclasse ereditaria deve implementare.
- Fornire un'interfaccia comune che consenta di scambiare la sottoclasse con tutte le altre sottoclassi.
Ecco un esempio:
abstract public class AbstractClass
{
abstract public void abstractMethod();
public void implementedMethod() { System.out.print("implementedMethod()"); }
final public void finalMethod() { System.out.print("finalMethod()"); }
}
Si noti che "abstractMethod ()" non ha alcun metodo body. Per questo motivo, non è possibile effettuare le seguenti operazioni:
public class ImplementingClass extends AbstractClass
{
// ERROR!
}
Non esiste un metodo che attui abstractMethod()! Quindi non c'è modo per la JVM di sapere cosa dovrebbe fare quando ottiene qualcosa di simile new ImplementingClass().abstractMethod().
Ecco un corretto ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
}
Si noti che non è necessario definire implementedMethod()o finalMethod(). Sono già stati definiti da AbstractClass.
Ecco un altro corretto ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
In questo caso, hai ignorato implementedMethod().
Tuttavia, a causa della finalparola chiave, non è possibile quanto segue.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
public void finalMethod() { System.out.print("ERROR!"); }
}
Non puoi farlo perché l'implementazione di finalMethod()in AbstractClassè contrassegnata come l'implementazione finale di finalMethod(): nessun'altra implementazione sarà consentita, mai.
Ora puoi anche implementare una classe astratta due volte:
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
// In a separate file.
public class SecondImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("second abstractMethod()"); }
}
Ora da qualche parte potresti scrivere un altro metodo.
public tryItOut()
{
ImplementingClass a = new ImplementingClass();
AbstractClass b = new ImplementingClass();
a.abstractMethod(); // prints "abstractMethod()"
a.implementedMethod(); // prints "Overridden!" <-- same
a.finalMethod(); // prints "finalMethod()"
b.abstractMethod(); // prints "abstractMethod()"
b.implementedMethod(); // prints "Overridden!" <-- same
b.finalMethod(); // prints "finalMethod()"
SecondImplementingClass c = new SecondImplementingClass();
AbstractClass d = new SecondImplementingClass();
c.abstractMethod(); // prints "second abstractMethod()"
c.implementedMethod(); // prints "implementedMethod()"
c.finalMethod(); // prints "finalMethod()"
d.abstractMethod(); // prints "second abstractMethod()"
d.implementedMethod(); // prints "implementedMethod()"
d.finalMethod(); // prints "finalMethod()"
}
Si noti che anche se abbiamo dichiarato bun AbstractClasstipo, viene visualizzato "Overriden!". Questo perché l'oggetto che abbiamo istanziato era in realtà un ImplementingClass, il cui implementedMethod()ovviamente è ignorato. (Potresti aver visto questo indicato come polimorfismo.)
Se desideriamo accedere a un membro specifico di una particolare sottoclasse, dobbiamo prima eseguire il cast di quella sottoclasse:
// Say ImplementingClass also contains uniqueMethod()
// To access it, we use a cast to tell the runtime which type the object is
AbstractClass b = new ImplementingClass();
((ImplementingClass)b).uniqueMethod();
Infine, non puoi fare quanto segue:
public class ImplementingClass extends AbstractClass, SomeOtherAbstractClass
{
... // implementation
}
È possibile estendere una sola classe alla volta. Se è necessario estendere più classi, devono essere interfacce. Puoi farlo:
public class ImplementingClass extends AbstractClass implements InterfaceA, InterfaceB
{
... // implementation
}
Ecco un'interfaccia di esempio:
interface InterfaceA
{
void interfaceMethod();
}
Questo è fondamentalmente lo stesso di:
abstract public class InterfaceA
{
abstract public void interfaceMethod();
}
L'unica differenza è che il secondo modo non fa sapere al compilatore che in realtà è un'interfaccia. Questo può essere utile se vuoi che le persone implementino solo la tua interfaccia e nessun altro. Tuttavia, come regola generale per principianti, se la tua classe astratta ha solo metodi astratti, probabilmente dovresti renderla un'interfaccia.
Quanto segue è illegale:
interface InterfaceB
{
void interfaceMethod() { System.out.print("ERROR!"); }
}
Non è possibile implementare metodi in un'interfaccia. Ciò significa che se si implementano due interfacce diverse, i diversi metodi in quelle interfacce non possono scontrarsi. Poiché tutti i metodi in un'interfaccia sono astratti, è necessario implementare il metodo e poiché il metodo è l'unica implementazione nella struttura ereditaria, il compilatore sa che deve utilizzare il metodo.
