Java8(又称jdk1.8)是Java语言开发的一个主要版本(即大版本)【对于新特性需使用API文档时，用1.8版本，否则查看不到】
函数式编程：简单理解就是把方法作为一个实参进行传递
函数式接口：一个接口中只有一个抽象方法；如何验证？使用@FunctionalInterface注解
该接口中只有一个抽象方法，所以是一个函数式接口；否则注解会提示错误异常
/**
* 接口中有：
* 全局常量
* 抽象方法
* 静态方法
* 默认方法
*/
//@FunctionalInterface 该注解是专门校验接口是否是一个函数式接口，如果校验成功，编译正常，反之编译报错
@FunctionalInterface
public interface NewFeaturesDemo {
//全局常量 默认 public static final
int numberValue = 258;
//抽象方法 默认public abstract
void add();
//静态方法
static void add1(){
System.out.println("是一个静态方法，有代码块！！！");
}
//默认方法【是Java8的新特性，Java8之前是没有默认方法的】
default void add2(){
System.out.println("是一个普通方法，ye有代码块！！！");
}
}
单元测试
功能：一个类可以实现N个主方法，通过加注解@Test的方式，该一个注解即一个主方法
/**
* 单元测试类
*/
public class UnitTesting {
@Test
public void testAll1(){
//访问全局常量
System.out.println(NewFeaturesDemo.numberValue);//258
}
@Test
public void testAll2(){
//访问抽象方法
new NewFeaturesDemo() {
@Override
public void add() {
System.out.println("我是一个抽象方法！！！");
}
}.add();//我是一个抽象方法！！！
}
@Test
public void testAll3(){
//访问静态方法
NewFeaturesDemo.add1();//是一个静态方法，有代码块！！！
}
@Test
public void testAll4(){
//访问默认方法
new NewFeaturesDemo() {
@Override
public void add() {
}
}.add2();//是一个普通方法，ye有代码块！！！
}
}
注意：鼠标在哪个区域则运行结果即该主方法区域结果，或在对应注解前有运行按钮
Java8主要新特性
A、Lambda 表达式及方法引用【一般联合使用】
使用Lambda 表达式的前提：抽象类或者接口中只能有一个抽象方法即必须是一个函数式接口
适用范围：（初始者）只有抽象方法或者接口才能使用Lambda 表达式，类也可以但使用比较小众
无参无返回值的抽象方法——Lambda 表达式
/**
* 无参数，无返回值
*/
//@FunctionalInterface 该注解是专门校验接口是否是一个函数式接口
@FunctionalInterface
public interface NewFeaturesDemo {
//抽象方法 默认public abstract
void add();
}
import org.junit.Test;
/**
* 单元测试类
*/
public class UnitTesting {
@Test
public void testAll(){
//【无参无返回值】访问抽象方法——使用传统方式
NewFeaturesDemo newFeaturesDemo = new NewFeaturesDemo() {
@Override
public void add() {
System.out.println("我是一个抽象方法！！！");
}
};
newFeaturesDemo.add();//我是一个抽象方法！！！
}
@Test
public void testAll1(){
//【无参无返回值】访问抽象方法——使用Lambda 表达式方式 1
NewFeaturesDemo newFeaturesDemo = () -> {
System.out.println("我是一个抽象方法！！！");
};//因为该接口里面只有一个抽象方法，所以用括号表示，括号里面关乎抽象方法里面是否有的参数
newFeaturesDemo.add();//我是一个抽象方法！！！
}
@Test
public void testAll2(){
//【无参无返回值】访问抽象方法——使用Lambda 表达式方式 2
//如果重写方法内部的代码内容只有一句代码，那么{}是可以省略不要的
NewFeaturesDemo newFeaturesDemo = () -> System.out.println("我是一个抽象方法！！！");
//因为该接口里面只有一个抽象方法，所以用括号表示，括号里面关乎抽象方法里面是否有的参数
newFeaturesDemo.add();//我是一个抽象方法！！！
}
}
有参有返回值——一个参数的抽象方法——Lambda 表达式
/**
* 有参数，有返回值【一个参数】
*/
//@FunctionalInterface 该注解是专门校验接口是否是一个函数式接口
@FunctionalInterface
public interface NewFeaturesDemo {
//抽象方法 默认public abstract
String add(String describe);
}
import org.junit.Test;
/**
* 单元测试类
*/
public class UnitTesting {
@Test
public void testAll(){
//【有参有返回值——一个参数】访问抽象方法——使用传统方式
NewFeaturesDemo newFeaturesDemo = new NewFeaturesDemo() {
@Override
public String add(String describe) {
return describe + "我是一个抽象方法！！！";
}
};
//有返回值必须输出或者被接收，不能直接调用
String add = newFeaturesDemo.add("使用传统方式");
System.out.println(add);//使用传统方式我是一个抽象方法！！！
}
@Test
public void testAll1(){
//【有参有返回值——一个参数】访问抽象方法——使用Lambda 表达式方式 1
NewFeaturesDemo newFeaturesDemo = (String describe) -> {
return describe + "我是一个抽象方法！！！";
};
//有返回值必须输出或者被接收，不能直接调用
String add = newFeaturesDemo.add("使用Lambda优化1");
System.out.println(add);//使用Lambda优化1我是一个抽象方法！！！
}
@Test
public void testAll2(){
//【有参有返回值——一个参数】访问抽象方法——使用Lambda 表达式方式 2
//如果重写方法内部的代码内容只有一句代码，那么{}是可以省略不要的，并且如果方法是有返回值的，return也必须省略掉否则编译报错
NewFeaturesDemo newFeaturesDemo = (String describe) -> describe + "我是一个抽象方法！！！";
//有返回值必须输出或者被接收，不能直接调用
String add = newFeaturesDemo.add("使用Lambda优化2");
System.out.println(add);//使用Lambda优化2我是一个抽象方法！！！
}
@Test
public void testAll3(){
//【有参有返回值——一个参数】访问抽象方法——使用Lambda 表达式方式 3
//如果重写方法内部的代码内容只有一句代码，那么{}是可以省略不要的，并且如果方法是有返回值的，return也必须省略掉否则编译报错
//如果在方法中形参类型都是可以省略不要的，它会自己类型推断
//如果形参列表只有1个，()也是可以省略不要的，但是注意了，如果形参列表有多个()是不可以省略的
//后面的变量名可以随意，不影响执行
NewFeaturesDemo newFeaturesDemo = describeXxxxx -> describeXxxxx + "我是一个抽象方法！！！";
//有返回值必须输出或者被接收，不能直接调用
String add = newFeaturesDemo.add("使用Lambda优化3");
System.out.println(add);//使用Lambda优化3我是一个抽象方法！！！
}
}
有参有返回值——多个参数的抽象方法——Lambda 表达式
/**
* 有参数，有返回值【多个参数】
*/
//@FunctionalInterface 该注解是专门校验接口是否是一个函数式接口
@FunctionalInterface
public interface NewFeaturesDemo {
//抽象方法 默认public abstract
String add(String describe,String describe1,String describe2);
}
import org.junit.Test;
/**
* 单元测试类
*/
public class UnitTesting {
@Test
public void testAll(){
//【有参有返回值——多个参数】访问抽象方法——使用传统方式
NewFeaturesDemo newFeaturesDemo = new NewFeaturesDemo() {
@Override
public String add(String describe, String describe1, String describe2) {
return describe + describe1 + describe2 + "我是一个抽象方法！！！";
}
};
//有返回值必须输出或者被接收，不能直接调用
String add = newFeaturesDemo.add("使用", "传统", "方式");
System.out.println(add);//使用传统方式我是一个抽象方法！！！
}
@Test
public void testAll1(){
//【有参有返回值——多个参数】访问抽象方法——使用Lambda 表达式方式 1
//如果重写方法内部的代码内容只有一句代码，那么{}是可以省略不要的，并且如果方法是有返回值的，return也必须省略掉否则编译报错
NewFeaturesDemo newFeaturesDemo = (String describe, String describe1, String describe2) -> describe + describe1 + describe2 + "我是一个抽象方法！！！";
//有返回值必须输出或者被接收，不能直接调用
String add = newFeaturesDemo.add("使用", "Lambda优化1", "方式");
System.out.println(add);//使用Lambda优化1方式我是一个抽象方法！！！
}
@Test
public void testAll2(){
//【有参有返回值——多个参数】访问抽象方法——使用Lambda 表达式方式 2
//如果重写方法内部的代码内容只有一句代码，那么{}是可以省略不要的，并且如果方法是有返回值的，return也必须省略掉否则编译报错
//方法形参列表内部的数据类型都是可以省略不要的
NewFeaturesDemo newFeaturesDemo = (describe,describe1,describe2) -> describe + describe1 + describe2 + "我是一个抽象方法！！！";
//有返回值必须输出或者被接收，不能直接调用
String add = newFeaturesDemo.add("使用", "Lambda优化2", "方式");
System.out.println(add);//使用Lambda优化2方式我是一个抽象方法！！！
}
}
无参有返回值的抽象方法——Lambda 表达式
/**
* 无参数，有返回值
*/
//@FunctionalInterface 该注解是专门校验接口是否是一个函数式接口
@FunctionalInterface
public interface NewFeaturesDemo {
//抽象方法 默认public abstract
String add();
}
import org.junit.Test;
/**
* 单元测试类
*/
public class UnitTesting {
@Test
public void testAll() {
//【无参有返回值】访问抽象方法——使用传统方式
NewFeaturesDemo newFeaturesDemo = new NewFeaturesDemo() {
@Override
public String add() {
return "使用传统方式我是一个抽象方法！！！";
}
};
//有返回值必须输出或者被接收，不能直接调用
String add = newFeaturesDemo.add();
System.out.println(add);//使用传统方式我是一个抽象方法！！！
}
@Test
public void testAll1() {
//【无参有返回值】访问抽象方法——使用Lambda 表达式方式
//如果重写方法内部的代码内容只有一句代码，那么{}是可以省略不要的，并且如果方法是有返回值的，return也必须省略掉否则编译报错
NewFeaturesDemo newFeaturesDemo = () -> "使用Lambda 表达式方式我是一个抽象方法！！！";
//有返回值必须输出或者被接收，不能直接调用
String add = newFeaturesDemo.add();
System.out.println(add);//使用Lambda 表达式方式我是一个抽象方法！！！
}
}
有参无返回值——一个参数的抽象方法——Lambda 表达式
/**
* 有参数，无返回值【一个参数】
*/
//@FunctionalInterface 该注解是专门校验接口是否是一个函数式接口
@FunctionalInterface
public interface NewFeaturesDemo {
//抽象方法 默认public abstract
void add(String describe);
}
import org.junit.Test;
/**
* 单元测试类
*/
public class UnitTesting {
@Test
public void testAll(){
//【有参无返回值——一个参数】访问抽象方法——使用传统方式
NewFeaturesDemo newFeaturesDemo = new NewFeaturesDemo() {
@Override
public void add(String describe) {
System.out.println(describe + "我是一个抽象方法！！！");
}
};
//无返回值直接方法调用即可
newFeaturesDemo.add("使用传统方式");//使用传统方式我是一个抽象方法！！！
}
@Test
public void testAll1(){
//【有参无返回值——一个参数】访问抽象方法——使用Lambda 表达式方式
//如果重写方法内部的代码内容只有一句代码，那么{}是可以省略不要的，并且如果方法是有返回值的，return也必须省略掉否则编译报错
//方法形参列表内部的数据类型都是可以省略不要的
//如果形参列表只有1个，()也是可以省略不要的，但是注意了，如果形参列表有多个()是不可以省略的
NewFeaturesDemo newFeaturesDemo = describe -> System.out.println(describe + "我是一个抽象方法！！！");
//无返回值直接方法调用即可
newFeaturesDemo.add("使用Lambda 表达式方式");//使用Lambda 表达式方式我是一个抽象方法！！！
}
}
有参无返回值——多个参数的抽象方法——Lambda 表达式
/**
* 有参数，无返回值【多个参数】
*/
//@FunctionalInterface 该注解是专门校验接口是否是一个函数式接口
@FunctionalInterface
public interface NewFeaturesDemo {
//抽象方法 默认public abstract
void add(String describe,String describe1,String describe2);
}
import org.junit.Test;
/**
* 单元测试类
*/
public class UnitTesting {
@Test
public void testAll(){
//【有参无返回值——多个参数】访问抽象方法——使用传统方式
NewFeaturesDemo newFeaturesDemo = new NewFeaturesDemo() {
@Override
public void add(String describe, String describe1, String describe2) {
System.out.println(describe + describe1 + describe2 + "我是一个抽象方法！！！");
}
};
//无返回值直接方法调用即可
newFeaturesDemo.add("使用","传统","方式");//使用传统方式我是一个抽象方法！！！
}
@Test
public void testAll1(){
//【有参无返回值——多个参数】访问抽象方法——使用Lambda 表达式方式
//如果重写方法内部的代码内容只有一句代码，那么{}是可以省略不要的，并且如果方法是有返回值的，return也必须省略掉否则编译报错
//方法形参列表内部的数据类型都是可以省略不要的
//如果形参列表只有1个，()也是可以省略不要的，但是注意了，如果形参列表有多个()是不可以省略的
NewFeaturesDemo newFeaturesDemo = (describe,describe1,describe2) -> System.out.println(describe + describe1 + describe2 + "我是一个抽象方法！！！");
/