SOLID: Los primeros 5 principios del diseño orientado a objetos | DigitalOcean (2023)

Introducción

SOLID es un acrónimo de los primeros cinco principios del diseño orientado a objetos (OOD) de Robert C. Martin (también conocido como el Tío Bob).

Nota: Aunque estos principios pueden aplicarse a varios lenguajes de programación, el código de muestra que se incluye en este artículo usará PHP.

Estos principios establecen prácticas que se prestan al desarrollo de software con consideraciones para su mantenimiento y expansión a medida que el proyecto se amplía. Adoptar estas prácticas también puede ayudar a evitar los aromas de código, refactorizar el código y aprender sobre el desarrollo ágil y adaptativo de software.

SOLID representa:

  • S: (Single) Principio de responsabilidad única
  • O: (Open) Principio abierto-cerrado
  • L: (Liskov) Principio de sustitución de Liskov
  • I: (Interface) Principio de segregación de interfaz
  • D: (Dependency) Principio de inversión de dependencia

En este artículo, se le presentará cada principio por separado para comprender la forma en que SOLID puede ayudarlo a ser un mejor desarrollador.

Principio de responsabilidad única

El principio de responsabilidad única (SRP) establece:

Una clase debe tener una y una sola razón para cambiar, lo que significa que una clase debe tener solo un trabajo.

Por ejemplo, considere una aplicación que toma una colección de formas, entre círculos y cuadrados, y calcula la suma del área de todas las formas de la colección.

Primero, cree las clases de forma y haga que los constructores configuren los parámetros requeridos.

Para las cuadrados, deberá saber la longitud de un lado:

class Square{ public $length; public function construct($length) { $this->length = $length; }}

Para los círculos, deberá saber el radio:

class Circle{ public $radius; public function construct($radius) { $this->radius = $radius; }}

A continuación, cree la clase AreaCalculator y luego escriba la lógica para sumar las áreas de todas las formas proporcionadas. El área de un cuadrado se calcula por longitud al cuadrado. El área de un círculo se calcula mediante pi por el radio al cuadrado.

class AreaCalculator{ protected $shapes; public function __construct($shapes = []) { $this->shapes = $shapes; } public function sum() { foreach ($this->shapes as $shape) { if (is_a($shape, 'Square')) { $area[] = pow($shape->length, 2); } elseif (is_a($shape, 'Circle')) { $area[] = pi() * pow($shape->radius, 2); } } return array_sum($area); } public function output() { return implode('', [ '', 'Sum of the areas of provided shapes: ', $this->sum(), '', ]); }}

Para usar la clase AreaCalculator, deberá crear una instancia de la clase y pasar una matriz de formas para mostrar el resultado en la parte inferior de la página.

A continuación, se muestra un ejemplo con una colección de tres formas:

(Video) Los principios SOLID, ¡explicados!

  • un círculo con un radio de 2
  • un cuadrado con una longitud de 5
  • un segundo cuadrado con una longitud de 6
$shapes = [ new Circle(2), new Square(5), new Square(6),];$areas = new AreaCalculator($shapes);echo $areas->output();

El problema con el método de salida es que AreaCalculator maneja la lógica para generar los datos.

Considere un escenario en el que el resultado debe convertirse a otro formato como JSON.

La clase AreaCalculator manejaría toda la lógica. Esto violaría el principio de responsabilidad única. La clase AreaCalculator solo debe ocuparse de la suma de las áreas de las formas proporcionadas. No debería importar si el usuario desea JSON o HTML.

Para abordar esto, puede crear una clase SumCalculatorOutputter por separado y usarla para manejar la lógica que necesita para mostrar los datos al usuario:

class SumCalculatorOutputter{ protected $calculator; public function __constructor(AreaCalculator $calculator) { $this->calculator = $calculator; } public function JSON() { $data = [ 'sum' => $this->calculator->sum(), ]; return json_encode($data); } public function HTML() { return implode('', [ '', 'Sum of the areas of provided shapes: ', $this->calculator->sum(), '', ]); }}

La clase SumCalculatorOutputter funcionaría así:

