Machine

25/06/2019 Translated by Google Principios  de  diseño  SOLID  en  Java  ­  CodesJava

Principios  de  diseño  SOLID  en  Java

Los  principios  SOLID  del  Diseño  Orientado  a  Objetos  incluyen  
los  siguientes  cinco  principios:
Principio  de  responsabilidad  única  (PRS)
Principio  de  diseño  abierto  cerrado
Principio  de  sustitución  de  Liskov  (LSP)
Principio  de  segregación  de  interfaz  (ISP)

Principio  de  Inyección  o  Inversión  de  Dependencia

Principio  de  responsabilidad  única  (PRS)
Es  un  principio  de  diseño  SÓLIDO  y  representa  una  "S"  en  el  acrónimo  
SÓLIDO.  De  acuerdo  con  SRP,  una  clase  siempre  debe  manejar  una  sola  
funcionalidad  o  no  debe  haber  más  de  una  razón  para  que  una  clase  cambie.  Se  utiliza  
para  lograr  un  acoplamiento  débil  entre  dos  funcionalidades  diferentes.

Entendamos  el  principio  de  responsabilidad  única  con  el  siguiente  ejemplo.  
A  continuación,  tenemos  una  clase  de  empleado  que  consta  de  sus  propiedades  y  un  
método  que  devuelve  si  la  promoción  es  debida  para  ese  empleado  o  no.

empleado  de  clase  pública  
{ private  String  empId;  cadena  
privada  nombre;  dirección  
de  cadena  privada ;

public  boolean  isPromotionDueThisYear(){ //lógica  de  
promoción
}

//Getters  y  Setters
}

La  clase  anterior  no  sigue  el  principio  de  responsabilidad  única  porque  la  clase  
Empleado  debe  tener  la  responsabilidad  única  de  mantener  los  atributos  básicos  
de  un  empleado.  Calcular  si  la  promoción  corresponde  o  no  a  ese  Empleado  no  es  
responsabilidad  de  la  clase  de  Empleado.

Mejor  solución:
Podemos  crear  una  nueva  clase  que  contendrá  la  lógica  de  cálculo  de  la  
promoción  por  separado.  Este  enfoque  seguirá  el  principio  de  responsabilidad  
única  porque  ahora  ambas  clases,  Empleado  y  Promociones,  tienen  
responsabilidades  únicas.

Promociones  de  clase  pública  {
public  boolean  isPromotionDueThisYear(Employee  emp){
//  lógica  de  promoción
}
}

empleado  de  clase  pública  
{ private  String  empId;  cadena  
privada  nombre;  dirección  
de  cadena  privada ;

https://codesjava.com/solid­design­principles­java­pdf 1/4
Machine
25/06/2019 Translated by Google Principios  de  diseño  SOLID  en  Java  ­  CodesJava

//Getters  y  Setters
}

Principio  de  diseño  abierto  cerrado
El  principio  de  diseño  abierto  cerrado  dice  que  las  entidades  de  software  como  clases,  
módulos,  funciones,  etc.  deben  estar  abiertas  para  la  extensión,  pero  cerradas  para  la  
modificación.  Es  un  principio  de  diseño  SÓLIDO  y  representa  una  "O"  en  el  acrónimo  
SÓLIDO.

Se  considera  que  una  clase  está  cerrada  si  se  garantiza  que  no  se  producirán  cambios.  
Se  puede  usar  como  una  clase  base  que  se  puede  ampliar  con  clases  secundarias.

Una  clase  se  considera  abierta  si  sus  subclases  pueden  mejorar  su  funcionalidad.

Entendamos  el  principio  de  diseño  abierto  y  cerrado  con  el  siguiente  ejemplo.  
Considere  un  caso  en  el  que  necesitamos  calcular  áreas  de  varias  formas.  Comenzamos  con  
la  creación  de  una  clase  para  nuestra  primera  forma,  Rectángulo.

