Modèle singleton
Point central : assurez-vous qu’une classe n’a qu’une seule instance et fournissez un point d’accès global.
Dans le développement réel, nous rencontrons souvent des situations dans lesquelles nous devons limiter une classe à une seule instance, comme les classes d'informations de configuration, les classes de pool de threads, etc. Dans ce cas, nous pouvons utiliser le modèle singleton. Le modèle singleton garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global afin que d'autres objets puissent obtenir des instances de la classe via ce point d'accès.
Lors de la mise en œuvre du modèle singleton, vous pouvez utiliser l'approche paresseuse ou affamée. Le style paresseux signifie que l'instance est instanciée lors du premier accès à l'instance, tandis que le style affamé crée l'instance lorsque la classe est chargée.
Voici un exemple de code simple pour le modèle singleton :
public class Singleton {
private static Singleton instance;
private Singleton() {
// 私有构造方法，防止外部创建实例
}
public static Singleton getInstance() {
if (instance == null) {
// 第一次访问时才进行实例化
instance = new Singleton();
}
return instance;
}
// 其他方法...
}
avantage:
- Cela garantit qu'il n'y a qu'une seule instance dans le monde, économisant ainsi les ressources système.
- Fournit un point d’accès global pour faciliter l’obtention d’instances par d’autres objets.
- Il est également garanti de n'avoir qu'une seule instance dans un environnement multithread.
Comparez avec d'autres modèles similaires :
- Un modèle d'usine simple et un modèle d'usine peuvent également créer des objets, mais ils sont principalement utilisés pour résoudre le problème de la création d'objets, plutôt que de garantir qu'il n'y a qu'une seule instance.
- Le modèle d'usine abstraite peut créer une série d'objets associés, mais son objectif est différent du modèle d'usine singleton. Le modèle d'usine abstraite concerne davantage la création d'un groupe d'objets, tandis que le modèle singleton ne nécessite qu'une seule instance.
- Le modèle de construction peut également créer des objets, mais il s'intéresse davantage au processus de construction et à la représentation d'objets complexes plutôt qu'à la garantie qu'il n'existe qu'une seule instance.
Résumé : Le modèle singleton est un modèle de création couramment utilisé. Il garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global pour obtenir facilement l'instance. L'utilisation du mode singleton peut économiser des ressources système, mais vous devez faire attention à la sécurité dans un environnement multithread. En le comparant avec d'autres modèles similaires, vous pouvez mieux comprendre les avantages et les scénarios applicables du modèle singleton.
Modèle d'usine
Idée de base : définir une interface pour créer des objets, mais laisser la sous-classe décider quelle classe instancier.
En programmation orientée objet, nous rencontrons souvent des situations où nous devons créer plusieurs objets avec certaines caractéristiques communes. Dans ce cas, nous pouvons utiliser le modèle d'usine pour gérer la création d'objets. Le modèle d'usine définit une interface pour créer des objets, mais la classe spécifique d'objets à créer est déterminée par la sous-classe.
Voici un exemple de code pour un modèle d'usine simple :
public interface Product {
void show();
}
public class ProductA implements Product {
@Override
public void show() {
System.out.println("This is product A.");
}
}
public class ProductB implements Product {
@Override
public void show() {
System.out.println("This is product B.");
}
}
public interface Factory {
Product createProduct();
}
public class FactoryA implements Factory {
@Override
public Product createProduct() {
return new ProductA();
}
}
public class FactoryB implements Factory {
@Override
public Product createProduct() {
return new ProductB();
}
}
public class Client {
public static void main(String[] args) {
Factory factory = new FactoryA();
Product product = factory.createProduct();
product.show();
}
}
avantage:
- Séparez la création et l'utilisation des objets, les utilisateurs ne se soucient que de l'interface et n'ont pas besoin de se soucier de la classe d'implémentation spécifique.
- Conformément au principe d'ouverture et de fermeture, lors de l'ajout d'un produit spécifique, il vous suffit d'écrire la classe de produit spécifique et la classe d'usine correspondantes, et il n'est pas nécessaire de modifier d'autres codes.
Comparez avec d'autres modèles similaires :
- Le modèle d'usine simple peut également créer des objets, mais il place la logique de création d'objet dans une classe d'usine, violant ainsi le principe d'ouverture-fermeture.
- Le modèle singleton garantit qu’il n’existe qu’une seule instance globalement et ne convient pas à la création de plusieurs objets ayant les mêmes caractéristiques.
- Le modèle d'usine abstrait est utilisé pour créer une série d'objets liés. La différence avec le modèle d'usine est que le modèle d'usine abstrait se concentre davantage sur la création d'un groupe d'objets.
Résumé : Le modèle d'usine est un modèle de création couramment utilisé. Il définit une interface pour créer des objets, mais la sous-classe détermine la classe à instancier. L'utilisation du modèle d'usine permet de séparer la création et l'utilisation des objets, conformément au principe d'ouverture et de fermeture. Comparé à d'autres modèles similaires, le modèle d'usine accorde plus d'attention au processus de création d'objets et convient aux situations dans lesquelles plusieurs objets présentant certains points communs doivent être créés.
modèle d'usine abstrait
Idée de base : fournir une interface permettant de créer une série d’objets liés ou interdépendants.
Le modèle Abstract Factory est un modèle de création qui fournit une interface permettant de créer une série d'objets liés ou interdépendants sans spécifier de classe spécifique.
Ce qui suit est un exemple simple de code du modèle de fabrique abstraite :
public interface ProductA {
void show();
}
public class ConcreteProductA1 implements ProductA {
@Override
public void show() {
System.out.println("This is concrete product A1.");
}
}
public class ConcreteProductA2 implements ProductA {
@Override
public void show() {
System.out.println("This is concrete product A2.");
}
}
public interface ProductB {
void show();
}
public class ConcreteProductB1 implements ProductB {
@Override
public void show() {
System.out.println("This is concrete product B1.");
}
}
public class ConcreteProductB2 implements ProductB {
@Override
public void show() {
System.out.println("This is concrete product B2.");
}
}
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
public class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
public class ConcreteFactory2 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
public class Client {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.show();
productB1.show();
AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.show();
productB2.show();
}
}
avantage:
- Créer ensemble un ensemble d’objets liés ou interdépendants, conçus pour respecter le principe de responsabilité unique.
- Le code client est découplé des classes d'usine spécifiques, ce qui facilite l'expansion de nouvelles gammes de produits.
Comparez avec d'autres modèles similaires :
- Le modèle d'usine peut également créer des objets, mais il se concentre sur le processus de création d'objets d'une certaine classe, tandis que le modèle d'usine abstrait se concentre davantage sur la création d'un ensemble d'objets liés ou interdépendants.
- Le modèle singleton garantit qu’il n’existe qu’une seule instance globalement et ne convient pas à la création d’une série d’objets.
Résumé : Le modèle de fabrique abstraite est un modèle de création couramment utilisé. Il fournit une interface permettant de créer une série d'objets liés ou interdépendants sans spécifier de classe spécifique. Le modèle d'usine abstrait crée ensemble un ensemble d'objets liés ou interdépendants, réalisant le découplage du client de la classe d'usine spécifique. Comparé à d’autres modèles similaires, le modèle Abstract Factory se concentre davantage sur la création d’un ensemble d’objets.
modèle de constructeur
Idée centrale : Séparer la construction d'un objet complexe de sa représentation, afin que le même processus de construction puisse créer des représentations différentes.
Le modèle constructeur est un modèle de création qui sépare la construction d'un objet complexe de sa représentation, permettant au même processus de construction de créer différentes représentations.
Voici un exemple de code de modèle de constructeur simple :
public class Product {
private String partA;
private String partB;
public void setPartA(String partA) {
this.partA = partA;
}
public void setPartB(String partB) {
this.partB = partB;
}
public void show() {
System.out.println("Part A: " + partA);
System.out.println("Part B: " + partB);
}
}
public abstract class Builder {
public abstract void buildPartA();
public abstract void buildPartB();
public abstract Product getResult();
}
public class ConcreteBuilder1 extends Builder {
private Product product = new Product();
@Override
public void buildPartA() {
product.setPartA("Part A from ConcreteBuilder1");
}
@Override
public void buildPartB() {
product.setPartB("Part B from ConcreteBuilder1");
}
@Override
public Product getResult() {
return product;
}
}
public class ConcreteBuilder2 extends Builder {
private Product product = new Product();
@Override
public void buildPartA() {
product.setPartA("Part A from ConcreteBuilder2");
}
@Override
public void buildPartB() {
product.setPartB("Part B from ConcreteBuilder2");
}
@Override
public Product getResult() {
return product;
}
}
public class Director {
public void construct(Builder builder) {
builder.buildPartA();
builder.buildPartB();
}
}
public class Client {
public static void main(String[] args) {
Director director = new Director();
Builder builder1 = new ConcreteBuilder1();
director.construct(builder1);
Product product1 = builder1.getResult();
product1.show();
Builder builder2 = new ConcreteBuilder2();
director.construct(builder2);
Product product2 = builder2.getResult();
product2.show();
}
}
avantage:
- Séparer la construction d'un objet complexe de sa représentation rend le processus de construction flexible et différentes représentations peuvent être créées pour le même processus de construction.
- Le client n'a pas besoin de connaître le processus de construction spécifique, il lui suffit de spécifier l'objet constructeur spécifique, ce qui simplifie l'utilisation du client.
Comparez avec d'autres modèles similaires :
- Le modèle d'usine est également utilisé pour créer des objets, mais il se concentre davantage sur le processus de création d'objets, tandis que le modèle de constructeur se concentre davantage sur le processus de construction et de représentation des objets.
- Le modèle Abstract Factory peut également créer une série d'objets liés, ce qui crée un groupe d'objets liés ensemble, tandis que le modèle Builder sépare la construction d'un objet complexe de sa représentation.
Résumé : Le modèle de construction est un modèle de création couramment utilisé qui sépare la construction d'un objet complexe de sa représentation, rendant le processus de construction flexible et capable de créer différentes représentations du même processus de construction. L'utilisation du modèle de générateur peut mieux résoudre le problème de la création d'objets complexes, tout en rendant le code client plus concis et plus facile à maintenir. Comparé à d’autres modèles similaires, le modèle constructeur se concentre davantage sur le processus de construction et la représentation des objets.
Modèle prototype
Présentation
Le modèle de prototype est un modèle de création qui crée de nouveaux objets en copiant des objets existants, évitant ainsi les processus d'initialisation répétés. L'idée principale est de copier des objets existants via la méthode clone pour créer de nouveaux objets. Le modèle de prototype convient aux situations dans lesquelles un grand nombre d'objets similaires doivent être créés, mais le processus de création d'objets prend du temps ou est coûteux.
Exemple de code
Voici un exemple de code utilisant le modèle prototype :
// 原型接口
interface Prototype {
Prototype clone(); // 克隆方法
}
// 具体原型类
class ConcretePrototype implements Prototype {
private String name;
public ConcretePrototype(String name) {
this.name = name;
}
@Override
public Prototype clone() {
return new ConcretePrototype(this.name);
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
ConcretePrototype prototype = new ConcretePrototype("原型对象");
ConcretePrototype clone = (ConcretePrototype) prototype.clone();
clone.setName("克隆对象");
System.out.println(prototype.getName()); // 输出：原型对象
System.out.println(clone.getName()); // 输出：克隆对象
}
}
Dans l'exemple ci-dessus, nous avons défini une interface prototype Prototypequi contient une méthode clone clone(). La classe prototype spécifique ConcretePrototypeimplémente l'interface prototype et implémente la méthode clone, dans laquelle un nouvel objet est créé et renvoyé. Le code client utilise le modèle prototype pour créer un objet prototype et obtient un objet clone via la méthode clone.
Analyse des avantages et des inconvénients
Les avantages du mode prototype sont les suivants :
- Économisez du temps et des ressources pour l’initialisation des objets. Étant donné que le mode prototype crée de nouveaux objets en clonant des objets existants, il évite les processus d'initialisation répétés et améliore l'efficacité de la création d'objets.
- Simplifiez le processus de création d’objets. Grâce au mode prototype, nous pouvons copier directement l'état d'un objet existant sans définir manuellement la valeur de chaque propriété, ce qui simplifie le processus de création d'objet.
Les inconvénients du modèle prototype sont les suivants :
- Le clonage d'objets peut être restreint. Le clonage de certains objets est restreint, par exemple, les objets singleton ne peuvent pas être clonés, les objets non sérialisables ne peuvent pas être clonés, etc.
- Le clonage d'objets peut entraîner des problèmes de copie profonde. Si les propriétés de l'objet contiennent des variables membres de type référence, des problèmes de copie complète peuvent survenir lors du clonage et vous devez y prêter attention.
Comparaison avec d'autres modes
- Modèle de prototype et modèle d'usine : Le modèle de prototype et le modèle d'usine sont tous deux des modèles de création, mais leurs objectifs sont différents. Le modèle de prototype se concentre sur la façon de créer de nouveaux objets en copiant des objets existants, tandis que le modèle d'usine se concentre sur la façon de créer des objets via des méthodes d'usine ou des classes d'usine.
- Modèle prototype et modèle singleton : Le modèle prototype et le modèle singleton sont tous deux des modèles créationnels, mais leurs objectifs sont complètement différents. Le modèle prototype vise à créer de nouveaux objets, chacun ayant un état indépendant, tandis que le modèle singleton vise à créer des objets uniques, partageant tous le même état.
En résumé, le modèle prototype est un modèle de création qui crée de nouveaux objets en copiant des objets existants. Il convient aux situations où un grand nombre d'objets similaires doivent être créés. Il peut améliorer l'efficacité de la création d'objets et simplifier le processus de création d'objets. Cependant, vous devez faire attention aux limites du clonage d’objets et aux problèmes de copie approfondie.
Dans l'ensemble, le modèle de prototype est un modèle de conception simple et pratique qui peut améliorer efficacement la réutilisation et l'efficacité de la création de code et convient à divers scénarios d'application.