javaSE . 匿名内部类，Lambda表达式，interface

 一.匿名内部类，interface

package com.shsxt.exercise;

public class AnonymousInner {

	public static void main(String[] args) {
		HaHa ha = new HaHa();
		ha.run();
		
		//匿名内部类      简化接口的实现类，可以使用匿名内部类（不经常使用的类，使用一次就可以了的类选用匿名内部类）
		//Car car = new Car();  //错误    Car是个接口，不允许实例化，不能直接new Car()
		                        //但是    可以通过new 这里Car这个接口的  实现类HaHa的类体的对象
			                   /*实现类HaHa的类体是：
			                    *@Override
								public void run() {
									System.out.println("重写的run()方法，哈哈哈");
								}
			                   */
		
		//正确代码
		//只能使用一次    匿名内部类只能使用一次，用完销毁
		//Car car = new Car()    将“Car car = ”可以省略后如下
		 
		/*new Car(){//从这个{}开始  就是   实现类的类体，就是匿名内部类的类体
			@Override
			public void run() {
				System.out.println("重写的run()方法，哈哈哈");
			}
		  };*/
		
		
		//可以多次调用    通过引用使用,可以多次调用
		Car car = new Car(){
			@Override
			public void run() {
				System.out.println("重写的run()方法，哈哈哈");
			}
			@Override
			public void run2() {
				System.out.println("重写的run()方法，哈哈哈");
			
			}
		};
		car.run();
		car.run2();
		
		
		//匿名内部类可以作为一个方法的参数使用
		test(new Car(){

			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("111");
			}

			@Override
			public void run2() {
				System.out.println("2222");
				
			}
			
		});
		
		}
	static void test(Car car){//Car car  ---->匿名内部类
		car.run();
	}

}


/*
 * 在抽象类中，可以包含一个或多个抽象方法；但在接口(interface)中，所有的方法必须都是抽象的，不能有方法体，它比抽象类更加“抽象”。
	接口：一种把类抽象的更彻底，接口里只能包含抽象方法的“特殊类”。接口不关心类的内部状态数据，定义的是一批类所遵守的规范。（它只规定这批类里必须提供某些方法，提供这些方法就可以满足实际要求）。
	接口(interface)是我们开发java项目，必须用到的方法，而接口是一种完全抽象的设计，没有任何实现。
	接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
	接口(interface)的特征:
	1.所有的成员变量都是public、static、final类型。 
	2.所有的方法都是public、abstract类型。 
	3.所有的嵌套类型（类或接口）都是public、static类型。
	由此可知，接口中的所有成员都是public的，因为接口是抽象的，必须由其他类所实现，故成员一定要具备足够的访问权限。
 */
interface Car{
	void run();
	void run2();
}

//实现类只用了一次，没有其他的作用，可以使用匿名内部类简化
class HaHa implements Car{
	@Override
	public void run() {
		System.out.println("重写的run()方法，哈哈哈");
	}

	@Override
	public void run2() {
		System.out.println("重写的run2()方法，哈哈哈");
		
	}
}

二.Lambda表达式

       JDK1.8新增

     目的：为了简化匿名内部类

     （）——>{}

       ()   抽象方法的参数列表

       ——>箭头函数，箭头符号，具有上下文推到的作用

       {}  抽象方法的方法体

       前提：函数式接口（只有一个抽象方法的接口，叫函数式接口）

                  检查是否为函数式接口：（注解）@FunctionalInterface

package com.shsxt.lambda05;
/*
 * Lambda表达式
 * 	jdk1.8新增
 * 	目的:为了简化匿名内部类
 *  ()->{}
 *  (): 抽象方法的参数列表
 *  ->:箭头函数,箭头符号,具有上下文推倒的作用
 *  {}:抽象方法的方法体
 *  函数式接口:只有一个抽象方法的接口,叫做函数式接口
 *  检测是否为函数式接口: @FunctionalInterface
 */
public class LambdaDemo05 {
	public static void main(String[] args) {
		A a=null;
		/*a=new A(){
			@Override
			public void a(int a) {
				System.out.println("我是匿名内部类的方法体实现");
			}
		};
		a.a();*/
		
		/*a=()->{System.out.println("我是Lambda的方法体实现");};
		a.a();*/
		
		/*a=(age)->{System.out.println("抽象方法存在一个参数,参数的数据类型可以省略,前后()可以省略"+age);};
		a.a(20);*/
		
		/*a=(age,height)->{System.out.println("抽象方法存在2个参数,参数的数据类型可以省略,前后的()不可以省略"+age+height);};
		a.a(20,180);*/
		
		//a=(age,height)->System.out.println("抽象方法的方法体语句只有一句,前后的{}可以省略"+age+height);
		
		//如果抽象方法有返回值,只有一条返回值语句,return和前后的{}都可以省略
		a=(age,height)-> -111 ;
		System.out.println(a.a(18,185));
	}
}

//函数式接口
@FunctionalInterface
interface A{
	int a(int age,int height);
	//void b();
}