Può essere utile certe volte definire una superclasse che dichiara una determinata struttura senza però fornire un'implementazione completa dei vari metodi. La struttura verrà condivisa dalle sottoclassi e ogni sottoclasse implementerà in modo specifico i vari metodi. Una tale superclasse sarà definita come abstract.
La sintassi per una dichiarazione di classe astratta è:
abstract class A{
Una classe astratta avrà dei metodi astratti cioè non definiti, ogni sottoclasse dovrà definire questi metodi nel modo più opportuno. La classe astratta serve solo a dare la struttura generale dando una lista di metodi che ogni sottoclasse dovrà implementare in qualche modo. La sintassi per dichiarare un metodo astratto è:

abstract tipo di ritorno nome(elenco parametri);
non si mette nessun corpo, neanche {}.

Una classe astratta può contenere metodi concreti.
Non vi possono essere oggetti di una classe astratta (non essendo i metodi definiti, la classe è "incompleta"), quindi una classe astratta non può essere istanziata con l'operatore new.
Ogni sottoclasse di una classe astratta deve definire tutti i metodi astratti della sua superclasse (o essere anch'essa dichiarata astratta).
L'esempio standard è quello di una classe Forme; ogni forma avrà un metodo paint e un metodo area, ovviamente tali metodi dipendono dalla natura della forma (rettangolo, triangolo,...), a questo livello di astrazione, non possiamo dare dettagli, perciò lascieremo questi metodi vuoti dichiarandoli abstract, poi ogni classe si occuperà di fornire i dettagli.

import java.awt.Graphics; abstract class Forme{ int x,y; String s = "Nome"; //costruttore Forme(int x, int y){ this.x = x; this.y = y; } //metodo concreto Nome String Nome(){ return s; } //metodo astratto abstract void draw(Graphics g); //metodo astratto abstract double area(); }//fine della classe

La classe dei rettangoli:

import java.awt.Graphics; public class Rett extends Forme{ //costruttore Rett(int x, int y){ super(x, y); } //implementazione metodo draw void draw(Graphics g){ g.drawRect(5, 5, x, y); } //implementazione metodo area double area(){ return x*y; } //metodo Nome String Nome(){ super.s = "Rettangolo"; return s; } }

quella dei triangoli rettangoli:

import java.awt.Graphics; public class RTriangle extends Forme{ //costruttore RTriangle(int x, int y){ super(x,y); } //implementazione metodo draw void draw(Graphics g){ g.drawLine(50,50,x+50,50); g.drawLine(50,50,50,y+50); g.drawLine(x+50,50,50,y+50); } //implementazione metodo area double area(){ return (x*y)/2; } //metodo Nome String Nome(){ super.s = "Triangolo rettangolo"; return s; } }

Per vedere queste classi all'opera:

import java.awt.*; import java.applet.*; public class EsAstr extends Applet{ Rett R = new Rett(30,20); RTriangle T = new RTriangle(40,20); /*Forme F = new Forme(); ERRORE, la classe astratta Forme non può essere istanziata*/ public void paint(Graphics g){ R.draw(g); T.draw(g); g.drawString("Area di R= " + R.area(),10,90); g.drawString("Area di T= " + T.area(),10,110); g.drawString("Nome di R: " + R.Nome(),10,130); g.drawString("Nome di T: " + T.Nome(),10,150); } }

Un esempio di classe astratta: la classe Graphics di java.awt; in particolare non è possibile istanziare un oggetto Graphics; la classe Component (e quindi tutte le sue sottoclassi) dispone del metodo getGraphics() che permette di ottenere un contesto grafico.