常用设计模式

设计模式

介绍

理解：设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。

常用设计模式：

  • 创建型模式，共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

  • 结构型模式，共7种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

  • 行为型模式，共11种：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

单例设计模式

理解：所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。

饿汉式

实现步骤：

  • 私有化构造器，不让外部直接创建对象
  • 内部声明私有的类变量创建类的对象
  • 提供公共方法返回类的对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Bank{
	
	//1.私化类的构造器
	private Bank(){
		
	}
	
	//2.内部创建类的对象
	//4.要求此对象也必须声明为静态的
	private static Bank instance = new Bank();
	
	//3.提供公共的静态的方法，返回类的对象
	public static Bank getInstance(){
		return instance;
	}
}

懒汉式

实现步骤：

  • 私有化构造器，不让外部直接创建对象
  • 内部声明私有的类变量
  • 提供公共方法返回类的对象，在方法内创建对象赋值给类变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Order{
	
	//1.私化类的构造器
	private Order(){
		
	}
	
	//2.声明当前类对象，没初始化
	//4.此对象也必须声明为static的
	private static Order instance = null;
	
	//3.声明public、static的返回当前类对象的方法
	public static Order getInstance(){
		
		if(instance == null){
			
			instance = new Order();
			
		}
		return instance;
	}
	
}

两种方式的对比

  • 饿汉式：
    • 坏处：对象加载时间过长
    • 好处：饿汉式是线程安全的
  • 懒汉式：
    • 好处：延迟对象的创建
    • 目前的写法坏处：线程不安全。—>到多线程内容时，再修改

使用场景

代理设计模式

理解：代理模式是Java开发中使用较多的一种设计模式。代理设计模式就是为其他对象提供一种代理以控制对这个对象的访问。

静态代理

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
83
84
85
86
public class ProxyTest {
    public static void main(String[] args) {
        RealStarProxy realStarProxy = new RealStarProxy(new RealStar());
        realStarProxy.confer();
        realStarProxy.bookTicket();
        realStarProxy.collectMoney();
        realStarProxy.sing();
        realStarProxy.signContract();
    }
}

//接口类
interface Star{
    void confer(); //面谈

    void signContract(); //签合同

    void bookTicket(); //订票

    void sing(); //唱歌

    void collectMoney(); //收钱
}

//被代理类
class RealStar implements Star{

    @Override
    public void confer() {

    }

    @Override
    public void signContract() {

    }

    @Override
    public void bookTicket() {

    }

    @Override
    public void sing() {
        System.out.println("明星：唱歌~~~~");
    }

    @Override
    public void collectMoney() {

    }
}

//代理类
class RealStarProxy implements Star{
    private Star real;

    public RealStarProxy(Star real){
        this.real = real;
    }

    @Override
    public void confer() {
        System.out.println("经纪人面谈");
    }

    @Override
    public void signContract() {
        System.out.println("经纪人签合同");
    }

    @Override
    public void bookTicket() {
        System.out.println("经纪人订票");
    }

    @Override
    public void sing() {
        real.sing();
    }

    @Override
    public void collectMoney() {
        System.out.println("经纪人收钱");
    }
}

使用场景

模板方法设计模式

理解：抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象 类的行为方式。

解决的问题：

  • 当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现
  • 在软件开发中实现一个算法时，整体步骤很固定、通用， 这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式
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
public class TemplateMethodTest {
    public static void main(String[] args) {
        SubTemplate subTemplate = new SubTemplate();
        subTemplate.spendTime();
    }
}

abstract class Template{
    //计算某段代码执行所花费的时间
    public void spendTime(){
        long start = System.currentTimeMillis();
        code(); //不确定的部分、易变的部分抽取出来
        long end = System.currentTimeMillis();
        System.out.println("执行花费时间为："+(end-start));
    }
    public abstract void code();
}

class SubTemplate extends Template{

    @Override
    public void code() {
        for (int i = 2; i <= 1000; i++) {
            boolean flag = true;
            for (int j = 2; j <= i/2; j++) {
                if(i % j == 0){
                    flag = false;
                    break;
                }
            }
            if(flag) System.out.print(i+" ");
        }
    }
}

使用场景