66 Clase derivate. Clase abstracte.

Polimorfism

Cap. 5
Clase derivate. Clase abstracte. Polimorfism

1. Să se construiască clasa ContBancar, folosită pentru a modela

un cont bancar, ce are ca variabilă de instanţă privată, variabila suma,
(suma de bani din cont). Ca metode:
‐ constructorul;
‐ adauga(), ce are ca parametru un număr real x, valoarea ce se
adaugă în cont;
‐ extrage(), ce are ca parametru un număr real x, valoarea ce se
extrage din cont, şi care scoate ca rezultat true, dacă se poate face
extragerea (suma >= x), şi false în caz contrar;
‐ getSuma(), ce returnează valoarea variabilei private suma;
‐ afisare(), ce afişează valoarea sumei de bani din cont.
Pe baza clasei ContBancar se va dezvolta prin derivare (moştenire)
clasa ContBancarExtins, în care se va adăuga o nouă variabilă de
instanţă: rata dobânzii anuale şi o nouă metodă:
adaugaDobandaLunara(), ce adaugă în cont dobânda calculată după
trecerea unei luni. În clasa ContBancarExtins se va redefini şi metoda
afisare(), astfel încât să se afişeze şi rata dobânzii. De asemenea, în
această nouă clasă se va defini constructorul, prin care se iniţializează
suma de bani din cont şi rata dobânzii.
Să se scrie şi o clasă de test pentru clasa ContBancarExtins.
class ContBancar
{
private double suma;
public ContBancar(double S)
{
suma=S;
}
public void adauga(double S)
{
suma=suma+S;
}
public boolean extrage(double S)
{
if(S>suma)return false;
suma=suma-S;
return true;
Clase derivate. Clase abstracte. Polimorfism 67

}
public double getSuma()
{
return suma;
}
public void afisare()
{
System.out.println("suma="+suma);
}
}

class ContBancarExtins extends ContBancar

{
private double rd;//rata dobanzii anuale
public ContBancarExtins(double S,double rata)
{
super(S);
rd=rata;
}
public void adaugaDobandaLunara()
{
double S=this.getSuma();
double dobanda=S*rd/12;
this.adauga(dobanda);
}
public void afisare()
{
System.out.println("suma="+this.getSuma());
System.out.println("rata dobanzii="+rd);
}
}

class TestCont
{
public static void main(String args[])
{
ContBancarExtins c=new ContBancarExtins(1000,0.12);
c.adauga(1000);
c.adaugaDobandaLunara();
c.afisare();
68 Clase derivate. Clase abstracte. Polimorfism

}
}

2. Să se construiască clasa Punct3D, folosită pentru a modela un

