day19.IO流

  1. 课前回顾:
  2.    字节流
  3.       FileInputStream:字节输入流(读)
  4.    字符流:
  5.       FileWriter:字符输出流(写)
  6.       FileReader:字符输入流(读)
  7.    字节缓冲流:
  8.       BufferedOutputStream:字节缓冲输出流
  9.       BufferedInptuStream:字节缓冲输入流
  10.    转换流:
  11.       OutputStreamWriter
  12.       InputStreamReader
  14. 今日内容:
  15.   1.会使用序列化流读写对象
  16.   2.会使用Properties集合结合IO流解析properties配置文件中的内容
  17.   3.会导入jar包
  18.   4.会使用Commons-io   io工具类
  19.   5.能看懂正则表达式以及基本的写法
  20.   6.会手写单例模式(懒汉式  饿汉式)
  21.   7.会使用lombok插件
  22.   8.会定义一个简单的枚举类,会调用里面的成员

day19[IO流_正则表达式_单例] - 图1

第一章.序列化流

一.序列化流和反序列化流介绍

  1. 1.作用: 读写对象的
  2. 2.对象:
  3.   序列化流:ObjectOutputStream(写对象)
  4.   反序列化流:ObjectInputStream(读对象)

day19[IO流_正则表达式_单例] - 图2

