Sunteți pe pagina 1din 18

Polimorfism

Supraîncărcarea și suprascrierea
metodelor.
profesor Dobrovolischii Olga
Programarea Orientată pe Obiecte

obiect
clasă
moștenire
polimorfism
abstractizare
încapsulare
Supradefinirea(suprascrierea, redefinirea,overriding) metodelor

Definiție: Atunci cînd o clasă rescrie o metodă a clasei părinte prin implementarea unei
metode cu același nume și cu aceeași sintaxă cu cea a superclasei are loc suprascrierea
metodei.

De exemplu:
public class vehicul{
void run(){
System.out.println(“Vehiculul merge!”);
}}
class Bicicleta extends Vehicul{
void run(){
System.out.println(“Bicicleta merge”);}}
Rețineți:
Numai metodele moștenite pot fi supradefinite
Metodele supradefinite trebuie să conțină același nume, aceeași listă de parametri și
același tip de return altfel nu merge vorba de suprascriere.
Metodele de tip final , static și constructorii nu pot fi supradefiniți.
O metodă supradefinită nu trebuie să conțină un modificator de acces mai restrictivă decît
metoda originală din clasa părinte:

Met.originala
implicit
implicit protected
public

protected protected
public

public public
public class B extends A {
void myMethod() {
System.out.println("Iarna");}
public static void main(String args[]) {
public class A { A obj = new B();
obj.myMethod();
}}
void myMethod() {

System.out.println("Examen");
public class B extends A {
protected void myMethod() {
}} System.out.println("Iarna");}
public static void main(String args[]) {
A obj = new B();
obj.myMethod();
}}

public class B extends A {


public void myMethod() {
System.out.println("Iarna");}
public static void main(String args[]) {
A obj = new B();
obj.myMethod();}}
public class B extends A {
public class A { protected void myMethod() {
System.out.println("Iarna");}
protected void myMethod() { public static void main(String args[]) {
A obj = new B();
obj.myMethod();
System.out.println("Examen");
}}

}}

public class B extends A {


public void myMethod() {
System.out.println("Iarna");}
public static void main(String args[]) {
A obj = new B();
obj.myMethod();}}
public class A { public class B extends A {
public void myMethod() {
public void myMethod() { System.out.println("Iarna");}
public static void main(String args[]) {
System.out.println("Examen"); A obj = new B();
obj.myMethod();}}
}}
public class A { public class B extends A {
public void myMethod() {
static public void myMethod() { System.out.println("Iarna");}
public static void main(String args[]) {
System.out.println("Examen"); A obj = new B();
obj.myMethod();}}
}}

