Sunteți pe pagina 1din 3

1/30/2020 Static, abstract, final

<< Legarea dinamica(tarzie) Curs Interfete >>

Static, abstract, final


Abstract
In ierarhia de clase este important ca o clasa sa mosteneasca caracteristici si functii de la mai multe clase. Pentru
ca Java permite mostenirea unei singure clase, este necesar un mecanism pentru a permite acest lucru. De fapt
C++ este singurul limbaj de programare obiectual ce permite mostenirea multipla. Revenind la Java, de multe ori
avem nevoie de clase ce trebuie sa implementeze aceleasi functii si uneori sa aiba aceleasi campuri sau versiuni
modificate ale unei clase de baza. Asta inseamna ca avem nevoie de clase ce nu trebuie sa implementeze acele
functii ci sa poata fi mostenite iar scopul lor sa fie tocmai acesta. Acestea sunt clasele abstracte.

Vom folosi proiectul C5 din directorul surse. Incepem cu clasa abstracta. E suficient ca o functie sa nu fie
implementata, clasa va deveni abstracta si nu se va instantia. Din aceasta cauza, trebuie sa precedati numele
clasei cu clasificatorul abstract. Functiile care nu se implementeaza trebuie si ele sa aiba modificatorul abstract.
Observati ca am definit o variabila membra pi de tip double, ce va fi mostenita in subclase. De fapt, ea ar fi
trebuit sa aiba si modificatorul final, dar despre asta ceva mai incolo, in aceasta pagina.

import java.math.*;
/**
* Clasa ce va fi mostenita de figuri geometrice specializate
* @author vas
*/
public abstract class FiguraGeometrica {
protected double pi = Math.PI;

public abstract double getAria();


public abstract double getPerimetru();

public String toString(){


return "Aria:" + Double.toString(getAria()) +
" Perimetru:" + Double.toString(getPerimetru());
}
}

Iata si cum arata o clasa ce extinde FiguraGeometrica. Ea trebuie sa implementeze cele doua functii abstracte din
FiguraGeometrica. Daca nu ar implementa toate functiile abstracte din FiguraGeometrica atunci si clasa
respectiva ar fi abstracta si nu ar putea fi instantiata. Marcatorul @Override poate lipsi (cum este la getAria) dar
e bine sa fie pus, pentru ca mareste vizibilitatea originii functiei (care este suprascrisa).

import java.math.*;

public class Cerc extends FiguraGeometrica {


private double raza;

public Cerc(double raza){


this.raza = raza;
}

public double getAria() {


return pi * Math.pow(raza,2.0 );//pi * r^2
}

@Override
public double getPerimetru() {
return 2.0 * pi * raza;
}

facultate.solidsoftsolutions.com/tutorials/CursJava/fisiere/f8.html 1/3
1/30/2020 Static, abstract, final

Iata si testul. Observati ca am folosit pentru afisare functia mostenita de la FiguraGeometrica, acesta fiind si unul
din motivele existentei claselor abstracte (implementeaza o parte din functiile necesare subclaselor). Sigur, am fi
putut sa suprascriem functia toString() in fiecare subclasa, dar aici nu are sens.

Desi FiguraGeometrica nu poate fi instantiata, fiind superclasa pentru Cerc, se poate obtine o referinta catre o
FiguraGeometrica ce aici se intampla sa fie Cerc. Clasa abstracta FiguraGeometrica va apela functiile getAria()
si getPerimetru() pentru obiectul referit (de tip Cerc) si va afisa la ecran informatiile.

public class Test {

public static void main(String[] args) {


Dreptunghi d = new Dreptunghi(10,5);
Cerc c = new Cerc(10);
System.out.println(d);
System.out.println(c);

//si ceva din polimorfism


FiguraGeometrica a = new Cerc(5);
System.out.println(a);
}
}

Final
Modificatorul final se foloseste pentru marcarea faptului ca respectiva entitate nu poate fi modificata. In cazul
claselor, clasa nu se mai poate extinde. Deoarece aceste clase nu se mai pot extinde, inseamna ca trebuie sa nu
fie abstracte si in cazul in care mostenesc clase abstracte sau implementeaza interfete, trebuie sa implementeze
toate functiile. O clasa final foarte folosita este java.math.Math (nu o puteti extinde).

In cazul variabilelor, variabila este constanta. Prin conventie, variabilele final sunt scrise cu litere majuscule, ca
mai jos.

public final class FaraMostenire {


private final String GEORGE = "George";

public String toString()


{
return GEORGE;
}
}

class PatratFix{
private int latura;
PatratFix(int marime){
latura = marime;
}

public int getLatura(){


return latura;
}

public void setLatura(int latura){


this.latura = latura;
}

public final double getAria(){


return latura * latura;
}
}

Prototipul public final double getAria() trebuie inteles astfel: metoda publica getAria() intoarce double si nu se
poate suprascrie in subclase. Cu alte cuvinte, metoda este critica in superclasa si nu se poate suprascrie.
facultate.solidsoftsolutions.com/tutorials/CursJava/fisiere/f8.html 2/3
1/30/2020 Static, abstract, final

Static

Acest modificator, pe care il intalniti si la functii si la variabile membre, este util atunci cand dorim o singura
instanta a variabilei membre, caz in care variabila se mai numeste si variabila a clasei.

O variabila statica, apartinand clasei si fiind unica, este accesibila fara a fi nevoie de instantierea vreunui obiect.
Modificarea variabilei statice se poate face folosind numele clasei sau o referinta catre un obiect din acea clasa.
Toate modificarile se reflecta in celelalte obiecte.

Metodele statice nu pot accesa decat membri statici. Daca va aduceti aminte, in prototipul functiei main avem
public static void main(String[] args). Ce trebuie sa deducem din aceasta este ca functia main nu poate accesa
decat functii membre statice, variabile statice dar in schimb poate fi accesata din exterior (de JVM) fara sa fie
nevoie ca JVM sa instantieze un obiect din acea clasa. Ca o consecinta, daca dorim sa folosim un obiect din acea
clasa(in care este main), trebuie sa-l cream in functia main. Ca o consecinta a acestui comportament, metodele
statice(ale clasei) nu pot fi modificate in subclase.

public class Muncitor {


private static int contor=0;
public String nume;

//trebuie sa fie statica pentru ca altfel nu putem obtine


//valoarea, care este statica
public static int getContor(){
return contor;
}

public Muncitor(String nume){


this.nume = nume;
contor++;
}
}

Intr-un test simplu, putem verifica comportamentul apelului functiei statice.

//observati ca putem apela direct metodele statice


//fara a instantia vreun obiect
System.out.println(Muncitor.getContor());
Muncitor vasile = new Muncitor("Vasile");
Muncitor ion = new Muncitor("Ion");

System.out.println("Exista " + Muncitor.getContor() + " muncitori");


//sau puteti folosi o instanta la apelul functiei statice
System.out.println("Exista " + ion.getContor() + " muncitori");

<< Legarea dinamica(tarzie) Curs Interfete >>

facultate.solidsoftsolutions.com/tutorials/CursJava/fisiere/f8.html 3/3