punct în spaţiu, ce are ca variabile de instanţă x, y, z, coordonatele
unui punct în spaţiu. Ca metode:
‐ constructorul;
‐ muta(), ce are trei parametrii dx, dy şi dz, pe baza cărora noile
coordonate ale punctului devin: x+dx, y+dy, z+dz;
‐ compara(), ce are ca parametru un punct p, şi care returnează
true, dacă punctul curent (cel referit prin this ) este egal cu punctul p,
şi false în caz contrar;
‐ distanta(), ce are ca parametru un punct p, şi care returnează
distanţa între punctul curent şi punctul p;
‐ getX() ce returnează valoarea coordonatei x;
‐ getY() ce returnează valoarea coordonatei y;
‐ getZ() ce returnează valoarea coordonatei z;
‐ afisare() ce afişează coordonatele punctului.
Pe baza clasei Punct3D, se va dezvolta clasa Punct3DColor, în care se
va adăuga o nouă variabilă de instanţă de tipul String: culoarea
punctului şi o nouă metodă getCuloare() ce returnează culoarea
punctului. Se vor redefini metodele compara() şi afişare() şi noul
constructor.
Să se scrie şi o clasă de test pentru clasa Punct3DColor.
class Punct3D
{
private int x;//coordonata x a punctului
private int y;
private int z;
public Punct3D(int x,int y, int z )
{
this.x=x;
this.y=y;
this.z=z;
}
public int getX()
{
return x;
}
public int getY()
Clase derivate. Clase abstracte. Polimorfism 69

{
return y;
}
public int getZ()
{
return z;
}
public void afisare()
{
System.out.println("x="+x);
System.out.println("y="+y);
System.out.println("z="+z);
}
public void muta(int dx, int dy, int dz)
{
x=x+dx;
y=y+dy;
z=z+dz;
}
public boolean compara(Punct3D p)
{
if((x==p.x)&&(y==p.y)&&(z==p.z))
return true;
else return false;
}
public double distanta(Punct3D p)
{
double dx=this.x-p.x;
double dy=this.y-p.y;
double dz=this.z-p.z;
double dist=Math.sqrt(dx*dx+dy*dy+dz*dz);
return dist;
}
}
class Punct3DColor extends Punct3D
{
private String culoare;
public Punct3DColor(int x, int y, int z, String culoare)
{
super(x,y,z);
70 Clase derivate. Clase abstracte. Polimorfism

this.culoare=culoare;
}
public String getCuloare()
{
return culoare;
}

public void afisare()

{
System.out.println("x="+getX());
System.out.println("y="+getY());
System.out.println("z="+getZ());
System.out.println("culoare="+culoare);
}
public boolean compara(Punct3DColor p)
{
if((this.getX()==p.getX())&&
(this.getY()==p.getY())&&
(this.getZ()==p.getZ())&&
(this.culoare==p.culoare))
return true;
else return false;
}
}

class TestPuncte
{
public static void main (String args[])
{
Punct3DColor p=new Punct3DColor(0,1,2,"negru");
p.muta(1,1,1);
p.afisare();
}
}

3. Să se dezvolte clasa abstractă A în care sunt definite două

metode:
‐ metoda abstractă calcul();
‐ metoda durataCalcul() ce returnează durata exprimată în
milisecunde, a execuţiei metodei calcul();
Clase derivate. Clase abstracte. Polimorfism 71

Din clasa abstractă A, se va deriva clasa B ce conţine implementarea

metodei calcul(). Se va dezvolta şi o clasă de test, pentru clasa
derivată B.
import javax.swing.*;
import java.util.*;
abstract class A
{
abstract public void calcul(int N);
public long durataCalcul(int N){
long t1=System.currentTimeMillis();
calcul(N);
long t2=System.currentTimeMillis();
return (t2-t1);
}
}
class B extends A
{
public void calcul(int N)
{
//Calculeaza N*N*N produse
int i,j,k;
long rezultat;
for(i=1;i<=N;i++)
for(j=1;j<=N;j++)
for(k=1;k<=N;k++)
rezultat=i*j*k;
}
}
class Test
{
public static void main(String args[])
{
final int N=1000;
B b=new B();
System.out.println("durata calcul = "+b.durataCalcul(N)+" ms.");
}
}
72 Clase derivate. Clase abstracte. Polimorfism

4. Să se construiască clasa Punct ce are ca variabile de instanţă