$shapes = [ new Circle(2), new Square(5), new Square(6),];$areas = new AreaCalculator($shapes);$output = new SumCalculatorOutputter($areas);echo $output->JSON();echo $output->HTML();

Ahora, la clase SumCalculatorOutputter maneja cualquier lógica que necesite para enviar los datos al usuario.

Eso cumple con el principio de responsabilidad única.

Principio abierto-cerrado

Principio abierto-cerrado (S.R.P.) establece:

Los objetos o entidades deben estar abiertos por extensión, pero cerrados por modificación.

Esto significa que una clase debe ser ampliable sin modificar la clase en sí.

Volvamos a ver la clase AreaCalculator y enfoquémonos en el método sum:

class AreaCalculator{ protected $shapes; public function __construct($shapes = []) { $this->shapes = $shapes; } public function sum() { foreach ($this->shapes as $shape) { if (is_a($shape, 'Square')) { $area[] = pow($shape->length, 2); } elseif (is_a($shape, 'Circle')) { $area[] = pi() * pow($shape->radius, 2); } } return array_sum($area); }}

Considere un escenario en el que el usuario desea la sum de formas adicionales como triángulos, pentágonos, hexágonos, etc. Tendría que editar constantemente este archivo y añadir más bloques if/else. Eso violaría el principio abierto-cerrado.

Una forma de mejorar el método sum es eliminar la lógica para calcular el área de cada forma fuera del método de la clase AreaCalculator y adjuntarlo a la clase de cada forma.

A continuación, se muestra area definido en Square:

(Video) Principios de Diseño Orientado a Objetos

class Square{ public $length; public function __construct($length) { $this->length = $length; } public function area() { return pow($this->length, 2); }}

Y aquí es el método area definido en Circle:

class Circle{ public $radius; public function construct($radius) { $this->radius = $radius; } public function area() { return pi() * pow($shape->radius, 2); }}

El método sum para AreaCalculator puede reescribirse así:

class AreaCalculator{ // ... public function sum() { foreach ($this->shapes as $shape) { $area[] = $shape->area(); } return array_sum($area); }}

Ahora, puede crear otra clase de forma y pasarla al calcular la suma sin romper el código.

Sin embargo, ahora surge otro problema: ¿Cómo sabe que el objeto pasado a AreaCalculator es realmente una forma o si la forma tiene un método llamado area?

La codificación de una interface es una parte integral de SOLID.

Cree un ShapeInterface que sea compatible con area:

interface ShapeInterface{ public function area();}

Modifique sus clases de forma para implement el ShapeInterface.

A continuación, se muestra la actualización a Square:

class Square implements ShapeInterface{ // ...}

Y aquí está la actualización a Circle:

class Circle implements ShapeInterface{ // ...}

En el método sum para AreaCalculator, puede verificar si las formas proporcionadas son realmente instancias de ShapeInterface; de lo contrario, lanzamos una excepción:

