Exemplu:
În fișierul S1.java este declarata clasa
S1, iar in fișierul CD1.java este declarata
clasa CD1, care extinde clasa S1 (este, deci, derivată din aceasta).
Reproducem aici declarațiile celor două clase:
/* Clasa S1 din care vor fi derivate alte clase */
public class S1 {
public int a;
protected double b;
private int c;
public final static int alpha=12;
public S1(int a, double b, int c) { //
constructorul clasei S1
this.a=a; this.b=b; this.c=c;
}
private double f1() { // o metoda privata
return a*c+b;
}
protected int f2() { // o metoda protejata
return a+2*c;
}
public double f3() { // o metoda publica in care
se folosesc f1 si f2
return 2*f1()+f2();
}
public String toString() { // redefinirea metodei
Object.toString()
return "(S1: "+a+" "+b+" "+c+")";
}
public static int f4(int k) {
return 2*k+alpha;
}
}
|
/* O clasa derivata din S1, in care se redefinesc
unele metode */
class CD1 extends S1 {
public CD1(int a, double b, int c) {
super(a,b,c);
}
public int f2() { // redefinirea metodei f2() din
superclasa
return 2*a;
}
public double f3() { // redefinirea metodei f3() din
superclasa
return f2()+super.f3();
}
}
|
Remarcăm următoarele:
- în metodele clasei S1 pot fi folosite toate câmpurile declarate în
această clasă, fie ele publice, protejate sau private; de asemenea, pot
fi invocate toate metodele din această clasă;
- în clasa S1 a fost redefinită metoda toString din clasa
Object, astfel incât să se întoarca un șir care conține valorile
câmpurilor a, b și c;
- metoda statică f4() din clasa S1 utilizează numai
câmpul static alpha al acestei clase;
- în constructorul clasei CD1 a fost invocat constructorul clasei S1
sub forma super(a,b,c). În acest mod au fost inițializate
toate câmpurile din superclasa S1, inclusiv câmpul privat c,
care nu este direct accesibil din clasa CD1;
- în clasa CD1 au fost redefinite metodele f2 și f3 din
superclasa S1 și a fost iarăși redefinită metoda toString;
- în mod normal, în clasa CD1 se folosesc metodele f2 și f3
redefinite în această clasă. Este totuși posibil ca în clasa CD1 să se
apeleze metodele superclasei, dacă în expresia de invocare se folosește
referinta super. Astfel, în metoda f3 din clasa CD1 există
expresia super.f3(), prin care se invoca metoda f3 din
superclasa S1;
- la redefinirea metodei f2, modul de acces a fost modificat din protected
in public;
- în metodele clasei CD1 nu au putut fi folosite câmpurile și
metodele private ale superclasei S1.
Testarea claselor S1 si CD1 se face în clasa TestCD1, care se
găsește în fișierul TestCD1.java. Iată
aceasta clasă:
/* Testarea claselor S1 si CD1 */
class TestCD1 {
public static void main(String args[]) {
S1 s=new S1(1, 1.1, 2);
CD1 cd=new CD1(10, 10.2, 20);
System.out.println("s="+s+" cd="+cd);
System.out.println("s.f2()="+s.f2()+"
s.f3()="+s.f3());
System.out.println("cd.f2()="+cd.f2()+"
cd.f3()="+cd.f3());
System.out.println("CD2.f4(3)="+CD2.f4(3)+"
S1.f4(3)="+S1.f4(3));
System.out.println("cd.f4(3)="+cd.f4(3)+"
s.f4(3)="+s.f4(3));
}
}
|
Executând aplicația TestCD1 se obțin urmatoarele rezultate:
s=(S1: 1 1.1 2) cd=(S1: 10
10.2 20)
s.f2()=5 s.f3()=11.2
cd.f2()=20 cd.f3()=460.4
CD2.f4(3)=18
cd.f4(3)=18 |
Remarcăm că:
- crearea instanțelor claselor S1 și CD1 s-a făcut aplicând
operatorul new asupra constructorilor claselor respective;
- în instrucțiunea
System.out.println("s="+s+" cd="+cd);
este de două ori invocată implicit metoda toString, pentru a converti
în șiruri afișabile obiectele s și cd;
prima dată este invocată metoda s.toString() din clasa S1. A
doua oară ar trebui sa fie invocată metoda cd.toString() din
clasa CD1 dar, intrucât metoda nu a fost redefinită în aceasta clasă, a
fost aplicată efectiv metoda toString() din superclasa
S1;
- în expresiile s.f2() si s.f3() sunt invocate
metodele din clasa S1, careia îi aparține s, iar in expresiile cd.f2()
și cd.f3() sunt invocate metodele corespunzătoare din clasa
CD1;
- metoda statică f4() din clasa S1 a fost invocată în patru
moduri: calificând numele metodei f1 cu numele clasei S1 (căreia îi
aparține de fapt această metodă), cu numele subclasei CD1 (care
moștenește această metodă) și cu numele instanțelor s și cd ale acestor
clase. Cum era de așteptat, în toate cele patru cazuri s-a obținut
același rezultat.
Puteti compila cele trei fișiere menționate și pune în
executie aplicația TestCD1 pentru a verifica respectarea afirmațiilor de
mai sus. Puteți, de asemenea, face modificări în metodele celor trei
clase menționate, astfel încât să verificați:
- ce se întâmplă dacă într-o metoda a clasei CD1 se încearcă
folosirea câmpurilor sau metodelor private ale superclasei S1;
- ce se întâmplă dacă în clasa TestDC1 se încearcă folosirea
câmpurilor sau metodelor private sau protejate din clasele S1 și CD1.
|