Merge pull request mouredev#4768 from AmadorQuispe/aqh

#10 - GO

Author: Roswell468

Roadmap/10 - EXCEPCIONES/go/AmadorQuispe.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+)
+
+//De manera general, GO representa cualquier tipo de error mediante la interfaz error:
+
+func main() {
+	//División por cero
+	if res, err := divideTwoNumbers(10, 0); err == nil {
+		fmt.Println(res)
+	} else {
+		fmt.Println(err)
+	}
+
+	//Indice fuera de rango
+	numbers := []int{1, 2, 3, 4, 5, 6}
+	val, err := getElementByIndex(numbers, 6)
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Println(val)
+
+	}
+
+	//Error personalizado
+	result, err := divisionPositive(-34, 3)
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Println(result)
+	}
+}
+
+func divideTwoNumbers(a, b int) (int, error) {
+	if b == 0 {
+		return 0, errors.New("cannot divide by zero")
+	}
+	return a / b, nil
+}
+
+func getElementByIndex[T any](slice []T, i int) (T, error) {
+	if len(slice) >= i {
+		var zeroValue T
+		return zeroValue, errors.New("index of range! it must be less than " + strconv.Itoa(i))
+	}
+	return slice[i], nil
+}
+
+type CustomError struct {
+	msg string
+}
+
+func (ce *CustomError) Error() string {
+	return ce.msg
+}
+
+func divisionPositive(numerator, denominator int) (int, error) {
+	if numerator < 0 || denominator < 0 {
+		return 0, &CustomError{msg: "not valid numbers negatives"}
+	}
+	return numerator / denominator, nil
+}

Roadmap/27 - SOLID OCP/go/AmadorQuispe.go

@@ -0,0 +1,168 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"math"
+)
+
+type ReportServiceBad[T any] struct {
+	data T
+}
+
+func (rs *ReportServiceBad[T]) ReportGenerator(typeReport string) {
+	if typeReport == "PDF" {
+		fmt.Println(rs.data)
+		fmt.Println("Generando reporte PDF")
+	} else if typeReport == "HTML" {
+		fmt.Println(rs.data)
+		fmt.Println("Generando reporte HTML")
+	}
+}
+
+// Re factorización para cumplir el OCP
+// ReportGenerator, interfaz que define el comportamiento de un generador de reportes
+type ReportGenerator interface {
+	GenerateReport(data interface{})
+}
+
+// PDFReportGenerator, implementación de ReportGenerator para reportes PDF
+type PDFReportGenerator struct{}
+
+func (p *PDFReportGenerator) GenerateReport(data interface{}) {
+	fmt.Println(data)
+	fmt.Println("Generando reporte PDF")
+}
+
+// HTMLReportGenerator, implementación de ReportGenerator para reportes HTML
+type HTMLReportGenerator struct{}
+
+func (h *HTMLReportGenerator) GenerateReport(data interface{}) {
+	fmt.Println(data)
+	fmt.Println("Generando reporte HTML")
+}
+
+// ReportService usa un generador de reportes para generar reportes
+type ReportService struct {
+	data      interface{}
+	reportGen ReportGenerator
+}
+
+func (rs *ReportService) GenerateReport() {
+	rs.reportGen.GenerateReport(rs.data)
+}
+
+// EXTRA
+type Operation interface {
+	Apply(num1, num2 float32) (float32, error)
+}
+
+// SUMA
+type Addition struct{}
+
+func (a *Addition) Apply(num1, num2 float32) (float32, error) {
+	return num1 + num2, nil
+}
+
+// RESTA
+type Subtraction struct{}
+
+func (a *Subtraction) Apply(num1, num2 float32) (float32, error) {
+	return num1 - num2, nil
+}
+
+// MULTIPLICACIÓN
+type Multiplication struct{}
+
+func (a *Multiplication) Apply(num1, num2 float32) (float32, error) {
+	return num1 * num2, nil
+}
+
+// DIVISIÓN
+type Division struct{}
+
+func (a *Division) Apply(num1, num2 float32) (float32, error) {
+	if num2 == 0 {
+		return 0, errors.New("division by zero")
+	}
+	return num1 / num2, nil
+}
+
+// POTENCIA
+type Pow struct{}
+
+func (a *Pow) Apply(num1, num2 float32) (float32, error) {
+	return float32(math.Pow(float64(num1), float64(num2))), nil
+}
+
+// Calculator usa una operación para calcular un resultado
+type Calculator struct{}
+
+func (c *Calculator) Calculate(operation Operation, num1, num2 float32) (float32, error) {
+	return operation.Apply(num1, num2)
+}
+
+func main() {
+	//VIOLA OCP
+	reportServiceBad := ReportServiceBad[string]{data: "data de ejemplo bad"}
+	reportServiceBad.ReportGenerator("PDF")
+
+	//OCP
+	data := "Datos de ejemplo"
+	pdfGenerator := &PDFReportGenerator{}
+	htmlGenerator := &HTMLReportGenerator{}
+
+	pdfReportService := &ReportService{data: data, reportGen: pdfGenerator}
+	htmlReportService := &ReportService{data: data, reportGen: htmlGenerator}
+
+	pdfReportService.GenerateReport()
+	htmlReportService.GenerateReport()
+
+	//CALCULATOR
+	num1 := float32(10)
+	num2 := float32(5)
+
+	calculator := &Calculator{}
+
+	addition := &Addition{}
+	subtraction := &Subtraction{}
+	multiplication := &Multiplication{}
+	division := &Division{}
+
+	result, err := calculator.Calculate(addition, num1, num2)
+	if err != nil {
+		fmt.Println("Error:", err)
+	} else {
+		fmt.Println("Suma:", result)
+	}
+
+	result, err = calculator.Calculate(subtraction, num1, num2)
+	if err != nil {
+		fmt.Println("Error:", err)
+	} else {
+		fmt.Println("Resta:", result)
+	}
+
+	result, err = calculator.Calculate(multiplication, num1, num2)
+	if err != nil {
+		fmt.Println("Error:", err)
+	} else {
+		fmt.Println("Multiplicación:", result)
+	}
+
+	result, err = calculator.Calculate(division, num1, num2)
+	if err != nil {
+		fmt.Println("Error:", err)
+	} else {
+		fmt.Println("División:", result)
+	}
+
+	//Potencia
+	pow := &Pow{}
+	result, err = calculator.Calculate(pow, num1, num2)
+	if err != nil {
+		fmt.Println("Error:", err)
+	} else {
+		fmt.Println("Potencia:", result)
+	}
+}