două numere întregi x şi y – coordonatele unui punct în plan, şi ca
metode:
‐ Constructorul ce face iniţializările;
‐ getX() ce returnează valoarea coordonatei x
‐ getY() ce returnează valoarea coordonatei y
‐ afisare() în care se afişează coordonatele punctului din clasa
Punct
Din clasa Punct se derivează două clase: PunctColor şi Punct3D.
Clasa PunctColor faţă de clasa Punct are în plus o variabilă de instanţă
în care este memorată culoarea punctului, un nou constructor în care
este iniţializată şi culoarea, metoda getCuloare() ce returnează
culoarea, şi redefineşte metoda clasei de bază, afişare(), afişând pe
lângă coordonatele x şi y şi culoarea.
Clasa Punct3D, ce reprezintă un punct în spaţiu, faţă de clasa Punct
are în plus o variabilă de instanţă z, un nou constructor în care sunt
iniţializate toate cele trei coordonate, metoda getZ() ce returnează
valoarea coordonatei z, şi redefineşte metoda clasei de bază, afişare(),
afişând pe lângă coordonatele x şi y şi coordonata z.
Folosind aceste trei clase se va dezvolta o aplicaţie în care se vor citi
de la tastatură N puncte (N- citit anterior), de tipul PunctColor sau
Punct3D. Pentru fiecare punct, în momentul citirii utilizatorul
aplicaţiei va specifica dacă va introduce un PunctColor sau un
Punct3D. Cele N puncte se vor memora într-un vector de obiecte de
tipul Punct (clasa de bază). În final se vor afişa pentru fiecare punct
din cele N informaţiile memorate (pentru fiecare punct se va apela
metoda afişare()). Această aplicaţie ilustrează conceptul de
polimorfism (Compilatorul ştie la rulare ce versiune de metodă
afişare() să apeleze).
import javax.swing.*;
class Punct
{
private int x;//coordonata x a punctului
private int y;
public Punct(int x0, int y0)
{
x=x0;
y=y0;
}
public int getX()
Clase derivate. Clase abstracte. Polimorfism 73

{
return x;
}
public int getY()
{
return y;
}
public void afisare()
{
System.out.println("x="+x);
System.out.println("y="+y);
}
}

class PunctColor extends Punct

{
private String culoare;
public PunctColor(int x, int y, String culoare)
{
super(x,y);
this.culoare=culoare;
}
public String getCuloare()
{
return culoare;
}

public void afisare()

{
//System.out.println("x="+x);GRESIT! x - este var. privata !
System.out.println("x="+getX());
System.out.println("y="+getY());;
System.out.println("culoare="+culoare);
}
}

class Punct3D extends Punct

{
private int z;
public Punct3D(int x,int y, int z )
74 Clase derivate. Clase abstracte. Polimorfism

{
super(x,y);
this.z=z;
}
public int getZ()
{
return z;
}
public void afisare()
{
System.out.println("x="+getX());
System.out.println("y="+getY());
System.out.println("z="+z);
}
}

