>关于Java17也是下一个长期稳定支持的版本，有必要去接触一下，前置开发环境；Java的版本要Java17及以上
>下载地址[戳我](https://www.oracle.com/java/technologies/downloads/#jdk17-windows)
关于idea的配置项
1. 创建一个maven工程
2. 自动导包配置
3. 不区分大小写的智能提示
4. 超过10个tab页自动关掉不常用的
5. 关于maven的`settings.xml`的配置
- 定义好`localRepository`可以使idea自动识别将jar下载到指定磁盘位置
```xml
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.2.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.2.0 https://maven.apache.org/xsd/settings-1.2.0.xsd">
<localRepository>D:/maven/repository</localRepository>
<mirrors>
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>central</mirrorOf>
</mirror>
</mirrors>
</settings>
```
6. 设置idea下次新建的项目下载的jar包到磁盘的位置
## 1. Java Record（`rui kao de`）
1. 由于idea的项目结构目录默认是5，修改成17就可以创建这样的类了
2. 创建一个这样的类
### 1.1. 创建`Record`类，并且赋值，取值
1. `Record`类的格式是在类名后加属性值，下面表示四个属性值
```java
public record Student(Integer id,String name,String email,Integer age) {
}
```
2. 接下来开始赋值以及取值
```java
@Test
public void test01() {
//赋值
Student student = new Student(1001, "张三", "33@qq.com", 20);
System.out.println("学生数据：" + student);
//public 方法器，获取属性值，只读，没有set,get方法
Integer id = student.id();
String name = student.name();
System.out.println("id:" + id + ",name:" + name);
}
```
### 1.2. 创建实例方法，静态方法，紧凑方法，定制构造方法
1. 创建各种方法
```java
public record Student(Integer id,String name,String email,Integer age) {
//实例方法,拼接数据
public String concat(String data) {
return String.format("姓名是%s,年龄是%d,拼接字符是" + data,name,age);
}
//静态方法，转成大写
public static String emailToUpperCase(String email) {
return Optional.ofNullable(email).orElse("no email").toUpperCase();
}
//紧凑方法
public Student {
System.out.println("紧凑方法：id:" + id);
if (id < 1) {
throw new RuntimeException("id不能小于1");
}
}
//定制构造方法
public Student(Integer id,String name) {
this(id,name,null,null);
}
}
```
2. 调用
```java
/**
* 调用实例方法
*/
@Test
public void test02() {
Student student = new Student(1001, "张三", "33@qq.com", 20);
String concat = student.concat("随便拼接");
System.out.println(concat);
}
/**
* 调用静态方法转成大写
*/
@Test
public void test03() {
String test = Student.emailToUpperCase("test");
System.out.println(test);
}
/**
* 紧凑和自定义
*/
@Test
public void test04() {
Student lisi = new Student(1002, "lisi");
System.out.println(lisi);
Student student = new Student(0,"zhangsan");
}
```
### 1.3. `Record`类实现接口，并重写
1. 创建一个接口
```java
public interface PrintInterfaceService {
void print();
}
```
2. 创建一个`Record`类，并实现上面的接口
```java
public record PrintInterfaceRecord(Integer id,String name,Integer qty) implements PrintInterfaceService {
@Override
public void print() {
StringJoiner stringJoiner = new StringJoiner("-");
StringJoiner joiner = stringJoiner.add(id.toString()).add(name).add(qty.toString());
System.out.println("商品信息 = "+joiner);
}
}
```
3. 开始调用
```java
/**
* Record类实现接口，并重写
*/
@Test
public void test05() {
PrintInterfaceRecord printInterfaceRecord = new PrintInterfaceRecord(1003,"手机",300);
printInterfaceRecord.print();
}
```
### 1.4. 创建方法内级别的`Record`类型，可以存储多个数据
1. 编写代码
```java
/**
* 创建方法内级别的Record类型，可以存储多个数据
*/
@Test
public void test06() {
//定义loacl record
record SaleRecord(String saleId,String productName,Double money){};
//创建对象
SaleRecord saleRecord = new SaleRecord("DADA-001", "屏幕显示器", 88.88);
System.out.println("内部定义的数据：" + saleRecord);
}
```
### 1.5. 嵌套，例如有一个用户，里面嵌套有地区，有电话
1. 创建三个`Record`类，分别为`Address`、`Customer`、`PhoneNum`
- - Address
```java
public record Address(String city,String address,String zipCode) {
}
```
- - Customer
```java
public record Customer(Integer id,String name,PhoneNum phoneNum,Address address) {
}
```
- - PhoneNum
```java
public record PhoneNum(String areaCode,String number) {
}
```
2. 调用
```java
/**
* 嵌套，有一个用户，里面嵌套有地区，有电话
*/
@Test
public void test07() {
Address address = new Address("北京", "王府井255号", "100100");
PhoneNum phoneNum = new PhoneNum("010", "400-8080-100");
Customer customer = new Customer(100, "张三", phoneNum, address);
System.out.println("嵌套数据：" + customer);
System.out.println("这个人的城市：" + customer.address().city());
}
```
## 2. Swich开关表达式
### 2.1. Switch判断箭头函数
```java
/**
* Switch判断箭头函数
*/
@Test
public void test01() {
int week = 2;
String memo = "";
switch (week) {
case 1 -> memo = "星期日";
case 2,3,4,5,6 -> memo = "工作日";
case 7 -> memo = "星期六";
default -> throw new RuntimeException("无效日期");
}
System.out.println("memo == " + memo);
}
```
### 2.2. Switch的yield返回值
```java
/**
* yield返回值
*/
@Test
public void test02() {
int week = 5;
String memo = switch (week) {
case 1 : yield "星期日";
case 2,3,4,5,6 : yield "工作日";
case 7 : yield "星期六";
default: yield "没有结果";
};
System.out.println("最终数据:" + memo);
}
```
### 2.3. `Switch`的代码块
```java
/**
* Switch代码块
*/
@Test
public void test03() {
int week = 5;
String memo = switch (week) {
case 1 -> {
System.out.println("星期日，执行其他代码");
yield "星期日";
}
case 2,3,4,5,6 -> {
System.out.println("工作日，执行其他代码块");
yield "2-6工作日";
}
case 7 -> {
System.out.println("星期六，执行其他代码块");
yield "星期六";
}
default -> {
System.out.println("执行其他信息");
yield "执行其他信息";
}
};
System.out.println("代码块信息：" + memo);
}
```
### 2.4. `Switch`的与`Record`类综合练习
>1. 记录模式是jdk 19 的功能，对于 17，直接判断类型即可，case Line -> {}，也可以使用模式匹配，case Line l -> {}
```java
//记录模式是jdk 19 的功能，对于 17，直接判断类型即可，case Line -> {}，也可以使用模式匹配，case Line l -> {}
@Test
public void test04() {
Line line = new Line(10, 20);
Rectangle rectangle = new Rectangle(20, 50);
Shape shape = new Shape(50, 80);
Object obj = rectangle;
int result = switch (obj) {
case Line l -> l.x() + l.y();
case Rectangle r -> r.x() + r.y();
case Shape s-> s.x() + s.y();
default -> 0;
};
System.out.println("最终结果："+ result);
}
```
## 3. Text Block文本框
> 文本块定义要求
> 1. 文本块以三个双引号字符开始,后跟一个行结束符。
> 2. 不能将文本块放在单行上
> 3. 文本块的内容也不能在没有中间行结束符的情况下跟随三个开头双引号
### 3.1. 文本框的三个双引号开始
```java
/**
* 三个双引号分别占一行的字符串和一个双引号的字符串比较是不相同的，多了一个回车、\t
* 最后的三个双引号与字符串在一行的话相比的话相同
*/
@Test
public void test01() {
String msg = """
hello
""";
String message = "hello";
System.out.println("比较："+ message.equals(msg));
System.out.println(msg);
System.out.println("------------");
System.out.println(message);
System.out.println("------------");
}
```
### 3.2. 文本块的方法，前面加5个空格
```java
/**
* 文本框调用方法使前面加空格
*/
@Test
public void test02() {
String msg = """
不错""";
//前面加五个空格
String indent = msg.indent(5);
System.out.println(msg);
System.out.println(indent);
String info = """
name:%s,
phone:%s,
age:%d
""".formatted("张三","18888888888",20);
System.out.println(info);
//准确来说， \ 放在行末，表示不换行处理，不是当作空格处理
String message = """
SpringBoot是一个快读开发框架，是"Spring"家族的一个\
成员，创建Spring项目
""";
System.out.println(message);
}
```
## 4. var生命局部变量
> 主要针对于不确定变量值，体现出能够自动转换的功能
```java
/**
* 关于var的定义
*/
@Test
public void test03() {
var msg = "好好学习";
var i = 18;
}
```
## 5. sealed 密封类
> 主要是在我们代码层面上继承方面得到进一步的控制，不能随随便便的去继承一个类
### 5.1. 密闭类
1. 创建一个父类(`Shape `)，供这三个子类`Circle,Square,Rectangle`去实现
```java
/**
* @Author: dada
* @Date: 2023/4/2 22:15
* @Version: 1.0
* @Description: 密闭类，限制有三个子类
* 子类的声明有三种
* 1. final 终结，依然是密封的
* 2. sealed 子类是密封类，需要子类再去实现
* 3. non-sealed 非密封类，扩展使用，不受限制，随便继承了
*/
public sealed class Shape permits Circle,Square,Rectangle {
private Integer width;
private Integer height;
public void draw() {
System.out.println("画一个图形...");
}
}
```
2. `Circle`创建一个终结类（不能再让其他类去继承当前类`[Circle ]`了），利用`final`修饰的
```java
public final class Circle extends Shape {
@Override
public void draw() {
System.out.println("final 终结，依然是密封的 == 图形");
}
}
```
3. 创建一个密封类，需要子类`Square`再去实现
```java
public sealed class Square extends Shape permits RoundSquare{
}
```
4. 创建`RoundSquare`子类，进行继承`Square` 类
```java
public final class RoundSquare extends Square{
@Override
public void draw() {
System.out.println("这里终结了");
}
}
```
5. 创建`Rectangle`类，`non-sealed` 非密封类，扩展使用，不受限制，随便继承了
```java
public non-sealed class Rectangle extends Shape {
@Override
public void draw() {
System.out.println("非密封的，随便继承");
}
}
```
6. 创建一个随便的类`Line`再去继承`Rectangle` 类，因为这个类没有限制了
```java
public class Line extends Rectangle {
@Override
public void draw() {
System.out.println("我又继承了");
}
}
```
### 5.2. 密闭接口（用法和密闭类用法一致）
1. 创建一个接口类，控制一个实现类去实现，如有其他类还需要的话，那就利用`逗号`分隔
```java
public sealed interface SomeService permits SomeServiceImpl {
void doThing();
}
```
2. `SomeServiceImpl` 类去实现
```java
public final class SomeServiceImpl implements SomeService {
@Override
public void doThing() {
System.out.println("最终的一个实现类");
}
}
```
## 6. instanceof模式匹配
>通常我们使用instanceof时，一般发生在需要对一个变量的类型进行判断，如果符合指定的类型，则强制类型转换为一个新变量。
```java
private static void oldStyle(Object o) {
if (o instanceof Furit) {
Furit furit = (GrapeClass) o;
System.out.println("This furit is :" + furit.getName);
}
}
```
1. 在使用instanceof的模式匹配后，上面的代码可进行简写。
```java
private static void oldStyle(Object o) {
if (o instanceof Furit furit) {
System.out.println("This furit is :" + furit.getName);
}
}
```
可以将类型转换和变量声明都在if中处理。同时，可以直接在if中使用这个变量。
2. 可以将类型转换和变量声明都在if中处理。同时，可以直接在if中使用这个变量。
3. . 因为只有当instanceof的结果为true时，才会定义变量furit，所以这里可以使用&&，但是改为||就会编译报错。
```java
private static void oldStyle(Object o) {
if (o instanceof Furit furit && furit.getColor()==Color.RED) {
System.out.println("This furit is :" + furit.getName);
}
}
```
关于Java17也是下一个长期稳定支持的版本，有必要去接触一下，前置开发环境；Java的版本要Java17及以上
AtUtil
