几种常见设计模式: 单例模式工厂模式静态代理

本文链接：https://blog.csdn.net/wdd199801140310/article/details/102748915

单例模式

*    保证一个类只能有一个对象,这个特点形式的类成为单例模式,但是不影响类中原有的功能
*
*   单例:
*       懒汉式:当第一次调用的时候才创建这个实例            ----线程不安全的,效率较高
*       饿汉式:在类第一次加成完成之后,就创建这个实例       ----线程安全的,效率较低
*
*   实现:
*       1.构造器私有化
*       2.私有的,静态的该类的引用,存储创建唯一的对象的
*       3.公共的静态的访问方式

//饿汉模式
public class SingleTon {
	//2.私有的,静态的该类的引用,存储创建唯一的对象的
	private static SingleTon single = new SingleTon();
	
	//1.构造器私有化
	private SingleTon(){}
	
	//3.公共的静态的访问方式 
	//返回值: 当前类型的对象   参数:没有
	public static SingleTon newInstance(){
		return single;
	}
}

/*
 * 懒汉式
 */
public class Single {
	//2.私有的,静态的该类的引用
	private static Single single=null;
	//1.私有的构造器
	private Single(){}
	//3.公共的静态的该类的引用
	public static Single newInstance(){
		if(single==null){
			single=new Single();
		}
		return single;
	}
}

//最后的结果返回的为true就是表示俩者的地址一样,说明就算new再多,也只会产生一个实例
public class Test {
	public static void main(String[] args) {
		//SingleTon single= new SingleTon();
		SingleTon single1=SingleTon.newInstance();
		SingleTon single2=SingleTon.newInstance();
		System.out.println(single1==single2);
		
		Single single3=Single.newInstance();
		Single single4=Single.newInstance();
		System.out.println(single3==single4);
	}
}

静态代理

*    1.真实角色和代理角色实现相同的接口|继承相同的父类
*    2.代理角色持有真实角色的引用:成员属性来进行维护
*    3.代理行为
* 优点: 减少与真实角色的交流,降低耦合度,起到功能的扩展,方便后期维护


public class StaticProxy {
	public static void main(String[] args) {
		//项目经理
		Manager manager=new Manager();
		//Hr 为谁代理,就要前面先创建一个主人,将主人传递进去
		Hr hr=new Hr(manager);
		hr.addUser();
	}
}

//录用人
interface AddUser{
	void addUser();
}

//真实角色
class Manager implements AddUser{

	@Override
	public void addUser() {
		System.out.println("录用了..");
	}
}

//代理角色
class Hr implements AddUser{
	//代理角色持有真实角色的引用
	Manager manager;
	//创建一个含有真实角色的引用
	public Hr(Manager manager) {
		this.manager=manager;
	}

	@Override
	public void addUser() {
		System.out.println( "发布招聘信息...");
		System.out.println( "预约面试...");
		manager.addUser();
		System.out.println( "谈薪资...");
	}
}

工厂模式

//设计模式之工厂类
public class FactoryTest {

	public static void main(String[] args) {
		//普通情况:
		/*DaNiu daniu = new DaNiu();
		daniu.run();*/
		
		//用工厂设计模式:  输入想制造什么类型的车
		Car car=factory("D");
		car.run();
	}
	
	//工厂:生产汽车       运用多态,不能直接写大牛或着布加迪,因为就写死了,
	//多态,父类引用指向子类对象,可以有效的先声明对象,具体给什么值到时候在说
	public static Car factory(String str){
		//接口不能被实例化,但是可以声明(接口也是一个数据类型,可以声明)
		Car car = null ;
		//字符比较最好字符串放在前面,可以避免空指针异常
		if ("DaNiu".equals(str)) {
			car = new DaNiu();
		}else if("BuJiaDi".equals(str)){
			car = new BuJiaDi();
		}else {
			
		}
		return car;
	}
	
}

interface Car{
	void run();
}


class DaNiu implements Car{

	@Override
	public void run() {
		System.out.println("大牛正在行驶...");
	}
	
}

class BuJiaDi implements Car{

	@Override
	public void run() {
		System.out.println("布加迪正在行驶...");
	}
	
}