Sunteți pe pagina 1din 5

Laborator 6

Incapsularea. Specificatori de protecție.

Moștenirea. Clase derivate.

6.1. Incapsularea

Este procedeul de « ascundere » a datelor prin utilizarea unor specificatori de protecție.

Aceștia sunt cuvinte cheie care se plasează în fața definiției clasei, a atributelor și metodelor și
stabilesc drepturile de acces ale clienților la membrii unei clase. Prin client se înțelege orice altă
metodă sau clasă care referă sau utilizează membrul respectiv din exterior.

In interiorul unei clase toți membrii pot fi accesați nerestrictiv, fără a se ține cont de specificatorii de
protecție.

Specificatorii de protecție în Java sunt:

public

private

protected

Clienții unei clase pot accesa doar acei membri care au ca specificator cuvantul public.

Membrii declarați private NU sunt vizibili în afara clasei. Ei nu pot fi nici folosiți nici modificați din
altă clasă.

Specificatorul protected este utilizat în contextul ierarhiilor de clase, membrii clasei fiind vizibili
numai din clasa derivată acesteia.

Regula pentru folosirea acestori specificatori este urmatoarea: atributele se vor declara în general
folosind modificatorul private iar metodele se vor declara public. Acest lucru permite
ascunderea stării unui obiect (încapsularea obiectului), pentru a putea controla accesul și
modificarea acestuia din exterior. Atributele care sunt interesante din exterior vor avea asociate
metode publice de gen getAtribut și, respectiv setAtribut (pentru a permite modificarea).

Obs : Dacă un membru este declarat fără nici un specificator, el se considera accesibil la nivelul
pachetului curent.

Pentru a defini constante care sa desemneze atributele unei clase care NU isi pot modifica valoarea
se poate folosi modificatorul final inaintea lor.
Sarcina 1 : Compilați și executați programul următor.

