Ahora conoceremos el tercer principio S.O.L.I.D.

Este principio introducido por Barbara Liskov en 1987 dice:

Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it. - Funciones que usen punteros o referencias a clases base deben ser capaz de usar objetos de clases derivadas sin conocerlos.

Esto es básicamente una extensión del principio Abierto-Cerrado. Lo que nos dice es que si tenemos una clase y varias subclases de esta al usar una referencia a la clase principal esta debe ser capaz de aceptar cualquier objeto de sus clases hijas.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
// Tenemos una clase base 
abstract class Operation {
   protected double operator1; 
   protected double operator2;
   
   public void setOperator1(double operator1) { 
      this.operator1 = operator1; 
   } 
   
   public void setOperator2(double operator2) { 
      this.operator2 = operator2; 
   }
   
   public abstract double calcular(); 
   
}

// Una clase derivada de Operation 
class SumOperation extends Operation { 
   public double calcular() { 
      double result = this.operator1 + this.operator2; 
      return result; 
   } 
}

//Otra clase derivada de Operation 
class MultiOperation extends Operation { 
   public double calcular() { 
      double result = this.operator1 * this.operator2; 
      return result; 
   } 
}

class Calculator { 
   //Aqui pasamos una referencia de la clase base 
   public void calcular(Operation op) { 
      //Esa referencia la usamos aqui que es op 
      double result = op.calcular(); 
      System.out.println("Resultado="+result); 
   } 
}

class Main { 
   public static void main(String[] args) { 
      Calculator c = new Calculator();
      SumOperation s = new SumOperation(); 
      s.setOperator1(10); 
      s.setOperator2(4); 
      //El metodo calcular acepta cualquier objeto 
      //de una clase derivada de Operation 
      c.calcular(s);
      MultiOperation m = new MultiOperation(); 
      m.setOperator1(6); 
      m.setOperator2(5); 
      //El metodo calcular acepta cualquier objeto 
      //de una clase derivada de Operation c.calcular(m); 
   } 
} 


Aquí vemos la aplicación de este principio en el método calcular. Este método usa una referencia a la clase base y nunca se entera cual es el objeto derivado(subtipo) que se esta usando.


Franky Villadiego

Volando hacia el desarrollo productivo!