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);
java
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);
}语法格式一：无参，无返回值
java
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 需要一个参数，但是没有返回值。
java
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("一个说的人当真了，一个听的人当真了");
}语法格式三：数据类型可以省略，因为可由编译器推断得出，称为"类型推断"
java
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 若只需要一个参数时，参数小括号可以省略
java
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 需要两个或以上的参数，多条执行语句，并且可以有返回值
java
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 与大括号若有，都可以省略
java
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;
java
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是非静态的方法，需要对象调用。
java
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是静态的方法，需要类调用。
java
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所属的类
java
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
java
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
java
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的实例化
java
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：一系列的中间操作
java
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：执行终止操作
java
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了。
java
try(资源对象的声明和初始化) {
业务逻辑代码，可能会产生异常
} catch(异常类型1 e) {
处理异常代码
} catch(异常类型2 e) {
处理异常代码
}
java
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了。
java
A a = new A();
B b = new B();
try(a; b){
可能产生的异常代码
} catch(异常类名 变量名) {
异常处理的逻辑
}
java
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
java
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 的模式匹配
java
if (obj instanceof String s) {
// 如果类型匹配 直接使用
} else {
// 如果类型不匹配则不能直接使用
}
java
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的使用
java
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，返回数据，同时结束运行（可使用":"替代"->"）
java
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);
}预览特性
java
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：表示一个空格
java
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）
java
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;
}
java
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三者之一
java
//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类的使用
java
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());
}