class AfisarePuncte
{
public static void main (String args[])
{
int N;//numarul de puncte
N=Integer.parseInt(JOptionPane.showInputDialog("N="));
Punct p[]=new Punct[N];//vectorul de obiecte Punct (clasa de
//baza)
int i;
for(i=0;i<N;i++){
String sRaspuns=JOptionPane.showInputDialog("Tip punct
(0,1,2) : ");
int raspuns=Integer.parseInt(sRaspuns);
int x=Integer.parseInt(JOptionPane.showInputDialog("x="));
int y=Integer.parseInt(JOptionPane.showInputDialog("y="));
if(raspuns==0){
//citeste un Punct:
p[i]=new Punct(x,y);}
else if(raspuns==1){
//citeste un PunctColor:
String culoare=JOptionPane.showInputDialog("culoare=");
p[i]=new PunctColor(x,y,culoare);}
else if(raspuns==2){
//citeste un Punct3D:
Clase derivate. Clase abstracte. Polimorfism 75

int z=Integer.parseInt(JOptionPane.showInputDialog("z="));
p[i]=new Punct3D(x,y,z);}
}//for
//Afisare vector:
for(i=0;i<N;i++)
p[i].afisare();
}
}

5. Să se dezvolte clasa Persoana ce are ca variabile de instanţă

numele şi prenumele unei persoane şi vârsta ei, şi ca metode:
‐ constructorul ce face iniţializările;
‐ getNume(), ce returnează numele;
‐ getPrenume(), ce returnează prenumele;
‐ afisare(), ce afişează informaţiile despre persoană.
Din clasa Persoană se va deriva clasa Student, ce are în plus ca
variabile de instanţă, numele facultaţii pe care o urmează şi numărul
matricol. În clasa Student se va dezvolta un nou constructor şi se va
redefini metoda afisare(). Se vor adăuga în plus metodele:
‐ getFacultate();
‐ getNumărMatricol().
Se va dezvolta o aplicaţie în care se vor citi de la tastatură N= 10
studenţi, ce se vor memora într-un vector. Se vor afişa câţi studenţi au
prenumele ”Ion”.
import javax.swing.*;
class Persoana
{
private String nume;
private String prenume;
private int varsta;
public Persoana(String n, String p, int v)
{
nume=n;
prenume=p;
varsta=v;
}
public String getNume()
{
return nume;
}
76 Clase derivate. Clase abstracte. Polimorfism

public String getPrenume()

{
return prenume;
}
public void afisare()
{
System.out.println(nume+" "+prenume+" : "+varsta);
}
}
class Student extends Persoana
{
private String numeFacultate;
private int nrMatricol;
public Student(String n, String p, int v, String facult, int nrMatr)
{
super(n,p,v);
numeFacultate=facult;
nrMatricol=nrMatr;
}
public String getFacultate()
{
return numeFacultate;
}
public int getNumarMatricol()
{
return nrMatricol;
}
}
class TestStudenti
{
public static void main(String args[])
{
final int N=2;
int i;
Student s[]=new Student[N];
for(i=0;i<N;i++){
String nume=JOptionPane.showInputDialog("nume=");
String prenume=JOptionPane.showInputDialog("prenume=");
int varsta=
Integer.parseInt(JOptionPane.showInputDialog("varsta="));
Clase derivate. Clase abstracte. Polimorfism 77

String facultate=JOptionPane.showInputDialog("facultate=");
int nrMatr=Integer.parseInt
(JOptionPane.showInputDialog("nr. matricol="));
s[i]=new Student(nume,prenume,varsta,facultate,nrMatr);
}
int contor_ion=0;
for(i=0;i<N;i++){
String prenumeCrt=s[i].getPrenume();
if(prenumeCrt.compareTo("Ion")==0)contor_ion++;
}
System.out.println(contor_ion);
}
}

6. Să construiască clasa Număr ce are ca variabilă de instanţă un

număr întreg a, şi ca metode:
‐ constructorul;
‐ afisare().
Din clasa Numar, se va deriva clasa DouaNumere, în care se va
adăuga variabila de instanţă b (ce reprezintă al doilea număr), şi se va
modifica constructorul şi metoda afisare().
Folosind cele două clase, se va dezvolta o aplicaţie în care se
generează un număr aleator 0 sau 1. Dacă este 0, se va instanţia un
obiect din clasa Numar (prin citire de la tastatură), dacă este 1, se va
instanţia un obiect din clasa DouăNumere (tot prin citire de la
tastatură). Pentru obiectul instanţiat se va apela metoda afisare().
import java.util.*;
import javax.swing.*;
class Numar
{
private int a;
public Numar(int x)
{
a=x;
}
public void afisare()
{
System.out.println("a="+a);
}
}
78 Clase derivate. Clase abstracte. Polimorfism

class DouaNumere extends Numar

{
private int b;
public DouaNumere(int a,int b )
{
super(a);
this.b=b;
}
public void afisare()
{
//afisare a:
super.afisare();//Cu cuv. cheie super se apeleaza metoda
//clasei de baza
//afisare b:
System.out.println("b="+b);
}
}

class AfisareNumere
{
public static void main (String args[])
{
Numar n;
Random r=new Random();
int caz=r.nextInt(2);
if(caz==0){
//citeste un numar:
int a=Integer.parseInt(JOptionPane.showInputDialog("a="));
n=new Numar(a);
}else
{
//citeste doua numere:
int a=Integer.parseInt(JOptionPane.showInputDialog("a="));
int b=Integer.parseInt(JOptionPane.showInputDialog("b="));
n=new DouaNumere(a,b);
}
//Afisare:
n. afisare();//Numai la executie se stie care versiune de metoda
// afisare() se va apela
Clase derivate. Clase abstracte. Polimorfism 79

}
}

7. Să se construiască clasa Cerc, ce are ca variabilă de instanţă

privată, un număr întreg r, ce reprezintă raza unui cerc. În această
clasă avem ca metode:
‐ constructorul, ce face iniţializarea razei;
‐ getRaza(), ce returnează raza;
‐ calculArie(),ce returnează aria cercului;
‐ suntEgale(), ce are ca parametru un Cerc c, şi care returnează
true dacă cercul curent este egal cu cercul c (au aceeaşi rază).
‐ afisare(), ce afişează raza cercului.
Din clasa Cerc se va deriva clasa CercExtins, în care se vor adăuga ca
variabile de instanţă x şi y: coordonatele centrului şi se vor redefini
metodele suntEgale() (cercurile sunt egale când au aceeaşi rază şi
aceleaşi coordonate ale centrului), şi afisare() (pe lângă rază, va afişa
şi coordonatele centrului)
Scrieţi şi o clasă de test pentru clasa CercExtins.
class Cerc
{
private int raza;
public Cerc(int x)
{
raza=x;
}
public int getRaza()
{
return raza;
}
public double calculArie()
{
return Math.PI*raza*raza;
}
public boolean suntEgale(Cerc c)
{
if(this.raza==c.raza)return true;
else return false;
}
public void afisare()
{
80 Clase derivate. Clase abstracte. Polimorfism

System.out.println("raza="+raza);
}

}
class CercExtins extends Cerc
{
private int x;
private int y;
public CercExtins(int r,int x0, int y0 )
{
super(r);
x=x0;
y=y0;
}
public boolean suntEgale(CercExtins c)
{
if((this.getRaza()==c.getRaza())&&(this.x==c.x)&&(this.y==c.y))
return true;
else return false;
}
public void afisare()
{
System.out.println("raza="+this.getRaza());
System.out.println("x="+x);
System.out.println("y="+y);
}
}

class TestCercExtins
{
public static void main (String args[])
{
CercExtins c=new CercExtins(3,0,1);
System.out.println("Aria= "+c.calculArie());
CercExtins c1=new CercExtins(3,0,10);
System.out.println("Sunt egale= "+c.suntEgale(c1));
}
}
Clase derivate. Clase abstracte. Polimorfism 81

8. Folosind cele două clase anterioare, Cerc şi CercExtins să se

dezvolte o aplicaţie în care se vor citi N cercuri (de tipul Cerc sau
CercExtins), ce se memorează într-un vector. Citirea unui obiect de tip
Cerc sau CercExtins este dată de valoarea 0 sau 1 a unui număr aleator
generat.
import java.util.*;
import javax.swing.*;
class AfisareCercuri
{
public static void main (String args[])
{
final int N=3;//numarul de cercuri
Cerc c[]=new Cerc[N];//vectorul de obiecte Cerc (clasa de
//baza)
Random r=new Random();
int i;
for(i=0;i<N;i++){
int caz=r.nextInt(2);
if(caz==0){
//citeste un Cerc:
String s_raza=JOptionPane.showInputDialog("raza=");
c[i]=new Cerc(Integer.parseInt(s_raza));
}else{
//citeste un CercExins:
String s_raza;
s_raza=JOptionPane.showInputDialog("raza=");
String s_x=JOptionPane.showInputDialog("x=");
String s_y=JOptionPane.showInputDialog("y=");
c[i]=new CercExtins(Integer.parseInt(s_raza),
Integer.parseInt(s_x),
Integer.parseInt(s_y));
}
}//for
//Afisare vector:
for(i=0;i<N;i++)
c[i].afisare();
}
}