企业官网建设流程全解析

JDK比较重要的时间节点和版本说明

1996 JDK1.0 2004 JDK5.0 最重要的一个里程碑式的版本 2014 JDK8.0 排第二的里程碑式的版本 ---> LTS 2017.9 JDK9.0 从此版本开始，每半年发布一个新的版本 2018.9 JDK11 ---> LTS 2021.9 JDK17 ---> LTS

新特性学习方向

- 角度1：新的语法规则（多关注）
自动装箱、自动拆箱、注解、enum、Lambda表达式、方法引用、switch表达式、try-catch变化、record等

- 角度2：增加、过时、删除API
StringBuilder、ArrayList、新的日期时间的API、Optional等

- 角度3：底层的优化、JVM参数的调整、GC的变化、内存结构（永久代---->元空间）

lambda表达式

Lambda表达式的使用举例：

(o1, o2) -> Integer.compare(o1, o2);

public void test() { Comparator<Integer> com1 = new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return Integer.compare(o1, o2); } }; int compare1 = com1.compare(12, 21); System.out.println(compare1); System.out.println("***********************"); //Lambda表达式的写法 Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2); int compare2 = com2.compare(23, 21); System.out.println(compare2); System.out.println("***********************"); //方法引用 Comparator<Integer> com3 = Integer::compare; int compare3 = com3.compare(23, 21); System.out.println(compare3); }

语法格式一：无参，无返回值

public void test1() { Runnable r1 = new Runnable() { @Override public void run() { System.out.println("我爱北京天安门"); } }; r1.run(); System.out.println("**********************"); Runnable r2 = () -> { System.out.println("我爱北京天安门"); }; r2.run(); }

语法格式二：Lambda 需要一个参数，但是没有返回值。

public void test2() { Consumer<String> con = new Consumer<String>() { @Override public void accept(String s) { System.out.println(s); } }; con.accept("谎言和誓言的区别是什么？"); System.out.println("**********************"); Consumer<String> con1 = (String s) -> { System.out.println(s); }; con1.accept("一个说的人当真了，一个听的人当真了"); }

语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

public void test3() { Consumer<String> con1 = (String s) -> { System.out.println(s); }; con1.accept("如果大学可以重来，你最想重来的事是啥？"); System.out.println("********************"); Consumer<String> con2 = (s) -> { System.out.println(s); }; con1.accept("谈一场轰轰烈烈的爱情"); }

语法格式四：Lambda 若只需要一个参数时，参数小括号可以省略

public void test4() { Consumer<String> con1 = (s) -> { System.out.println(s); }; con1.accept("世界那么大，我想去看看"); System.out.println("**********************"); Consumer<String> con2 = s -> { System.out.println(s); }; con2.accept("世界那么大，我想去看看"); }

语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值

public void test5() { Comparator<Integer> com1 = new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { System.out.println(o1); System.out.println(o2); return o1.compareTo(o2); } }; System.out.println(com1.compare(12, 21)); System.out.println("*******************************"); Comparator<Integer> com2 = (o1, o2) -> { System.out.println(o1); System.out.println(o2); return o1.compareTo(o2); }; System.out.println(com2.compare(12, 21)); }

语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略

public void test6() { Comparator<Integer> com1 = (o1, o2) -> { return o1.compareTo(o2); }; System.out.println(com1.compare(12, 6)); System.out.println("****************************"); Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2); System.out.println(com2.compare(12, 6)); }

Lambda表达式的格式举例：

Lambda形参列表 -> Lambda体

Lambda表达式的格式

-> : lambda操作符或箭头操作符
-> 的左边：lambda形参列表，对应着要重写的接口中的抽象方法的形参列表。
-> 的右边：lambda体，对应着接口的实现类要重写的方法的方法体。

Lambda表达式的本质：

> 一方面，Lambda表达式作为接口的实现类的对象。 ---> "万事万物皆对象"
> 另一方面，Lambda表达式是一个匿名函数。

函数式接口：

函数式接口定义

> 如果接口中只声明一个抽象方法，则此接口就称为函数式接口。

> 因为只有给函数式接口提供实现类的对象时，我们才可以使用lambda表达式。

