Creational on Aurora

Prototype Pattern in Design Pattern

Wed, 10 Jun 2020 17:20:16 +0000

原型模式

Overview

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。

当直接创建对象的代价比较大时，则采用这种模式。

例如，一个对象需要在一个高代价的数据库操作之后被创建。

我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

主要解决

在运行期建立和删除原型。

何时使用

当一个系统应该独立于它的产品创建，构成和表示时
当要实例化的类是在运行时刻指定时，例如，通过动态装载
为了避免创建一个与产品类层次平行的工厂类层次时
当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

应用实例

细胞分裂
JAVA 中的 Object clone() 方法

优点

性能提高
逃避构造函数的约束

实现

BaseShape

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


package individual.cy.learn.pattern.creational.prototype;

/**
 * @author mystic
 */
public abstract class BaseShape implements Cloneable {
 private String id;
 protected String type;

 /**
 * to draw a geometric
 */
 public abstract void draw();

 public String getType() {
 return type;
 }

 public String getId() {
 return id;
 }

 public void setId(String id) {
 this.id = id;
 }

 @Override
 public BaseShape clone() {
 BaseShape clone = null;
 try {
 clone = (BaseShape) super.clone();
 } catch (CloneNotSupportedException e) {
 e.printStackTrace();
 }
 return clone;
 }

}

Circle

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.creational.prototype;

/**
 * @author mystic
 */
public class Circle extends BaseShape {

 public Circle() {
 type = "Circle";
 }

 @Override
 public void draw() {
 System.out.println("Circle.draw");
 }
}

Square

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.creational.prototype;

/**
 * @author mystic
 */
public class Square extends BaseShape {

 public Square() {
 type = "Square";
 }

 @Override
 public void draw() {
 System.out.println("Square.draw");
 }
}

Rectangle

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.creational.prototype;

/**
 * @author mystic
 */
public class Rectangle extends BaseShape {

 public Rectangle() {
 type = "Rectangle";
 }

 @Override
 public void draw() {
 System.out.println("Rectangle.draw");
 }
}

ShapeCache

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


package individual.cy.learn.pattern.creational.prototype;

import java.util.Hashtable;

/**
 * @author mystic
 */
public class ShapeCache {

 private static final Hashtable<String, BaseShape> SHAPE_MAP = new Hashtable<String, BaseShape>();

 public static BaseShape getShape(String shapeId) {
 BaseShape cachedShape = SHAPE_MAP.get(shapeId);
 return cachedShape.clone();
 }

 public static void loadCache() {
 Circle circle = new Circle();
 circle.setId("1");
 SHAPE_MAP.put(circle.getId(), circle);

 Square square = new Square();
 square.setId("2");
 SHAPE_MAP.put(square.getId(), square);

 Rectangle rectangle = new Rectangle();
 rectangle.setId("3");
 SHAPE_MAP.put(rectangle.getId(), rectangle);
 }

}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package individual.cy.learn.pattern.creational.prototype;

/**
 * @author mystic
 */
public class PrototypePatternTester {
 public static void main(String[] args) {
 ShapeCache.loadCache();

 BaseShape cachedShape1 = ShapeCache.getShape("1");
 System.out.println("cachedShape1.getType() = " + cachedShape1.getType());

 BaseShape cachedShape2 = ShapeCache.getShape("2");
 System.out.println("cachedShape2.getType() = " + cachedShape2.getType());

 BaseShape cachedShape3 = ShapeCache.getShape("3");
 System.out.println("cachedShape3.getType() = " + cachedShape3.getType());
 }
}

1
2
3


cachedShape1.getType() = Circle
cachedShape2.getType() = Square
cachedShape3.getType() = Rectangle

Builder Pattern in Design Pattern

Fri, 22 May 2020 16:38:43 +0000

建造者模式

Overview

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

一个 Builder 类会一步一步构造最终的对象。

该 Builder 类是独立于其他对象的。

主要解决

主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作。

其通常由各个部分的子对象用一定的算法构成，由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用

