designMode code issue
秋水 Lv5
 2023-12-05 16:09:00  

简单工厂模式和策略模式的具体实现以及区别

当然可以。让我们来分别探讨策略模式（Strategy Pattern）和简单工厂模式（Simple Factory Pattern），并理解它们之间的区别。这两种模式在面向对象设计中都很常见，但它们的应用场景和目的有所不同。

策略模式（Strategy Pattern）

策略模式允许你定义一系列的算法，将每一个算法封装起来，并且使它们可以互换。这个模式让算法独立于使用它的客户端而变化。通常用于实现同一类型任务的不同变体。

示例代码

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
// 策略接口
public interface Strategy {
    public void execute();
}

// 具体策略A
public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略A");
    }
}

// 具体策略B
public class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略B");
    }
}

// 上下文类
public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

使用策略模式的客户端代码：

1
2
3
4
5
6
7
8
9
public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context(new ConcreteStrategyA());
        context.executeStrategy();

        context = new Context(new ConcreteStrategyB());
        context.executeStrategy();
    }
}

简单工厂模式（Simple Factory Pattern）

简单工厂模式不是一个正式的设计模式，更多的是一种编程习惯。它用来创建对象的接口，将对象的创建和使用分离。通常用于创建多种类型的对象，其中每个对象都派生自同一个基类或接口。

示例代码

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
// 产品接口
public interface Product {
    void use();
}

// 具体产品A
public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

// 具体产品B
public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

// 简单工厂
public class SimpleFactory {
    public Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}

使用简单工厂模式的客户端代码：

1
2
3
4
5
6
7
8
9
10
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product product = factory.createProduct("A");
        product.use();

        product = factory.createProduct("B");
        product.use();
    }
}

区别

  1. 目的：策略模式主要是用来封装算法和行为，而简单工厂模式用于创建对象。
  2. 应用场景：策略模式常用于算法的选择，简单工厂模式用于创建不同但相关类型的对象。
  3. 实现方式：策略模式通过定义策略接口并创建具体策略类来实现算法的封装和替换。简单工厂模式通过一个工厂类来根据输入参数创建并返回不同的实例。

总结来说，策略模式关注的是行为的多样性和可替换性，而简单工厂模式关注的是创建对象的过程，将对象的创建和使用解耦。

简单工厂模式和工厂方法模式的区别

  • 首先简单工厂模式破坏了，开放封闭原则，如果我添加新的功能，我需要新添加新的类，然后修改客户端的switch。
  • 简单工厂模式和工厂方法模式的区别在于，工厂模式在更换对象的时候，不需要很大的改动就可以实现，是简单工厂模式的进一步抽象和推广，运用了多态性。
  • 缺点在于每增加一个产品，就要增加一个产品工厂类。

代理模式代码实现

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
package Proxy;

/**
 * 定义真实实体类与代理实体类共用的接口
 * @author tai_master
 * @date 2023/12/14
 */
public interface Subject {
    public void request();
}

package Proxy;

/**
 * 真实实体类
 * @author tai_master
 * @date 2023/12/14
 */
public class RealSubject implements Subject{
    @Override
    public void request() {
        System.out.println("真实对象的请求");
    }
}

package Proxy;

public class ProxyClient {
    public static void main(String[] args) {
        Proxy proxy = new Proxy();
        proxy.request();
    }
}

package Proxy;

/**
 *
 * 代理类
 * @author tai_master
 * @date 2023/12/14
 */
public class Proxy implements Subject{
    Subject subject;
    public Proxy(){
        subject = new RealSubject();

    }
    @Override
    public void request() {
        subject.request();
    }
}


设计模式读书笔记

设计模式的特点

  • 单一职责

  • 开放封闭原则

  • 依赖倒转原则

    a. 高层模块不应该依赖低层模块，两个都应该依赖抽象。

    b. 抽象不应该依赖细节。细节应该依赖抽象。

  • 里氏代换原则

    a . 子类型必须能够替换条他们的父类型

如何实现开放封闭呢

  • 编写代码的时候，创建抽象来隔离以后可能会发生的同类变化
  • 但不要全部抽象，这样也不好

原型模式和深拷贝的区别

原型模式

  • 首先原型模式是设计模式的一种，主要是用来创建对象的副本，核心思想是通过复制一个现有对象的原型来创建新的对象
  • 用途：当直接创建对象成本过高时，（设计复杂的初始化步骤）使用原型模式更高效，允许系统动态的添加或删除产品，并能够在运行时指定对象的新类型。
  • 在Java中，通常通过实现 Cloneable 接口和重写 Object 类的 clone() 方法来实现。默认情况下，clone() 方法提供浅拷贝。
  • 原型模式的侧重点是在不需要知道对象创建细节的情况下，提供一种方便的方式来创建对象的副本。

深拷贝

  • 深拷贝是创建对象副本的方法之一，在深拷贝过程中，对象的所有成员变量和复杂类型都会被复制。
  • 当对象包含其他对象的引用时，如果需要副本完全独立于原始对象，使用深拷贝
  • 可以通过递归，序列化，反序列化
  • 深拷贝侧面点是确保对象在所有层级上与原始对象完全独立。

总结

原型模式侧重于提供一种创建对象副本的灵活方式，而深拷贝侧重于确保对象副本的完全独立性。”

  • Post title：designMode code issue
  • Post author：秋水
  • Create time：2023-12-05 16:09:00
  • Post link：tai769.github.io2023/12/05/designMode-code-issue/
  • Copyright Notice：All articles in this blog are licensed under BY-NC-SA unless stating additionally.