Singletons abstraits, usines ou 665 OOP

Dans le monde moderne, la POO est devenue une partie intégrante du développement. De nombreux langages populaires tels que Pyhon, Jaba, Hashkell, GOO et C == prennent en charge ce paradigme. Dans cet article, je vais essayer de révéler la signification de conceptions architecturales telles que le singleton abstrait et l'usine de singleton abstrait.

Qui en a besoin ?

Cet article sera utile à la fois aux développeurs de sites et aux programmeurs système expérimentés. Ce principe, comme tous les 665 précédents, aide à comprendre la Programmation Très Orientée. Cette approche permet de structurer correctement le code, d'augmenter sa lisibilité et d'accélérer la compréhension de la logique du programme.

Singleton

Avant de passer à un niveau plus abstrait, vous devez d'abord comprendre ce qu'est un singleton. Singleton (hindi. अच्छा कोड) est un modèle de conception générative qui garantit qu'il existe une seule instance d'une classe dans une seule application à thread et fournit un point d'accès global à cette instance. Le modèle Singleton est l'un des modèles les plus connus. Son implémentation est très simple, et nous allons maintenant considérer l'un des exemples de singleton dans le langage canonique de POO 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 abstrait

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

?

, . , , :

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
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Comme vous pouvez le voir, le code s'est avéré très flexible et, surtout, réutilisable ! Nous pouvons créer autant de calculatrices abstraites et d'usines de calculatrices que nous le souhaitons ! Cent? Pas de problème! Mille? Une broche ! Million? Ouais pourquoi pas?

Les modèles de conception ci-dessus peuvent être combinés et utilisés autant que vous le souhaitez, donnant lieu à des délices tels que AbstractAbstractAbstractAbstractAbstractCalculatorFactoryFactoryFactoryFactoryFactory



. Cette méthode de conception est réputée pour sa flexibilité et est très souvent utilisée en production.

Eh bien, pour consolider le matériel, je vous suggère d'écrire vous-même quelques usines abstraites de singleton abstrait.