一些基本部件不会变，而其组合经常变化的时候

应用实例

KFC里的可乐，薯条，炸鸡翅等是不变的，而其组合（套餐）是经常变化的
Java的StringBuilder

使用场景

当一个类的构造函数参数个数超过4个，而且这些参数有些是可选的参数，考虑使用构造者模式
多个部件或者零件，都可以装配到一个对象中，但是产生的运行结果又相同
产品类非常复杂，或者产品类中调用顺序不同产生了不同的作用
初始化一个对象特别复杂，如使用多个构造方法，或者说有很多参数，并且都有默认值时

优点

易扩展
便于控制细节风险

实现

Computer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73


package individual.cy.learn.pattern.creational.builder;

/**
 * @author mystic
 */
public class Computer {
 /**
 * Required
 */
 private final String cpu;
 /**
 * Required
 */
 private final String ram;
 private final String keyboard;
 private final String headset;
 private final String display;

 public Computer(ComputerBuilder builder) {
 this.cpu = builder.cpu;
 this.ram = builder.ram;
 this.keyboard = builder.keyboard;
 this.headset = builder.headset;
 this.display = builder.display;
 }

 public static Computer.ComputerBuilder builder(String cpu, String ram) {
 return new Computer.ComputerBuilder(cpu, ram);
 }

 public static class ComputerBuilder {
 private final String cpu;
 private final String ram;
 private String keyboard;
 private String headset;
 private String display;

 public ComputerBuilder(String cpu, String ram) {
 this.cpu = cpu;
 this.ram = ram;
 }

 public Computer build() {
 return new Computer(this);
 }

 public Computer.ComputerBuilder keyboard(String keyboard) {
 this.keyboard = keyboard;
 return this;
 }

 public Computer.ComputerBuilder headset(String headset) {
 this.headset = headset;
 return this;
 }

 public ComputerBuilder display(String display) {
 this.display = display;
 return this;
 }
 }

