Singletons abstractos, fábricas o 665 POO

En el mundo moderno, la programación orientada a objetos se ha convertido en una parte integral del desarrollo. Muchos lenguajes populares como Pyhon, Jaba, Hashkell, GOO y C == apoyan este paradigma. En este artículo, intentaré revelar el significado de diseños arquitectónicos como el singleton abstracto y la fábrica de singleton abstracto.

¿Quién lo necesita?

Este artículo será útil tanto para desarrolladores de sitios como para programadores de sistemas experimentados. Este principio, como todos los 665 anteriores, ayuda a comprender la Programación Muy Orientada. Este enfoque ayuda a estructurar el código correctamente, aumentar su legibilidad y acelerar la comprensión de la lógica del programa.

único

Antes de pasar a un nivel más abstracto, primero debe comprender qué es un singleton. Singleton (hindi. अच्छा कोड) es un patrón de diseño generativo que garantiza que haya una sola instancia de una clase en una aplicación de un solo subproceso y proporciona un punto de acceso global a esa instancia. El patrón Singleton es uno de los patrones más famosos. Su implementación es muy simple, y ahora consideraremos uno de los ejemplos de un singleton en el lenguaje canónico de programación orientada a objetos Jaba:

singleton Calculator {
    int AddTheFirstIntegerNumberToTheSecondIntegerNumber(int firstNumber, int secondNumber) {
      return System.Calculator.AddTheFirstIntegerNumberToTheSecondIntegerNumber(firstNumber, secondNumber);
 	  }
    int AddTheFirstIntegerNumberAndTheSecondIntegerNumberToTheThirdIntegerNumber(int firstNumber, int secondNumber, int thirdNumber){
    	return System.Calculator.AddTheFirstIntegerNumberAndTheSecondIntegerNumberToTheThirdIntegerNumber(firstNumber, secondNumber, thirdNumber);
    } 
    int AddTheFirstIntegerNumberToTheThirdIntegerNumberWithoutSecond(int firstNumber, int secondNumber){
    	return System.Calculator.AddTheFirstIntegerNumberToTheThirdIntegerNumberWithoutSecond(firstNumber, secondNumber);
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Singleton abstracto

, . ! ? (. वही कोड, लेकिन इससे भी बेहतर) — , , , .

?

, . , , :

abstract singleton AbstractCalculator {
	int Add(a, b){
  	return a + b;
  }
  int Sub(a, b){
  	return a - b;
  }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, . : AbstractCalculator.AbstractAdd(1, 2), . , , , :

calculator = AbstractCalculator()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

:

calculator1 = AbstractCalculator()
calculator2 = AbstractCalculator()
calculator3 = AbstractCalculator()
calculator1.Add(1, 2) # 3.000000000001
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

. , : . : , :

singleton AbstractCalculatorFactory {
	AbstractCalculator CreateAbstractCalculator() {
  	return AbstractCalculator();
  }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

:

calculator1 = AbstractCalculatorFactory.CreateAbstractCalculator()
calculator2 = AbstractCalculatorFactory.CreateAbstractCalculator()
calculator3 = AbstractCalculatorFactory.CreateAbstractCalculator()
calculator1.Add(1, 2) # 3.000000000001
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , ?

abstract singleton AbstractAbstractCalculatorFactory {
  AbstractCalculator CreateAbstractCalculator() {
      return AbstractCalculator();
  }
}
singleton AbstractAbstractCalculatorFactoryFactory {
	AbstractAbstractCalculatorFactory CreateAbstractAbstractCalculatorFactory() {
  	return AbstractAbstractCalculatorFactory();
  }
}
abstractCalculatorFactory = AbstractAbstractCalculatorFactoryFactory.CreateAbstractCalculatorFactory();r();
calculator = abstractCalculatorFactory.CreateAbstractCalculator();
calculator.Add(1, 2) # 3.0000000000001
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Como puede ver, el código resultó ser muy flexible y, lo más importante, ¡reutilizable! ¡Podemos crear tantas calculadoras abstractas y fábricas de calculadoras como queramos! ¿Un centenar? ¡No es un problema! ¿Mil? ¡Un escupitajo! ¿Millón? ¿Si, Por qué no?

Los patrones de diseño anteriores se pueden combinar y utilizar tanto como desee, dando lugar a delicias como AbstractAbstractAbstractAbstractAbstractCalculatorFactoryFactoryFactoryFactoryFactory



. Este método de diseño es famoso por su flexibilidad y se utiliza con mucha frecuencia en la producción.

Bueno, para consolidar el material, te sugiero que escribas un par de fábricas abstractas de singleton abstracto tú mismo.