Java开发-3大设计模式

设计模式

单例设计模式

  • 构造方法私有化

  • 声明一个本类对象

  • 给外部提供一个静态方法获取对象实例

饿汉式

  • 类加载后创建对象，程序结束后回收该对象
  • 占用内存时间长，效率高
1
2
3
4
5
6
7
8
public class C0401SingleMode {
    private C0401SingleMode() {
    }
    private static C0401SingleMode s = new C0401SingleMode();
    public static C0401SingleMode getInstance(){
        return s;
    }
}

懒汉式

  • 占用内存时间短
  • 效率低
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class C0401SingleMode {
    //懒汉式单例类.在第一次调用的时候实例化自己
    //私有化构造方法
    private C0401SingleMode() {
    }
    //声明引用对象
    private static C0401SingleMode single;
    //给定一个静态方法，getInstance
    public static C0401SingleMode getInstance(){
        //判断对象为空，new一个对象
        if (single == null){
            single = new C0401SingleMode();
        }
        return single;
    }
}
  1. 工具类（只有功能方法，没有属性）
  2. 工具类频繁使用
  3. 节省资源避免重复创建对象

私有化构造+静态方法实现单例较消耗内存

简单工厂模式

  • 由工厂对象决定创建哪一种产品类的实例
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
public class C0402FactorMode {
    public static void main(String[] args) {
        //不使用工厂模式时，需要通过new接口的子类对象来使用方法，耦合高，容易出错
        Product Phone = new Phone();
        Phone.work();

        Product Phone1 = ProductFactory.getProduct("Phone");
        Phone1.work();
    }
}
//工厂类,
class ProductFactory{
    //方法getProduct,根据传参need判断,返回Product接口的对象
    public static Product getProduct(String need){
        //判断代码,根据字符串值判断返回的对象
        switch (need){
            case "Phone":return new Phone();
            case "Computer" : return new Computer();
        }
        return null;
    }
}
//定义一个接口
interface Product {
    void work();
}
//实现接口类Phone
class Phone implements Product{
    //重写接口方法
    @Override
    public void work() {
        System.out.println("Phone working");
    }
}
//实现接口类Computer
class Computer implements Product{
    //重写接口方法
    @Override
    public void work() {
        System.out.println("Computer working");
    }
}

静态代理模式

  1. 定义接口
  2. 接口实现类重写接口方法
  3. 定义代理类实现接口
    1. 私有化接口对象属性
    2. 定义返回值为接口对象的显式构造器、并指定传参为接口类型的对象，指定传参对象作为构造器指定对象（即调用传参对象）
  4. new 接口对象，new代理模式对象并把接口对象作为传参
  5. 调用方法
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
public class C0403ProxyMode {
    public static void main(String[] args) {
    Action userAction = new UserAction();
    //把对象userAction传给了ActionProxy的构造器
    ActionProxy target = new ActionProxy(userAction);
    target.doAction();
    }
}
class ActionProxy implements Action{
    //定义一个属性，Action类型属性target
    private Action target;
    //无参构造
    public ActionProxy(){}
    //有参构造
    public ActionProxy(Action target) {
        //把传进来的target参数付给this对象
        this.target = target;
    }
    //重写接口方法
    @Override
    public void doAction() {
        //两个Time记录时间
        long stratTime = System.currentTimeMillis();
        //调用了this.target的doAction方法，实际上
        this.target.doAction();
        Long endTime = System.currentTimeMillis();
        System.out.println("is used time:"+(endTime-stratTime));
    }
}

//实现接口
interface Action{
    void doAction();
}
//接口实现类
class UserAction implements Action{
    @Override
    public void doAction() {
        System.out.println("working");
    }
}

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！