Crea un programma per calcolare il perimetro di due tipi di triangolo: isoscele e scaleno. Le due classi I (isoscele) e S (scaleno) devono essere derivate da una superclasse T che contiene il metodo di validazione isT(..) che stabilisce se il triangolo esiste ed il metodo peri(..) per il calcolo del perimetro.

Ricordiamo che un triangolo esiste solo se la lunghezza di ogni lato è inferiore alla somma degli altri due lati.
Possono essere valutati solo triangoli scaleni (S) ed isosceli (I). Una volta istanziato un oggetto di classe S o di classe I se il triangolo esiste viene restituito il perimetro. Se il triangolo non esiste, viene restituito 0 .

class provaTriangoli{
public static void main (String args []) {
S s=new S(2,1,3);//scaleno
I i=new I(3,4);//isoscele lati=3,3,4
System.out.println(s.getS());
System.out.println(i.getI());
}//fine main
}// fine classe
class T{
protected boolean isT(int x,int y,int z) {
  if (((x+y)>z) && ((x+z)>y) && ((y+z)>x))return true;
  else return false;
}
protected int peri(int h,int k,int w){return h+k+w;}
}//fine classe T

class S extends T {//scaleno
private int a,b,c,p;
S(int A,int B,int C){//costruttore
  a=A;b=B;c=C;
  if(isT(a,b,c)==true)p=peri(a,b,c);
  else p=0;
}//fine costruttore
public int getS() {return p;}
}//fine classe S

class I extends T {//scaleno
private int a,b,p;
I(int A,int B){//costruttore
  a=A;b=B;
  if(isT(a,a,b)==true)p=peri(a,a,b);
  else p=0;
}//fine costruttore
public int getI() {return p;}
}//fine classe I

L'output di questo listato sarà:
0
10
questo perché il primo triangolo (quello scaleno) non esiste.
Si nota come i costruttori di S ed I facciano uso dei metodi ereditati. L'uso:
protected boolean isT(int x,int y,int z)
protected int peri(int h,int k,int w)
della clausola protected, permette solo alle due sottoclassi di fare uso dei due metodi.
Le due classi S ed I possono essere compendiate in un unica classe SI utilizzando uno dei meccanismi del polimorfismo: l'overload di metodi, lo stesso nome per un metodo rappresenta elaborazioni differenti dichiarate in sottoclassi e quindi durante l'esecuzione del programma, in oggetti diversi.
Metodi contenuti in diverse classi della gerarchia possono avere lo stesso identificatore, gli stessi parametri di ingresso (per numero e tipo di dato) e restituire un risultato dello stesso tipo di dato, ma possono differire per l'elaborazione eseguita.
Se un metodo di una sottoclasse ridefinisce un metodo con la stessa firma dichiarato nella superclasse si dice che i due metodi sono sovrapposti (overriding).
Se due metodi di una classe restituiscono lo stesso tipo, hanno lo stesso identificatore ma hanno segnatura (dei parametri diversa) si parla di metodi sovraccarichi (overload). Nella seguente rielaborazione del programma precedente i due costruttori della classe SI sono overloaded:

class provaTriangoli{
public static void main (String args []) {
SI s=new SI(2,1,3);//scaleno
SI i=new SI(3,4);//isoscele lati=3,3,4
System.out.println(s.getSI());
System.out.println(i.getSI());
}//fine main
}// fine classe
class T{//classe Triangolo
protected boolean isT(int x,int y,int z) {
  if (((x+y)>z) && ((x+z)>y) && ((y+z)>x))return true;
  else return false;
}
protected int peri(int h,int k,int w){return h+k+w;}
}//fine classe T
class SI extends T {
private int a,b,c,p;
SI(int A,int B,int C){//costruttore scaleno
  a=A;b=B;c=C;
  if(isT(a,b,c)==true)p=peri(a,b,c);
  else p=0;
}//fine costruttore
SI(int A,int B){//costruttore isoscele
a=A;b=B;
if(isT(a,a,b)==true)p=peri(a,a,b);
else p=0;
}//fine costruttore
int getSI() {return p;}
}//fine classe SI

Esistono due costruttori SI(..) uno con 3 parametri in ingresso per il triangolo scaleno e uno con 2 parametri per il triangolo isoscele, quindi con diversa segnatura. Il programma eseguirà il metodo invocato da una chiamata con i parametri corrispondenti:questo è un esempio di overload di metodi.