常见模式|静态代理|内部类|Lambda表达式

常见模式

单例模式:保证一个类,只能存在一个实例

懒汉式: 第一次调用时候,才创建实例从 —线程不安全
饿汉式: 在类第一次加载完成之后,就创建实例 —线程安全的

实例步骤:
1.私有的构造器
2.私有的,静态的,该类的引用
3.公共的静态的访问方式

• 懒汉式:保证线程安全通过 同步锁 synchronized

   public class SingleTon01 {
   	//2.私有的,静态的,该类的引用
   	private static SingleTon01 singleTon=null;  //存储唯一的实例
   	//1.私有的构造器
   	private SingleTon01(){}
   	
   	//3.公共的静态的访问方式  返回值:需要 SingleTon01  参数:不需要
   	//同步方法,效率较低,范围大
   	/*public static synchronized SingleTon01 newInstance(){
   		// A  B  C
   		if(singleTon==null){
   			singleTon = new SingleTon01();
   		}
   		return singleTon;
   	}*/
   	
   	//同步方法,效率较低,范围大
   	/*public static SingleTon01 newInstance(){
   		// A  B  C
   		synchronized (SingleTon01.class) {
   			if(singleTon==null){
   				singleTon = new SingleTon01();
   			}
   		}
   		return singleTon;
   	}*/
   	//双重检查  double check:锁的范围小,效率高
   	public static SingleTon01 newInstance(){
   		// A  B  C
   		if(singleTon==null){
   			// A  B  C 
   			synchronized (SingleTon01.class) {
   				if(singleTon==null){
   					singleTon = new SingleTon01();
   				}
   			}
   		}
   		return singleTon;
   	}
   	
   }
  

• 饿汉式:

  第一次加载,就创建对象

   public class Single02 {
   	//2.静态的,私有的,该类的引用
   	private static Single02 single=new Single02();
   	//1.构造器私有化
   	private Single02(){}
   	
   	//3.公共的访问方式
   	public static Single02 newInstance(){
   		return single;
   	}
   }
  
   //  主方法
   public class Test {
   	public static void main(String[] args) {
   		//SingleTon01 single=new SingleTon01();
   		SingleTon01 single01=SingleTon01.newInstance();
   		SingleTon01 single02=SingleTon01.newInstance();
   		System.out.println(single01 == single02);
   		
   		Single02 single03=Single02.newInstance();
   		Single02 single04=Single02.newInstance();
   		System.out.println(single03==single04);
   	}
   }
  

简单工厂模式

1.抽象产品角色: 具体产品角色继承的父类|实现的父接口
2.具体产品角色: 抽象产品角色的实现类或者子类
3.工厂角色 : 帮助创建实例

	publi