Java Language Classi astratte


Esempio

Una classe astratta è una classe contrassegnata con la parola chiave abstract . Esso, contrariamente alla classe non astratta, può contenere metodi astratti - implementazione-meno. È tuttavia valido creare una classe astratta senza metodi astratti.

Una classe astratta non può essere istanziata. Può essere sottoclassato (esteso) finché la sottoclasse è anch'essa astratta, o implementa tutti i metodi contrassegnati come astratti da super classi.

Un esempio di una classe astratta:

public abstract class Component {
    private int x, y;
    
    public setPosition(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public abstract void render();
}

La classe deve essere contrassegnata come astratta, quando ha almeno un metodo astratto. Un metodo astratto è un metodo che non ha implementazione. Altri metodi possono essere dichiarati all'interno di una classe astratta che ha implementazione al fine di fornire codice comune per qualsiasi sottoclasse.

Il tentativo di creare un'istanza di questa classe fornirà un errore di compilazione:

//error: Component is abstract; cannot be instantiated   
Component myComponent = new Component();

Tuttavia una classe che estende Component e fornisce un'implementazione per tutti i suoi metodi astratti e può essere istanziata.

public class Button extends Component {

    @Override
    public void render() {
        //render a button
    }
}

public class TextBox extends Component {

    @Override
    public void render() {
        //render a textbox
    }
}

Anche le istanze di classi ereditanti possono essere espresse come classe genitore (normale ereditarietà) e forniscono un effetto polimorfico quando viene chiamato il metodo astratto.

Component myButton = new Button();
Component myTextBox = new TextBox();

myButton.render(); //renders a button
myTextBox.render(); //renders a text box

Classi astratte vs interfacce

Le classi e le interfacce astratte forniscono entrambi un modo per definire le firme dei metodi, mentre richiedono la classe di estensione / implementazione per fornire l'implementazione.

Ci sono due differenze chiave tra classi astratte e interfacce:

  • Una classe può estendere solo una singola classe, ma può implementare molte interfacce.
  • Una classe astratta può contenere campi di istanza (non static ), ma le interfacce possono contenere solo campi static .
Java SE 8

I metodi dichiarati nelle interfacce non potevano contenere implementazioni, quindi sono state utilizzate classi astratte quando era utile fornire metodi aggiuntivi quali implementazioni chiamate metodi astratti.

Java SE 8

Java 8 consente alle interfacce di contenere metodi predefiniti , solitamente implementati utilizzando gli altri metodi dell'interfaccia , rendendo le interfacce e le classi astratte ugualmente potenti in questo senso.

Sottoclassi anonime di classi astratte

Per comodità java consente l'istanziazione di istanze anonime di sottoclassi di classi astratte, che forniscono implementazioni per i metodi astratti sulla creazione del nuovo oggetto. Usando l'esempio precedente questo potrebbe assomigliare a questo:

Component myAnonymousComponent = new Component() {
    @Override
    public void render() {
        // render a quick 1-time use component
    }
}