 @Override
 public String toString() {
 return "Computer{" +
 "cpu='" + cpu + '\'' +
 ", ram='" + ram + '\'' +
 ", keyboard='" + keyboard + '\'' +
 ", headset='" + headset + '\'' +
 ", display='" + display + '\'' +
 '}';
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package individual.cy.learn.pattern.creational.builder;

/**
 * @author mystic
 */
public class BuilderPatternTester {
 public static void main(String[] args) {
 Computer hp = Computer.builder("i9", "32G").build();
 Computer dell = Computer.builder("i9", "32G")
 .display("Samsung")
 .headset("Beats")
 .keyboard("Filco")
 .build();
 System.out.println("dell = " + dell);
 System.out.println("hp = " + hp);
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


16:36:50: Executing task 'BuilderPatternTester.main()'...

Configuration on demand is an incubating feature.
> Task :compileJava
> Task :processResources NO-SOURCE
> Task :classes

> Task :BuilderPatternTester.main()
dell = Computer{cpu='i9', ram='32G', keyboard='Filco', headset='Beats', display='Samsung'}
hp = Computer{cpu='i9', ram='32G', keyboard='null', headset='null', display='null'}

BUILD SUCCESSFUL in 1s
2 actionable tasks: 2 executed
16:36:52: Task execution finished 'BuilderPatternTester.main()'.

Abstract Factory Pattern in Design Pattern

Fri, 22 May 2020 13:28:40 +0000

抽象工厂模式

Overview

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。

每个生成的工厂都能按照工厂模式提供对象。

主要解决

主要解决接口选择的问题。

何时使用

系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

应用实例

QQ 换皮肤，一整套一起换

优点

当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

实现

Shape and Subclass

Shape interface

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public interface GeometricShape {
 /**
 * draw a geometric shape
 */
 void draw();
}

ShapeType2D

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public enum ShapeType2D {
 /**
 * 2d geometric shape
 */
 LINE, CIRCLE, SQUARE
}

ShapeType3D

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public enum ShapeType3D {
 /**
 * 3d geometric shape
 */
 SPHERE, CUBE, CYLINDER
}

2D Shape

Line

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public class Line implements GeometricShape {
 @Override
 public void draw() {
 System.out.println("Line.draw");
 }
}

Circle

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public class Circle implements GeometricShape {
 @Override
 public void draw() {
 System.out.println("Circle.draw");
 }
}

Square

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public class Square implements GeometricShape {
 @Override
 public void draw() {
 System.out.println("Square.draw");
 }
}

3D Shape

Cude

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public class Cube implements GeometricShape {
 @Override
 public void draw() {
 System.out.println("Cube.draw");
 }
}

Sphere

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public class Sphere implements GeometricShape {
 @Override
 public void draw() {
 System.out.println("Sphere.draw");
 }
}

Cylinder

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public class Cylinder implements GeometricShape {
 @Override
 public void draw() {
 System.out.println("Cylinder.draw");
 }
}

Factory

Abstract Factory

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public abstract class AbstractFactory {
 /**
 * To get a 2d geometric shape
 *
 * @param type shape name
 * @return Geometric Shape
 */
 public abstract GeometricShape getGeometricShape2D(ShapeType2D type);

 /**
 * To get a 3d geometric shape
 *
 * @param type shape name
 * @return Geometric Shape
 */
 public abstract GeometricShape getGeometricShape3D(ShapeType3D type);
}

Two Dimension Shape Factory

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public class TwoDimensionShapeFactory extends AbstractFactory {
 @Override
 public GeometricShape getGeometricShape2D(ShapeType2D type) {
 switch (type) {
 case LINE:
 return new Line();
 case CIRCLE:
 return new Circle();
 case SQUARE:
 return new Square();
 default:
 return null;
 }
 }

 @Override
 public GeometricShape getGeometricShape3D(ShapeType3D type) {
 return null;
 }
}

Three Dimension Shape Factory

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public class ThreeDimensionShapeFactory extends AbstractFactory {

 @Override
 public GeometricShape getGeometricShape2D(ShapeType2D type) {
 return null;
 }

 @Override
 public GeometricShape getGeometricShape3D(ShapeType3D type) {
 switch (type) {
 case SPHERE:
 return new Sphere();
 case CUBE:
 return new Cube();
 case CYLINDER:
 return new Cylinder();
 default:
 return null;
 }
 }
}

Factory Creator

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


package individual.cy.learn.pattern.creational.abstractfactory;

import java.util.function.Supplier;

/**
 * @author mystic
 */
public enum FactoryCreator {
 /**
 * create 2D, 3D geometric shape
 */
 TWO_D_SHAPE_FACTORY(TwoDimensionShapeFactory::new), THREE_D_SHAPE_FACTORY(ThreeDimensionShapeFactory::new);

 private final Supplier<AbstractFactory> factorySupplier;

 FactoryCreator(Supplier<AbstractFactory> factorySupplier) {
 this.factorySupplier = factorySupplier;
 }

 public AbstractFactory getInstance() {
 return factorySupplier.get();
 }

 public static AbstractFactory getFactory(FactoryCreator creator) {
 return creator.getInstance();
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package individual.cy.learn.pattern.creational.abstractfactory;

/**
 * @author mystic
 */
public class AbstractFactoryPatternTester {
 public static void main(String[] args) {
 // draw 2d shape
 FactoryCreator.TWO_D_SHAPE_FACTORY
 .getInstance()
 .getGeometricShape2D(ShapeType2D.LINE)
 .draw();

 // draw 3d shape
 FactoryCreator.THREE_D_SHAPE_FACTORY
 .getInstance()
 .getGeometricShape3D(ShapeType3D.CYLINDER)
 .draw();
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


13:18:52: Executing task 'AbstractFactoryPatternTester.main()'...

Configuration on demand is an incubating feature.
> Task :compileJava
> Task :processResources NO-SOURCE
> Task :classes

> Task :AbstractFactoryPatternTester.main()
Line.draw
Cylinder.draw

BUILD SUCCESSFUL in 1s
2 actionable tasks: 2 executed
13:18:54: Task execution finished 'AbstractFactoryPatternTester.main()'.

Factory Pattern in Design Pattern

Thu, 21 May 2020 13:34:16 +0000

工厂模式

Overview

工厂方法模式一种创建对象的模式，它被广泛应用在JDK中以及Spring和Struts框架中。

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

通过给工厂对象传递不同参数来实现获得不同的子类。

主要解决

主要解决接口选择的问题。

我们通过工厂来替我们选择，对于不知情的人，只要传入参数，工厂会自动为我们选择一个类。

何时使用

我们明确地计划不同条件下创建不同实例时。

应用实例

购买汽车，直接去工厂提货，而不需要知道汽车是怎么制造的
Hibernate 换数据库只需换方言和驱动就可以

优点

一个调用者想创建一个对象，只要知道其名称就可以了
扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以
屏蔽产品的具体实现，调用者只关心产品的接口

实现

Shape and Subclass

Shape interface

1
2
3
4
5
6


public interface Shape {
 /**
 * draw a geometry
 */
 void draw();
}

Circle

1
2
3
4
5
6


public class Circle implements Shape {
 @Override
 public void draw() {
 System.out.println("Circle.draw");
 }
}

Rectangle

1
2
3
4
5
6


public class Rectangle implements Shape {
 @Override
 public void draw() {
 System.out.println("Rectangle.draw");
 }
}

Square

1
2
3
4
5
6


public class Square implements Shape {
 @Override
 public void draw() {
 System.out.println("Square.draw");
 }
}

Factory

Solution 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


public class ShapeFactory {
 public Shape getShape(String shapeType) {
 if (shapeType == null) {
 return null;
 }
 if (shapeType.equalsIgnoreCase("circle")) {
 return new Circle();
 } else if (shapeType.equalsIgnoreCase("rectangle")) {
 return new Rectangle();
 } else if (shapeType.equalsIgnoreCase("square")) {
 return new Square();
 }
 return null;
 }
}

Solution 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


public enum ShapeCreator {
 /**
 * create Circle, Rectangle, Square
 */
 CIRCLE(Circle::new), RECTANGLE(Rectangle::new), SQUARE(Square::new);

 private final Supplier<Shape> shapeSupplier;

 ShapeCreator(Supplier<Shape> shapeSupplier) {
 this.shapeSupplier = shapeSupplier;
 }

 public Shape getInstance() {
 return shapeSupplier.get();
 }

 public static Shape getShape(ShapeCreator creator) {
 return creator.getInstance();
 }
}

Solution 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


public enum ShapeCreator2 {
 /**
 * create Circle, Rectangle, Square
 */
 CIRCLE(new Circle()), RECTANGLE(new Rectangle()), SQUARE(new Square());

 private final Shape shape;

 ShapeCreator2(Shape shape) {
 this.shape = shape;
 }

 public Shape getShape() {
 return shape;
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


package individual.cy.learn.pattern.creational.factory;

/**
 * @author mystic
 */
public class FactoryPatternTester {
 public static void main(String[] args) {
 ShapeFactory factory = new ShapeFactory();

 // Acquire Circle
 Shape circle = factory.getShape("circle");
 circle.draw();

 // Acquire Rectangle
 Shape rectangle = factory.getShape("rectangle");
 rectangle.draw();

 // Acquire Square
 Shape square = factory.getShape("square");
 square.draw();

 System.out.println();

 ShapeCreator.CIRCLE.getInstance().draw();
 ShapeCreator.RECTANGLE.getInstance().draw();
 ShapeCreator.SQUARE.getInstance().draw();

 System.out.println();

 System.out.println(ShapeCreator.CIRCLE.getInstance());
 System.out.println(ShapeCreator.CIRCLE.getInstance());
 System.out.println(ShapeCreator.CIRCLE.getInstance());
 // Or this usage
 System.out.println(ShapeCreator.getShape(ShapeCreator.CIRCLE));
 System.out.println(ShapeCreator.getShape(ShapeCreator.CIRCLE));
 System.out.println(ShapeCreator.getShape(ShapeCreator.CIRCLE));

 System.out.println();

 System.out.println(ShapeCreator2.CIRCLE.getShape());
 System.out.println(ShapeCreator2.CIRCLE.getShape());
 System.out.println(ShapeCreator2.CIRCLE.getShape());

 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


Circle.draw
Rectangle.draw
Square.draw

Circle.draw
Rectangle.draw
Square.draw

individual.cy.learn.pattern.creational.factory.Circle@12f40c25
individual.cy.learn.pattern.creational.factory.Circle@3ada9e37
individual.cy.learn.pattern.creational.factory.Circle@5cbc508c
individual.cy.learn.pattern.creational.factory.Circle@3419866c
individual.cy.learn.pattern.creational.factory.Circle@63e31ee
individual.cy.learn.pattern.creational.factory.Circle@68fb2c38

individual.cy.learn.pattern.creational.factory.Circle@2eafffde
individual.cy.learn.pattern.creational.factory.Circle@2eafffde
individual.cy.learn.pattern.creational.factory.Circle@2eafffde

ShapeCreator创建子对象,都是不同的

ShapeCreator2子对象都是同一个

Let's learn what's singleton

Thu, 30 Apr 2020 16:12:37 +0000

单例(Singleton)

数学与逻辑学中，singleton定义为“有且仅有一个元素的集合”。

什么是单例?

一个类有且仅有一个实例, 并提供一个可以访问它的全局访问点.

单例有什么用?

解决一个全局使用类的频繁创建与销毁.

怎么实现单例?

实现方案

隐藏类的构造方法
定义一个公有的静态方法, 通过它返回类的唯一实例

java实现

DCL(Double Checked Lock)实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


public class Lazy4SafeDoubleCheck {
 private static volatile Lazy4SafeDoubleCheck singleton = null;

 private Lazy4SafeDoubleCheck() {
 // 1. 避免反射创建多个实例
 if(singleton != null){
 throw new RuntimeException()
 }
 }

 public static Lazy4SafeDoubleCheck getSingleton() {
 if (singleton == null) {
 synchronized (Lazy4SafeDoubleCheck.class) {
 if (singleton == null) {
 singleton = new Lazy4SafeDoubleCheck();
 }
 }
 }
 return singleton;
 }

 // 2. 避免反序列化创建多个实例
 private Object readResolve() throws ObjectStreamException {
 return singleton;
 }
}

枚举实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public enum SingletonEnum {
 /**
 * 使用枚举实现的单例
 */
 INSTANCE;

 public void otherMethods() {
 System.out.println("Something");
 }
}

Creational on Aurora

Prototype Pattern in Design Pattern

原型模式

Overview

主要解决

何时使用

应用实例

优点

实现

BaseShape

Circle

Square

Rectangle

ShapeCache

Tester

相关文章

Builder Pattern in Design Pattern

建造者模式

Overview

主要解决

何时使用

应用实例

使用场景

优点

实现

Computer

Tester

相关文章

Abstract Factory Pattern in Design Pattern

抽象工厂模式

Overview

主要解决

何时使用

应用实例

优点

实现

Shape and Subclass

Shape interface

ShapeType2D

ShapeType3D

2D Shape

Line

Circle

Square

3D Shape

Cude

Sphere

Cylinder

Factory

Abstract Factory

Two Dimension Shape Factory

Three Dimension Shape Factory

Factory Creator

Tester

相关文章

Factory Pattern in Design Pattern

工厂模式

Overview

主要解决

何时使用

应用实例

优点

实现

Shape and Subclass

Shape interface

Circle

Rectangle

Square

Factory

Solution 1

Solution 2

Solution 3

Tester

相关文章

Let's learn what's singleton

单例(Singleton)

什么是单例?

单例有什么用?

怎么实现单例?

实现方案