设计模式之单例、模板方法、代理、工厂

设计模式

定义

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

常用设计模式

创建型模式

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

结构型模式

​ 共7种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式

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

单例模式

定义

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

饿汉式

class Bank{
	//1.私化类的构造器
	private Bank(){	
	}
	//2.内部创建类的对象
	//4.要求此对象也必须声明为静态的
	private static Bank instance = new Bank();
	//3.提供公共的静态的方法，返回类的对象
	public static Bank getInstance(){
		return instance;
	}
}

饿汉式2（使用了静态代码块）

class Order{
	//1.私化类的构造器
	private Order(){		
	}
	//2.声明当前类对象，没初始化
	//4.此对象也必须声明为static的
	private static Order instance = null;
	static{//当类加载时才会new
		instance = new Order();
 		}
	//3.声明public、static的返回当前类对象的方法
	public static Order getInstance(){
		return instance;
	}
}

懒汉式

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;
	}
}

两种方式的对比

饿汉式：

•  坏处：对象加载时间过长。(提早创建好对象)
  

•  好处：饿汉式是线程安全的
  

懒汉式：

•  好处：延迟对象的创建。(只有在需要的时候才创建)
  

•  目前的写法坏处：线程不安全。--->到多线程内容时，再修改
  

模板方法

定义

​ 在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变
部分可以抽象出来，供不同子类实现。这就是一种模板模式。

举例

abstract class Template{	
	//计算某段代码执行所需要花费的时间
	public void spendTime(){		
		long start = System.currentTimeMillis();		
		this.code();//不确定的部分、易变的部分		
		long end = System.currentTimeMillis();
		System.out.println("花费的时间为：" + (end - start));
	}
	public abstract void code();
}
class SubTemplate extends Template{
	@Override
	public void code() {//计算100以内的质数	
		for(int i = 2;i <= 1000;i++){
			boolean isFlag = true;
			for(int j = 2;j <= Math.sqrt(i);j++){
				if(i % j == 0){
					isFlag = false;
					break;
				}
			}
			if(isFlag){
				System.out.println(i);
			}
		}
	}
}

应用场景

代理模式

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

(找其他对象代这个对象完成一些任务)

举例

public class NetWorkTest{
    psvm{
        Server s = new Server();
        ProxyServer p = new ProxyServer(s);
        //ProxyServer p = new ProxyServer(new Server());
        p.browse();               
    }
}
interface NetWork{
	public void browse();
}
//被代理类
class Server implements NetWork{
	@Override
	public void browse() {
		System.out.println("真实的服务器访问网络");
	}
}
//代理类
class ProxyServer implements NetWork{
	private NetWork work;
	public ProxyServer(NetWork work){
		this.work = work;
	}
	public void check(){
		System.out.println("联网之前的检查工作");
	}	
	@Override
	public void browse() {
		check();
		work.browse();
	}
}

举例二

package com.atguigu.java;
public class StaticProxyTest {
	public static void main(String[] args) {
		Star s = new Proxy(new RealStar());
		s.confer();
		s.signContract();
		s.bookTicket();
		s.sing();
		s.collectMoney();
	}
}
interface Star {
	void confer();// 面谈
	void signContract();// 签合同
	void bookTicket();// 订票
	void sing();// 唱歌
	void collectMoney();// 收钱
}
class RealStar implements Star {
	public void confer() {
	}
	public void signContract() {
	}
	public void bookTicket() {
	}
	public void sing() {
		System.out.println("明星：歌唱~~~");
	}
	public void collectMoney() {
	}
}
class Proxy implements Star {
	private Star real;
	public Proxy(Star real) {
		this.real = real;
	}
	public void confer() {
		System.out.println("经纪人面谈");
	}
	public void signContract() {
		System.out.println("经纪人签合同");
	}
	public void bookTicket() {
		System.out.println("经纪人订票");
	}
	public void sing() {
		real.sing();//g
	}
	public void collectMoney() {
		System.out.println("经纪人收钱");
	}
}

工厂模式

解决的问题

实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

具体

简单工厂模式

用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）

工厂方法模式

用来生产同一等级结构中的固定产品。（支持增加任意产品)

抽象工厂模式

用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族)