当前位置：首页 > news >正文

DAY24 方法引用、Base64、正则、lombok

news 2025/10/4 11:27:49

学习目标

- 能够定义枚举MAN ==> public static final Sex MAN = new Sex();WOMAN ==> public static final Sex WOMAN = new Sex();MAN("男")==>public static final Sex MAN = new Sex("男");WOMAN("女")==>public static final Sex WOMAN = new Sex("女");
- 能够使用四种方法的引用对象名引用成员方法: 对象名::成员方法(通过对象名调用成员方法)System.out::println"aaa"::toUpperCase类名引用静态成员方法: 类名::静态成员方法(通过类名调用静态方法)Math::random类的构造方法引用: Person::new (根据构造方法创建对象)数组的构造器引用: int[]::new (根据new创建数组对象)
- 能够使用Base64对基本数据、URL和MIME类型进行编解码String str = "公司绝密资料";System.out.println("原字符串:"+str);//使用Base64对字符串str进行加密String s1 = Base64.getEncoder().encodeToString(str.getBytes());System.out.println("加密后的字符串:"+s1);//使用Base64对字符串进行解密byte[] bytes = Base64.getDecoder().decode(s1);String s2 = new String(bytes);System.out.println("解密后的字符串:"+s2);	
- 能够理解正则表达式的作用//正则表达式本质就是一个包含某种规则的字符串,用于对其他的字符串进行校验
- 能够使用正则表达式的字符类1. [abc]：代表a或者b，或者c字符中的一个。2. [^abc]：代表除a,b,c以外的任何字符。3. [a-z]：代表a-z的所有小写字符中的一个。4. [A-Z]：代表A-Z的所有大写字符中的一个。5. [0-9]：代表0-9之间的某一个数字字符。6. [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。7. [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符。
- 能够使用正则表达式的逻辑运算符1. &&：并且2. | ：或者
- 能够使用正则表达式的预定义字符类1. "." ： 匹配任何字符。(重点)2. "\\d"：任何数字[0-9]的简写；(重点)3. "\\w"：单词字符：[a-zA-Z_0-9]的简写 (重点)
- 能够使用正则表达式限定符的1. X? : 0次或1次2. X* : 0次到多次  任意次3. X+ : 1次或多次4. X{n} : 恰好n次 X=n次5. X{n,} : 至少n次  X>=n次6. X{n,m}: n到m次(n和m都是包含的)    n =< X <= m
- 能够使用正则表达式的分组分组括号( )校验字符串"abc"可以出现任意次String regex = "(abc)*";
- 能够在String的split方法中使用正则表达式String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。

一.JDK8的新特性

1.方法引用(了解)

1).方法引入的概述

package com.itheima.demo01;import java.util.function.Consumer;/*方法引用:JDK1.8之后出现的新特性,用于简化Lambda表达式当一些内容已经存在了,我们就可以使用方法引用,直接引用这些已经存在的内容*/
public class Demo01 {public static void main(String[] args) {//调用method方法,方法的参数Consumer是一个接口,需要传递接口的实现类对象,可以使用匿名内部类method(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}},"abc");//调用method方法,方法的参数Consumer是一个函数式接口,所以我们可以使用Lambda表达式作为接口的实现类对象method((String s)->{System.out.println(s);},"abc");//简化Lambdmethod(s->System.out.println(s),"abc");/*Lambda表达式目的:传递一个承诺书s,对参数s进行输出输出语句中System.out(PrintStream打印流)对象是已经存在的PrintStream打印流中的方法println也是已经存在的对象和方法都是已经存在的,就可以使用方法引用简化Lambda表达式直接使用对象PrintStream来引用成员方法println,用来输出字符串格式:对象名::成员方法*/method(System.out::println,"abc");}/*定义一个方法,方法的参数使用Consumer接口,泛型使用String传递一个字符串在方法内部使用Consumer接口中的方法accept对字符串进行消费*/public static void method(Consumer<String> con,String s){con.accept(s);//至于怎么消费字符串,在lambda表达式中对accept方法进行重写}
}

2).对象名–引用成员方法

package com.itheima.demo02;import java.util.function.Supplier;/*对象名--引用成员方法格式:::方法引用的运算符对象名::成员方法名当对象和成员方法都是已经存在的时候,就可以使用对象名来引用成员方法java.util.function.Supplier<T>:函数式接口接口中唯一的抽象方法:T get() 用来获取一个接口指定泛型类型的数据Supplier接口使用什么泛型,就可以使用get方法获取一个什么类型的数据*/
public class Demo01 {public static void main(String[] args) {//调用method方法,方法的参数Supplier是一个函数式接口,所以我们可以使用Lambda表达式作为接口的一个实现类对象method(()->{//返回一个大写的字符串String s = new String("abc");return s.toUpperCase();});//简化Lambda表达式method(()-> new String("abc").toUpperCase());/*字符串对象"abc"是已经存在的字符串中的方法toUpperCase也是已经存在的使用字符串对象"abc"直接引用成员方法toUpperCase对象名::引用成员方法*/String s = new String("abc");method(s::toUpperCase);method(new String("abc")::toUpperCase);method("abc"::toUpperCase);method("abc"::toLowerCase);//method("abc"::abc);//Cannot resolve method 'abc'}/*定义一个方法,方法的参数使用Supplier接口,泛型使用String方法的内部使用Supplier接口的方法get获取一个字符串*/public static void method(Supplier<String> sup){String s = sup.get();System.out.println(s);}
}

3).类名–引用静态方法

package com.itheima.demo02;import java.util.function.Supplier;/*类名--引用静态方法格式:类名::静态成员方法如果类和静态成员方法已经存在的,那么就可以使用类名直接引用静态成员方法*/
public class Demo02 {/*定义一个方法,方法的参数使用Supplier接口,泛型使用Double方法内部使用Supplier接口中的方法get获取一个小数*/public static void method(Supplier<Double> sup){Double d = sup.get();System.out.println(d);}public static void main(String[] args) {//调用method方法,方法的参数Supplier是一个函数式接口,所以我们可以使用Lambda表达式作为接口的一个实现类对象method(()->{//返回一个随机的小数return Math.random();//[0.0-1.0)});//简化Lambdamethod(()->Math.random());/*Math数学工具类是已经存在的random静态的成员方法已经存在的可以直接使用Math类名引用静态成员方法random,简化LambdaMath::random:也是一个Supplier接口的实现类对象*/method(Math::random);}
}

4).类–构造引用

package com.itheima.demo02;import java.util.function.Function;/*类--构造引用格式:构造方法::new  Person::new  ==>使用构造方法引用new创建对象如果类中的构造方法是已经存在的,使用构造方法直接引用new关键字创建对象java.util.function.Function<T,R>:函数式接口接口中唯一的抽象方法:R apply(T t) 根据参数类型T获取类型R的接口,用于类型转换  T-->R例如:Function<String,Integer>:根据传递String类型的数据,获取Integer类型的结果  "123"  Integer.parseInt("123")Function<String,Person>:根据传递String类型的数据,获取Person类型的结果    "aaa"  new Person("aaa")*/
public class Demo03 {public static void main(String[] args) {//调用method方法,方法的参数Function是一个函数式接口,所以我们可以使用Lambda表达式作为接口的一个实现类对象method((String s)->{return new Person(s);},"小明");//简化Lambda表达式method(s->new Person(s),"小花");/*Lambda表达式的目的:根据字符串的名字,创建Person对象返回创建Person对象的带参数构造方法是已经存在的 public Person(String name)创建对象使用的关键字new已经存在的所以就可以使用构造方法引用new关键字创建对象构造方法::new*/method(Person::new,"柳岩");}/*定义一个方法,方法的参数使用Function接口,泛型使用<String,Person>传递字符串在方法的内部使用Function接口中的方法apply,把字符串转换为Person对象返回*/public static void method(Function<String,Person> fun,String s){Person p = fun.apply(s);System.out.println(p);}
}

package com.itheima.demo02;public class Person {private String name;public Person() {}public Person(String name) {this.name = name;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +'}';}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

5).数组–构造引用

package com.itheima.demo02;import java.util.Arrays;
import java.util.function.Function;/*数组--构造引用格式:数组的数据类型[]::newint[]::new 创建一个int类型的数组  int[] arr = new int[10];double[]::new 创建一个double类型的数组 double[] arr = new double[10];*/
public class Demo04 {public static void main(String[] args) {//调用method方法,方法的参数Function是一个函数式接口,所以我们可以使用Lambda表达式作为接口的一个实现类对象method((Integer len)->{//根据数组的长度,创建一个指定长度的数组返回return new int[len];},10);//简化Lambdamethod(len-> new int[len],10);/*Lambda表达式目的:创建一个指定长度的数组  new int[len];数组的数据类型已经存在的int数组的长度也是已经存在的10使用方法引用简化Lambda表达式int[]::new使用int[]引用new关键字,根据数组的长度创建数组返回*/method(int[]::new,10);}/*定义一个方法,方法的参数使用Function接口,泛型使用<Integer,int[]>传递int类型数组的长度在方法内部,使用Function接口中的方法apply,根据传递的数组长度,创建一个指定长度的数组返回*/public static void method(Function<Integer,int[]> fun,int length){int[] arr = fun.apply(length);System.out.println(Arrays.toString(arr));}
}

6).方法引用在Stream流中的使用(重点)

package com.itheima.demo02;import java.util.stream.Stream;/*方法引用在Stream流中的使用(重点)*/
public class Demo05Stream {public static void main(String[] args) {//获取一个StreamStream<String> stream = Stream.of("a", "b", "c");//使用forEach遍历Stream流//stream.forEach(s-> System.out.println(s));//使用方法引用简化Lambda表达式stream.forEach(System.out::println);}
}

2.Base64加密和解密(重点)

package com.itheima.demo03Base64;import java.util.Base64;/*java.util.Base64工具类该类仅由用于获得Base64编码方案的编码器和解码器的静态方法组成。作用:使用Base64里边的编码器对数据进行编码(加密)使用Base64里边的解码器对数据进行解码(解密)静态方法:static Base64.Encoder getEncoder()  获取加密器(编码器)static Base64.Decoder getDecoder()  获取解密器(解码器)java.util.Base64.Encoder:是Base64的内部类,用于对数据进行加密成员方法:String encodeToString(byte[] src) 使用Base64编码方案将指定的字节数组编码为字符串。java.util.Base64.Decoder:是Base64的内部类,用于对数据进行解密成员方法:byte[] decode(String src) 使用Base64编码方案将Base64编码的字符串解码为新分配的字节数组。*/
public class Demo01Base64 {public static void main(String[] args) {//定义一个原始的字符串String s1 = "国家的绝密文件!";System.out.println("原字符串:"+s1);//原字符串:国家的绝密文件!//使用加密器Encoder中的方法encodeToString把字符串进行加密//Base64.Encoder encoder = Base64.getEncoder();//获取加密器//String s2 = encoder.encodeToString(s1.getBytes());//调用加密的方法String s2 = Base64.getEncoder().encodeToString(s1.getBytes());System.out.println("加密后的字符串:"+s2);//加密后的字符串:5Zu95a6255qE57ud5a+G5paH5Lu2IQ==//使用解密器Decoder中的方法decode把加密字符串进行解密byte[] bytes = Base64.getDecoder().decode(s2);String s3 = new String(bytes);System.out.println("解密后的字符串:"+s3);//解密后的字符串:国家的绝密文件!}
}

二.正则表达式(重点)

1.正则表达式的概念及演示

package com.itheima.demo04regex;import java.util.Scanner;/*正则表达式:就是一个包含了某些规则的字符串用来对其他的字符串进行校验,校验其他的字符串是否满足正则表达式的规则需求:对QQ号进行校验: "123456"  "012345" "123a45"1.长度5-15位之间2.全是数字组成3.第1位不能是0校验QQ号的正则表达式"[1-9][0-9]{4,14}"学习正则的目标:很少自己写正则,能看懂一般的正则表达式即可*/
public class Demo01Regex {public static void main(String[] args) {//使用Scanner获取一个用户输入的字符串System.out.println("请输入一个QQ号:");String qq = new Scanner(System.in).nextLine();boolean b1 = checkQQ(qq);System.out.println("b1:"+b1);boolean b2 = checkQQRegex(qq);System.out.println("b2:"+b2);}/*定义校验QQ号的方法:使用正则表达式String类中方法:boolean matches(String regex) 告诉这个字符串是否匹配给定的 regular expression 。判断字符串是否满足参数传递的正则表达式的规则满足:返回true不满足:返回false*/public static boolean checkQQRegex(String qq){return qq.matches("[1-9][0-9]{4,14}");}/*定义校验QQ号的方法:不使用正则表达式*/public static boolean checkQQ(String qq){//1.长度5-15位之间if(qq.length()<5 || qq.length()>15){return false;}//2.全是数字组成char[] chars = qq.toCharArray();for (char c : chars) {//判断字符是否在'0'到'9'之间if (c<'0' || c>'9'){return false;}}//3.第1位不能是0if("0".equals(qq.charAt(0)+"")){return false;}//满足所有的规则return true;}
}

2.正则表达式-字符类

package com.itheima.demo04regex;/*java.util.regex.Pattern:正则表达式的编译表示形式。 定义了正则表达式的一些规则正则表达式-字符类:[]表示一个区间,区间的范围可以自己定义语法示例：1. [abc]：代表a或者b，或者c字符中的一个。2. [^abc]：代表除a,b,c以外的任何字符。3. [a-z]：代表a-z的所有小写字符中的一个。4. [A-Z]：代表A-Z的所有大写字符中的一个。5. [0-9]：代表0-9之间的某一个数字字符。6. [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。7. [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符[13579]  [2-57-9]*/
public class Demo02Regex {public static void main(String[] args) {String str = "ead";//falsestr = "hid";//truestr = "hud";//truestr = "Hud";//false//1.验证str是否以h开头，以d结尾，中间是a,e,i,o,u中某个字符String regex = "h[aeiou]d";//使用字符串调用matches方法进行校验boolean b1 = str.matches(regex);System.out.println("b1:"+b1);//2.验证str是否以h开头，以d结尾，中间不是a,e,i,o,u中的某个字符regex = "h[^aeiou]d";str = "wad";//falsestr = "h2d";//truestr = "had";//falseboolean b2 = str.matches(regex);System.out.println("b2:"+b2);//3.验证str是否a-z的任何一个小写字符开头，后跟adregex = "[a-z]ad";str = "dad";//truestr = "3ad";//falseboolean b3 = str.matches(regex);System.out.println("b3:"+b3);//4.验证str是否以a-d或者m-p之间某个字符开头，后跟adregex = "[a-dm-p]ad";str = "cad";//truestr = "ead";//falseboolean b4 = str.matches(regex);System.out.println("b4:"+b4);}
}

3.正则表达式-逻辑运算符

package com.itheima.demo04regex;/*正则表达式-逻辑运算符语法示例：1. &&：并且   多个条件同时满足2. || ：或者  满足其中一个条件即可*/
public class Demo03Regex {public static void main(String[] args) {String str = "had";//truestr = "Had";//falsestr = "ead";//false/*1.要求字符串是否是除a、e、i、o、u外的其它小写字符开头，后跟ad除a、e、i、o、u外: [^aeiou]小写字符:[a-z]这两个条件同时满足 并且 &&*/String regex = "[[^aeiou]&&[a-z]]ad";boolean b1 = str.matches(regex);System.out.println("b1:"+b1);/*2.要求字符串是aeiou中的某个字符开头，后跟ad"[a||e||i||o||u]ad"就相当于"[aeiou]ad" 或运算符是可以省略不写的*///regex = "[a||e||i||o||u]ad";regex = "[aeiou]ad";str = "aad";//truestr = "add";//falsestr = "wdd";//falseboolean b2 = str.matches(regex);System.out.println("b2:"+b2);}
}

4.正则表达式-预定义字符

package com.itheima.demo04regex;/*正则表达式-预定义字符语法示例：1. "." ： 匹配任何字符。(重点)2. "\\d"：任何数字[0-9]的简写 (重点)3. "\\D"：任何非数字[^0-9]的简写4. "\\s"： 空白字符(空格)：[ \t\n\x0B\f\r] 的简写5. "\\S"： 非空白字符：[^\s] 的简写6. "\\w"：单词字符：[a-zA-Z_0-9]的简写(重点)7. "\\W"：非单词字符：[^\w]注意:\本身就是转义字符,写正则表达式的时候,必须写\\,把有特殊含义的\转义为一个普通的\使用*/
public class Demo04Regex {public static void main(String[] args) {String str = "250";//truestr = "25a";//false//1.验证str是否3位数字String regex = "[0-9][0-9][0-9]";regex = "\\d\\d\\d";boolean b1 = str.matches(regex);System.out.println("b1:"+b1);//2.验证手机号：1开头，第二位：3/5/8，剩下9位都是0-9的数字regex = "1[358][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]";regex = "1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d";str = "13888888888";//truestr = "23888888888";//falsestr = "138888888881";//falsestr = "138888888a8";//falseboolean b2 = str.matches(regex);System.out.println("b2:"+b2);//3.验证字符串是否以h开头，以d结尾，中间是任何字符regex = "h.d";str = "h%d";//truestr = "h中d";//truestr = "1中d";//falsestr = "hd";//falseboolean b3 = str.matches(regex);System.out.println("b3:"+b3);/*4.验证str是否是：had.注意:had.这个字符串中的.不是任意的字符串,就是一个普通.需要使用转义字符把有特殊含有的.转义为普通的.*///regex = "had.";regex = "had\\.";str = "hadA";//falsestr = "had.";//trueboolean b4 = str.matches(regex);System.out.println("b4:"+b4);}
}

5. 正则表达式-数量词

package com.itheima.demo04regex;/*正则表达式-数量词语法示例：1. X? : 0次或1次2. X* : 0次到多次  任意次3. X+ : 1次或多次4. X{n} : 恰好n次 X==n次5. X{n,} : 至少n次  X>=n次6. X{n,m}: n到m次(n和m都是包含的)   n=<X<=m*/
public class Demo05Regex {public static void main(String[] args) {String str = "";//falsestr = "123";//truestr = "1234";//falsestr = "12a";//false//1.验证str是否是三位数字String regex = "\\d{3}";   //regex = "\\d\\d\\d";boolean b1 = str.matches(regex);System.out.println("b1:"+b1);//2.验证str是否是多位数字:数字出现的次数1次以上regex = "\\d+";str = "123213213213123123";//truestr = "1";//truestr = "";//falsestr = "12312aa12312";//falseboolean b2 = str.matches(regex);System.out.println("b2:"+b2);//3.验证str是否是手机号:1开头，第二位：3/5/8，剩下9位都是0-9的数字regex = "1[358]\\d{9}"; //regex = "1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d";str = "13888888888";//truestr = "138888888881";//falseboolean b3 = str.matches(regex);System.out.println("b3:"+b3);//4.验证小数:必须出现小数点，但是只能出现1次double d = 1.1;d = 0.1;d = .1;d = 1.;//d = .;//System.out.println(d);regex = "\\d*\\.\\d*";str = "1.1";//truestr = "0.1";//truestr = ".1";//truestr = "1.";//truestr = "aa.1";//falsestr = "1..1";//falseboolean b4 = str.matches(regex);System.out.println(b4);//5.验证小数：小数点可以不出现，也可以出现1次regex = "\\d*\\.?\\d*";str = "11";//truestr = "111231.123123123";//truestr = "";//truestr = "a";//falsestr = "11..11";//falseboolean b5 = str.matches(regex);System.out.println("b5:"+b5);//6.验证小数：要求匹配：3、3.、3.14、+3.14、-3.regex = "[+-]?\\d+\\.?\\d*";str = "3";//truestr = "3.";//truestr = "3.14";//truestr = "+3.14";//truestr = "-3.";//trueboolean b6 = str.matches(regex);System.out.println("b6:"+b6);//7.验证qq号码：1).5--15位；2).全部是数字;3).第一位不是0regex = "[1-9]\\d{4,14}";str = "11111";//truestr = "1234";//falsestr = "01234";//falsestr = "123123a4";//falseboolean b7 = str.matches(regex);System.out.println("b7:"+b7);}
}

6.正则表达式-分组括号( )

package com.itheima.demo04regex;/*正则表达式-分组括号( )*/
public class Demo06Regex {public static void main(String[] args) {//校验字符串"abc"作为一组可以出现任意次String regex = "(abc)*";String str = "";//truestr = "abc";//truestr = "abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc";//truestr = "aabbcc";//falseboolean b1 = str.matches(regex);System.out.println("b1:"+b1);str = "DG8FV-B9TKY-FRT9J-99899-XPQ4G";//truestr = "DG8FV-B9TKY-FRTJ-99899-XPQ4G";//falsestr = "DG8FV-B9TKYFRT1J-99899-XPQ4G";//false//验证这个序列号：分为5组，每组之间使用-隔开，每组由5位A-Z或者0-9的字符组成regex = "([A-Z0-9]{5}-){4}[A-Z0-9]{5}";boolean b2 = str.matches(regex);System.out.println("b2:"+b2);}
}

7.String类中和正则表达式相关的方法

package com.itheima.demo04regex;/*String类中和正则表达式相关的方法boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。*/
public class Demo07Regex {public static void main(String[] args) {show04();}/*String replaceAll(String regex, String replacement)使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。过滤文章中的关键字*/private static void show04() {String s = "12asdfdsaf32adfdsa1f3a12af312daf321hello312你好3123";System.out.println("原字符串:"+s);//需求:使用replaceAll方法把字符串中每一个数字替换为@_@String s1 = s.replaceAll("\\d", "@_@");System.out.println("替换后的字符串:"+s1);//替换后的字符串:@_@@_@asdfdsaf@_@@_@adfdsa@_@f@_@a@_@@_@af@_@@_@@_@daf@_@@_@@_@hello@_@@_@@_@你好@_@@_@@_@@_@//需求:使用replaceAll方法把字符串中1个数字或者是连续的数字替换为一个@_@String s2 = s.replaceAll("\\d+", "@_@");System.out.println("替换后的字符串:"+s2);System.out.println("林志玲3223423林志玲sdfadsfadsfadsfa林志玲".replaceAll("林志玲+","***"));//***3223423***sdfadsfadsfadsfa***}/*String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。*/private static void show03() {String s = "11 22 33 44";s = "11   22       33      44";//根据空格切割字符串String[] arr = s.split(" +");//根据一个空格或者多个空格切割字符串System.out.println(arr.length);for (String str : arr) {System.out.println(str);}}/*String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。split方法的参数是正则表达式.任意字符串\\.把有特殊含义的字符转换为普通.*/private static void show02() {String s = "192.168.1.100";//根据.切割字符串String[] arr = s.split("\\.");System.out.println(arr.length);//0for (String str : arr) {System.out.println(str);}}/*String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。*/private static void show01() {String s = "11-22-33-44";//根据-切割字符串String[] arr = s.split("-");for (String str : arr) {System.out.println(str);}}
}

三.lombok(了解)

1.lombok介绍

Lombok通过增加一些“处理程序”，可以让java变得简洁、快速。
Lombok能以注解形式来简化java代码，提高开发效率。

开发中经常需要写的javabean(和数据库表对应的类)，都需要花时间
去添加相应的getter/setter，也许还要去写构造方法、equals等方法，而且需要维护。
Lombok能通过注解的方式，在编译时自动为属性生成构造方法、getter/setter、equals、hashcode、
toString方法。出现的神奇就是在源码中没有getter和setter方法，但是在编译生成的字节码文件中有
getter和setter方法。这样就省去了手动重建这些代码的麻烦，使代码看起来更简洁些。

2.lombok使用

在这里插入图片描述

package com.itheima.demo05lombok;import lombok.*;/*lombok的作用:使用注解简化代码@Getter和@Setter作用：生成成员变量的get和set方法。写在成员变量上，只对当前成员变量有效。写在类上，对所有成员变量有效。注意：静态成员变量无效。@ToString：作用：生成toString()方法。该注解只能写在类上。@NoArgsConstructor和@AllArgsConstructor@NoArgsConstructor：无参数构造方法。@AllArgsConstructor：满参数构造方法。该注解只能写在类上。@EqualsAndHashCode作用：生成hashCode()和equals()方法。该注解只能写在类上。@Data作用： 生成setter/getter、equals、canEqual、hashCode、toString方法，如为final属性，则不会为该属性生成setter方法。该注解只能写在类上。*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person {private String name;private int age;private String sex;
}

package com.itheima.demo05lombok;public class Demo01Lombok {public static void main(String[] args) {Person p = new Person();p.setName("老王");p.setAge(18);p.setSex("男");System.out.println(p);//Person(name=老王, age=18, sex=男)Person p2 = new Person("翠花",18,"女");System.out.println(p2);}
}