Java8 新特性
文章目录
- 函数接口定义
接口中默认的方法修饰为普通方法
在JDK8之前.interface之中可以定义变量和方法,变量必须是public,static, final的, 方法必须是public,abstract的, 由于这些修饰符都是默认的
- 接口定义方法: public抽象方法,需要子类实现
- 接口定义变量, public static final
在JDK1.8 开始, 支持使用static的default修饰 可以写方法体, 不需要子类重写
方法:
- 普通方法: 可以有方法体
- 抽象方法: 没有方法体需要子类实现,重写.
public interface JDKInterface {
/**
* 抽象方法 需要子类实现
* 默认类型：public、abstract
*/
void add();
void addOrder();
/**
* 默认方法 可以写方法体
*/
default void getDefaultOrder() {
System.out.println("我是默认的方法体");
}
}
public class JDKInterfaceImpl implements JDKInterface {
/**
* 默认的情况下必须重写接口中抽象方法 默认和静态方法是不需要必须重写
*/
@Override
public void add() {
}
@Override
public void addOrder() {
}
}Lambda表达式
什么是lambda表达式
lambda好处: 简化我们匿名内部类的调用
lambda+方法引入 代码变得更加精简
为什么要使用Lambda表达式
可以非常简洁的形式调用我们的匿名函数接口。
public interface OrderService {
/**
* 如果需要使用OrderService接口
* 接口是无法new 可以通过匿名内部类new
* 定义子类
*/
void get();
}public class Test02 {
public static void main(String[] args) {
// 1.使用new的实现类的形式调用接口
OrderService orderService = new OrderService() {
@Override
public void get() {
System.out.println("hhhhh");
}
};
orderService.get();
// 2.使用匿名内部接口调用
new OrderService() {
@Override
public void get() {
System.out.println("hhhhh");
}
}.get();
// 3.使用lambda调用接口
((OrderService) () -> System.out.println("hhhhh")).get();
}
}Lambda表达式的规范
使用Lambda表达式 依赖于函数接口
- 在接口中只能允许使用一个抽象方法
- 在函数接口中定义object类中方法
- 使用默认或者静态方法
-
@FunctionalInterface 表示该接口为函数接口
Java中使用Lambda表达式的规范，必须是为函数接口
函数接口的定义：在该接口中只能存在一个抽象方法，该接口称作为函数接
函数接口定义
- 在接口中只能有一个抽象方法
-
FunctionalInterface标记为接口为函数接口 - 可以通过default修饰普通方法
- 可以定义object类中的方法
@FunctionalInterface
public interface MyFunctionalInterface {
void add();
default void get() {
}
/**
* object父类中的方法可以在 函数接口中重写
*
* @return
*/
String toString();
}
Lambda基础语法
( ) — 参数列表
–> 分割
{} 方法体
(a,b)->{
}
- 无参方法调用
- 带参数方法调用
():函数方法参数列表
->分隔 {}方法体
(a,b)->{
Sout(a,b)
}
Lambda语法：
():参数列表
->分隔
{}:方法体
()->{}
无参方法调用
@FunctionalInterface
public interface AcanthopanaxInterface {
void get();
}
public class Test03 {
public static void main(String[] args) {
//1.使用匿名内部类调用
new AcanthopanaxInterface() {
@Override
public void get() {
System.out.println("get");
}
}.get();
//2.使用lamdba表达式调用方法
AcanthopanaxInterface acanthopanaxInterface = () -> {
System.out.println("使用lamdba表达式调用方法");
};
acanthopanaxInterface.get();
}
}带参数方法调用
@FunctionalInterface
public interface YouShenInterface {
String get(int i, int j);
}
public class Test04 {
public static void main(String[] args) {
//1.使用匿名内部类调用
YouShenInterface youShenInterface = new YouShenInterface() {
@Override
public String get(int i, int j) {
return i + "-----" + j;
}
};
System.out.println(youShenInterface.get(2, 4));
//2.使用lamdba表达式调用方法
YouShenInterface you = (i, j) -> {
return i + "-----" + j;
};
System.out.println(you.get(2,6));
//3.使用lamdba表达式调用方法
((YouShenInterface)(i,j)->i+"---"+j).get(6,7);
}
}精简语法
public class Test05 {
public static void main(String[] args) {
AcanthopanaxInterface acanthopanaxInterface = () -> System.out.println("我是方法");
acanthopanaxInterface.get();
//精简代码 // 使用lambda方法体中中只有一条语句的情况下
((AcanthopanaxInterface) () -> System.out.println("我是你别笔笔不")).get();
YouShenInterface youShenInterface = (i, j) -> {
return i + "++++++" + j;
};
// 使用Lambda 方法体中只有一条语句的情况下，在这时候我们不需要写{} 也可以不需要写return
String s = ((YouShenInterface) (i, j) -> i + "++++++" + j).get(4, 5);
System.out.println(s);
}
}Lambda实战案例
案例一:
public class Test06 {
public static void main(String[] args) {
ArrayList<String> string = new ArrayList<>();
string.add("qqqq");
string.add("rrrrrr");
string.add("aaaaa");
//普通输出:
string.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println("0---"+s);
}
});
//Lambda:
string.forEach((o)->{
System.out.println(o);
});
}
}案例二:
public class Test07 {
public static void main(String[] args) {
ArrayList<UserEntity> userLists = new ArrayList<>();
userLists.add(new UserEntity("cqqqq", 23));
userLists.add(new UserEntity("ooooo", 14));
userLists.add(new UserEntity("-----", 44));
//方法一: 排序 //普通内部类:
userLists.sort(new Comparator<UserEntity>() {
@Override
public int compare(UserEntity o1, UserEntity o2) {
return o1.getAge() - o2.getAge();
}
});
//方法一: 排序 //Lambda:
userLists.sort((o1, o2) -> o1.getAge() - o2.getAge());
userLists.forEach((t) -> {
System.out.println(t.toString());
});
}
}