Curs 9 POO Calc. 2, 07.12.

2021

MOSTENIRE. CLASE DERIVATE

programare prin diferente

Scriem clasa Punct, clasa de baza, ce modeleaza un punct in plan.

class Punct{
private int x;
private int y;
public Punct(int x, int y){
this.x=x;
this.y=y;
}
public void setX(int x){ this.x=x;}
public void setY(int y){ this.y=y;}
public int getX(){return x;}
public int getY(){return y;}
public double dist0(){
return Math.sqrt(x*x+y*y);
}
public double distanta(Punct p){
return Math.sqrt((p.x-this.x)*(p.x-this.x)+(p.y-this.y)*(p.y-this.y));
}
@Override
public boolean equals(Object obj){
//coordonatele x si y , respectiv egale:
Punct p=(Punct)obj;
if(p.x==this.x && p.y==this.y)return true;
else return false;
}
public void afisare(){
System.out.println("x="+x+"y="+y);
}
}

Clasa derivata , PunctColor:

class PunctColor extends Punct{
private String culoare;
public PunctColor(int x, int y, String culoare){
super(x,y);//apel constructor clasa de baza
this.culoare=culoare;
}
public void setCuloare(String culoare){
this.culoare=culoare;
}
public String getCuloare(){ return culoare;}
@Override
public boolean equals(Object obj){
//coordonatele x si y , respectiv egale, si culorile egale:
PunctColor p=(PunctColor)obj;
//if(p.x==this.x && p.y==this.y && culoare.equals(obj.culoare)) return true;
GRESIT
if(p.getX()==this.getX() && p.getY()==this.getY() && culoare.equals(p.culoare))
return true;
 else return false;
}
@Override
public void afisare(){
System.out.println("x="+getX()+"y="+getY());
System.out.println("culoare="+culoare);
}
}

class Test{
public static void main(String args[]){
PunctColor p1=new PunctColor(1,2,"red");
PunctColor p2=new PunctColor(1,2,"white");
double d12=p1.distanta(p2);
System.out.println("distanta="+d12);
p1.afisare();
}
}

INLANTUIREA CONSTRUCTORILOR
(constructor chaining)
Crearea unui obiect dintr-o clasa (cu new) implica apelul implicit al
constructorilor
tuturor superclaselor, de-alungul lantului de mostenire.
Atentie: se vor apela implicit, chiar daca lipseste apelul explicit cu super() !
class F extends T
...

class T extends B
...

Constructor chaining:
F obj=new F();// Cand se apeleaza new , se va intra in constructor clasa F si
primul lucru pe care-l va face: va apela
//constructorului tatalui lui F, deci constructorul lui T.
//Primul lucru pe care-l va face constructorul lui T: va apela constructorul
tatalui lui,
// deci va apela constructorul lui B.

Intr-o clasa putem avea 0, 1 sau mai multi constructori

In cazul in care nu are niciun constructor definit explicit, Java
va crea implicit un constructor fara parametrii si care nu face nimic.

Exemplu:
//clasa stramos pt celelalte din lantul de derivare:
class A{ //clasa bunic
public A(){
System.out.println("Sunt stramosul A");
}
}

class AA extends A{ //clasa tata

public AA(){
System.out.println("Sunt AA, fiul lui A");
}
public AA(int x){
System.out.println("Sunt AA, al doilea constructor, cu x="+x);
}
}
class AAA extends AA{ //clasa fiu
public AAA(){
System.out.println("Sunt AAA, fiul lui AA");
}
}

