几种常用模式

一、单例模式

• 一个类只能有一个实例
• 有两种实现方式：懒汉式、饿汉式

• 实现步骤

  1. 构造器私有化；（作用：控制外部不允许直接创建对象,因为不能调用构造器）
  2. 提供一个静态的私有的该类的引用；
  3. 公共的静态的访问方式，返回一个该类的对象

1）饿汉式

条件：类第一次加载完成就创建对象,线程安全,但相对来说效率较低

 // 饿汉式
public class Single01 {
//	先建立一个私有的静态的对象
	private static Single01 single = new Single01();
//	私有的构造器  控制外部不允许直接创建对象,因为不能调用构造器
	private Single01(){}
//	公共的静态的访问方式
	public static Single01  newInstance(){
		return single;
	}	
}

2）懒汉式

条件：只有第一次调用功能时,才创建对象,线程不安全,但相对来说效率较高

//懒汉式
public class Single02 {
//	创建一个私有的静态的
	private static Single02 single = null;
//	私有构造器  控制外部不允许直接创建对象,因为不能调用构造器
	private Single02(){}
//	创建一个公共的静态的访问方式
	public static Single02 newInsatnce(){
		if (single==null){
			single=new Single02();
		}
		return single;
	}
//	
}

测试案例：

//测试案例
public class TestSingle {
	public static void main(String[] args) {
//		饿汉式
		Single01 single1 = Single01.newInstance();
		Single01 single2 = Single01.newInstance();
		System.out.println(single1==single2);	//true 说明只有一个实例
		System.out.println(single2);		//返回地址
//		懒汉式		
		System.out.println("=================");
		Single02 single4 = Single02.newInsatnce();
		Single02 single5 = Single02.newInsatnce();
		System.out.println(single4==single5);	//true 说明只有一个实例
	}
}

二、代理模式

• 有两种：静态代理模式、动态代理模式

• 1）静态代理

  案例：公司招人

  分析：真实代理：项目经理；代理角色：hr

  真实角色需要和代理角色实现相同的接口:相同的实现目的-->招人

  public class StaticProxy03 {
  	public static void main(String[] args) {
  		//真实角色
  		Manager man=new Manager("老裴");
  		//Hr
  		Hr hr=new Hr(man);
  		hr.addUser();		
  	}
  }
  
  //接口
  interface AddUser{
  	boolean addUser();
  }
  
  //真实角色 项目经理
  class Manager implements AddUser{
  	String name;
  	
  	public Manager() {
  		// TODO Auto-generated constructor stub
  	}
  
  	public Manager(String name) {
  		super();
  		this.name = name;
  	}
  
  	@Override
  	public boolean addUser() {
  		System.out.println("已录用...");
  		return true;
  	}
  	
  }
  
  //代理角色 Hr
  class Hr implements AddUser{
  	private Manager manger;
  	
  	public Hr() {
  		// TODO Auto-generated constructor stub
  	}
  
  	public Hr(Manager manger) {
  		this.manger = manger;
  	}
  
  
  	public Manager getManger() {
  		return manger;
  	}
  
  	public void setManger(Manager manger) {
  		this.manger = manger;
  	}
  
  	@Override
  	public boolean addUser() {
  		System.out.println("发布招聘信息");
  		if(manger.addUser()){
  			System.out.println("谈薪资");
  			return true;
  		}else{
  			return false;
  		}
  	}
  	
  }
  
  

  三、简单工厂模式

• 抽象产品角色 :具体产品角色实现的父接口|父类
• 具体产品角色:抽象产品角色 的实现类|子类
• 工厂角色:生产产品的

• public class Factory04 {
  	public static void main(String[] args) {
  		Car car=factory("Mes");
  		car.run();
  	}
  	
  	//工厂角色  创造不同的车
  	public static Car factory(String name){
  		Car car=null;
  		if(name.equals("Mes")){
  			car=new Mes();
  		}else{
  			car=new YeMa();
  		}
  		return car;
  	}
  }
  
  interface Car{
  	void run();
  }
  
  //奔驰
  class Mes implements Car{
  
  	@Override
  	public void run() {
  		System.out.println("坐在引擎盖上哭...");
  	}
  	
  }
  
  //野马
  class YeMa implements Car{
  
  	@Override
  	public void run() {
  		System.out.println("野马...");
  	}
  	
  }