api中函数式接口所在的包

jdk8中声明的函数式接口都在java.util.function包下。

4个基本的函数式接口

| 接口 | 对应的抽象方法 |
| 消费型接口：Consumer<T> | void accept(T t) |
| 供给型接口：Supplier<T> | T get() |
| 函数型接口：Function<T,R> | R apply(T t) |
| 判断型接口：Predicate<T> | boolean test(T t) |

Lambda表达式的语法规则总结

-> 的左边：Lambda形参列表，参数的类型都可以省略。如果形参只有一个，则一对()也可以省略。

-> 的右边：Lambda体，对应着重写的方法的写法。如果方法体中只有一行执行语句，则一对{}可以省略。
如果有return关键字，则必须一并省略。

方法引用

举例：

Integer :: compare;

public void test() { Comparator<Integer> com1 = new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return Integer.compare(o1, o2); } }; int compare1 = com1.compare(12, 21); System.out.println(compare1); System.out.println("***********************"); //Lambda表达式的写法 Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2); int compare2 = com2.compare(23, 21); System.out.println(compare2); System.out.println("***********************"); //方法引用 Comparator<Integer> com3 = Integer::compare; int compare3 = com3.compare(23, 21); System.out.println(compare3); }

方法引用的理解

> 方法引用，可以看做是基于lambda表达式的进一步刻画。
> 当需要提供一个函数式接口的实例时，我们可以使用lambda表达式提供此实例。
> 当满足一定的条件的情况下，我们还可以使用方法引用或构造器引用替换lambda表达式。

方法引用的本质：

方法引用作为了函数式接口的实例。 ---> “万事万物皆对象”

格式：

类(或对象) :: 方法名

具体使用情况说明：

情况1：对象 :: 实例方法

要求：函数式接口中的抽象方法a与其内部实现时调用的对象的某个方法b的形参列表和返回值类型都相同（或一致、兼容）。此时，可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用。

注意：此方法b是非静态的方法，需要对象调用。

