回顾；内部类和Lambda表达式小用

内部类–Lambda表达式

内部类都是在类中类（类似盖中盖）但又不全是。
内部类细分的话有以下的几种：
成员内部类
局部内部类
私有内部类
静态内部类
匿名内部类

---

• 成员内部类:
  内部类定义在外部类的成员位置
  成员：可以使用成员修饰符,public static …
  类:可以继承类,可以实现接口
  具体的实例：

在这里插入代码片public class Outer{
	public String name="张三";
	private int age=18;
	private static int height=180;
		//成员内部类
	public class Inner extends A implements B{
		static final int A=5;
		private int b=10;
		
		public void haha(){
			System.out.println(A);
			System.out.println(name);
			System.out.println(age);
			System.out.println(height);
		}

		@Override
		public void test() {}
	}
	
	//外部类的成员方法
	public void outer(){
		Inner in=new Inner();
		System.out.println(Inner.A);
		System.out.println(in.A);
		System.out.println(in.b);
		in.haha();
	}
}

class A{}
interface B{
	void test();
}

成员内部类可以直接访问外部类所私有的一切
内部类中不可以叮以静态的内容
除了一个：静态的常量
static final int A=5;

---

• 局部内部类：

方法中定义内部类
1.局部内部类不可以使用成员修饰符修饰(比如:public,static…不包括final)
2.只能在当前定义局部内部类的—方法中可以通过内部类的对象—使用内部类中的成员,通过类可以使用静态

代码示意：

public class LocalInner {
	public static void main(String[] args) {
	//方法的调用
		new Outer05().outer();
	}
}

//外部类
class Outer05{
	String name="李四";
	//成员方法
	void test(final int args){
		int a=5;  //局部变量
		//局部内部类
		class Inner{
			static final int age=18;
			int height=185;
			void inner(){
				System.out.println(a);
				System.out.println(age);
				System.out.println(name);
				System.out.println(args);
			
			}
		}
		//在当前方法中使用局部内部类中的内容
		System.out.println(Inner.age);
		Inner in=new Inner();
		in.inner();
		System.out.println(in.height);
	}
	
	void outer(){
		test(4);
		//错误的示范
		/*Inner in=new Inner();
		in.inner();*/
	}
}

---

• 私有内部类:
  1.私有内部类中可以使用外部类中所有的内容,包括私有的
  2.私有内部类只能在外部类中可以通过对象使用私有内部类中的私有内容,其他类中不能使用

public class PrivateInner {
	public static void main(String[] args) {
	//错误代码示范
		//new Outer03().new Inner().haha();
	}
}

//外部类
class Outer03{
	private int a=10;
	private static int b=20;
	//私有内部类
	private class Inner{
		private int c=30;
		
		private void inner(){
			System.out.println(c);
			System.out.println(a);
			System.out.println(b);
		}
	}
	
	//外部类的成员方法
	public void outer(){
		Inner in=new Inner();
		System.out.println(in.c);
		in.inner();
	}
}

---

• 静态内部类
  1.静态内部类可以定义静态的内容可以定义成员的内容
  2.在静态内部类中使用外部类中的非静态的内容,要通过外部类的对象去使用
  3.在外部类中可以通过类名使用静态内部类中的静态内容,需要通过对象使用静态内部类中的成员内容
  4.在其他类中可以通过外部类名.静态内部类名.静态内容使用静态内部类中的静态内容

public class StaticInner {
	public static void main(String[] args) {
		System.out.println(Outer.Inner.id);
		Outer.Inner.hehe();
		Outer.Inner in=new Outer.Inner();
		in.haha();
	}
}

class Outer{
	private int a=5;
	private static int b=10;
	
	//静态内部类
	static class Inner{
		//静态内部类中的静态变量
		static int id=0;
		//静态内部类中的成员变量
		String name="张三";
		
		//静态内部类中的静态方法
		static void hehe(){
			System.out.println(id);
			Inner in=new Inner();
			System.out.println(in.name);
			
			System.out.println(b);
			Outer s=new Outer();
			System.out.println(s.a);
		}
		//静态内部类中的成员方法
		void haha(){
			System.out.println(id);
			System.out.println(name);
			Outer04 s=new Outer04();
			System.out.println(b);
			System.out.println(s.a);
		}
	}
	
	//外部类中的成员方法
	void outer(){
		System.out.println(Inner.id);
		Inner in=new Inner();
		System.out.println(in.name);
		Inner.hehe();
		in.haha();
	}
}

---

• 匿名内部类
  一个没有名字的类，匿名内部类的主要作用就是简化代码
  当然后面还有Lambda表达式更加的简洁

public class AnonymousInner {
	public static void main(String[] args) {
		//1.匿名内部类
		/*new Animal(){ //--匿名内部类的蕾体  是new后面的接口或者父类的实现类|子类的类体
			public void dog() {
				System.out.println("撸狗…….");
			}

			@Override
			public void cat() {
				System.out.println("吸猫...");
			}
		}.cat();*/

		//2.引用接收匿名内部类对象的地址---接口多态
		Animal s=new Animal(){ 
			public void dog() {
				System.out.println("撸狗……");
			}
			@Override
			public void cat() {
				System.out.println("吸猫...");
			}
		};
		s.dog();
		s.cat();
	}
}
interface Animal{
	void dog();
	void cat();
}

1.有只是用一次的内部类，用完就被回收放弃的
2.也有直接将接口实现类的重写方法放在了接口的后面
运用了接口的多态，直接将匿名类的类体指向了一个引用

在匿名内部类的基础之上，便有了现在的Lambda表达式

Lambda表达式

舍去了臃肿的内部类大的结构，值需要重写方法的参数列表一级方法体

解开注释，在接口中对应参数列表可以一一实现

/*
 * Lambda表达式

 * 语法:  ()->{}
 * 	() :-->重写的抽象方法的参数列表
 * 	-> :箭头符号,箭头函数,Lambda符号
 *  {} :重写的抽象方法的方法体
 *  
 * 
 *  @FunctionalInterface : 强制检查是否为函数式接口
 */
public class LambdaDemo {
	public static void main(String[] args) {
		Animal animal=new Animal(){
			@Override
			public void dog() {
				System.out.println("撸狗");
			}
		};
		animal.dog();
		
		//Lambda表达式写法1
/*		Animal animal=()->{
			System.out.println("撸狗");
		};
		animal.dog();*/
		
		//写法2:如果方法的语句体只有1句,前后的{}可以省略
/*		Animal animal=()->System.out.println("撸狗");
		animal.dog();*/
		
		
		//写法3: 如果存在参数,参数的数据类型可以省略
/*		Animal animal=(i,j)->System.out.println("第"+i+"天撸狗"+j+"次");
		animal.dog(10,11);*/
		
		//写法4:如果存在参数,并且参数只有一个前后的()可以省略
/*		Animal animal= i ->{
			System.out.println("撸狗"+i+"次");
		};
		animal.dog(100);*/
		
		
		/*写法5: 有返回值类型的方法,如果方法体语句只有1句,
		并且是return语句的时候,这时前后{},包括return都可以省略*/
		/*Animal animal= str -> str.length();
		//返回字符串的长度
		System.out.println(animal.dog("狗狗狗"));*/
	}
}

//函数式接口
@FunctionalInterface
interface Animal{
	void dog();
//	void dog(int i,int j);
//	void dog(int a);
//	int dog(String string);
}