import java.io.*;
/**
* Clasa Persoana descrie datele private si comportamentul unei persoane
*/
public class Persoana {

/* Atributele clasei */
private String nume; // numele de familie
private String prenume; // prenumele persoanei
private int varsta; // varsta in ani impliniti
private double inaltimea; // inaltimea persoanei in cm
private char sex; // sexul persoanei. Valori posibile 'F' sau 'M'

/* Metodele clasei */

// Constructor al clasei Persoana - cu toate datele


public Persoana( String numePers, String prenumePers, int varstaPers,
double inaltimeaPers, char sexPers) {
nume = numePers;
prenume = prenumePers;
varsta = varstaPers;
inaltimea = inaltimeaPers;
sex=sexPers;
}

/** Metoda getNume - permite aflarea numelui


* @return numele si prenumele persoanei
*/
public String getNume() {
return nume+" "+prenume;
}

/** Metoda getVarsta - permite aflarea varstei


* @return varsta persoanei in ani impliniti
*/
public int getVarsta() {
return varsta;
}

/** Metoda getInaltimea - permite aflarea inaltimii


* @return inaltimea persoanei in cm
*/
public double getInaltimea() {
return inaltimea;
}

/** Metoda getSex - permite aflarea sexului


* @return sexul persoanei sub forma de sir de caractere
*/
public String getSex() {
String s;
switch (sex) {
case 'F': s = "feminin"; break;
case 'M': s = "masculin"; break;
default: s = "neprecizat";
System.out.println("Atributul sex are o valoare eronata!"); break;
}
return s;
}
/** Metoda setNume - permite schimbarea numelui dupa casatorie
* se aplica doar pentru sex='F'
* @param numeNou numele dupa schimbare
*/
public void setNume(String numeNou) {
if (sex=='F')
nume = numeNou;
else
System.out.println("Nu se permite schimbarea numelui unei
persoane de sex masculin!");
}

/** Metoda setVarsta - permite schimbarea varstei


* @param varstaNoua varsta noua
*/
public void setVarsta(int varstaNoua) {
if (varstaNoua>=0 && varstaNoua<150)
varsta = varstaNoua;
else
System.out.println("Varsta gresita!");
}

/** Metoda setInaltimea - permite schimbarea inaltimii persoanei


* @param inaltimeNoua inaltimea noua
*/
public void setInaltimea(double inaltimeaNoua) {
if (inaltimeaNoua>=10.0 && inaltimeaNoua<251.0)
inaltimea = inaltimeaNoua;
else
System.out.println("Inaltimea gresita!");
}

/** Metoda afiseazaInformatii - afiseaza pe consola informatiile despre


persoana
*/
void afiseazaInformatii() {
System.out.println("- Date despre persoana -");
System.out.println("Numele: " + getNume());
System.out.println("Varsta: " + getVarsta());
System.out.println("Inaltimea: " + getInaltimea());
System.out.println("Sexul: " + getSex());
}
public static void main(String[] args) throws IOException {

Persoana p;

p = new Persoana( "Ionescu", "Mihaela", 23, 1.74, 'F');


p.afiseazaInformatii();
}
}

Observați cum se accesează membrii privați ai clasei Persoana prin intermediul metodelor publice
ale clasei.

Sarcina 2 : Completați funcția principală astfel încât să modificați Numele, Varsta și Inaltimea
persoanei utilizând funcțiile setNume(), setVarsta() și setInaltimea() ;
6. 2. Moștenirea. Clase derivate.

Unul dintre avantajele oferite de tehnologia POO este posibilitatea de a extinde comportamentul
unei clase existente prin definirea unei clase noi care moștenește conținutul primei clase, adăugând
la acesta elemente specifice.

Clasa de bază, care va fi moștenită se mai numește și superclasă. Clasa derivată care realizează
extinderea se mai numește și subclasă.

Relația de moștenire este o relație de forma "este un fel de" ; cu alte cuvinte, subclasa "este un fel
de" superclasă. De altfel, dacă se pune problema de a decide dacă o anumită clasă trebuie sau nu să
moștenească o alta clasă, decizia se va lua în funcție de răspunsul la întrebarea: este prima clasă "un
fel de" cealaltă clasă? Practic, relația de moștenire între clase este o reflectare a ierarhizarii existente
între entitățile modelate de clasele respective.

Pentru a specifica faptul că o subclasă moștenește o clasă de bază, în Java se utilizează următoarea
construcție:

class nume_subclasa extends nume_superclasa {


//continut specific subclasei
}

In ceea ce privește gradul relației de moștenire, în Java avem de a face cu moștenire simplă: o
subclasă poate extinde o singură superclasa; totuși aceeași superclasă poate fi extinsă de mai multe
subclase distincte.

O subclasă, la randul ei, poate constitui superclasa pentru o alta clasă. O clasă de bază împreună cu
toate descendentele ei formează o ierarhie de clase.

In metodele unei subclase pot fi referiți acei membri mosteniți care în superclasă au fost precedați de
specificatorii protected sau public. Referirea membrilor mosteniți se face directm la fel ca și
pentru membrii specifici. Acest lucru este foarte normal, deoarece și membrii mosteniți sunt
continuti în subclasă, doar că ei nu au fost declarați explicit. Includerea lor se face automat, ca efect
al clauzei extends.

In clienții unei subclase pot fi referiți acei membri, moșteniți sau locali, care sunt precedați de
specificatorul public. Membrii declarați ca private sau protected sunt accesibili doar dacă
clientul se afla în același pachet cu subclasa respectivă.

Sarcina 3 : Codul următor definește subclasa Student care este derivată din superclasa
Persoana din exemplul anterior. Compilați și rulați acest cod. Ce concluzie trageți ?
/**
* Clasa Student - derivata din clasa Persoana
*
*/
public class Student extends Persoana {
static int nr_ani = 5;
int an_studiu;

public Student(String numePers, String prenumePers,


int varstaPers, double inaltimeaPers, char sexPers) {
super(numePers, prenumePers, varstaPers, inaltimeaPers, sexPers);
an_studiu = 1;
}

public void afiseazaInformatii() {


super.afiseazaInformatii();
System.out.println("Anul de studiu: "+an_studiu);
}

public static void main(String args[]) {


Student s1 = new Student("Dragos","Elena", 24, 1.63, 'F');
Persoana p1;

p1 = s1;
s1.afiseazaInformatii();
p1.afiseazaInformatii();
}
}