#28 - JavaScript

Author: RicJDev

Roadmap/28 - SOLID LSP/javascript/RicJDev.js

@@ -1,81 +1,122 @@
-/*
- * EJERCICIO:
- * Explora el "Principio SOLID de Sustitución de Liskov (Liskov Substitution Principle, LSP)"
- * y crea un ejemplo simple donde se muestre su funcionamiento
- * de forma correcta e incorrecta.
- *
- * DIFICULTAD EXTRA (opcional):
- * Crea una jerarquía de vehículos. Todos ellos deben poder acelerar y frenar, así como
- * cumplir el LSP.
- * Instrucciones:
- * 1. Crea la clase Vehículo.
- * 2. Añade tres subclases de Vehículo.
- * 3. Implementa las operaciones "acelerar" y "frenar" como corresponda.
- * 4. Desarrolla un código que compruebe que se cumple el LSP.
- */
 //EJERCICIO
+console.log('\nSin LSP');
+class RectangleNoLSP {
+	constructor(height, width) {
+		this.height = height;
+		this.width = width;
+	}
 
-/*
+	getArea() {
+		return this.height * this.width;
+	}
 
-"Si S es un subtipo de T, entonces los objetos de tipo T en un programa de computadora pueden ser sustituidos por objetos de tipo S, sin alterar ninguna de las propiedades deseables de ese programa."
+	rotateToVerticalPosition() {
+		let changeValue = this.height;
 
-*/
-class GeometricShape {
-	constructor() {
-		this.area = this.getArea();
+		if (this.width > this.height) {
+			this.height = this.width;
+			this.width = changeValue;
+		}
 	}
 
-	getArea() {
-		return 1;
+	checkVerticalPosition() {
+		if (this.height > this.width) {
+			console.log('Está en posición vertical');
+		} else {
+			console.log('No está en posición vertical');
+		}
+	}
+}
+
+class SquareNoLSP extends RectangleNoLSP {
+	constructor(side) {
+		super(side, side);
 	}
 }
 
-class Rectangle extends GeometricShape {
+const rectangleNoLSP = new RectangleNoLSP(3, 4);
+const squareNoLSP = new SquareNoLSP(5);
+
+console.log('Área del círculo:', squareNoLSP.getArea());
+console.log('Área del rectángulo:', rectangleNoLSP.getArea());
+
+console.log(rectangleNoLSP.height);
+rectangleNoLSP.checkVerticalPosition();
+
+rectangleNoLSP.rotateToVerticalPosition();
+
+console.log(rectangleNoLSP.height);
+rectangleNoLSP.checkVerticalPosition();
+
+console.log(squareNoLSP.height);
+squareNoLSP.checkVerticalPosition();
+
+squareNoLSP.rotateToVerticalPosition();
+
+console.log(squareNoLSP.height);
+squareNoLSP.checkVerticalPosition();
+
+/*
+En el ejemplo anterior vemos que, si bien un cuadrado podría ser similar a un rectángulo, no son exactamente lo mismo y no se comportan igual. Como esto no se ha tenido en cuenta para el diseño de las clases, al invocar los métodos para ponerlo en posición vertical y verificar si ya lo está, el programa no funciona como debería, lo que en un caso más complejo acarrearía problemas para la reutilización del código y su mantenimiento.
+*/
+
+console.log('\nCon LSP');
+class Quadrilateral {
 	constructor(height, width) {
-		super();
 		this.height = height;
 		this.width = width;
-		this.area = this.getArea();
 	}
 
 	getArea() {
 		return this.height * this.width;
 	}
 }
 
-class Square extends GeometricShape {
-	constructor(height) {
-		super();
-		this.height = height;
-		this.area = this.getArea();
+class Rectangle extends Quadrilateral {
+	constructor(height, width) {
+		super(height, width);
 	}
 
-	getArea() {
-		return this.height ** 2;
-	}
-}
+	rotateToVerticalPosition() {
+		let changeValue = this.height;
 
-class Circle extends GeometricShape {
-	constructor(radius) {
-		super();
-		this.radius = radius;
-		this.area = this.getArea();
+		if (this.width > this.height) {
+			this.height = this.width;
+			this.width = changeValue;
+		}
 	}
 
-	getArea() {
-		return this.radius * 2 * Math.PI;
+	checkVerticalPosition() {
+		if (this.height > this.width) {
+			console.log('Está en posición vertical');
+		} else {
+			console.log('No está en posición vertical');
+		}
 	}
 }
 
-function displayArea(shape) {
-	console.log(shape.area);
+class Square extends Quadrilateral {
+	constructor(side) {
+		super(side, side);
+	}
 }
 
-let square = new Square(12);
+const quadrilateral = new Quadrilateral(12, 10);
+const rectangle = new Rectangle(10, 23);
+const square = new Square(10);
 
-displayArea(square);
+console.log('Área de un cuadrilátero abstracto:', quadrilateral.getArea());
+console.log('Área de un rectángulo:', rectangle.getArea());
+console.log('Área de un cuadrado:', square.getArea());
+
+/*
+"Si S es un subtipo de T, entonces los objetos de tipo T en un programa de computadora pueden ser sustituidos por objetos de tipo S, sin alterar ninguna de las propiedades deseables de ese programa."
+
+En este caso, la capacidad de ponerse en posición vertical es única del rectángulo, y si fuera necesario sustituir un cuadrilátero cualquiera por un rectángulo, seguirán funcionando todos los métodos de la clase del cuadrilátero. Cierto que aquí solo se calcula el área de la figura, pero en un caso más complejo esto es de mucha ayuda y ahorra trabajo. 
+*/
 
 //EXTRA
+console.log('\nJerarquía de vehículos');
 class Vehicle {
 	constructor() {
 		this.speed = 0;