二.序列化流_ObjectOutputStream

  1. 1.作用:写对象
  2. 2.构造:
  3.   ObjectOutputStream(OutputStream out) 
  4.                      OutputStream:抽象类,所以传递需要传递OutputStream的子类对象
  5. 3.方法:
  6.   void writeObject(Object obj) -> 写对象 
  7. 4.注意:
  8.   如果想要实现序列化流,那么被操作的对象要实现Serializable接口
  1. /*
  2.       序列化方法
  3.       构造:
  4.         ObjectOutputStream(OutputStream out)
  5.                      OutputStream:抽象类,所以传递需要传递OutputStream的子类对象
  6.       方法:void writeObject(Object obj) -> 写对象
  7.      */
  8.     private static void write01()throws Exception {
  9.        //创建对象
  10.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day19\\io\\person.txt"));
  11.         //写对象
  12.         oos.writeObject(new Person("柳岩",36));
  13.         //关闭资源
  14.         oos.close();
  15.     }
  1. public class Person implements Serializable {
  2.     private String name;
  3.     private int age;
  5.     public Person() {
  6.     }
  8.     public Person(String name, int age) {
  9.         this.name = name;
  10.         this.age = age;
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public int getAge() {
  22.         return age;
  23.     }
  25.     public void setAge(int age) {
  26.         this.age = age;
  27.     }
  29.     @Override
  30.     public String toString() {
  31.         return "Person{" +
  32.                 "name='" + name + '\'' +
  33.                 ", age=" + age +
  34.                 '}';
  35.     }
  36. }

三.反序列化_ObjectInputStream

  1. 1.作用:读对象
  2. 2.构造:
  3.   ObjectInputStream(InputStream in) 
  4.                     InputStream:抽象类,所以传递的是子类对象
  5. 3.方法:
  6.   Object readObject()->读对象
  1. /*
  2.       反序列化:
  3.         构造:
  4.           ObjectInputStream(InputStream in)
  5.                     InputStream:抽象类,所以传递的是子类对象
  6.         方法:
  7.           Object readObject()->读对象
  8.      */
  9.     private static void read01()throws Exception {
  10.       //创建对象
  11.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day19\\io\\person.txt"));
  12.         Object o = ois.readObject();
  13.         //向下转型
  14.         Person p = (Person)o;
  15.         System.out.println(p);
  16.         //关流
  17.         ois.close();
  18.     }

四.不想被序列化操作(了解)

  1. 方式1:将不想被序列化的成员变成[static]的
  2. 方式2:将不想被序列化的成员变成[transient]的-->推荐使用
  1.     private String name;
  2.     //private static int age;
  3.     private transient int age;

五.反序列化时出现的问题以及分析以及解决

  1. 出现的原因:
  2.    当一个对象中的代码被修改了,没有重新的序列化,就直接反序列化了
  3. 异常:InvalidClassException(序列化冲突)
  5. 当修改代码之后,重新生成了class文件,也会产生一个新的序列号,但是我们没有重新序列化一下
  7. 所以此时文件中还是保存的之前序列化的内容,版本号也是之前的1111
  9. 此时我们直接反序列化,用class文件中的2222版本号和文件中的1111做比对,发现对不上,就会出现版本号冲突问题
  1. public class Person implements Serializable {
  2.     static final long serialVersionUID = 42L;
  3.     private String name;
  4.     public int age;
  6.     public Person() {
  7.     }
  9.     public Person(String name, int age) {
  10.         this.name = name;
  11.         this.age = age;
  12.     }
  14.     public String getName() {
  15.         return name;
  16.     }
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  22.     public int getAge() {
  23.         return age;
  24.     }
  26.     public void setAge(int age) {
  27.         this.age = age;
  28.     }
  30.     @Override
  31.     public String toString() {
  32.         return "Person{" +
  33.                 "name='" + name + '\'' +
  34.                 ", age=" + age +
  35.                 '}';
  36.     }
  37. }

day19[IO流_正则表达式_单例] - 图3

六.扩展(经验值)

  1. 1.问题1:
  2.   如果想序列化多个对象到文件中,怎么反序列化?  循环
  3. 2.问题2:
  4.   如果我们反序列化的时候,不确定存储了多少个对象,那么循环反序列化次数就不确定,在不确定次数的前提下很容易出现:EOFException(文件意外到达结尾)
  6.   解决:
  7.    将多个对象放到一个集合中,将这一个集合序列化到文件中
  8.    当反序列化的时候,我们直接读取这一个集合对象,然后再遍历集合
  1. public class Test01 {
  2.     public static void main(String[] args)throws Exception {
  3.         //write01();
  4.         read01();
  5.     }
  7.     /*
  8.       反序列化:
  9.         构造:
  10.           ObjectInputStream(InputStream in)
  11.                     InputStream:抽象类,所以传递的是子类对象
  12.         方法:
  13.           Object readObject()->读对象
  14.      */
  15.     private static void read01()throws Exception {
  16.       //创建对象
  17.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day19\\io\\person3.txt"));
  18.         //Person person1 = (Person) ois.readObject();
  19.         //Person person2 = (Person) ois.readObject();
  20.         //Person person3 = (Person) ois.readObject();
  21.         //System.out.println(person1);
  22.         //System.out.println(person2);
  23.         //System.out.println(person3);
  25.         /*for (int i = 0; i < 4; i++) {
  26.             Person person = (Person) ois.readObject();
  27.             System.out.println(person);
  28.         }*/
  30.         ArrayList<Person> list = (ArrayList<Person>) ois.readObject();
  31.         for (Person person : list) {
  32.             System.out.println(person);
  33.         }
  34.         //关流
  35.         ois.close();
  36.     }
  38.     /*
  39.       序列化方法
  40.       构造:
  41.         ObjectOutputStream(OutputStream out)
  42.                      OutputStream:抽象类,所以传递需要传递OutputStream的子类对象
  43.       方法:void writeObject(Object obj) -> 写对象
  44.      */
  45.     private static void write01()throws Exception {
  46.        //创建对象
  47.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day19\\io\\person3.txt"));
  48.         //写对象
  49.         //oos.writeObject(new Person("柳岩",36));
  50.         //oos.writeObject(new Person("杨幂",32));
  51.         //oos.writeObject(new Person("金莲",26));
  53.         //创建集合
  54.         ArrayList<Person> list = new ArrayList<>();
  55.         list.add(new Person("柳岩",36));
  56.         list.add(new Person("杨幂",32));
  57.         list.add(new Person("金莲",26));
  59.         //序列化这存有多个对象的集合
  60.         oos.writeObject(list);
  61.         //关闭资源
  62.         oos.close();
  63.     }
  64. }

第二章.打印流_PrintStream(了解)

1.PrintStream打印流基本使用

  1. 1.概述:PrintStream:打印流
  2. 2.方法:
  3.   println():原样输出,输出之后自动换行
  4.   print():原样输出,输出之后不会自动换行
  5. 3.构造:
  6.   PrintStream(String fileName) 
  7.               fileName:指定输出的文件路径
  1. public class Test02 {
  2.     public static void main(String[] args)throws Exception {
  3.         PrintStream ps = new PrintStream("day19/io/print.txt");
  4.         ps.println("哈哈哈哈");
  5.         ps.print("嘿嘿嘿嘿");
  6.         ps.close();
  7.     }
  8. }
  1. 问题:
  2.   如果想将System.out.println输出语句打印到控制台上的内容,转移到指定的文件中,怎么做
  3. 解决:改变输出语句的流向
  5. 使用:System类中的方法
  6.      static void setOut(PrintStream out) ->将输出语句输出在控制台上的内容转移到文件中
  1. public class Test03 {
  2.     public static void main(String[] args)throws Exception {
  3.         PrintStream ps = new PrintStream("day19/io/print.txt");
  5.         //改变流向
  6.         System.setOut(ps);
  8.         System.out.println("哈哈哈");
  9.         ps.close();
  10.     }
  11. }

2.PrintStream打印流完成续写

  1. 构造:
  2.   PrintStream(OutputStream out)
  3. 续写:
  4.   PrintStream(new FileOutputStream("文件路径",true))
  1. public class Test03 {
  2.     public static void main(String[] args)throws Exception {
  3.         PrintStream ps = new PrintStream(new FileOutputStream("day19/io/print.txt",true));
  5.         //改变流向
  6.         System.setOut(ps);
  8.         System.out.println("哈哈哈");
  9.         ps.close();
  10.     }
  11. }

第三章.Properties集合结合IO使用

一.Properties集合IO流使用

  1. 回顾:
  2. 1.介绍:properties extends HashTable
  3. 2.特点:
  4.   a.key 和 value 默认都是String的
  5.   b.不能存null值  null键
  6.   c.线程安全,效率低
  7.   d.元素无序
  8. 3.方法:
  9.   String getProperty(String key)  -> 根据key获取value
  10.   Object setProperty(String key, String value) ->存储key value
  11.   Set<String> stringPropertyNames()  -> 获取所有的key放到set集合中
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         Properties properties = new Properties();
  4.         properties.setProperty("涛哥","三上悠亚");
  5.         properties.setProperty("文章","马伊琍");
  6.         properties.setProperty("黄晓明","杨颖");
  8.         //遍历
  9.         Set<String> set = properties.stringPropertyNames();
  10.         for (String key : set) {
  11.             String value = properties.getProperty(key);
  12.             System.out.println(key+"...."+value);
  13.         }
  14.     }
  15. }