În cazul în care metoda din clasa părinte are specificatorul static declarat înaintea metodei
atunci spunem că metoda din clasa părinte ascunde metoda suprascrisă din clasa derivată.
5. Faptul că folosim într-o clasă o metodă cu aceeași sintaxă ca în clasa părinte aplică
principiul moștenirii, iar faptul că în subclasă metoda clasei părinte are o implementare
diferită aplică principiul polimorfismului. Deviza polimorfismului”aceeași metodă,
implementare diferită”.
Exemplu de suprascriere a metodei toString() a clasei Object în clasa Elev
class Elev {
private String nume, prenume;
int virsta;
public Elev(String nume, String prenume, int virsta) {
this.nume = nume;
this.prenume = prenume;
this.virsta = virsta;
@Override
public String toString() {
return "Elev [nume=" + nume + ", prenume=" + prenume + ", virsta=" + virsta + "]";
public class SElev {
}public static void main(String[] args) {
Elev e1 = new Elev("Creanga", "Ion", 50);
System.out.println(e1);}}
Supraîncărcarea(overloading) metodelor

Definiție: Atunci cînd într-o clasă există metode cu același nume dar cu sintaxă diferită
spunem că metoda este supraîncărcată. Procesul de creare a acestui tip de metode se
numește supraîncărcare(Același nume, dar parametri și posibil tip de return diferit).

Metodele supraîncărcate:

Trebuie să aibă aibă listă de argumente diferită(număr de argumente și tip diferit )


Pot avea tip de return diferit
Pot avea diferiți modificatori de acces
Pot arunca diferite tipuri de excepții
1. Exemplu de supraîncărcare a constructorului
class Elev{
private String nume,prenume;
private int virsta;
public Elev(){
this.nume=nume;
this.prenume=prenume;}
public Elev(String nume, String prenume;int virsta){
this.nume=nume;
this.prenume=prenume;
this.virsta=virsta;}
Exemplu de supraîncărcare a metodelor
class Angajat{
private String nume,prenume;
protected int nrOre,plataOra;
int salariu(){
return nrOre*plataOra;
class Manager extends Angajat{
int salariu(int adaos){
return nrOre*plataOra+adaos;
}
}
3. Exemplu de supraîncărcare a unei metode pentru un număr diferit de parametri:
class Operatii{
int suma(int a, int b){
return a+b;
}
int suma(int a, int b, int c){
return a+b+c;
}
int suma(int a, int b, int c, int d){
return a+b+c+d;
}
}
4. Exemplu de supraîncărcare a unei metode pentru parametri cu tip diferit:
class Operatii{
int suma(int a, int b){
return a+b;}
double suma(double a, double b){
return a+b;
}
double suma(int a, double b, double c){
return a+b+c;}}
Rețineți:

Metodele supraîncărcate apar în aceeași clasă sau subclasă, au același nume dar lista de
parametri diferită

Se realizează la etapa compilării programului

Dacă vom supraîncărca metode cu aceeași listă de parametri , dar tip de return diferit vom
obține eroare de compilare, aceasta nu oferă suficientă informație compilatorului pentru a face
diferența.

Metodele statice, private și finale pot fi supraîncărcate


Polimorfismul static(compile time)

Polimorfismul determinat în timpul compilării unei aplicații este cunoscut ca polimorfism static.
Tehnica metodelor supraîncărcate este un exemplu de astfel de polimorfism. Anume la etapa
de compilare, compilatorul este capabil să facă diferența între diferite contexte și să realizeze
implementarea corectă fiecărui context de utilizare a metodei.

Atunci cînd are loc supraîncărcarea constructorilor , anume la faza de compilare compilatorul
este în stare să asocieze obiectului anume acel constructor al clasei ce are același număr de
parametri ca și constructorul apelat pentru obiectul dat. La fel este și în cazul metodelor. În
timpul compilării, compilatorul în dependență de numărul real de argumente și a tipurilor de
argumente va executa metoda supraîncărcată relevantă.
Polimorfismul dinamic(run time)

Polimorfismul determinat în timpul execuției unei aplicații este cunoscut ca polimorfism


dinamic. Tehnica metodelor supradefinite este un exemplu de astfel de polimorfism. La etapa
de execuție se decide care algoritm să fie executat: cel din clasa părinte(metoda inițială) , sau
cel din clasa copil(ce supradefinită) , în dependență de tipul obiectului și nu după tipul variabilei
ce memorează referința către obiectul respectiv.

Exemplu:
class Parinte{
public void oMetoda(){
System.out.println(“Metoda parinte”);
class Copil extends Parinte{
public void oMetoda(){
System.out.println(“Metoda copil”);
public static void main(String args[]){
Parinte obj = new Copil();
obj.oMetoda();}}
Exerciții
Se consideră următoarele clase:

public class ClassA { public class ClassB extends ClassA {


public void metodaUnu(int i) { public static void metodaUnu(int i) {
} }
public void metodaDoi(int i) { public void metodaDoi(int i) {
public static void metodaTrei(int i) {
}
} public void metodaTrei(int i) {
public static void metodaPatru(int i) { }
} public static void metodaPatru(int i)
} {
}
}
a.Care metodă suprascrie o metodă din superclasa?
b.Care metodă ascunde o metodă din superclasa?
c.Ce fac celelalte metode?
c. What do the other methods do?
2. Compuneți în Java clasa Operații ce va conține:
metoda adunare() supraîncărcată de 5 ori: pentru 2 parametri întregi, pentru 2 parametri
reali, 3 parametri întregi, 4 parametri întregi și pentru un număr variabil de argumente
care vor calcula și afișa suma argumentelor primite.
metoda main();

3. Compuneți un proiect Java ce va conține:


clasa Muncitor care va avea ca atribut oreLucrate, ca metode: constructorul clasei,
metoda double salariu() va returna salariul care se calculează conform formulei:
numărul de ore*2000;
clasa SefEchipa moștenește clasa Muncitor care va avea ca metode: constructorul clasei
, metoda salariu() modificată astfel încît să returneze salariul după formula : numărul de
ore*5000;
clasa Maistru moștenește clasa SefEchipă are ca metode constructorul clasei și metoda
salariu() modificată astfel încît să returneze salariul după formula:numarul de ore*7000;
clasa Test în care instanțiați obiecte pentru clasele create