 class AreaCalculator{ // ... public function sum() { foreach ($this->shapes as $shape) { if (is_a($shape, 'ShapeInterface')) { $area[] = $shape->area(); continue; } throw new AreaCalculatorInvalidShapeException(); } return array_sum($area); }}

Eso cumple con el principio abierto-cerrado.

Principio de sustitución de Liskov

El principio de sustitución de Liskov establece:

Digamos que q(x) sea una propiedad demostrable sobre objetos de x, de tipo T. Entonces, q(y) debe ser demostrable para los objetos y, de tipo S, donde S es un subtipo de T.

Esto significa que cada subclase o clase derivada debe ser sustituible por su clase base o clase principal.

(Video) Cómo implementar los principios SOLID en JAVA

A partir de la clase AreaCalculator mostrada como ejemplo, considere una nueva clase VolumeCalculator que extiende la clase AreaCalculator:

class VolumeCalculator extends AreaCalculator{ public function construct($shapes = []) { parent::construct($shapes); } public function sum() { // logic to calculate the volumes and then return an array of output return [$summedData]; }}

Recuerde que la clase SumCalculatorOutputter se asemeja a esto:

class SumCalculatorOutputter { protected $calculator; public function __constructor(AreaCalculator $calculator) { $this->calculator = $calculator; } public function JSON() { $data = array( 'sum' => $this->calculator->sum(); ); return json_encode($data); } public function HTML() { return implode('', array( '', 'Sum of the areas of provided shapes: ', $this->calculator->sum(), '' )); }}

Si intenta ejecutar un ejemplo como este:

$areas = new AreaCalculator($shapes);$volumes = new VolumeCalculator($solidShapes);$output = new SumCalculatorOutputter($areas);$output2 = new SumCalculatorOutputter($volumes);

Cuando invoca el método HTML en el objeto $output2, obtendrá un error E_NOTICE que le informará de conversión de matriz a cadena.

Para solucionar esto, en vez de devolver una matriz desde el método sum de la clase VolumeCalculator, devuelva $summedData:

class VolumeCalculator extends AreaCalculator{ public function construct($shapes = []) { parent::construct($shapes); } public function sum() { // logic to calculate the volumes and then return a value of output return $summedData; }}

$summedData puede ser float, double o integer.

Eso cumple con el principio de sustitución de Liskov.

Principio de segregación de interfaz

El principio de segregación de interfaz establece:

Un cliente nunca debe ser forzado a implementar una interfaz que no usan ni los clientes no deben ser forzados a depender de métodos que no usan.

Siguiendo con el ejemplo anterior de ShapeInterface, tendrá que admitir las nuevas formas tridimensionales de Cuboid y Spheroid, y estas formas también tendrán que calcular el volumen.

Consideraremos lo que sucedería si modificara ShapeInterface para añadir otro contrato:

interface ShapeInterface{ public function area(); public function volume();}

Ahora, cualquier forma que cree debe implementar el método volume, pero sabemos que las cuadrados son formas planas y que no tienen volumen, por lo que esta interfaz forzaría a la clase Square a implementar un método que no usa.

Esto violaría el principio de segregación de interfaz. En su lugar, podría crear otra interfaz llamada ThreeDimensionalShapeInterface que tiene el contrato de volume y las formas tridimensionales pueden implementar esta interfaz:

interface ShapeInterface{ public function area();}interface ThreeDimensionalShapeInterface{ public function volume();}class Cuboid implements ShapeInterface, ThreeDimensionalShapeInterface{ public function area() { // calculate the surface area of the cuboid } public function volume() { // calculate the volume of the cuboid }}

Este es un enfoque mucho mejor, pero hay que tener cuidado cuando se trata de escribir estas interfaces En vez de usar un ShapeInterface o un ThreeDimensionalShapeInterface, puede crear otra interfaz, quizá ManageShapeInterface e implementarla en las formas planas y en las tridimensionales.

(Video) Los Principios SOLID explicados ¡Con ejemplos! 100% PRÁCTICO

De esta manera, puede tener una sola API para administrar las formas:

interface ManageShapeInterface{ public function calculate();}class Square implements ShapeInterface, ManageShapeInterface{ public function area() { // calculate the area of the square } public function calculate() { return $this->area(); }}class Cuboid implements ShapeInterface, ThreeDimensionalShapeInterface, ManageShapeInterface{ public function area() { // calculate the surface area of the cuboid } public function volume() { // calculate the volume of the cuboid } public function calculate() { return $this->area(); }}

Ahora en la clase AreaCalculator, puede sustituir la invocación al método area con calculate y también verificar si el objeto es una instancia de ManageShapeInterface y no de ShapeInterface.

Eso cumple con el principio de segregación de interfaz.

Principio de inversión de dependencia

El principio de inversión de dependencia establece:

Las entidades deben depender de abstracciones, no de concreciones. Indica que el módulo de alto nivel no debe depender del módulo de bajo nivel, sino que deben depender de las abstracciones.

Este principio permite el desacoplamiento.

A continuación, se muestra un ejemplo de un PasswordReminder que se conecta a una base de datos de MySQL:

class MySQLConnection{ public function connect() { // handle the database connection return 'Database connection'; }}class PasswordReminder{ private $dbConnection; public function __construct(MySQLConnection $dbConnection) { $this->dbConnection = $dbConnection; }}

Primero, MySQLConnection es el módulo de bajo nivel mientras que PasswordReminder es de alto nivel, pero según la definición de D en SOLID, que establece que Depende de la abstracción y no de las concreciones. Este fragmento de código anterior viola este principio, ya que se está forzando a la clasevPasswordReminder a depender de la clase MySQLConnection.

Si más adelante cambiara el motor de la base de datos, también tendría que editar la clase PasswordReminder, y esto violaría el principio abierto-cerrado.

A la clase PasswordReminder no le debe importar qué base de datos usa su aplicación. Para solucionar estos problemas, se puede codificar a una interfaz, ya que los módulos de alto nivel y bajo nivel deben depender de la abstracción:

interface DBConnectionInterface{ public function connect();}

La interfaz tiene un método connect y la clase MySQLConnection implementa esta interfaz. Además, en lugar de escribir directamente la clase MySQLConnection en el constructor del PasswordReminder, se indica la clase DBConnectionInterface y, sin importar el tipo de base de datos que utilice su aplicación, la clase PasswordReminder puede conectarse sin ningún problema a la base de datos y no se viola el principio abierto-cerrado.

class MySQLConnection implements DBConnectionInterface{ public function connect() { // handle the database connection return 'Database connection'; }}class PasswordReminder{ private $dbConnection; public function __construct(DBConnectionInterface $dbConnection) { $this->dbConnection = $dbConnection; }}

Este código establece que los módulos de alto nivel y los de bajo nivel dependen de la abstracción.

Conclusión

En este artículo, se le presentaron los cinco principios del código SOLID. Los proyectos que se adhieren a los principios SOLID pueden compartirse con los colaboradores, ampliarse, modificarse, probarse y refactorizarse con menos complicaciones.

Continúe aprendiendo leyendo sobre otras prácticas para el desarrollo ágil y adaptativo de software.

(Video) Principios de diseño SOLID

FAQs

¿Qué es el principio SOLID? ›

Los Principios SOLID tienen cinco principios de diseño de clases Orientado a Objetos. Son un conjunto de reglas y mejores prácticas a seguir al diseñar una estructura de clase. Estos cinco principios nos ayudan a comprender la necesidad de ciertos patrones de diseño y arquitectura de software en general.

¿Qué son los principios Solid en Java? ›

Este principio establece que los clientes no deben ser forzados a depender de interfaces que no utilizan. Es importante que cada clase implemente las interfaces que va a utilizar. De este modo, agregar nuevas funcionalidades o modificar las existentes será más fácil.

¿Qué es el patrón SOLID? ›

Solid es un acrónimo inventado por Robert C. Martin para establecer los cinco principios básicos de la programación orientada a objetos y diseño. Este acrónimo tiene bastante relación con los patrones de diseño, en especial, con la alta cohesión y el bajo acoplamiento.

¿Qué es SOLID en programación? ›

Principio de responsabilidad única, en inglés Single Responsability Principle: consiste en que un módulo o clase debe ser responsable solo de una parte de la funcionalidad del código. Con esto, si llega a existir una razón para cambiar algo, no será necesario reescribir todo.

¿Cuáles son los 5 principios Solid? ›