1.Properties结合IO流使用方法

  1. void load(InputStream inStream)  -> 将流中的数据加载到properties集合中
  3. 作用:解析配置文件中的数据
  1. 1.创建一个配置文件(.properties结尾的文件)
  2. 2.在.properties文件中写数据
  3.   a.都是以key=value的形式编写
  4.   b.中间不要有空格
  5.   c.每一个键值对写完需要换行编写其他的键值对数据
  6.   d.在properties文件中的key,value默认都是String的,不要写上""
  7.   e.配置文件中最好不要出现中文
  9. 3.创建properties文件内容:
  10.   username=root
  11.   password=root
  1. public class Test02 {
  2.     public static void main(String[] args)throws Exception {
  3.         Properties properties = new Properties();
  4.         /*
  5.           void load(InputStream inStream)  -> 将流中的数据加载到properties集合中
  6.          */
  7.         FileInputStream in = new FileInputStream("day19\\io\\pro.properties");
  9.         properties.load(in);
  11.         //遍历
  12.         Set<String> set = properties.stringPropertyNames();
  13.         for (String key : set) {
  14.             String value = properties.getProperty(key);
  15.             System.out.println(key+"..."+value);
  16.         }
  17.     }
  18. }

第四章.Commons-io工具包

一.介绍

  1. IO技术开发中，代码量很大，而且代码的重复率较高。如果我们要遍历目录，拷贝目录就需要使用方法的递归调用，也增大了程序的复杂度。
  3. Apache软件基金会，开发了IO技术的工具类`commonsIO`，大大简化IO开发。

