java8新特性

一、Java8 对接口的改变

　　1、增加了default方法和static方法，这两种方法完全可以有方法体，而且必须要有方法体。

　　2、default方法属于实例，static方法属于类（接口）。

 车

public interface TestInterface01 {
//java8中接口的静态方法必须要有方法体，它属于接口；
static void testStatic() {
//doSomething
}
//java8中默认方法必须要有方法体，它属于实例对象；
default void test1() {
//doSomething
}
}

 

　　3、接口里面的静态方法不会被继承；静态变量会被继承下来。

　　4、如果一个类实现了多个接口，并且这些接口互相之间没有继承关系，同时存在默认的方法，如果不重写同名的默认方法则会报：“不相关默认值” 的错误。

　　　　如果多个接口有继承关系，默认方法会被子接口覆盖。

　　5、如果遇到有多个实现，并且有相同的默认方法，实现类可以通过特殊的语法来指定需要调用哪个接口的默认方法；

　　　　方式： 重写相同的默认方法  在方法体中采用：  <接口名>.super.<方法名>([参数])    的语法方式来指定需要调用那个接口的方法。

public interface TestInterface01 {
//java8中接口的静态方法必须要有方法体，它属于接口；
static void testStatic() {
//doSomething
}
//java8中默认方法必须要有方法体，它属于实例对象；
default void test1() {
//doSomething
System.out.println("this is Interface01");
}
}

public interface TestInterface02 {

default void test1() {
//doSomething
System.out.println("this is Interface02");
}
}

public class TestClass implements TestInterface01,TestInterface02{
//遇到没有继承关系的多个接口有重复的抽象方法，必须重写这个接口，可以指定执行接口中的一个或者多个重复的方法
@Override
public void test1() {
// TODO Auto-generated method stub
TestInterface01.super.test1();
TestInterface02.super.test1();
}

public static void main(String[] args) {
TestClass tes = new TestClass();
tes.test1();
}

}

 

　　6、如果一个接口只有一个抽象方法（包括继承的） ， 那么该接口叫做函数式接口。

　　　　函数式接口可以用Lambda 表达式实现。

　　7、如果接口里面使用FunctionalInterface 注解，则为限定接口只能是函数式接口，即只能有一个抽象方法。

 

@FunctionalInterface
public interface TestInterface02 {

default void test1() {
//doSomething
System.out.println("this is Interface02");
}
//在使用注解@FunctionalInterface修饰接口时，该接口只能是函数式接口，有且只能有一个抽象方法 
void test02();
}

　　8、Lambda表达式使用实例：

public class TestLambda {
public static void main(String[] args) {
//java8以前采用匿名内部类的方式实现接口,执行代码; 会生成一个内部类的class文件 ;
new TestLambdaInterface01() {
@Override
public void test() {
// TODO Auto-generated method stub
System.out.println("采用匿名内部类的方式实现接口");
}
}.test(); //此.text() 为调用内部类的方法；
/*
* 采用lambda表达式不会产生class对象
* 参数说明：
* (): 存放参数的地方
* -> : 连接符号
* {} : 方法体
*/
//采用lambda表达式来实现
TestLambdaInterface01 t1 =()->{
System.out.println("采用lambda表达式实现");
};
t1.test();

//如果接口中方法只有一句话，可以省略一对大括号和一个分号
TestLambdaInterface01 t2 = ()->System.out.println("采用lambda表达式实现t2");
t2.test();
//lambda表达式有一个参数
TestLambdaInterface02 t3 =(x)->{
System.out.println(x);
};
t3.test(10);
//lambda表达式简写
TestLambdaInterface02 t31 = (x)->System.out.println(x);
t31.test(20);
//2个参数的情况
TestLambdaInterface03 t41 = (x,y)->{
int t = x+y;
System.out.println(t);
};
t41.test(2, 3); // 5
//2个参数如果输入一个句话也可以简写
TestLambdaInterface03 t42=(x,y)->System.out.println(x+y);;
t42.test(3, 5); // 8
//有返回值的情况,有大括号，不能省略 return关键字;
TestLambdaInterface04 t51 = (x)->{
return x+10;
};
int tt = t51.test(2);
System.out.println(tt);
//有返回值的情况，如果省略大括号的情况下一定要同时省略 return关键字 ，直接将返回的表达式赋值给引用对象;
TestLambdaInterface04 t52 =(x)->x+10;
int tt2 = t52.test(22);
System.out.println(tt2);
}
}

@FunctionalInterface
interface TestLambdaInterface01{
void test();
}
@FunctionalInterface
interface TestLambdaInterface02{
//有一个参数
void test(int x);
}
@FunctionalInterface
interface TestLambdaInterface03{
//有两个参数
void test(int x,int y);
}
@FunctionalInterface
interface TestLambdaInterface04{
//有一个参数和一个返回值
int test(int x);
}