Rectángulo  de  clase  pública  
{ doble  longitud  pública ;  
público  de  doble  ancho; }

A  continuación,  cree  una  clase  para  calcular  el  área  de  este  rectángulo  que  tiene  un  
método  de  cálculo  de  área  de  rectángulo  ().

Calculadora  de  área  de  clase  pública  {
public  double  computeRectangleArea(Rectángulo  rectángulo){ return  rectángulo.longitud  
*rectángulo.ancho;
}
}

Ahora  tenemos  el  círculo  como  una  nueva  forma.  Entonces  creamos  una  clase  Circle.

Círculo  de  clase  pública  {
público  doble  radio; }

Luego  modificamos  la  clase  AreaCalculator  para  agregar  cálculos  circulares  a  través  
de  un  nuevo  método  de  cálculo  de  área  circular  ().

Calculadora  de  área  de  clase  pública  {
public  double  computeRectangleArea(Rectángulo  rectángulo){ return  rectángulo.longitud  
*rectángulo.ancho;

}  public  double  generateCircleArea(Circle  circle){ return  
(22/7)*circle.radius*circle.radius;
}
}

Cada  vez  que  surge  un  nuevo  requisito,  tenemos  que  modificar  nuestra  clase  para  que  este  
diseño  no  esté  cerrado  a  la  modificación.

Mejor  solución:
Primero  crearemos  una  forma  de  tipo  base  que  será  implementada  por  todas  las  formas.  
Tiene  un  método  abstracto  de  calcular  el  área  ().  Cada  subclase  anula  este  método  y  
proporcionará  su  propia  implementación.  Este  diseño  sigue  el  principio  de  diseño  abierto  
y  cerrado,  ya  que  la  clase  Shape  está  abierta  para  la  extensión  y  cerrada  para  la  modificación.

https://codesjava.com/solid­design­principles­java­pdf 2/4
Machine
25/06/2019 Translated by Google Principios  de  diseño  SOLID  en  Java  ­  CodesJava

Forma  de  interfaz  pública  
{ public  double  computeArea  ();
}

Rectángulo  de  clase  pública  implementa  Forma{
longitud  doble ;  
doble  ancho;  
public  double  computeArea(){ devuelve  
*
el  ancho  de  la  longitud;
}
}

clase  pública  Circle  implementa  Shape{
público  doble  radio;  public  
double  calculeArea(){ return  
(22/7)*radius*radius;
}
}

Principio  de  sustitución  de  Liskov  (LSP)
Es  un  principio  de  diseño  SÓLIDO  y  representa  una  "L"  en  el  acrónimo  
SÓLIDO.  Según  LSP,  los  subtipos  deben  ser  sustituibles  por  supertipos.  El  
concepto  principal  detrás  del  principio  de  diseño  LSP  SOLID  es  que  la  clase  o  
subclase  derivada  debe  mejorar  la  funcionalidad,  no  reducirla.

Por  ejemplo,  tenemos  la  clase  Animal  con  un  método  MakeNoise(),  entonces  
cualquier  subclase  de  Animal  debería  implementar  makeNoise().

Principio  de  segregación  de  interfaz  (ISP)
Es  un  principio  de  diseño  SÓLIDO  y  representa  "I"  en  el  acrónimo  SÓLIDO.
Según  el  ISP,  los  clientes  no  deben  verse  obligados  a  implementar  
métodos  innecesarios  que  no  utilizarán.  Para  lograr  el  principio  de  diseño  ISP  
SOLID,  preferimos  muchas  interfaces  específicas  del  cliente,  más  pequeñas,  
en  lugar  de  una  interfaz  más  grande.

Entendamos  el  principio  de  segregación  de  la  interfaz  con  el  siguiente  ejemplo.  
En  el  siguiente  ejemplo,  tenemos  una  interfaz  que  tiene  dos  métodos  para  generar  
informes  en  diferentes  formatos,  generar  Excel  ()  y  generar  Pdf  ().