二.添加第三方jar包

  1. Apahce软件基金会属于第三方，（Oracle公司第一方，我们自己第二方，其他都是第三方）我们要使用第三方开发好的工具，需要添加jar包。
  3. jar包：就是Java自己的压缩包，包中是开发好的功能，全部以class文件形态出现，我们添加直接使用即可。
  5. 引入jar包:
  6. 1.在当前模块下创建一个Directory,取名为lib
  7. 2.将想使用的jar包粘贴到lib下
  8. 3.对着jar包,右键->选择 add as library
  9. 4.选择module library
  10. 5.点击ok

三.工具包的使用

  1. IOUtils类
  2. - 静态方法：IOUtils.copy(InputStream in,OutputStream out)传递字节流，实现文件复制。
  3. - 静态方法：IOUtils.closeQuietly(任意流对象)悄悄的释放资源，自动处理close()方法抛出的异常。
  1. public class Demo01IOUtils {
  2.     public static void main(String[] args) throws Exception{
  3.         /*
  4.           IOUtils类
  5.             静态方法：IOUtils.copy(InputStream in,OutputStream out)传递字节流，实现文件复制。
  6.             静态方法：IOUtils.closeQuietly(任意流对象)悄悄的释放资源，自动处理close()方法抛出的异常。
  7.          */
  8.         IOUtils.copy(new FileInputStream("E:\\Idea\\io\\1.jpg"),new FileOutputStream("E:\\Idea\\io\\a\\柳岩.jpg"));
  9.     }
  10. }
  1. FileUtils类
  3. - 静态方法：FileUtils.copyDirectoryToDirectory(File src,File dest);
  4.            传递File类型的目录，进行整个目录的复制，自动进行递归遍历。
  6.            参数:
  7.              src:要复制的文件夹路径
  8.              dest:要将文件夹粘贴到哪里去
  10. - 静态方法：writeStringToFile(File file,String str)写字符串到文本文件中。
  11. - 静态方法：String readFileToString(File file)读取文本文件，返回字符串。
  1. public class Demo02FileUtils {
  2.     public static void main(String[] args)throws Exception {
  3.         /*
  4.           FileUtils类
  6.          - 静态方法：FileUtils.copyDirectoryToDirectory(File src,File dest);
  7.            传递File类型的目录，进行整个目录的复制，自动进行递归遍历。
  9.            参数:
  10.              src:要复制的文件夹路径
  11.              dest:要将文件夹粘贴到哪里去
  13.         - 静态方法：writeStringToFile(File file,String str)写字符串到文本文件中。
  14.         - 静态方法：String readFileToString(File file)读取文本文件，返回字符串。
  15.          */
  17.         //FileUtils.copyDirectoryToDirectory(new File("E:\\Idea\\io"),new File("E:\\"));
  19.        // FileUtils.writeStringToFile(new File("day19\\io\\commons.txt"),"我爱你柳岩");
  21.         String s = FileUtils.readFileToString(new File("day19\\io\\commons.txt"));
  22.         System.out.println(s);
  23.     }
  24. }

第五章.正则表达式

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

  1. 1.概述:拥有特定规则的字符串
  2. 2.作用:主要是用于校验
  3.       我们可以利用正则表达式来规定我们填写的数据到底符不符合正则表达式的规定(密码,用户名,邮箱,手机号,身份证等)
  5. 3.需求:校验一个QQ号
  6.   a.长度5-15位
  7.   b.全是数字
  8.   c.第一位不能是0
  9. 4.正则表达式
  10.   [1-9][0-9]{4,14}
  11. 5.如何校验一个字符串是否符合我们的正则表达式?
  12.   String中有一个方法:
  13.   boolean matches(String regex) -> 判断一个字符串是否符合regex(参数)规定的规则
  1. public class Demo01Regex {
  2.     public static void main(String[] args) {
  3.         Scanner sc = new Scanner(System.in);
  4.         System.out.println("请你输入QQ号:");
  5.         String qq = sc.next();
  6.         //boolean result = method(qq);
  7.         boolean result = method01(qq);
  8.         System.out.println(result);
  9.     }
  11.     private static boolean method01(String qq) {
  12.         boolean matches = qq.matches("[1-9][0-9]{4,14}");
  13.         return matches;
  14.     }
  16.     /*
  17.         a.长度5-15位
  18.         b.全是数字
  19.         c.第一位不能是0
  20.      */
  21.     private static boolean method(String qq) {
  22.         //判断长度
  23.         if (qq.length()<5 || qq.length()>15){
  24.             return false;
  25.         }
  27.         //判断是否全是数字
  28.         char[] chars = qq.toCharArray();
  29.         for (char c : chars) {
  30.             if (c<'0' || c>'9'){
  31.                 return false;
  32.             }
  33.         }
  35.         //判断第一位是否为0
  36.         if (qq.startsWith("0")){
  37.             return false;
  38.         }
  39.         return true;
  40.     }
  41. }