Roadmap/27 - SOLID OCP/java/AmadorQuispe.java

@@ -0,0 +1,103 @@
+package com.amsoft.roadmap.example27;
+
+import java.util.Map;
+
+public class Example27 {
+    public static void main(String[] args) {
+        Report report = new HTMLReport();
+        report.generate();
+
+        Calculator calculator = new Calculator();
+        System.out.println("La suma de 5 + 6 es: " + calculator.calculate(new Addition(),5,6));
+        System.out.println("La resta de 10 - 6 es: " + calculator.calculate(new Subtraction(),10,6));
+        System.out.println("La multiplicación de 10 * 6 es: " + calculator.calculate(new Multiplication(),10,6));
+        System.out.println("La división de 10 / 2 es: " + calculator.calculate(new Division(),10,2));
+        System.out.println("La potencia de 9 elevado 3 es: " + calculator.calculate(new Pow(),9,3));
+    }
+}
+//Viola OCP, si queremos agregar un reporte Excel debemos modificar la clase, agregando un if
+/*class ReportGenerator{
+    public void generateReport(String type){
+        if(type.equals("PDF")){
+            System.out.println("Generando reporte PDF");
+        } else if (type.equals("HTML")) {
+            System.out.println("Generando reporte HTML");
+        }
+    }
+}*/
+
+
+//Cumple OCP, declaramos un interfaz con un método que debe implementar las clases concretas
+//Si queremos agregar un reporte Excel simplemente creamos una clase que implementa la interfaz
+interface Report{
+    void generate();
+}
+
+class PDFReport implements Report{
+
+    @Override
+    public void generate() {
+        System.out.println("Generando reporte PDF");
+    }
+}
+
+class HTMLReport implements Report{
+
+    @Override
+    public void generate() {
+        System.out.println("Generando reporte HTML");
+    }
+}
+
+
+
+
+//EXTRA
+interface Operable {
+    double calculate(double num1,double num2);
+}
+
+class Addition implements Operable {
+
+    @Override
+    public double calculate(double num1, double num2) {
+        return num1 + num2;
+    }
+}
+
+class Subtraction implements Operable {
+
+    @Override
+    public double calculate(double num1, double num2) {
+        return num1 - num2;
+    }
+}
+
+class Multiplication implements Operable{
+
+    @Override
+    public double calculate(double num1, double num2) {
+        return num1 * num2;
+    }
+}
+
+class Division implements Operable {
+
+    @Override
+    public double calculate(double num1, double num2) {
+        return num1/num2;
+    }
+}
+
+class Calculator {
+    public double calculate(Operable operation, double num1, double num2){
+        return operation.calculate(num1,num2);
+    }
+}
+class Pow implements Operable {
+
+    @Override
+    public double calculate(double num1, double num2) {
+        return Math.pow(num1,num2);
+    }
+}