匿名内部类和Lamda

内部类分为：局部内部类，成员内部类，静态内部类，匿名内部类

因为接口不能直接new，其实就是创建了一个接口的实现类。

匿名内部类，没有名字。并且必须实现父类的所有的抽象方法。

上代码：

//抽象类
public abstract class Abstr {
	public abstract void get();
	public abstract void set();
}

//接口
public interface Inter {
	public int get(int a, int b);
}

//测试类
public class Test {
	public static void main(String[] args) {
		//匿名内部类
		Inter i1=new Inter() {
			@Override
			public int get(int a, int b) {
				int sum=a+b;
				return sum;
			}
		};
		System.out.println(i1.get(10,20));
        //实现抽象类的所有抽象方法
		Abstr a=new Abstr() {
			@Override
			public void set() {
			}
			@Override
			public void get() {
			}
		};
	}
}

Lamda表达式要求：

1. jdk1.8
2. 只能是接口，并且接口中只能有一个抽象方法
3. @functionalInterface这个注解一旦加上以后，本接口就只能有一个抽象方法。

lamda单行 多行 

//接口
public interface Inter1 {
	public int test(int a,int b);
}
//测试类
public class Test {
	public static void main(String[] args) {
		//在有参数的情况下 (这里就写参数 ) 参数可以不声明类型 
		//参数的声明可写 可不写 但是返回值一定不能写return
		Inter1 i1=(int a,int b)->   a+b;  //单行 直接 写在后面一行。有返回值
		System.out.println(i1.test(20, 20)); 
		//多行有返回值的   这里写的是接口的方法体
                Inter1 i2=(a,b)->{
			int sum=a+b;
			return sum;
		};
		System.out.println(i2.test(20, 30));
	}
}

构造引用，普通对象引用普通方法，类名引用静态方法

@FunctionalInterface
interface Message{
	public void test();
}
class Book{
	public Book(){
		System.out.println("你真棒");
	}
}
public class Test {
	public static void main(String[] args) {
		Message mes=Book :: new;
		//表示创建接口并且实现抽象方法 
		//实现的方法体是Book对象的 new也就是构造方法。mes拥有Book的构造方法
		mes.test();
	}
}
///
//带有参数的构造方法
@FunctionalInterface
interface Message{
	public void test(String str);//接口必需要有同类型的参数
}
class Book{
    String str;
	public Book(String str){//构造方法带参数
            this.str=str;
		System.out.println(str+"你真棒");
	}
}
public class Test {
	public static void main(String[] args) {
		Message mes=Book :: new;
		//表示创建接口并且实现抽象方法 
		//实现的方法体是Book对象的 new也就是构造方法。mes拥有Book的构造方法
		mes.test("荆方冰");//输出 荆方冰你真棒
	}
}

普通对象引用普通方法 （泛型）

interface Inter1<P,R>{
	//泛型的类型  <K> key ,<V> value, <E> element  , <? extends Book>,<P> parameter ,R  return    
	public R getMes(P p);
}
public class Test1 {
	//我们使用String类给我们提供的一个方法 类使用这个接口
	//依然是  lamda表达式的形式 
	//对比开始startWith   对比结束endWith  返回boolean
	public static void main(String[] args) {
		String str="abcdefg";
		String str1=new String("abcdefg");
		//System.out.println(str.startsWith("ad"));
		//表示创建接口实现类并且引用方法  str对象的 
		//对象引用普通方法
		Inter1<String,Boolean> i1=str ::startsWith;
		System.out.println(i1.getMes("a")); 
	}
}

函数式接口

jdk1.8 给我们提供了很多函数式接口  java.util.function

1. 功能型接口      Function
2. 消费型接口     Consumer
3. 生产型  （供给型）   Supplier
4. .断言型（校验，测试） Predicate

//功能型函数接口
public class Test6 {
	public static void main(String[] args) {
        //Integer parseInt的参数和返回值 要与 Function的泛型类型一致
		Function<String, Integer> fun=Integer ::parseInt;//功能型函数 主要方法为 apply()
		System.out.println(fun.apply("9999"));
	}
}
//消费型函数接口
public class Test7 {
	public static void main(String[] args) {
		//消费型接口 实现输出print方法
		Consumer<String> con=System.out::print;
		con.accept("消费型接口主要方法为 accept");
	}
}
//供给型接口
public class Test8 {
	public static void main(String[] args) {
        //供给型接口 实现输出当前系统时间
		Supplier<Long> supp=System::currentTimeMillis;
		System.out.println(supp.get());//Supplier的主要方法为 get（）
	}
}
//断言型接口   java提供的有用于验证正则表达式的类  
public class Test9 {
	public static void main(String[] args) {
		//断言  测试 校验类型  比如 我们测试一个字符串是不是数字 
		String str="100s0";
		Predicate<String> p=str::matches;
                //可以传入正则表达式
		System.out.println(p.test("\\d+")); //Predicate的主要方法为 test（）