2.正则表达式-字符类

  1. java.util.regex.Pattern:正则表达式的编译表示形式。
  2.     正则表达式-字符类:[]表示一个区间,范围可以自己定义
  3.         语法示例：
  4.         1. [abc]：代表a或者b，或者c字符中的一个。
  5.         2. [^abc]：代表除a,b,c以外的任何字符。
  6.         3. [a-z]：代表a-z的所有小写字符中的一个。
  7.         4. [A-Z]：代表A-Z的所有大写字符中的一个。
  8.         5. [0-9]：代表0-9之间的某一个数字字符。
  9.         6. [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。
  10.         7. [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符
  1. public class Demo02Regex {
  2.     public static void main(String[] args) {
  3.         //1.验证字符串是否以h开头,d结尾,中间是aeiou的某一个字符
  4.         String regex = "[h][aeiou][d]";
  5.         boolean result01 = "had".matches(regex);
  6.         System.out.println(result01);
  8.         boolean result02 = "hyd".matches(regex);
  9.         System.out.println(result02);
  11.         System.out.println("==========================");
  12.         //2.验证字符串是否以h开头,d结尾,中间不是aeiou中的某一个字符
  13.         String regex1 = "[h][^aeiou][d]";
  14.         boolean result03 = "hyd".matches(regex1);
  15.         System.out.println(result03);
  17.         System.out.println("========================");
  19.         //3.验证字符串是否a-z任何一个小写字母开头,后面是ad
  20.         String regex2 = "[a-z][a][d]";
  21.         boolean result04 = "aad".matches(regex2);
  22.         System.out.println(result04);
  23.     }
  24. }

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

  1.  正则表达式-逻辑运算符
  2.         语法示例：
  3.         1. &&：并且
  4.         2. | ：或者
  1. public class Demo03Regex {
  2.     public static void main(String[] args) {
  3.         //要求字符串是小写[a-z]并且字符[^aeiou]开头,后跟ad
  4.         String regex = "[[a-z]&&[^aeiou]][a][d]";
  5.         boolean result01 = "aad".matches(regex);
  6.         System.out.println(result01);
  8.         boolean result02 = "zad".matches(regex);
  9.         System.out.println(result02);
  11.         System.out.println("====================");
  13.         //2.要求字符串是aeiou中的某一个字母开头,后跟ad
  14.         String regex01 = "[a|e|i|o|u][a][d]";
  15.         //String regex01 = "[aeiou][a][d]";
  16.         boolean result03 = "aad".matches(regex01);
  17.         System.out.println(result03);
  19.     }
  20. }

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

  1.  正则表达式-预定义字符
  2.     语法示例：
  3.     1. "." ： 匹配任何字符。(重点)
  4.     2. "\\d"：任何数字[0-9]的简写；(重点)
  5.     3. "\\D"：任何非数字[^0-9]的简写；
  6.     4. "\\s"： 空白字符：[ \t\n\x0B\f\r] 的简写
  7.     5. "\\S"： 非空白字符：[^\s] 的简写
  8.     6. "\\w"：单词字符：[a-zA-Z_0-9]的简写(重点)
  9.     7. "\\W"：非单词字符：[^\w]
  1. public class Demo04Regex {
  2.     public static void main(String[] args) {
  3.         //1.验证字符串是否是三位数字
  4.         //String regex = "[0-9][0-9][0-9]";
  5.         String regex = "\\d\\d\\d";
  6.         boolean result01 = "111".matches(regex);
  7.         System.out.println(result01);
  9.         System.out.println("======================");
  10.         //2.验证手机号:1开头;第二位3  5  8  整下的9位都是0-9的数字
  11.         //String regex01 = "[1][358][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]";
  12.         String regex01 = "[1][358]\\d\\d\\d\\d\\d\\d\\d\\d\\d";
  13.         boolean result02 = "13888888888".matches(regex01);
  14.         System.out.println(result02);
  16.         System.out.println("=========================");
  17.         //3.验证字符串是否以h开头,以d结尾,中间是任何一个字符
  18.         String regex02 = "[h].[d]";
  19.         boolean result03 = "h1d".matches(regex02);
  20.         System.out.println(result03);
  21.     }
  22. }

5. 正则表达式-数量词

  1.  正则表达式-数量词
  2.         语法示例：x代表字符
  3.         1. X? : x出现的数量为 0次或1次
  4.         2. X* : x出现的数量为 0次到多次 任意次
  5.         3. X+ : x出现的数量为 1次或多次 X>=1次
  6.         4. X{n} : x出现的数量为 恰好n次 X=n次
  7.         5. X{n,} : x出现的数量为 至少n次 X>=n次  x{3,}
  8.         6. X{n,m}: x出现的数量为 n到m次(n和m都是包含的)   n=<X<=m
  1. public class Demo05Regex {
  2.     public static void main(String[] args) {
  3.         //1.验证字符串是否是3个数字
  4.         String regex = "[0-9]{3}";
  5.         boolean result01 = "111".matches(regex);
  6.         System.out.println(result01);
  8.         System.out.println("================");
  10.         //2.验证字符串是否为多个数字:1个以上
  11.         String regex02 = "[0-9]+";
  12.         boolean result02 = "1".matches(regex02);
  13.         System.out.println(result02);
  15.         System.out.println("====================");
  16.         //3.验证手机号:1开头;第二位3  5  8  整下的9位都是0-9的数字
  17.         String regex03 = "[1][358][0-9]{9}";
  18.         boolean result03 = "13838381438".matches(regex03);
  19.         System.out.println(result03);
  21.         System.out.println("=====================");
  22.         //4.验证QQ号:第一位不能为0   5-15位   全部都是数字
  23.         String regex04 = "[1-9][0-9]{4,14}";
  24.         boolean result04 = "111111".matches(regex04);
  25.         System.out.println(result04);
  26.     }
  27. }

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

  1. 正则表达式-分组括号( )
  1. public class Demo06Regex {
  2.     public static void main(String[] args) {
  3.         //1.校验字符串abc可以出现任意次
  4.         String regex = "(abc)*";
  5.         boolean result = "abcabcabcabc".matches(regex);
  6.         System.out.println(result);
  7.     }
  8. }

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

  1.  String类中和正则表达式相关的方法
  2.         boolean matches(String regex) 判断字符串是否匹配给定的正则表达式。
  3.         String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
  4.         String replaceAll(String regex, String replacement)把满足正则表达式的字符串,替换为新的字符
  1. public class Demo07Regex {
  2.     public static void main(String[] args) {
  3.        // String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
  4.         String s = "abc haha  hehe";
  5.         String[] split = s.split(" +");
  6.         System.out.println(Arrays.toString(split));
  7.         // String replaceAll(String regex, String replacement)把满足正则表达式的字符串,替换为新的字符
  8.         String s1 = "abc haha  hehe";
  9.         String z = s1.replaceAll(" +", "z");
  10.         System.out.println(z);
  11.     }
  12. }

8.正则表达式生成网址:

  1. https://www.sojson.com/regex/generate

第六章.设计模式

  1. 设计模式（Design pattern），是一套被反复使用、经过分类编目的、代码设计经验的总结，使用设计模式是为了可重用代码、保证代码可靠性、程序的重用性。
  3. 1995 年，GoF（Gang of Four，四人组）合作出版了《设计模式：可复用面向对象软件的基础》一书，共收录了 23 种设计模式。
  5. 总体来说设计模式分为三大类：
  7. 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。-->创建对象
  9. 结构型模式，共七种：[适配器模式]、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。-->对功能进行增强
  11. 行为型模式，共十一种：策略模式、模板方法模式、[观察者模式]、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、[中介者模式]、解释器模式。

一.单例模式

  1. 目的:为了让一个类只产生一个对象共外界使用

1.饿汉式：

  1. 1.迫不及待地想要这个对象,就想让这个对象赶紧产生
  1. public class Singleton {
  2.     /*
  3.        目的:让一个类只产生一个对象,供外界使用
  4.        所以:我们就不能让外界随意new
  5.      */
  6.     private Singleton(){
  8.     }
  10.     /*
  11.       不能让外界new
  12.       需要在本类中自己new对象出来,而且还得保证对象随着类的加载而加载
  13.      */
  14.      private static Singleton singleton = new Singleton();
  16.      /*
  17.        对外提供一个方法,返回本类内部new的对象
  18.       */
  19.      public static Singleton getSingleton(){
  20.          return singleton;
  21.      }
  22. }
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         for (int i = 0; i < 10; i++) {
  4.             Singleton singleton = Singleton.getSingleton();
  5.             System.out.println(singleton);
  6.         }
  7.     }
  8. }