class TestInlantuireConstructori{
public static void main(String args[]){

new AAA();//obiect anonim

/* Va afisa:
Sunt stramosul A
Sunt AA, fiul lui A
Sunt AAA, fiul lui AA
*/
}

MOdificam programul astfel:

class A{
public A(){
System.out.println("Sunt stramosul A");
}
}
class AA extends A{
public AA(){
System.out.println("Sunt AA, fiul lui A");
}
public AA(int x){
System.out.println("Sunt AA, al doilea constructor, cu x="+x);
}
}
class AAA extends AA{
public AAA(){
super();//apelez explicit un constructor din clasa de baza (AA)
System.out.println("Sunt AAA, fiul lui AA");
}
}
//NU SE VA MODIFICA CE SE AFISEAZA IN main ! (la fel ca in exemplul anterior)

class TestInlantuireConstructori{
public static void main(String args[]){
new AAA();//obiect anonim
/* Va afisa:
Sunt stramosul A
Sunt AA, fiul lui A
Sunt AAA, fiul lui AA
*/
}

/////////////
MOdificam programul astfel:
class A{
public A(){
System.out.println("Sunt stramosul A");
}
}
class AA extends A{
public AA(){
 System.out.println("Sunt AA, fiul lui A");
}
public AA(int x){
System.out.println("Sunt AA, al doilea constructor, cu x="+x);
}
}
class AAA extends AA{
public AAA(){
super(12);//apelez explicit un constructor din clasa de baza (AA)
System.out.println("Sunt AAA, fiul lui AA");
}
}

class TestInlantuireConstructori{
public static void main(String args[]){
new AAA();//obiect anonim
/* Va afisa:
Sunt stramosul A
Sunt AA, al doilea constructor, cu x=12
Sunt AAA, fiul lui AA
*/
}

Un alt exemplu de mostenire

//Clasa de baza:

class ContBancar{
private double suma;//suma de bani din cont
public ContBancar(double suma){
this.suma=suma;
}
public void adauga(double x){
suma=suma+x;
}
public boolean extrage(double x){
if(suma>=x){
suma=suma-x;
return true;
}else return false;
}
public double get(){ return suma;}
}

class ContBancarCuDobanda extends ContBancar{

private double rd;//rata dobanzii anuale Ex: 0.01
public ContBancarCuDobanda(double suma, double rd){
super(suma);
this.rd=rd;
}
public void adaugaDobandaLunar(){
//12 luni ... dobanda=suma*rd
//1 luna ..... ?
suma=suma+suma*rd/12;
}
public double getDobandaAnuala(){
return suma*rd/12;
}
}

class TestContBancar{
public static void main(String args[]){
ContBancarCuDobanda cbd=new ContBancarCuDobanda(1000);
cbd.adauga(1000);
double d=cbd.getDobandaAnuala();
System.out.println("dobanda anuala la suma de "+cbd.get()+" este: "+d);
}
}

Observatie importanta :
Se poate folosi tipul clasei de baza , in locul tipului clasei derivate
Invers, nu !
Object obj=new Patrat(); //Da, corect Un Patrat este un Object . Invers, nu
//Tipul declarat al lui obj este Object. Tipul rezultat din instantiere este
Patrat.
int S=obj.arie(); NU, pt ca in clasa Object , nu e definita metoda arie()
int S=((Patrat))obj.arie();

Nu se poate invers:
Patrat p=new Object(); GRESIT !

Pe cazul general: (tipul declarat poate fi clasa de Baza)

Baza obj=new Derivata(..);

CLASE ABSTRACTE. INTERFETE.

O clasa abstracta este o clasa ce contine ca orice clasa normala var. de instnta si
metode, dar, se poate ca
unele metode sa nu aiba implementare (sunt doar declarate)
Metodele fara implementare (abstracte) sunt declarate cu cuvantul cheie abstract.
Clasa abstracta serveste ca un sablon iar implementarea va fi data in clasele
derivate din clasa abstracta.

IMP: Nu se pot instantia obiecte dintr-o clasa abstracta !

O clasa abstracta se declara cu cuvantul cheie abstract.
abstract class A{
....
}
Nu putem avea:
A a=new A(); //GRESIT !

Putem avea:
class D extends A {....}

abstract class A{
abstract public void calcul(int N);
public long durataCalcul(int N){
//cat dureaza executia metodei calcul() ?
long t1=System.currentTimeMillis();
calcul();
long t2=System.currentTimeMillis();
return (t2-t1);
}
}

class AA extends A{
 //mosteneste met. durataCalcul()
public void calcul(int N){
//un calcul pt a consuma timp procesor
int i, j,k;
for(i=1;i<=N;i++)
for(j=1;j<=N;j++)
for(k=1;k<=N;k++)
int rezultat=i*j*k;
}
}

class Test{
public static voiod main(String args[]){
AA aa=new AA();
System.out.println("durata="+aa.durataCalcul());
}
}