interfaz  pública  GenerateReport{ public  void  
generateExcel();  public  void  
generarPDF();
}

Ahora  considere  un  caso  en  el  que  el  cliente  Test  quiere  usar  esta  interfaz  pero  quiere

use  informes  solo  en  formato  PDF  y  no  en  excel.  Con  el  diseño  anterior  no  puede  
lograrlo  porque  lo  estamos  obligando  a  implementar  ambos  métodos.  Entonces,  
este  diseño  no  sigue  el  principio  de  segregación  de  interfaz.

Mejor  solución:
Podemos  dividir  la  interfaz  GenerateReport  en  dos  pequeñas  interfaces  que  contienen  
métodos  separados  y  el  cliente  puede  usar  el  método  deseado.

Principio  de  Inyección  o  Inversión  de  Dependencia
Es  un  principio  de  diseño  SÓLIDO  y  representa  una  "D"  en  el  acrónimo  
SÓLIDO.  De  acuerdo  con  el  principio  de  inversión  de  dependencia,  el  código  debería  
depender  de  abstracciones  en  lugar  de  detalles  concretos.  Nosotros

https://codesjava.com/solid­design­principles­java­pdf 3/4
Machine
25/06/2019 Translated by Google Principios  de  diseño  SOLID  en  Java  ­  CodesJava

debemos  diseñar  nuestro  software  de  tal  manera  que  varios  módulos  puedan  
separarse  entre  sí  usando  una  capa  abstracta  para  unirlos.  BeanFactory  
en  Spring  Framework  representa  el  uso  clásico  de  este  principio.  Todos  los  
módulos  de  Spring  Framework  se  proporcionan  como  componentes  separados  
que  pueden  funcionar  juntos  simplemente  inyectando  dependencias  en  otro  
módulo.

Inyección:
La  inyección  es  un  proceso  de  pasar  la  dependencia  a  un  objeto  dependiente.

Inyección  de  dependencia  (DI):
La  inyección  de  dependencia  (DI)  es  un  patrón  de  diseño  que  implementa  
el  principio  de  inversión  de  control  para  resolver  dependencias.  Permite  que  un  
programador  elimine  las  dependencias  codificadas  para  que  la  aplicación  
se  acople  libremente  y  sea  extensible.

Analicemos  la  dependencia  de  objetos  con  el  siguiente  ejemplo:

Estudiante  de  clase  pública  {
Dirección  privada  dirección;

public  Student()  
{ dirección  =  nueva  dirección();
}
}

En  el  ejemplo  anterior,  la  clase  Estudiante  requiere  un  objeto  Dirección  y  es  
responsable  de  inicializar  y  usar  el  objeto  Dirección.  Si  la  clase  de  Dirección  se  
cambia  en  el  futuro,  también  tendremos  que  hacer  cambios  en  la  clase  de  
Estudiante.  Este  enfoque  crea  un  acoplamiento  estrecho  entre  los  objetos  Student  
y  Address.  Podemos  resolver  este  problema  utilizando  el  patrón  de  diseño  
de  inyección  de  dependencia.  es  decir,  el  objeto  Dirección  se  implementará  
de  forma  independiente  y  se  proporcionará  al  Estudiante  cuando  se  cree  
una  instancia  del  Estudiante  mediante  la  inyección  de  dependencias  basada  en  
el  constructor  o  en  el  setter.

Puede  leer  los  siguientes  temas  para  la  inyección  de  dependencia:

Tutorial  de  inyección  de  dependencia  de  Spring.

Tutorial  de  inyección  basado  en  Spring  Builder.

Tutorial  de  ambigüedades  de  tipo  de  inyección  de  constructor.

Tutorial  de  inyección  de  dependencia  basado  en  Setter.

Tutorial  de  colecciones  de  inyección  de  dependencia  de  Spring.

Por  favor  comparte

Me  gusta  Compartir Pío Ahorrar

https://codesjava.com/solid­design­principles­java­pdf 4/4