2.懒汉式：

  1. 1.不着急要这个对象,什么时候使用,什么时候new对象给外界使用,但是还要保证是同一个对象
  1. public class Singleton {
  2.     /*
  3.        目的:让一个类只产生一个对象,供外界使用
  4.        所以:我们就不能让外界随意new
  5.      */
  6.     private Singleton(){
  8.     }
  10.     /*
  11.       不能让外界new
  12.       需要在本类中自己new对象出来,但是懒汉式不需要让对象随着类的加载而new
  13.      */
  14.      private static Singleton singleton  = null;
  16.      /*
  17.        对外提供一个方法,返回本类内部new的对象
  18.        在此方法中将对象new出来,供外界使用,但是要保证对象只有一个产生
  19.        -->双重检测锁
  20.       */
  21.      public static Singleton getSingleton(){
  22.          if (singleton==null){
  23.              synchronized (Singleton.class){
  24.                  if (singleton==null){
  25.                      singleton = new Singleton();
  26.                  }
  27.              }
  28.          }
  29.          return singleton;
  30.      }
  31. }
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         for (int i = 0; i < 10; i++) {
  4.             Singleton singleton = Singleton.getSingleton();
  5.             System.out.println(singleton);
  6.         }
  7.     }
  8. }

3.小结

  1. 1.单例模式:
  2.   a.将构造私有化
  3.   b.在内部创建对象,并且用private static修饰
  4.   c.对外提供静态方法,将内部new的对象返回给外部