  • Principio de responsabilidad única.
  • Principio abierto-cerrado.
  • Principio de sustitución de Liskov.
  • Principio de segregación de interfaz.
  • Principio de inversión de dependencia.
  • Conclusión.
Feb 19, 2021

¿Cuántos principios tiene SOLID? ›

Los principios SOLID

O – Open/Closed Principle (OCP) L – Liskov Substitution Principle (LSP) I – Interface Segregation Principle (ISP) D – Dependency Inversion Principle (DIP)

¿Qué beneficios aporta usar los principios Solid? ›

Los Principios Solid indican cómo organizar funciones y estructuras de datos en componentes y cómo dichos componentes deben estar interconectados. Normalmente estos componentes suelen ser clases, aunque esto no implica que dichos principios sólo sean aplicables a ellas.

¿Cuáles son los principios de diseño de software? ›

Los principios de desarrollo de software son una serie de reglas y recomendaciones específicas que los programadores deben seguir durante el desarrollo si quieren escribir un código limpio, comprensible y fácil de mantener.

¿Cuáles son los principios GRASP? ›

Los principios del Software de Asignación de Responsabilidad General, abreviados como GRASP, son un conjunto de principios que resuelven algún problema del software común a muchos proyectos de desarrollo.

¿Qué es SOLID en C#? ›

Algunos principios de desarrollo de software fantásticos se han reunido bajo el acrónimo SOLID: Single responsibility (responsabilidad única), Open for extension and closed for modification (abierto a extensiones y cerrado a modificaciones), Liskov substitution (sustitución de Liskov), Interface segregation ( ...

¿Qué es SOLID en javascript? ›

SOLID es un acrónimo de los primeros 5 principios de ODD, estos hacen la vida más fácil para un programador, contando con las siguientes ventajas: Código mantenible. Sencillo de hacer cambios y escalar. Hace que su refactorización sea rápida.

¿Qué es SOLID en Python? ›

SOLID es el acrónimo mnemónico que hace referencia a cada uno de los principios por sus siglas en inglés. Estas siglas son: Single Responsibility Principle (SRP) o Principio de Responsabilidad Única. Open-Closed Principle (OCP) o Principio de Abierto/Cerrado.

¿Qué son los principios en programación? ›

Son colecciones de variables, una serie de valores a los que accedemos mediante una sola referencia. Con este conjunto de instrucciones podemos crear cualquier programa, desde una calculadora sencilla, pasando por lectura y escritura de archivos, hasta un videojuego.

¿Cuáles son los patrones de diseño en Java? ›

Resumiendo, los patrones de diseño en Java son soluciones generales y reutilizables a problemas que se encuentran con relativa frecuencia en la programación con este sistema.

¿Qué son los patrones de diseño de software? ›

Los patrones de diseño (design patterns) son elementos reutilizables creados para resolver problemas comunes. Es decir que con su aplicación y utilización podremos corregir diferentes problemas que presenta nuestro código de una manera segura, estable y testeada por cientos de programadores de todo el mundo.

¿Qué principio nos dice que en un programa se debe permitir modificaciones? ›

O: Open / Closed Principle

El principio Open/Closed dice que una clase/método debe estar abierto a extensiones pero cerrado a modificaciones.

¿Qué principio dice que una clase debería ocuparse de un solo menester? ›

Single Responsibility Principle (SRP) El principio que da origen a la S de S.O.L.I.D es el de una única responsabilidad y dice que cada clase debe ocuparse de un solo menester.

¿Qué son los 7 principios fundamentales? ›

Humanidad, Imparcialidad, Neutralidad, Independencia, Voluntariado, Unidad y Universalidad.

¿Cuántos son los principios fundamentales? ›

Humanidad, imparcialidad, neutralidad, inde- pendencia, voluntariado, unidad y universalidad: estos siete Principios Fundamentales resumen la ética del Movimiento y constituyen la esen- cia de su modo de proceder cuando ayuda a las personas necesitadas durante los conflictos armados, los desastres naturales y otras ...

¿Qué es y para qué sirve el Solidwork? ›

Los principios SOLID nos permiten administrar la mayoría de problemas de diseño de software, y si seguimos los mismos, vamos a conseguir desarrollar un código más limpio, más mantenible, más escalable a futuro y menos propenso a errores.

¿Cuáles son los elementos principales de un objeto? ›

Los objetos se componen de 3 partes fundamentales: metodos, eventos y atributos.

¿Cuántos tipos de programación orientada a objetos hay? ›

En la actualidad existen diferentes lenguajes de programación orientada a objetos, como C++, Objective C, Java, Ruby, Visual Basic, Visual C Sharp, Simula, Perl, TypeScript, Smalltalk, PHP o Python.

¿Qué es una interfaz orientada a objetos? ›

Una interfaz es un conjunto de métodos y propiedades que no tiene ninguna implementación. La implementación la va a hacer cada uno de los elementos que herede de la interfaz dependiendo de sus necesidades.

¿Qué es la programación limpia? ›

"El código limpio es simple y sencillo. Un código limpio se lee como una prosa bien escrita. El código limpio nunca oscurece la intención del diseñador, sino que se completa con abstracciones nítidas y líneas de control sencillas".

¿Cuándo desarrollar un sistema debes hacer que cumpla con los principios básicos cuáles son estos principios? ›

Los principios en los que se basa SOLID son los siguientes:
  • Principio de Responsabilidad Única (Single Responsibility Principle)
  • Principio Open/Closed (Open/Closed Principle)
  • Principio de Sustitución de Liskov (Liskov Substitution Principle)
  • Principio de Segregación de Interfaces (Interface Segregation Principle)

¿Cuántos son los principios de diseño? ›

Seis son los principios básicos del diseño: balance, proximidad, alineación, repetición, contraste y espacio. Unos principios que ayudan a su vez a combinar los 6 elementos básicos: línea, forma, dirección, tamaño, textura y color. Su combinación dependerá, en gran medida, de la habilidad e intención del autor.

¿Qué son los principios básicos? ›

Los valores y principios básicos, son los que fundamentan a la organización, a la gestión interna y a la acción externa en la sociedad, en el Estado y en la Comunidad Internacional.

¿Qué son los principios del diseño? ›

Los principios del diseño son lo que diferencia a un diseño meditado y trabajado del resto. No debemos pasar por alto, que el fin último de cualquier pieza de diseño gráfico es causar una impresión, preferiblemente una duradera.

¿Qué son los patrones GRASP y GoF? ›

Los GRASP no implementan las soluciones, más bien nos llevan a pensar en el diseño, a nivel de principios generales (más principios de DOO...); mientras que los GoF nos dan una solución implementable con su propio diagrama de clases que nos muestra la forma en que debemos usarlos.

¿Qué significa la siglas GRASP? ›

GRASP es la abreviatura de “GLOBALGAP Risk Assessment on Social Practices” (Evaluación de Riesgos en las Prácticas Sociales). El Módulo GRASP es una herramienta que ayuda a los productores a demostrar su cumplimiento con la legislación laboral, tanto internacional como nacional.

¿Cómo se clasifican los patrones GoF? ›

Los patrones que se agrupan en esta categoría son once (11): Interpreter, Template Method, Chain of Responsibility, Command, Iterator, Mediator, Memento, Observer, State, Strategy, Visitor.

¿Cómo se escribe SOLID? ›

Sebastian wasn't able to eat solid food for two weeks after his surgery. Sebastián no pudo comer alimentos sólidos durante dos semanas después de la cirugía.

¿Qué es SOLID and Clean Code? ›

SOLID es un acrónimo presentado por Uncle Bob a principios del año 2000, representa los 5 principios básicos de la programación orientada a objetos. El termino Clean Code proviene del libro Clean Code: A Handbook of Agile Software Craftsmanship de Uncle Bob.

¿Qué indica el principio abierto cerrado? ›

El principio abierto/cerrado expresa la necesidad de que ante un cambio de los requisitos, el diseño de las entidades existentes permanezca inalterado, recurriéndose a la extensión del comportamiento de dichas entidades añadiendo nuevo código, pero nunca cambiando el código ya existente.

¿Qué es SOLID en react? ›

Los principios solid son el fundamento para crear y aplicar patrones de diseño en el desarrollo de software en general. Como hemos visto antes, podemos aplicar estos principios por medio de "patrones de diseño" al estilo de React JS.

¿Cuando implementamos el patrón Singleton cual principio SOLID se infringe o viola? ›

Agregarle a cualquier clase otra responsabilidad implica violar el principio de responsabilidad único (la S de Solid).

¿Qué indica el principio de responsabilidad única elabore un ejemplo de código? ›

S: Principio de responsabilidad única

Si por el contrario, una clase tiene varias responsabilidades, esto implica que el cambio en una responsabilidad provocará la modificación en otra responsabilidad. Considera este ejemplo: class Coche { String marca; Coche(String marca){ this.

¿Que nos enseña el Dependency Inversion Principle? ›

Este principio especifica cómo deben ser las relaciones entre componentes para evitar el acoplamiento entre los distintos módulos de un software.

¿Qué son los 4 principios lógicos? ›

Principios Lógicos Supremos: identidad, no contradicción, tercer excluso y razón suficiente.

¿Cuáles son los principios basicos del lenguaje? ›

Los principios hacen referencia a las propiedades generales del lenguaje humano; son abstractos, comunes a todas las lenguas, (por lo tanto, universales) e innatos. En cambio, los parámetros hacen referencia a las distintas opciones que cada lengua adopta, son concretos, particulares de cada lengua y aprendidos.

¿Cuándo usar Prototype? ›

Aplicabilidad. Utiliza el patrón Prototype cuando tu código no deba depender de las clases concretas de objetos que necesites copiar. Esto sucede a menudo cuando tu código funciona con objetos pasados por código de terceras personas a través de una interfaz.

¿Cómo se clasifican los patrones de diseño? ›

definen que “un patrón de diseño es una abstracción de una solución en un nivel alto. Los patrones solucionan problemas que existen en muchos niveles de abstracción” y los clasificaron en 3 grandes categorías basadas en su propósito: creacionales, estructurales y de comportamiento.

¿Cuándo usar Abstract Factory? ›

El patrón Abstract Factory está aconsejado cuando se prevé la inclusión de nuevas familias de productos, pero puede resultar contraproducente cuando se añaden nuevos productos o cambian los existentes, puesto que afectaría a todas las familias creadas.

¿Qué es SOLID en Android? ›

Son un conjunto de principios aplicables a la Programación Orientada a Objetos que, si los usas correctamente, te ayudarán a escribir software de calidad en cualquier lenguaje de programación orientada a objetos. Gracias a ellos, crearás código que será más fácil de leer, testear y mantener.

¿Cuáles son los principios de la calidad de software? ›

Principio 3: Para gestionar la calidad los desarrolladores deben medirla. Principio 4: La calidad de un producto la determina el proceso usado para desarrollarlo. Principio 5: Ya que las pruebas solucionan solo una fracción de los defectos, debes tener pruebas de calidad.

¿Cuáles son los principios de desarrollo de software? ›

Los principios de desarrollo de software son una serie de reglas y recomendaciones específicas que los programadores deben seguir durante el desarrollo si quieren escribir un código limpio, comprensible y fácil de mantener.

¿Qué son los patrones de diseño en javascript? ›

¿Qué es un patrón de diseño? Los patrones de diseño son unas técnicas para resolver problemas comunes en el desarrollo de software y otros ámbitos referentes al diseño de interacción o interfaces.

¿Que nos enseña el interface Segregation Principle? ›

El principio de segregación de interfaces se relaciona también con un concepto de herencia, particularmente sobre la implementación de métodos a partir de clases abstractas e interfaces. Se puede definir simplemente de la siguiente manera: Los clientes no deben ser forzados a depender de métodos que no utilizan.

Videos

1. Los increíbles PRINCIPIOS SOLID en la programación 🧱 ¿Que son y para que sirven? ¿Son útiles o no? 🤔
(Victor Robles WEB)
2. Diseño luego Programo: Principios de Diseño SOLID
(Catch Exception Canal)
3. Principios SOLID en React.js (Buenas prácticas) con ejemplos prácticos
(midulive)
4. Los principios SOLID fácil y rápido teoría + código
(Debuggeando Ideas)
5. 🟥 Principios SOLID - 5 + 1 Reglas que CAMBIARÁN tu forma de PROGRAMAR [2022]
(DevExperto - Formación Android & Kotlin)
6. Desarrollando software robusto utilizando los principios de diseño SOLID
(Software Guru)
Top Articles
Latest Posts
Article information

Author: Virgilio Hermann JD

Last Updated: 02/23/2023

Views: 5632

Rating: 4 / 5 (41 voted)

Reviews: 80% of readers found this page helpful

Author information

Name: Virgilio Hermann JD

Birthday: 1997-12-21

Address: 6946 Schoen Cove, Sipesshire, MO 55944

Phone: +3763365785260

Job: Accounting Engineer

Hobby: Web surfing, Rafting, Dowsing, Stand-up comedy, Ghost hunting, Swimming, Amateur radio

Introduction: My name is Virgilio Hermann JD, I am a fine, gifted, beautiful, encouraging, kind, talented, zealous person who loves writing and wants to share my knowledge and understanding with you.