import java.io.PrintStream; import java.util.function.Consumer; import java.util.function.Supplier; public class Main { // 情况一：对象 :: 实例方法 //Consumer中的void accept(T t) //PrintStream中的void println(T t) public void test1() { //1. Consumer<String> con1 = new Consumer<String>() { @Override public void accept(String s) { System.out.println(s); } }; con1.accept("hello!"); //2. lambda表达式 Consumer<String> con2 = s -> System.out.println(s); con2.accept("hello!"); //3. 方法引用 PrintStream out = System.out; Consumer<String> con3 = out::println; con3.accept("hello!"); } public void test2() { Employee emp = new Employee(1001, "马化腾", 34, 6000.38); //1. Supplier<String> sup1 = new Supplier<String>() { @Override public String get() { return emp.getName(); } }; System.out.println(sup1.get()); //2. lambda表达式 Supplier<String> sup2 = () -> emp.getName(); System.out.println(sup2.get()); //3. 方法引用 Supplier<String> sup3 = emp::getName; } }

情况2：类 :: 静态方法

要求：函数式接口中的抽象方法a与其内部实现时调用的类的某个静态方法b的形参列表和返回值类型都相同（或一致、兼容）。此时，可以考虑使用方法b实现对应方法的替换、覆盖。此替换或覆盖即为方法引用。

注意：此方法b是静态的方法，需要类调用。

import java.util.Comparator; import java.util.function.Function; public class Main { // 情况二：类 :: 静态方法 //Comparator中的int compare(T t1, T t2) //Integer中的int compare(T t1, T t2) public void test3() { //1 Comparator<Integer> com1 = new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return Integer.compare(o1, o2); } }; System.out.println(com1.compare(12, 21)); //2. Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2); System.out.println(com2.compare(21, 34)); //3. 方法引用 Comparator<Integer> com3 = Integer::compare; System.out.println(com3.compare(34, 34)); } public void test4() { //1. Function<Double, Long> fun1 = new Function<Double, Long>() { @Override public Long apply(Double aDouble) { return Math.round(aDouble); } }; //2. Function<Double, Long> fun2 = aDouble -> Math.round(aDouble); //3. 方法引用 Function<Double, Long> fun3 = Math::round; } }

情况3：类 :: 实例方法

要求：函数式接口中的抽象方法a与其内部实现时调用的对象的某个方法b的返回值类型相同。同时，抽象方法a中有n个参数，方法b中有n-1个参数，且抽象方法a的第1个参数作为方法b的调用者，且抽象方法a的后n-1个参数与方法b的后n-1个参数的类型相同（或一致）。则可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用。

注意：此方法b是非静态的方法，需要对象调用。但是形式上，写出对象a所属的类

import java.util.Comparator; import java.util.function.BiPredicate; public class Main { // 情况三：类 :: 实例方法（难） // Comparator中的int compare(T t1, T t2) // String中的int t1.compareTo(t2) public void test5() { //1. Comparator<String> com1 = new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.compareTo(o2); } }; System.out.println(com1.compare("abc", "abd")); //2. Comparator<String> com2 = (s1, s2) -> s1.compareTo(s2); System.out.println(com2.compare("abc", "abb")); //3. Comparator<String> com3 = String::compareTo; System.out.println(com3.compare("abc", "abb")); } public void test6() { //1. BiPredicate<String, String> biPre1 = new BiPredicate<String, String>() { @Override public boolean test(String s1, String s2) { return s1.equals(s2); } }; //2. BiPredicate<String, String> biPre2 = (s1, s2) -> s1.equals(s2); //3. 方法引用 BiPredicate<String, String> biPre3 = String::equals; } }

构造器引用

格式：

类名 :: new

import java.util.function.Supplier; public class Main { //构造器引用 //Supplier中的T get() public void test1() { //1. Supplier<Employee> sup1 = new Supplier<Employee>() { @Override public Employee get() { return new Employee(); } }; System.out.println(sup1.get()); //2.构造器引用 Supplier<Employee> sup2 = Employee::new;//调用的是Employee类中空参的构造器 System.out.println(sup2.get()); } }

说明：

> 调用了类名对应的类中的某一个确定的构造器
> 具体调用的是类中的哪一个构造器呢？取决于函数式接口的抽象方法的形参列表！

数组引用

格式：数组名[ ] :: new

import java.util.function.Function; public class Main { // 数组引用 //Function中的R apply(T t) public void test4() { //1. Function<Integer, Employee[]> func1 = new Function<Integer, Employee[]>() { @Override public Employee[] apply(Integer length) { return new Employee[length]; } }; System.out.println(func1.apply(10).length); //2. Function<Integer, Employee[]> func2 = Employee[]::new; System.out.println(func2.apply(20).length); } }

Stream API

Stream API vs 集合框架

> Stream API 关注的是多个数据的计算（排序、查找、过滤、映射、遍历等），面向CPU的。
集合关注的数据的存储，向向内存的。

> Stream API 之于集合，类似于SQL之于数据表的查询。

使用说明

①Stream 自己不会存储元素。

②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。即一旦执行终止操作，就执行中间操作链，并产生结果。

④Stream一旦执行了终止操作，就不能再调用其它中间操作或终止操作了。

Stream 执行流程

步骤1：Stream的实例化

import java.util.Arrays; import java.util.stream.IntStream; import java.util.stream.Stream; public class Main { // 创建 Stream 方式一：通过集合 stream() public void test1() { List<Employee> list = EmployeeData.getEmployees(); // default Stream<E> stream() : 返回一个顺序流 Stream<Employee> stream = list.stream(); // default Stream<E> parallelStream() : 返回一个并行流 Stream<Employee> stream1 = list.parallelStream(); System.out.println(stream); System.out.println(stream1); } // 创建 Stream 方式二：通过数组 Arrays.stream public void test2() { // 调用Arrays类的static <T> Stream<T> stream(T[] array)：返回一个流 Integer[] arr = new Integer[]{1, 2, 3, 4, 5}; Stream<Integer> stream = Arrays.stream(arr); int[] arr1 = new int[]{1, 2, 3, 4, 5}; IntStream stream1 = Arrays.stream(arr1); } // 创建 Stream 方式三：通过Stream的 of() public void test3() { Stream<String> stream = Stream.of("AA", "BB", "CC", "SS", "DD"); } }

步骤2：一系列的中间操作

import java.util.Arrays; import java.util.List; public class Main { //1-筛选与切片 public void test1() { // filter(Predicate p) — 接收 Lambda，从流中排除某些元素。 // 练习：查询员工表中薪资大于7000的员工信息 List<Employee> list = EmployeeData.getEmployees(); Stream<Employee> stream = list.stream(); stream.filter(emp -> emp.getSalary() > 7000).forEach(System.out::println); System.out.println(); // limit(n) — 截断流，使其元素不超过给定数量。 // 错误的。因为stream已经执行了终止操作，就不可以再调用其它的中间操作或终止操作了。 // stream.limit(2).forEach(System.out::println); //先过滤，后打印 // list.stream().filter(emp -> emp.getSalary() > 7000).limit(4).forEach(System.out::println); list.stream().limit(4).forEach(System.out::println); System.out.println(); // skip(n) — 跳过元素，返回一个扔掉了前 n 个元素的流。 // 若流中元素不足 n 个，则返回一个空流。与 limit() 的区别在于 skip() 不会影响流的长度。 list.stream().skip(5).forEach(System.out::println); System.out.println(); // distinct() — 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素 list.stream().distinct().forEach(System.out::println); } //2-映射 public void test2() { //map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上。 //练习：转换为大写 List<String> list = Arrays.asList("aa", "bb", "cc", "dd"); //方式1: list.stream().map(str -> str.toUpperCase()).forEach(System.out::println); //方式2: list.stream().map(String::toUpperCase).forEach(System.out::println); //练习：获取员工姓名长度大于3的员工。 List<Employee> employees = EmployeeData.getEmployees(); employees.stream().filter(emp -> emp.getName().length() > 3).forEach(System.out::println); //练习：获取员工姓名长度大于3的员工的姓名。 //方式1: employees.stream().filter(emp -> emp.getName().length() > 3).map(emp -> emp.getName()).forEach(System.out::println); //方式2: employees.stream().map(emp -> emp.getName()).filter(name -> name.length() > 3).forEach(System.out::println); //方式3: employees.stream().map(Employee::getName ()).filter(name -> name.length() > 3).forEach(System.out::println); } //3-排序 public void test3() { //sorted()——自然排序 Integer[] arr = new Integer[]{345, 3, 64, 3, 46, 7, 3, 34, 65, 68}; String[] arr1 = new String[]{"GG", "DD", "MM", "SS", "JJ"}; Arrays.stream(arr).sorted().forEach(System.out::println); System.out.println(Arrays.toString(arr)); //arr数组并没有因为升序，做调整。 Arrays.stream(arr1).sorted().forEach(System.out::println); //因为Employee没有实现Comparable接口，所以报错！ // List<Employee> list = EmployeeData.getEmployees(); // list.stream().sorted().forEach(System.out::println); //sorted(Comparator com)——定制排序 List<Employee> list = EmployeeData.getEmployees(); list.stream().sorted((e1, e2) -> e1.getAge() - e2.getAge()).forEach(System.out::print); //针对于字符串从大大小排列 Arrays.stream(arr1).sorted((s1, s2) -> -s1.compareTo(s2)).forEach(System.out::print); // Arrays.stream(arr1).sorted(String::compareTo).forEach(System.out::println); } }

步骤3：执行终止操作

import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class Main { //1-匹配与查找 public void test1() { // allMatch(Predicate p) —— 检查是否匹配所有元素。 // 练习：是否所有的员工的年龄都大于18 List<Employee> list = EmployeeData.getEmployees(); System.out.println(list.stream().allMatch(emp -> emp.age() > 18)); // anyMatch(Predicate p) —— 检查是否至少匹配一个元素。 //练习：是否存在年龄大于18岁的员工 System.out.println(list.stream().anyMatch(emp -> emp.age() > 18)); //练习：是否存在员工的工资大于10000 System.out.println(list.stream().anyMatch(emp -> emp.salary() > 10000)); // findFirst——返回第一个元素 System.out.println(list.stream().findFirst().get()); } public void test2() { // count——返回流中元素的总个数 List<Employee> list = EmployeeData.getEmployees(); System.out.println(list.stream().filter(emp -> emp.getSalary() > 7000).count()); // max(Comparator c) — 返回流中最大值 //练习：返回最高工资的员工 System.out.println(list.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))); //练习：返回最高的工资： //方式1: System.out.println(list.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())).get().getSalary()); //方式2: System.out.println(list.stream().map(emp -> emp.getSalary()).max(Double::compare).get()); // min(Comparator c) —— 返回流中最小值 // 练习：返回最低工资的员工 System.out.println(list.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))); // forEach(Consumer c) —— 内部迭代 list.stream().forEach(System.out::println); // 针对于集合，jdk8中增加了一个遍历的方法 list.forEach(System.out::println); // 针对于List来说，遍历的方式：① 使用Iterator ② 增强for ③ 一般for ④ forEach() } //2-归约 public void test3() { // reduce(T ident, BinaryOperator) —— 可以将流中元素反复结合起来，得到一个值。返回 T // 练习1：计算1-10的自然数的和 List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); System.out.println(list.stream().reduce(0, (x1, x2) -> x1 + x2)); System.out.println(list.stream().reduce(0, (x1, x2) -> Integer.sum(x1, x2))); System.out.println(list.stream().reduce(0, Integer::sum)); System.out.println(list.stream().reduce(10, (x1, x2) -> x1 + x2)); // reduce(BinaryOperator) —— 可以将流中元素反复结合起来，得到一个值。返回 Optional<T> // 练习2：计算公司所有员工工资的总和 List<Employee> employeeList = EmployeeData.getEmployees(); System.out.println(employeeList.stream().map(emp -> emp.getSalary()).reduce((salary1, salary2) -> Double.sum(salary1, salary2))); System.out.println(employeeList.stream().map(emp -> emp.getSalary()).reduce(Double::sum)); } //3-收集 public void test4() { // collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法 // 练习1：查找工资大于6000的员工，结果返回为一个List或Set List<Employee> list1 = list.stream().filter(emp -> emp.getSalary() > 60000).collect(Collectors.toList()); list1.forEach(System.out::println); System.out.println(); list.forEach(System.out::println); System.out.println(); // 练习2：按照员工的年龄进行排序，返回到一个新的List中 List<Employee> list2 = list.stream().sorted((e1, e2) -> e1.getAge() - e2.getAge()).collect(Collectors.toList()); list2.forEach(System.out::println); } }

语法层面

jShell工具（REPO工具，交互式编程环境工具）：利用shell在没有创建类的情况下，在命令行里直接声明变量，计算表达式，执行语句。无需跟人解释“public static void main(String[] args)”这句“废话”。

try-catch结构的变化。try(...){}

在try的后面可以增加一个（），在括号中可以声明流对象（需要直接或间接实现AutoClassable接口）并初始化。try中的代码执行完毕，会自动把流对象释放，就不用写finally了。

try(资源对象的声明和初始化) { 业务逻辑代码，可能会产生异常 } catch(异常类型1 e) { 处理异常代码 } catch(异常类型2 e) { 处理异常代码 }

public void test02() { try( FileWriter fw = new FileWriter("test.txt"); BufferedWriter bw = new BufferedWriter(fw); ) { bw.write("hello,世界"); } catch(IOException e) { e.printStackTrace(); } }

try的前面可以定义流对象，try后面的（）中可以直接引用流对象的名称。在try代码执行完毕后，流对象也可以释放掉，也不用写finally了。

A a = new A(); B b = new B(); try(a; b){ 可能产生的异常代码 } catch(异常类名 变量名) { 异常处理的逻辑 }

public void test05() { InputStreamReader reader = new InputStreamReader(System.in); OutputStreamWriter writer = new OutputStreamWriter(System.out); try (reader; writer) { // reader、writer是final的，不可再被赋值 // reader = new InputStreamReader(System.in); } catch (IOException e) { e.printStackTrace(); } }

局部变量的类型推断：var

public void test1(){ //1. 局部变量的实例化 var list = new ArrayList<String>(); var set = new LinkedHashSet<Integer>(); //2. 增强for循环中的索引 for (var v : list) { System.out.println(v); } //3. 传统for循环中 for (var i = 0; i < 100; i++) { System.out.println(i); } //4. 返回值类型含复杂泛型结构 var iterator = set.iterator(); //Iterator<Map.Entry<Integer, Student>> iterator = set.iterator(); }

instanceof 的模式匹配

if (obj instanceof String s) { // 如果类型匹配 直接使用 } else { // 如果类型不匹配则不能直接使用 }

public boolean equals(Object o){ if(o instanceof Computer other){ return this.model.equals(other.model) && this.price == other.price; } return false; }

switch表达式、switch的模式匹配

使用"->"代替":"：代替break的使用

public void test() { Week day = Week.FRIDAY; int a = switch (day) { case MONDAY -> 1; case TUESDAY, WEDNESDAY, THURSDAY -> 2; case FRIDAY -> 3; case SATURDAY, SUNDAY -> 4; default -> throw new RuntimeException("What day is today?" + day); }; System.out.println(a); }

使用yield，返回数据，同时结束运行（可使用":"替代"->"）

public void test() { Week day = Week.FRIDAY; int a = switch (day) { case MONDAY -> { yield 1; } case TUESDAY, WEDNESDAY, THURSDAY -> { yield 2; } case FRIDAY -> { yield 3; } case SATURDAY, SUNDAY -> { yield 4; } default -> throw new RuntimeException("What day is today?" + day); }; System.out.println(a); }

预览特性

public void test(Object o) { String formatted = switch (o) { case Integer i -> "int " + i; case Long l -> "long " + l; case Double d -> "double " + d; case String s -> "String " + s; default -> o.toString(); }; System.out.println(formatted); }

文本块的使用：“”文本块“”

\ ：取消换行操作
\s：表示一个空格

public void test(){ String newQuery1 = """ SELECT id,name,email \ FROM customers\s WHERE id > 4 \ ORDER BY email DESC """; System.out.println(newQuery1); }

新的引用数据类型：record（记录：一定程度上看作JavaBean）

public record Order1(int orderId, String orderName) { // 编译器会自动生成构造器、equals()、hashCode()、toString() 等 //- 还可以在record声明的类中定义静态字段、静态方法、构造器或实例方法。 static String info = "我是一个人"; public static void show() { System.out.println("我是一个人！"); } public Person() { this(0, null); } public void eat() { System.out.println("人吃饭"); } //- 不能在record声明的类中定义实例字段；类不能声明为abstract；不能声明显式的父类等。 // final int age; }

public void test2(){ Order1 order1 = new Order1(1001, "orderAA"); //测试toString() System.out.println(order1); //测试getter() System.out.println(order1.orderId()); System.out.println(order1.orderName()); Order1 order2 = new Order1(1001, "orderAA"); //测试equals() System.out.println(order1.equals(order2)); //测试hashCode()和equals() HashSet<Order1> set = new HashSet<>(); set.add(order1); set.add(order2); System.out.println(set); }

密封类：sealed class

密封类，可以被指定的子类继承，非指定的类不能继承

要求指定的子类必须是final、sealed、non-sealed三者之一

//Person 是一个密封类，可以被指定的子类继承，非指定的类不能继承Person类 public sealed class Person permits Student, Teacher, Worker { } //要求指定的子类必须是final、sealed、non-sealed三者之一 final class Student extends Person { } //Student类不能被继承了。 sealed class Teacher extends Person permits SeniorTeacher { } //Teacher类只能被指定的子类继承 non-sealed class SeniorTeacher extends Teacher { } non-sealed class Worker extends Person { } //Worker类在继承时，没有任何限制 class WatchWorker extends Worker { } //class Farmer extends Person {}

其他

Optional类的使用

public void test(){ String star = "迪丽热巴"; star = null; // 使用Optional避免空指针的问题 // 1. 实例化: // ofNullable(T value): 用来创建一个Optional实例, value可能是空, 也可能非空 Optional<String> optional = Optional.ofNullable(star); // orElse(T other): 如果Optional实例内部的value属性不为null, 则返回value。如果value为null, // 则返回other. String otherStar = "杨幂"; String finalStar = optional.orElse(otherStar); System.out.println(finalStar.toString()); }