设计模式——工厂设计模式

发表于 更新于 分类于 阅读次数： Changyan： 本文字数： 1k 阅读时长 ≈ 4 分钟

JavaSE进阶——该篇主要讲解Java中的工厂设计模式

sum: 保证类与类的低耦合

工厂设计模式及其作用

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。之前创建类对象时, 都是使用 new 对象的形式创建, 除new 对象方式以外, 工厂模式也可以创建对象.

工厂设计模式的作用

解决类与类之间的耦合问题

工厂设计模式实现步骤（案例）

  • 需求：定义汽车工厂类，生产各种品牌的车

  • 实现步骤

    • 编写一个Car接口, 提供run方法
    • 编写一个Falali类实现Car接口,重写run方法
    • 编写一个Benchi类实现Car接口,重写run方法
    • 提供一个CarFactory(汽车工厂),用于生产汽车对象
    • 定义CarFactoryTest测试汽车工厂
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
74
75
76
77
78
79
80
81
82
package com.itheima.factorydesign_demo;

/*
  - 需求：定义汽车工厂类，生产各种品牌的车

  - 实现步骤
      - 编写一个Car接口, 提供run方法
      - 编写一个Falali类实现Car接口,重写run方法
      - 编写一个Benchi类实现Car接口
      =============================================
      - 提供一个CarFactory(汽车工厂),用于生产汽车对象
      - 定义CarFactoryTest测试汽车工厂
 */
public class CarTest {
    public static void main(String[] args) {
        Car benchi = CarFactory.getInstance(Brand.BENCHI);
        System.out.println(benchi);
    }
}

// 汽车接口
interface Car {
    public abstract void run();
}

// 编写一个Falali类实现Car接口,重写run方法
class Falali implements Car {
    public Falali() {
    }

    @Override
    public void run() {
        System.out.println("法拉利破百需要3秒...");
    }
}

// 编写一个Benchi类实现Car接口
class Benchi implements Car {
    @Override
    public void run() {
        System.out.println("奔驰破百需要5秒...");
    }
}

// 汽车品牌枚举
enum Brand {
    BENCHI, FALALI, BAOMA, BINLI, AODI;
}

// 提供一个CarFactory(汽车工厂),用于生产汽车对象
class CarFactory {
    private CarFactory() {
    }

    public static Car getInstance(Brand brand) {
        switch (brand) {
            case FALALI:
                return new Falali();
            case BENCHI:
                return new Benchi();
            default:
                return null;
        }
    }
}

//// 提供一个CarFactory(汽车工厂),用于生产汽车对象
//class CarFactory{
//    private CarFactory(){}
//
//    public static Car getInstance(String brand) {
//        if(brand.equals("Falali")){
//            return new Falali(10);
//        }else if(brand.equals("Benchi")) {
//            return new Benchi();
//        }else {
//            return null;
//        }
//    }
//}


总结

public class Student{
….
}

//耦合性高: 当更换类时，需要修改代码
MyStudent stu = new MyStudent();

//新方案： 接口或父类
public interface Person{
}
public class Student implements Person{
…
}
public class Worker implements Person{
….
}
//耦合降低了，但还是存在耦合
Person p = new Student();//多态

//新方案： 工厂模式 （解决类和类之间耦合问题）

public class 工厂类 {
//实现对象的创建 （例：创建学生对象、创建老师对象、创建工人对象、….）

//私有构造方法
private 工厂类(){}

//静态方法
public static Person getInstance(String name){
if(“teacher”.eqauls(name)){
return new Teacher();
}
if(“student”.equals(name)){
return new Student();
}
}
}

//配置文件: bean.properties
name=teacher

//使用工具类，加载bean.properties配置文件
ResourceBundle rb = ResourceBundle.getBundle(“bean”);
String beanName = rb.getString(“name”);

Person p = 工厂类.getInstance( beanName );

//由程序员主动创建对象，变为被动在获取对象 （对象的创建权转移到：工厂类）