第七章.Lombok使用

1 lombok介绍

Lombok通过增加一些“处理程序”，可以让java变得简洁、快速。

Lombok能以注解形式来简化java代码，提高开发效率。开发中经常需要写的javabean，都需要花时间去添加相应的getter/setter，也许还要去写构造器、equals等方法，而且需要维护。

Lombok能通过注解的方式，在编译时自动为属性生成构造器、getter/setter、equals、hashcode、toString方法。出现的神奇就是在源码中没有getter和setter方法，但是在编译生成的字节码文件中有getter和setter方法。这样就省去了手动重建这些代码的麻烦，使代码看起来更简洁些。

5.2 lombok使用

  • 添加lombok的jar包：lombok-1.18.8.jar。
  • 为IDEA添加lombok插件（连接网络使用）
  • 安装完毕后，重启IDEA。
    day19[IO流_正则表达式_单例] - 图4

day19[IO流_正则表达式_单例] - 图5

day19[IO流_正则表达式_单例] - 图6

5.3 lombok常用注解

@Getter和@Setter

  • 作用：生成成员变量的get和set方法。
  • 写在成员变量上，指对当前成员变量有效。
  • 写在类上，对所有成员变量有效。
  • 注意：静态成员变量无效。

day19[IO流_正则表达式_单例] - 图7

@ToString

  • 作用：生成toString()方法。
  • 注解只能写在类上。

day19[IO流_正则表达式_单例] - 图8

@NoArgsConstructor和@AllArgsConstructor

  • @NoArgsConstructor：无参数构造方法。
  • @AllArgsConstructor：满参数构造方法。
  • 注解只能写在类上。

day19[IO流_正则表达式_单例] - 图9

@EqualsAndHashCode

  • 作用：生成hashCode()和equals()方法。
  • 注解只能写在类上。

day19[IO流_正则表达式_单例] - 图10

@Data

  • 作用：生成get/set，toString，hashCode，equals，无参构造方法
  • 注解只能写在类上。

day19[IO流_正则表达式_单例] - 图11