Principiul substituției în relația de moștenire

Cum credeți? Dacă două obiecte sunt diferite, este posibil ca programul să le trateze ca fiind de același tip?

În această lecție continuând discuția despre implementarea moștenirii în Java, vom descoperi cum este posibil acest lucru în Java. Iar cheia este - principiul substituției! 

Acesta mai este cunoscut și ca Liskov Substitution Principle (LSP). A fost formulat în 1987 de Barbara Liskov, o cercetătoare în informatică, împreună cu colega ei Jeannette Wing.

Barbara Liskov a prezentat principiul în cadrul unei lucrări despre programarea orientată pe obiecte, explicând cum clasele derivate trebuie să poată înlocui clasele de bază fără a deteriora comportamentul programului.

Deci, principiul are o istorie de peste 35 de ani, fiind unul dintre pilonii fundamentali ai principiilor SOLID în programarea modernă.

Principiul substituției ne spune că un obiect al unei clase derivate poate înlocui cu succes un obiect al clasei de bază, fără ca funcționalitatea programului să fie afectată.

În această postare, vom vedea un exemplu simplu cu forme geometrice – cerc și dreptunghi – pentru a înțelege cum funcționează principiul substituției în practică. 

// Clasa de bază
class Forma {
 public double aria() {
  return 0;
 }
}
// Clasa derivată Dreptunghi
class Dreptunghi extends Forma {
 private double latime, inaltime;
 public Dreptunghi(double latime, double inaltime) {
  this.latime = latime;
  this.inaltime = inaltime; }
 public double aria() {
  return latime * inaltime;
 }
}
// Clasa derivată Cerc
class Cerc extends Forma {
 private double raza;
 public Cerc(double raza) {
  this.raza = raza;
 }
 public double aria() {
  return 3.14 * raza * raza;
 }
}
public class Main {
 public static void main(String[] args) {
  Forma f1 = new Dreptunghi(5, 10); // Obiect Dreptunghi
  Forma f2 = new Cerc(7);           // Obiect Cerc
  System.out.println("Aria dreptunghiului: " + f1.aria());
  System.out.println("Aria cercului: " + f2.aria());
 }}

În exemplul prezentat mai sus f1 și f2 sunt declarate ca tip Forma care este clasa de bază sau clasa părinte, dar obiectele sunt de fapt Dreptunghi și Cerc, care sunt clasele derivate sau clasele copil.
Metoda aria() apelată pe fiecare obiect folosește implementarea clasei derivate. 

Acesta și este de fapt principiul substituției, putem înlocui obiectele clasei de bază cu obiecte derivate fără să schimbăm codul care le folosește. 

Cum decizi dacă ai nevoie să aplici acest principiu sau nu? 

Regula e simplă: folosești principiul substituției doar când obiectul copil se comportă la fel ca obiectul părinte și nu ai nevoie de funcții speciale.

Următoarea schemă te ajută să decizi rapid dacă poți folosi principiul substituției atunci când lucrezi cu clase și obiecte în Java:  

Pentru a demonstra mai clar eficiența acestui principiu, voi modifica metoda main() și voi crea o colecție de figuri geometrice, în care voi adăuga obiecte de tipuri diferite (Dreptunghi, Cerc), dar le voi trata pe toate ca obiecte de tip Forma.”

public class Main {
 public static void main(String[] args) {
   // Colecție de forme geometrice
   ArrayList<Forma> forme = new ArrayList<>();
   // Adăugăm diferite forme
   forme.add(new Dreptunghi(5, 10));
   forme.add(new Cerc(7));
   forme.add(new Dreptunghi(3, 4));
   forme.add(new Cerc(2.5));
   // Parcurgem colecția și afișăm aria fiecărei forme
   for (Forma f : forme) {
    System.out.println("Aria formei: " + f.getClass()+" "+ f.aria());
   }}}

Observați că în colecție folosim tipul general Forma, dar avem permisiunea de a adăuga obiecte diferite precum Cerc sau Dreptunghi. Programul funcționează corect deoarece obiectele claselor derivate pot înlocui obiectul clasei de bază. În fond acesta și este exact rolul principiului substituției.

Astfel, în alte contexte am putea crea, un buchet compus din diferite tipuri de flori, un cadou compus din diferite tipuri de bomboane, un colier compus din diferite tipuri de pietre prețioase, etc.

După cum observăm, lucrăm cu același tip general și apelăm aceeași metodă aria(), dar în contexte diferite. În funcție de tipul real al obiectului, metoda produce rezultate diferite. Acesta este principiul polimorfismului, iar principiul substituției stă la baza realizării acestuia în programarea orientată pe obiecte.

Succes!

❤️