单例模式、静态代理以及内部类的使用

单例模式

单例模式核心的作用是保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

饿汉式：

指在单例类加载的时候就初始化需要单例的对象；饿汉式单例模式的特点是线程安全，调用效率高，但是不能延时加载。

public class Single {
	//类初始化时，立即加载这个对象（没有延时加载优势）。加载类时，线程安全
	private static Single single=new Single();
	//构造器私有化，外部不能调用
	private Single(){
		
	}
	//方法没有同步，调用效率高
	public static Single newInstance(){
		return single;
	}
}

懒汉式

如果单例对象需要占用很大的内存，那么一开始就初始化该对象会一直占用大量的内存。如果不在类加载时初始化，而在想用的时候再初始化这个对象，这是就需要懒汉式的单例模式了。
懒汉式单例模式的特点是线程安全，调用效率不高，但是可以延时加载。

public class Single02 {
	//类初始化时，不初始化这个对象（延时加载，真正用的时候在创建）
	private static Single02 single=null;
	//私有的构造器
	private Single02(){
		
	}
	//公共的访问方式
	public static Single02 newInstace(){
		if(single==null){
			single=new Single02();
		}
		return single;
	}
}

静态代理

• 真实角色需要和代码角色实现相同的接口
• 代理需要持有真实角色的引用
• 代理行为
• 减少与真实角色的交流,提高代码的安全性,解耦,便于后期维护,代理角色可以扩展功能

public class StaticProxy {
	public static void main(String[] args) {
		Manager manager=new Manager();
		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() {
		
	}
	
	public Hr(Manager manager) {
		super();
		this.manager = manager;
	}

	@Override
	public void addUser() {
		System.out.println("发布招聘信息。。。");
		manager.addUser();
		System.out.println("开始谈薪资。。。");
	}
	
}

工厂模式

工厂模式实现了创建者和调用者的分离。工厂模式可分为：简单工厂模式、工厂方法模式、抽象工厂模式。这里我们只要了解简单工厂模式即可。

public class Factory {
	public static void main(String[] args) {
		Car car=factory("QQ");
		car.run();
	}
	
	public static Car factory(String name){
		Car car;
		if("QQ".equals(name)){
			car=new QQ();
		}else{
			car=new VV7();
		}
		return car;
	}
}

interface Car{
	void run();
}

class QQ implements Car{

	@Override
	public void run() {
		System.out.println("QQ在跑");
	}
	
}

class VV7 implements Car{

	@Override
	public void run() {
		System.out.println("VV7在跑");
	}
	
}

内部类

内部类是一种特殊的类，它指的是定义在一个类的内部的类。在实际开发中，为了方便使用外部类的相关属性和方法，通常需要定义一个内部类。
内部类的分类：成员内部类（非静态内部类和静态内部类）、匿名内部类和局部内部类。

成员内部类

成员内部类可以使用private、default、protected、public进行修饰。

public class Outer01 {
	private int a=5;
	String str="123";
	//定义内部类
	public class Inner extends A{
		int b=3;
		static final int c=10;
		String str="456";
		
		public void inner(){
			String str="789";
			System.out.println("我是内部类中的成员方法");
			System.out.println(b);
			System.out.println(a);
			
			//局部str
			System.out.println(str);
			//内部类成员str
			System.out.println(this.str);
			//外部类成员str
			System.out.println(new Outer01().str);
		}
		//外部类中的成员方法
		void outer(){
			//内部类对象
			Inner in=new Inner();
			System.out.println(in.b);
		}
	}
}
class A{
	
}

匿名内部类

匿名内部类适合那种只需要使用一次的类

public class Anonymous {
	public static void main(String[] args) {
		/*new Swing(){

			@Override
			public void swing() {
				System.out.println("一边游泳一边喝水");
			}
			
		}.swing();*/
		//有引用接收的匿名内部类对象
		/*Swing s=new Swing(){

			@Override
			public void swing() {
				System.out.println("一边游泳一边敲代码");
			}
			
		};
		s.swing();*/
		
		//作为方法的参数使用
		test(new Swing(){
			@Override
			public void swing() {
				System.out.println("一边敲代码一边玩游戏");
			}
		});
	}
	
	static void test(Swing s){
		s.swing();
	}
}

interface Swing{
	void swing();
}

Lamdba表达式

Lambda表达式 jdk1.8的新特性

• 作用:用来简化匿名内部类

• 前提: 函数式接口

• 函数式接口: 只有一个抽象方法的接口就是函数式接口

• 检查函数式接口: @FunctionalInterface

• 语法:

•  ()->{}
  

•  () ->抽象方法的参数列表
  

•  -> 箭头函数|Lambda符号,具有上下文推到的作用
  

•  {} 抽象方法的方法体
  

public class LambdaDemo {
	public static void main(String[] args) {
		Pizza p=null;
		/*
		//匿名内部类
		Pizza p=new Pizza(){
			@Override
			public void show(int a) {
				System.out.println("我会匿名内部类");
			}
		};
		//Lamdba表达式写法1：
		p=()->{System.out.println("我是Lamdba表达式写法1");};
		
		//Lamdba表达式写法2：如果方法体语句只有一句,前后的{}可以省略
		p=()->System.out.println("我是Lamdba表达式写法2");
		
		//Lamdba表达式写法3：如果抽象方法有参数,参数的数据类型可以省略
		p=(a)->System.out.println("我是Lamdba表达式写法3");
		
		//Lamdba表达式写法4：如果抽象方法参数只有一个,前后的()可以省略
		p=a->System.out.println("我是Lamdba表达式写法4");
		
		//Lamdba表达式写法5： 如果语句体只有一句,但是是return的话,前后的{}与return关键字可以一起省略
		p=a-> "我是Lamdba表达式写法5";
		System.out.println(p.show(1));
		*/
		p.show(1);
	}
}
interface Pizza{
	//void show(int a);
	String show(int a);
}