异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

什么是异常？
         异常是程序在"编译"或者"执行"的过程中可能出现的问题。
         异常是应该尽量提前避免的。
         异常可能也是无法做到绝对避免的，异常可能有太多情况了，开发中只能提前干预！！
         异常一旦出现了，如果没有提前处理，程序就会退出JVM虚拟机而终止，开发中异常是需要提前处理的。

         研究异常并且避免异常，然后提前处理异常，体现的是程序的安全, 健壮性！！！

         Java会为常见的代码异常都设计一个类来代表。

    异常的体系:
         Java中异常继承的根类是：Throwable。

             Throwable(根类，不是异常类)
          /              \
        Error           Exception（异常，需要研究和处理）
                        /            \
                       编译时异常     RuntimeException(运行时异常)


        Error : 错误的意思，严重错误Error，无法通过处理的错误，一旦出现，程序员无能为力了，
            只能重启系统，优化项目。
            比如内存奔溃，JVM本身的奔溃。这个程序员无需理会。

        Exception:才是异常类，它才是开发中代码在编译或者执行的过程中可能出现的错误，
            它是需要提前处理的。以便程序更健壮！

    Exception异常的分类:
         1.编译时异常：继承自Exception的异常或者其子类，编译阶段就会报错，
                必须程序员处理的。否则代码编译就不能通过！！

         2.运行时异常: 继承自RuntimeException的异常或者其子类，编译阶段是不会出错的，它是在
                运行时阶段可能出现，运行时异常可以处理也可以不处理，编译阶段是不会出错的，
                但是运行阶段可能出现，还是建议提前处理！！
    小结：
        异常是程序在编译或者运行的过程中可能出现的错误！！
        异常分为2类：编译时异常，运行时异常。
            -- 编译时异常：继承了Exception,编译阶段就报错，必须处理，否则代码不通过。
            -- 运行时异常：继承了RuntimeException,编译阶段不会报错，运行时才可能出现。
        异常一旦真的出现，程序会终止，所以要研究异常，避免异常，处理异常，程序更健壮!!

常见的运行时异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行时异常的概念:
            继承自RuntimeException的异常或者其子类，
            编译阶段是不会出错的，它是在运行时阶段可能出现的错误，
            运行时异常编译阶段可以处理也可以不处理,代码编译都能通过！！

            1.数组索引越界异常: ArrayIndexOutOfBoundsException。
            2.空指针异常 : NullPointerException。
              直接输出没有问题。但是调用空指针的变量的功能就会报错！！
            3.类型转换异常：ClassCastException。
            4.迭代器遍历没有此元素异常：NoSuchElementException。
            5.数学操作异常：ArithmeticException。
            6.数字转换异常： NumberFormatException。

   小结：
       运行时异常继承了RuntimeException ,编译阶段不报错，运行时才可能会出现错误!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。。。");
        /** 1.数组索引越界异常: ArrayIndexOutOfBoundsException。*/
        int[] arrs = {10 ,20 ,30};
        System.out.println(arrs[2]);
        // System.out.println(arrs[3]); // 此处出现了数组索引越界异常。代码在此处直接执行死亡！

        /** 2.空指针异常 : NullPointerException。直接输出没有问题。但是调用空指针的变量的功能就会报错！！ */
        String name = null ;
        System.out.println(name); // 直接输出没有问题
        // System.out.println(name.length());  // 此处出现了空指针异常。代码在此处直接执行死亡！

        /** 3.类型转换异常：ClassCastException。 */
        Object o = "齐天大圣";
        //Integer s = (Integer) o;  // 此处出现了类型转换异常。代码在此处直接执行死亡！


        /** 5.数学操作异常：ArithmeticException。 */
        // int c = 10 / 0 ; // 此处出现了数学操作异常。代码在此处直接执行死亡！


        /** 6.数字转换异常： NumberFormatException。 */
        String num = "23aa";
        Integer it = Integer.valueOf(num); // 此处出现了数字转换异常。代码在此处直接执行死亡！
        System.out.println(it+1);

        System.out.println("程序结束。。。。。。");
    }
}

常见的编译时异常认识

1
2
3
4
5
6
7
8
9
10
11
12
13
14

编译时异常：继承自Exception的异常或者其子类，没有继承RuntimeException
              "编译时异常是编译阶段就会报错"，
              必须程序员编译阶段就处理的。否则代码编译就报错！！

   编译时异常的作用是什么：
           是担心程序员的技术不行，在编译阶段就爆出一个错误, 目的在于提醒!
           提醒程序员这里很可能出错，请检查并注意不要出bug。

           编译时异常是可遇不可求。遇到了就遇到了呗。
   小结：
       编译时异常是编译阶段就会报错的，继承了Exception,编译时
       异常是可遇不可求。遇到了就遇到了呗。

       编译时异常编译阶段必须处理，否则代码编译不通过!!

异常处理过程解析

异常的产生默认

1
2
3
4
5
6
7
8
9
10
11
12

(自动处理的过程！)
    （1）默认会在出现异常的代码那里自动的创建一个异常对象：ArithmeticException。
    （2）异常会从方法中出现的点这里抛出给调用者，调用者最终抛出给JVM虚拟机。
    （3）虚拟机接收到异常对象后，先在控制台直接输出异常栈信息数据。
    （4）直接从当前执行的异常点干掉当前程序。
    （5）后续代码没有机会执行了，因为程序已经死亡。

 小结：
     异常一旦出现，会自动创建异常对象，最终抛出给虚拟机，虚拟机
     只要收到异常，就直接输出异常信息，干掉程序！！

     默认的异常处理机制并不好，一旦真的出现异常，程序立即死亡！

编译时异常的处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

方式一：
 编译时异常：编译阶段就会报错，一定需要程序员处理的，否则代码无法通过！！

    抛出异常格式：
        方法 throws 异常1 ,  异常2 , ..{

        }
        建议抛出异常的方式：代表可以抛出一切异常，
        方法 throws Exception{

        }
    方式一：
        在出现编译时异常的地方层层把异常抛出去给调用者，调用者最终抛出给JVM虚拟机。
        JVM虚拟机输出异常信息，直接干掉程序，这种方式与默认方式是一样的。
        虽然可以解决代码编译时的错误，但是一旦运行时真的出现异常，程序还是会立即死亡！
        这种方式并不好!

    小结：
        编译时异常编译阶段就报错，必须程序员处理。
        方式一：出现异常的地方层层抛出，谁都不处理，最终抛出给虚拟机。
        这种方式虽然可以解决编译时异常，但是如果异常真的出现了，程序会直接死亡，所以这种方式并不好!
        
        
方式二：在出现异常的地方自己处理，谁出现谁处理。
    自己捕获异常和处理异常的格式：捕获处理
         try{
            // 监视可能出现异常的代码！
         }catch(异常类型1 变量){
            // 处理异常
         }catch(异常类型2 变量){
            // 处理异常
         }...
    监视捕获处理异常企业级写法：
         try{
             // 可能出现异常的代码！
         }catch (Exception e){
            e.printStackTrace(); // 直接打印异常栈信息
         }
         Exception可以捕获处理一切异常类型！
    小结：
        第二种方式，可以处理异常，并且出现异常后代码也不会死亡。
        这种方案还是可以的。
        但是从理论上来说，这种方式不是最好的，上层调用者不能直接知道底层的执行情况！
        
        
方式三： 在出现异常的地方把异常一层一层的抛出给最外层调用者，
            最外层调用者集中捕获处理！！（规范做法）
    小结：
        编译时异常的处理方式三：底层出现的异常抛出给最外层调用者集中捕获处理。
        这种方案最外层调用者可以知道底层执行的情况，同时程序在出现异常后也不会立即死亡，这是
        理论上最好的方案。
        虽然异常有三种处理方式，但是开发中只要能解决你的问题，每种方式都又可能用到!!

运行时异常的处理机制

1
2
3
4
5
6
7
8
9
10
11
12

运行时异常在编译阶段是不会报错，在运行阶段才会出错。
   运行时异常在编译阶段不处理也不会报错，但是运行时如果出错了程序还是会死亡
   所以运行时异常也建议要处理。

   运行时异常是自动往外抛出的，不需要我们手工抛出。

   运行时异常的处理规范：直接在最外层捕获处理即可，底层会自动抛出！！

   小结：
        运行时异常编译阶段不报错，可以处理也可以不处理，建议处理！！
        运行时异常可以自动抛出，不需要我们手工抛出。
        运行时异常的处理规范：直接在最外层捕获处理即可，底层会自动抛出！！

finally关键字

1
2
3
4
5
6
7
8
9
10
11
12
13
14

用在捕获处理的异常格式中的，放在最后面。
        try{
            // 可能出现异常的代码！
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            // 无论代码是出现异常还是正常执行，最终一定要执行这里的代码！！
        }
        try: 1次。
        catch：0-N次  (如果有finally那么catch可以没有!!)
        finally: 0-1次

    finally的作用: 可以在代码执行完毕以后进行资源的释放操作。
    什么是资源？资源都是实现了Closeable接口的，都自带close()关闭方法！！

异常的语法注意

1
2
3
4
5

- 运行时异常被抛出可以不处理。可以自动抛出,编译时异常必须处理.按照规范都应该处理!
        - 重写方法申明抛出的异常，应该与父类被重写方法申明抛出的异常一样或者范围更小
        - 方法默认都可以自动抛出运行时异常！  throws RuntimeException可以省略不写!!
        - 当多异常处理时，捕获处理，前边的异常类不能是后边异常类的父类。
        - 在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收操作。

自定义异常(了解)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

引入:Java已经为开发中可能出现的异常都设计了一个类来代表.
        但是实际开发中,异常可能有无数种情况,Java无法为
        这个世界上所有的异常都定义一个代表类。
        假如一个企业如果想为自己认为的某种业务问题定义成一个异常
        就需要自己来自定义异常类.

    需求：认为年龄小于0岁，大于200岁就是一个异常。

    自定义异常:
        自定义编译时异常.
            a.定义一个异常类继承Exception.
            b.重写构造器。
            c.在出现异常的地方用throw new 自定义对象抛出!
            编译时异常是编译阶段就报错，提醒更加强烈，一定需要处理！！

        自定义运行时异常.
            a.定义一个异常类继承RuntimeException.
            b.重写构造器。
            c.在出现异常的地方用throw new 自定义对象抛出!
            提醒不强烈，编译阶段不报错！！运行时才可能出现！！
    小结：
        自定义异常是程序员自己定义的异常
        继承Exception/RuntimeException，重写构造器。
        在出现异常的地方用throw new 自定义异常对象抛出!

Git

基础操作指令

命令如下：

1. clone（克隆）: 从远程仓库中克隆代码到本地仓库

2. checkout （检出）:从本地仓库中检出一个仓库分支然后进行修订

3. add（添加）: 在提交前先将代码提交到暂存区

4. commit（提交）: 提交到本地仓库。本地仓库中保存修改的各个历史版本

5. fetch (抓取) ： 从远程库，抓取到本地仓库，不进行任何的合并动作，一般操作比较少。

6. pull (拉取) ： 从远程库拉到本地库，自动进行合并(merge)，然后放到到工作区，相当于
   fetch+merge

7. push（推送） : 修改完成后，需要和团队成员共享代码时，将代码推送到远程仓库

查看修改的状态（status）

作用：查看的修改的状态（暂存区、工作区）
命令形式：git status

添加工作区到暂存区(add)

作用：添加工作区一个或多个文件的修改到暂存区
命令形式：git add 单个文件名|通配符

​ · 将所有修改加入暂存区：git add .

提交暂存区到本地仓库(commit）

作用：提交暂存区内容到本地仓库的当前分支
命令形式：git commit -m ‘注释内容’

查看提交日志(log)

在3.1.3中配置的别名git-log 就包含了这些参数，所以后续可以直接使用指令git-log

作用:查看提交记录
命令形式：git log [option]

options
–all 显示所有分支
–pretty=oneline 将提交信息显示为一行
–abbrev-commit 使得输出的commitId更简短
–graph 以图的形式显示

版本回退

作用：版本切换
命令形式：git reset –hard commitID
commitID 可以使用git-log 或git log 指令查看
如何查看已经删除的记录？
git reflog
这个指令可以看到已经删除的提交记录

添加文件至忽略列表

一般我们总会有些文件无需纳入Git 的管理，也不希望它们总出现在未跟踪文件列表。 通常都是些自动
生成的文件，比如日志文件，或者编译过程中创建的临时文件等。 在这种情况下，我们可以在工作目录
中创建一个名为 .gitignore 的文件（文件名称固定），列出要忽略的文件模式。下面是一个示例：

1
2
3
4
5
6
7
8
9
10
11
12

# no .a files
*.a
# but do track lib.a, even though you're ignoring .a files above
!lib.a
# only ignore the TODO file in the current directory, not subdir/TODO
/TODO
# ignore all files in the build/ directory
build/
# ignore doc/notes.txt, but not doc/server/arch.txt
doc/*.txt
# ignore all .pdf files in the doc/ directory
doc/**/*.pdf

分支

查看本地分支

git branch

创建本地分支

git branch 分支名

切换分支(checkout)

git checkout 分支名

我们还可以直接切换到一个不存在的分支（创建并切换）

git checkout -b 分支名

合并分支(merge)

一个分支上的提交可以合并到另一个分支

git merge 分支名称

删除分支

不能删除当前分支，只能删除其他分支

删除分支时，需要做各种检查

git branch -d b1

不做任何检查，强制删除

git branch -D b1

开发中分支使用原则与流程

在开发中，一般有如下分支使用原则与流程：

master （生产） 分支
线上分支，主分支，中小规模项目作为线上运行的应用对应的分支；

develop（开发）分支
是从master创建的分支，一般作为开发部门的主要开发分支，如果没有其他并行开发不同期上线
要求，都可以在此版本进行开发，阶段开发完成后，需要是合并到master分支,准备上线。

feature/xxxx分支
从develop创建的分支，一般是同期并行开发，但不同期上线时创建的分支，分支上的研发任务完
成后合并到develop分支。

hotfix/xxxx分支，
从master派生的分支，一般作为线上bug修复使用，修复完成后需要合并到master、test、

develop分支。
还有一些其他分支，在此不再详述，例如test分支（用于代码测试）、pre分支（预上线分支）等

解决冲突

当两个分支上对文件的修改可能会存在冲突，例如同时修改了同一个文件的同一行，这时就需要手动解
决冲突，解决冲突步骤如下

1. 处理文件中冲突的地方

2. 将解决完冲突的文件加入暂存区(add)

3. 提交到仓库(commit)

   冲突部分的内容处理如下所示

   

解决GitBash乱码问题

1. 打开GitBash执行下面命令

   1	git config --global core.quotepath false

2. ${git_home}/etc/bash.bashrc 文件最后加入下面两行

   1 2	export LANG="zh_CN.UTF-8" export LC_ALL="zh_CN.UTF-8"

Collection集合概述

什么是集合

集合是一个大小可变的容器。
容器中的每个数据称为一个元素。数据==元素。
集合的特点是：类型可以不确定，大小不固定。集合有很多种，不同的集合特点和使用场景不同。

​ 数组：类型和长度一旦定义出来就都固定了。

集合有啥用

在开发中，很多时候元素的个数是不确定的。
而且经常要进行元素的增删该查操作，集合都是非常合适的。
开发中集合用的更多!!

Java中集合的代表是：Collection.
Collection集合是Java中集合的祖宗类。
学习Collection集合的功能，那么一切集合都可以用这些功能！！

Collection集合的体系:
                        Collection<E>(接口)
                  /                                \
             Set<E>(接口)                            List<E>(接口)
            /               \                       /                \
         HashSet<E>(实现类)  TreeSet<>(实现类)     ArrayList<E>(实现类)  LinekdList<>(实现类)
         /
     LinkedHashSet<>(实现类)

集合的特点

Set系列集合：添加的元素是无序，不重复，无索引的。
– HashSet:添加的元素是无序，不重复，无索引的。
– LinkedHashSet:添加的元素是有序，不重复，无索引的。
– TreeSet:不重复，无索引，按照大小默认升序排序!!
List系列集合：添加的元素是有序，可重复，有索引。
– ArrayList：添加的元素是有序，可重复，有索引。底层基于数组存储数据的，查询快，增删慢
– LinekdList：添加的元素是有序，可重复，有索引。底层是基于链表存储数据的，查询慢，增删快

小结：
Collection是集合的祖宗类，Collection集合的功能是一切集合都可以直接使用的。

Collection集合的常用API

Collection是集合的祖宗类，它的功能是全部集合都可以继承使用的，所以要学习它。
Collection API如下：
public boolean add(E e)： 把给定的对象添加到当前集合中 。
public void clear() :清空集合中所有的元素。
public boolean remove(E e): 把给定的对象在当前集合中删除。
public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
public boolean isEmpty(): 判断当前集合是否为空。
public int size(): 返回集合中元素的个数。
public Object[] toArray(): 把集合中的元素，存储到数组中

Collection集合的遍历方式

什么是遍历? 为什么开发中要遍历？
遍历就是一个一个的把容器中的元素访问一遍。
开发中经常要统计元素的总和，找最值，找出某个数据然后干掉等等业务都需要遍历。

Collection集合的遍历方式是全部集合都可以直接使用的，所以我们学习它。
Collection集合的遍历方式有三种:
    （1）迭代器。
    （2）foreach(增强for循环)。
    （3）JDK 1.8开始之后的新技术Lambda表达式(了解)

a.迭代器遍历集合。
    -- 方法：
        public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的
        E next():获取下一个元素值！
        boolean hasNext():判断是否有下一个元素，有返回true ,反之。
    --流程：
        1.先获取当前集合的迭代器
            Iterator<String> it = lists.iterator();
        2.定义一个while循环，问一次取一次。
          通过it.hasNext()询问是否有下一个元素，有就通过
          it.next()取出下一个元素。

1
2
3
4
5
6
7
8
9
10

b.foreach(增强for循环)遍历集合。
        foreach是一种遍历形式，可以遍历集合或者数组。
        foreach遍历集合实际上是迭代器遍历的简化写法。
        foreach遍历的关键是记住格式：
           for(被遍历集合或者数组中元素的类型 变量名称 : 被遍历集合或者数组){

           }
       小结：
           foreach遍历集合或者数组很方便。
           缺点：foreach遍历无法知道遍历到了哪个元素了，因为没有索引。

1

c.JDK 1.8开始之后的新技术Lambda表达式。

常见的数据结构种类

1
2
3
4
5
6
7
8

集合是基于数据结构做出来的，不同的集合底层会采用不同的数据结构。
    不同的数据结构，功能和作用是不一样的。

    什么是数据结构？
        数据结构指的是数据以什么方式组织在一起。
        不同的数据结构，增删查的性能是不一样的。
        不同的集合底层会采用不同的数据结构，我们要知道集合的底层是基于哪种数据结构存储和操作数据的。
            这样才能知道具体场景用哪种集合。

Java常见的数据结构有哪些

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

数据存储的常用结构有：栈、队列、数组、链表和红黑树
       a.队列（queue）
          -- 先进先出，后进后出。
          -- 场景：各种排队。叫号系统。
          -- 有很多集合可以实现队列。

       b.栈（stack）
          -- 后进先出，先进后出
          -- 压栈 == 入栈
          -- 弹栈 == 出栈
          -- 场景：手枪的弹夹。


       c.数组
          -- 数组是内存中的连续存储区域。
          -- 分成若干等分的小区域（每个区域大小是一样的）
          -- 元素存在索引
          -- 特点：查询元素快（根据索引快速计算出元素的地址，然后立即去定位）
                  增删元素慢（创建新数组，迁移元素）

       d.链表
          -- 元素不是内存中的连续区域存储。
          -- 元素是游离存储的。每个元素会记录下个元素的地址。
          -- 特点：查询元素慢
                  增删元素快（针对于首尾元素，速度极快，一般是双链表）

       e.红黑树
            二叉树：binary tree 永远只有一个根节点,是每个结点不超过2个节点的树（tree） 。
            查找二叉树,排序二叉树：小的左边，大的右边，但是可能树很高，性能变差。
            为了做排序和搜索会进行左旋和右旋实现平衡查找二叉树，让树的高度差不大于1
            红黑树（就是基于红黑规则实现了自平衡的排序二叉树）：
               树尽量的保证到了很矮小，但是又排好序了，性能最高的树。

            红黑树的增删查改性能都好！！！

List集合

ArrayList集合

1
2
3
4
5
6
7
8
9
10
11

List集合继承了Collection集合的全部功能，同时因为List系列集合有索引，
        因为List集合多了索引，所以多了很多按照索引操作元素的功能:
        ArrayList实现类集合底层基于数组存储数据的，查询快，增删慢！
            - public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
            - public E get(int index):返回集合中指定位置的元素。
            - public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
            - public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回更新前的元素值。
       小结：
           List系列集合有序，可重复，有索引的。
           ArrayList实现类集合底层基于数组存储数据的，查询快，增删慢！！
           开发中ArrayList集合用的最多！！

List系列集合的遍历方式有：4种

1
2
3
4
5
6
7

List系列集合多了索引，所以多了一种按照索引遍历集合的for循环。

    List遍历方式：
        （1）for循环。
        （2）迭代器。
        （3）foreach。
        （4）JDK 1.8新技术。

LinkedList集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

LinkedList也是List的实现类：底层是基于链表的，增删比较快，查询慢！！
    LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的
    所以LinkedList除了拥有List集合的全部功能还多了很多操作首尾元素的特殊功能：
        - public void addFirst(E e):将指定元素插入此列表的开头。
        - public void addLast(E e):将指定元素添加到此列表的结尾。
        - public E getFirst():返回此列表的第一个元素。
        - public E getLast():返回此列表的最后一个元素。
        - public E removeFirst():移除并返回此列表的第一个元素。
        - public E removeLast():移除并返回此列表的最后一个元素。
        - public E pop():从此列表所表示的堆栈处弹出一个元素。
        - public void push(E e):将元素推入此列表所表示的堆栈。

   小结：
        LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的。
        所以提供了很多操作首尾元素的特殊API可以做栈和队列的实现。

        如果查询多而增删少用ArrayList集合。(用的最多的)
        如果查询少而增删首尾较多用LinkedList集合。

Set集合

HashSet集合

1
2
3

研究两个问题(面试热点)：
        1）Set集合添加的元素是不重复的，是如何去重复的？
        2）Set集合元素无序的原因是什么？

Set系列集合元素去重复的流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

集合和泛型都只能支持引用数据类型。

    1.对于有值特性的，Set集合可以直接判断进行去重复。
    2.对于引用数据类型的类对象，Set集合是按照如下流程进行是否重复的判断。
        Set集合会让两两对象，先调用自己的hashCode()方法得到彼此的哈希值（所谓的内存地址）
        然后比较两个对象的哈希值是否相同，如果不相同则直接认为两个对象不重复。
        如果哈希值相同，会继续让两个对象进行equals比较内容是否相同，如果相同认为真的重复了
        如果不相同认为不重复。

                Set集合会先让对象调用hashCode()方法获取两个对象的哈希值比较
                   /                     \
                false                    true
                /                          \
            不重复                        继续让两个对象进行equals比较
                                           /          \
                                         false        true
                                          /             \
                                        不重复          重复了

        需求：只要对象内容一样，就希望集合认为它们重复了。重写hashCode和equals方法。

    小结：
        如果希望Set集合认为两个对象只要内容一样就重复了，必须重写对象的hashCode和equals方法。

Set系列集合元素无序的根本原因。(面试必考)

1
2
3
4
5
6
7
8
9

Set系列集合添加元素无序的根本原因是因为底层采用了哈希表存储元素。

    JDK 1.8之前：哈希表 = 数组 + 链表  + （哈希算法）
    JDK 1.8之后：哈希表 = 数组 + 链表 + 红黑树  + （哈希算法）
        当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

    小结：
        Set系列集合是基于哈希表存储数据的
        它的增删改查的性能都很好！！但是它是无序不重复的！如果不在意当然可以使用！

LinkedHashSet集合

1
2
3
4
5
6
7
8
9
10
11

是HashSet的子类，元素是“有序” 不重复，无索引.

   LinkedHashSet底层依然是使用哈希表存储元素的，
   但是每个元素都额外带一个链来维护添加顺序！！
   不光增删查快，还有序。缺点是多了一个存储顺序的链会占内存空间!!而且不允许重复，无索引。

   总结：
        如果希望元素可以重复，又有索引，查询要快用ArrayList集合。（用的最多）
        如果希望元素可以重复，又有索引，增删要快要用LinkedList集合。（适合查询元素比较少的情况，经常要首尾操作元素的情况）
        如果希望增删改查都很快，但是元素不重复以及无序无索引，那么用HashSet集合。
        如果希望增删改查都很快且有序，但是元素不重复以及无索引，那么用LinkedHashSet集合。

TreeSet集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

TreeSet: 不重复，无索引，按照大小默认升序排序!!
    TreeSet集合称为排序不重复集合，可以对元素进行默认的升序排序。

    TreeSet集合自自排序的方式：
        1.有值特性的元素直接可以升序排序。（浮点型，整型）
        2.字符串类型的元素会按照首字符的编号排序。
        3.对于自定义的引用数据类型，TreeSet默认无法排序，执行的时候直接报错，因为人家不知道排序规则。

    自定义的引用数据类型的排序实现：
        对于自定义的引用数据类型，TreeSet默认无法排序
        所以我们需要定制排序的大小规则，程序员定义大小规则的方案有2种：
        a.直接为对象的类实现比较器规则接口Comparable，重写比较方法（拓展方式）
             // 如果程序员认为比较者大于被比较者 返回正数！
             // 如果程序员认为比较者小于被比较者 返回负数！
             // 如果程序员认为比较者等于被比较者 返回0！

        b.直接为集合设置比较器Comparator对象,重写比较方法
             // 如果程序员认为比较者大于被比较者 返回正数！
             // 如果程序员认为比较者小于被比较者 返回负数！
             // 如果程序员认为比较者等于被比较者 返回0！
        注意：如果类和集合都带有比较规则，优先使用集合自带的比较规则。

    小结：
        TreeSet集合对自定义引用数据类型排序，默认无法进行。
        但是有两种方式可以让程序员定义大小规则：
             a.直接为对象的类实现比较器规则接口Comparable，重写比较方法（拓展方式）
             b.直接为集合设置比较器Comparator对象,重写比较方法
        注意：如果类和集合都带有比较规则，优先使用集合自带的比较规则。

Collections工具类的使用

1
2
3
4
5
6
7
8

java.utils.Collections:是集合工具类
   Collections并不属于集合，是用来操作集合的工具类。
   Collections有几个常用的API:
        - public static <T> boolean addAll(Collection<? super T> c, T... elements)
            给集合对象批量添加元素！
        - public static void shuffle(List<?> list) :打乱集合顺序。
        - public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
        - public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

引用数据类型的排序

1
2
3
4
5
6
7
8
9
10
11

字符串按照首字符的编号升序排序！

    自定义类型的比较方法API:
         - public static <T> void sort(List<T> list):
               将集合中元素按照默认规则排序。
               对于自定义的引用类型的排序人家根本不知道怎么排，直接报错！
               如果希望自定义的引用类型排序不报错，可以给类提供比较规则:Comparable。

         - public static <T> void sort(List<T> list，Comparator<? super T> c):
                将集合中元素按照指定规则排序,自带比较器
                注意：如果类有比较规则，而这里有比较器，优先使用比较器。

可变参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14

可变参数用在形参中可以接收多个数据。
    可变参数的格式：数据类型... 参数名称

    可变参数的作用：
         传输参数非常灵活，方便。
         可以不传输参数。
         可以传输一个参数。
         可以传输多个参数。
         可以传输一个数组。

    可变参数在方法内部本质上就是一个数组。
    可变参数的注意事项：
            1.一个形参列表中可变参数只能有一个！！
            2.可变参数必须放在形参列表的最后面！！

Map集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

Map集合是另一个集合体系。
    Collection是单值集合体系。

    Map集合是一种双列集合，每个元素包含两个值。
    Map集合的每个元素的格式：key=value(键值对元素)。
    Map集合也被称为“键值对集合”。

    Map集合的完整格式：{key1=value1 , key2=value2 , key3=value3 , ...}

    Map集合有啥用？
       1.Map集合存储的信息更加的具体丰富。
            Collection: ["苍老师","日本","女","动作演员",23,"广州"]
            Map : {name="苍老师" , jiaxiang=小日本 , sex="女" , age = 23 , addr=广州}

       2.Map集合很适合做购物车这样的系统。
            Map:  {娃娃=30 , huawei=1 , iphonex=1}

    注意：集合和泛型都只能支持引用数据类型，集合完全可以称为是对象容器，存储都是对象。

    Map集合的体系：
            Map<K , V>(接口,Map集合的祖宗类)
           /                      \
          TreeMap<K , V>           HashMap<K , V>(实现类,经典的，用的最多)
                                     \
                                      LinkedHashMap<K, V>(实现类)

    Map集合的特点：
        1.Map集合的特点都是由键决定的。
        2.Map集合的键是无序,不重复的，无索引的。
            Map集合后面重复的键对应的元素会覆盖前面的整个元素！
        3.Map集合的值无要求。
        4.Map集合的键值对都可以为null。

       HashMap:元素按照键是无序，不重复，无索引，值不做要求。
       LinkedHashMap:元素按照键是有序，不重复，无索引，值不做要求。

Map集合的常用API(重点中的重点)

1
2
3
4
5
6

- public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。
   - public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
   - public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
   - public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
   - public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
   - public boolean containKey(Object key):判断该集合中是否有此键。

Map集合的遍历方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Map集合的遍历方式有：3种。
       （1）“键找值”的方式遍历：先获取Map集合全部的键，再根据遍历键找值。
       （2）“键值对”的方式遍历：难度较大。
       （3）JDK 1.8开始之后的新技术：Lambda表达式。
       
   a.“键找值”的方式遍历Map集合。
       1.先获取Map集合的全部键的Set集合。
       2.遍历键的Set集合，然后通过键找值。
       
   b.“键值对”的方式遍历：
       1.把Map集合转换成一个Set集合:Set<Map.Entry<K, V>> entrySet();
       2.此时键值对元素的类型就确定了，类型是键值对实体类型：Map.Entry<K, V>
       3.接下来就可以用foreach遍历这个Set集合，类型用Map.Entry<K, V>
       
c.JDK 1.8开始之后的新技术：Lambda表达式。

Map集合存储自定义类型

1
2
3
4
5

Map集合的键和值都可以存储自定义类型。

    小结：
        Map集合的键和值都可以存储自定义类型。
        如果希望Map集合认为自定义类型的键对象重复了，必须重写对象的hashCode()和equals()方法

LinkedHashMap集合

1
2
3
4
5
6
7
8
9
10
11
12
13

LinkedHashMap是HashMap的子类。
        -- 添加的元素按照键有序，不重复的。
    HashSet集合相当于是HashMap集合的键都不带值。
    LinkedHashSet集合相当于是LinkedHashMap集合的键都不带值。

    底层原理完全一样，都是基于哈希表按照键存储数据的，
    只是HashMap或者LinkedHashMap的键都多一个附属值。


    小结：
        HashMap集合是无序不重复的键值对集合。
        LinkedHashMap集合是有序不重复的键值对集合。
        他们都是基于哈希表存储数据,增删改查都很好。

TreeMap集合

1
2
3
4
5
6
7
8

TreeMap集合按照键是可排序不重复的键值对集合。(默认升序)
   TreeMap集合按照键排序的特点与TreeSet是完全一样的。
   小结：
       TreeMap集合和TreeSet集合都是排序不重复集合
       TreeSet集合的底层是基于TreeMap，只是键没有附属值而已。
       所以TreeMap集合指定大小规则有2种方式：
            a.直接为对象的类实现比较器规则接口Comparable，重写比较方法（拓展方式）
            b.直接为集合设置比较器Comparator对象,重写比较方法

输出一个字符串中每个字符出现的次数。（经典面试题）

1
2
3
4
5

（1）键盘录入一个字符串。aabbccddaa123。
        （2）定义一个Map集合，键是每个字符，值是其出现的次数。 {a=4 , b=2 ,...}
        （3）遍历字符串中的每一个字符。
        （4）拿着这个字符去Map集合中看是否有这个字符键，有说明之前统计过，其值+1
            没有这个字符键，说明该字符是第一次统计，直接存入“该字符=1”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class MapDemo01 {
    public static void main(String[] args) {
        // （1）键盘录入一个字符串。aabbccddaa123。
        Scanner scanner = new Scanner(System.in);
        System.out.print("请您输入一个字符串：");
        String datas = scanner.nextLine();

        // （2）定义一个Map集合，键是每个字符，值是其出现的次数。
        Map<Character , Integer> infos = new HashMap<>(); // {a=2,b=2}

        // （3）遍历字符串中的每一个字符。
        // datas = aabbccddaa123
        for(int i = 0 ; i < datas.length() ; i++ ){
            // 取出当前索引的字符
            char ch = datas.charAt(i);
            // （4）拿着这个字符去Map集合中看是否有这个字符键，有说明之前统计过，其值+1
            //   没有这个字符键，说明该字符是第一次统计，直接存入“该字符=1”
            if(infos.containsKey(ch)){
                // 说明这个字符之前已经出现过，其值+1
                infos.put(ch , infos.get(ch) + 1);
            }else{
                // 说明这个字符第一次出现，直接存入 a=1
                infos.put(ch , 1);
            }
        }
        // （5）输出结果
        System.out.println("结果："+infos);

    }
}

知识回顾

面向对象

用代码去高度模拟现实世界，以便为人类的业务服务。
Java是一种面向对象的高级编程语言。
高级编程语言：代码风格很像人类的自然语言。
zhubajie.eat(“西瓜”);

面向对象最重要的两个概念：类和对象。

类

是描述相同事物的共同特征的抽象。 人类。

对象

是具体存在的实例，是真实的。 实例==对象

在代码层面：必须先有类，才能创建出对象。

定义类的格式

修饰符 class 类名{
// 1.成员变量（Field：描述类和对象的属性信息的）.
// 2.成员方法（Method:描述类或者对象的行为信息的）
// 3.构造器（Constructor:初始化一个类的对象并返回引用）
// 4.代码块
// 5.内部类
}

注意

​ – 类名的首字母应该大写，满足“驼峰写法”。
​ – 一个Java代码文件中可以定义多个类。但是只能有一个类
​ 是用public修饰的，而且public修饰的类名必须成为代码的文件名称。

类中的成分研究

类中有且仅有五大成分

1.成员变量（Field：描述类和对象的属性信息的）.
2.成员方法（Method:描述类或者对象的行为信息的）
3.构造器（Constructor:初始化一个类的对象并返回引用）
4.代码块
5.内部类

注意：只要不是这5大成分放在类下就会报错

构造器的复习

作用

初始化一个类的对象并返回引用。

格式

修饰符 类名(形参){

}

构造器初始化对象的格式

类名 对象名称 = new 构造器;

注意：一个类默认会自带一个无参数构造器，即使不写它也存在，但是如果一个类它写了一个构造器，那么默认的无参数构造器就被覆盖了!!

this关键字的作用

1. this代表了当前对象的引用
2. this关键字可以用在实例方法和构造器中
3. this用在方法中，谁调用这个方法，this就代表谁
4. this用在构造器，代表了构造器正在初始化的那个对象的引用

static关键字

引入

我们之前定义了很多成员变量（name , age , sex）
其实我们只写了一份，但是发现每个对象都可以用，就说明
Java中这些成员变量或者方法是存在所属性的。
有些是属于对象的，有些是属于类本身的。

Java是通过成员变量是否有static修饰来区分是类的还是属于对象的。

static == 静态 == 修饰的成员（方法和成员变量）属于类本身的。

分类

按照有无static修饰，成员变量和方法可以分为：

成员变量：
（1）静态成员变量（类变量）：
有static修饰的成员变量称为静态成员变量也叫类变量，属于类本身的，

直接用类名访问即可。

2）实例成员变量
无static修饰的成员变量称为实例成员变量，属于类的每个对象的

必须用类的对象来访问。

成员方法：
（1）静态方法
有static修饰的成员方法称为静态方法也叫类方法，属于类本身的

直接用类名访问即可

2）实例方法
无static修饰的成员方法称为实例方法，
属于类的每个对象的，必须用类的对象来访问

小结

成员变量有2种
– 有static修饰的属于类叫静态成员变量，与类一起加载一次，直接用类名调用即可。
– 无static修饰的属于类的每个对象的叫实例成员变量，
与类的对象一起加载，对象有多少个，实例成员变量就加载多少份。必须用类的对象调用。

成员方法有2种：

– 有static修饰的属于类叫静态方法，直接用类名调用即可。
– 无static修饰的属于类的每个对象的叫实例方法，必须用类的对象调用

this和super关键字使用总结

this代表了当前对象的引用（继承中指代子类对象）：
this.子类成员变量。
this.子类成员方法。
this(…):可以根据参数匹配访问本类其他构造器。（还没有学习）
super代表了父类对象的引用（继承中指代了父类对象空间）
super.父类成员变量。
super.父类的成员方法。
super(…):可以根据参数匹配访问父类的构造器。
拓展：this(…)根据参数匹配访问本类其他构造器。
注意：
this(…)借用本类其他构造器。
super(…)调用父类的构造器。
this(…)和super(…)必须放在构造器的第一行，否则报错!
所以this(…)和super(…)不能同时出现在构造器中!!!

final关键字

final是最终的含义。
final用于修饰：类，方法，变量
1.final修饰类，类不能被继承了。
2.final可以修饰方法，方法就不能被重写了。
3.final修饰变量总规则：变量有且仅能被赋值一次。

拓展：final和abstract的关系?

互斥关系,不能同时修饰类或者同时修饰方法！！

修饰变量

final修饰变量的总规则：有且仅能被赋值一次。

变量有几种？
成员变量
– 静态成员变量：有static修饰，属于类，只加载一份。
– 实例成员变量：无static修饰，属于每个对象,与对象一起加载。
局部变量
– 只能方法中，构造器中，代码块中，for循环中，用完作用范围就消失了。
### 修饰局部变量：
​ – 让值被固定或者说保护起来，执行的过程中防止被修改。

修饰静态成员变量

​ final修饰变量的总规则：有且仅能被赋值一次。
​ final修饰静态成员变量，变量变成了常量。
​ 常量：有public static final修饰，名称字母全部大写，多个单词用下划线连接。

修饰实例成员变量

inal修饰变量的总规则：有且仅能被赋值一次。
拓展：
final修饰实例成员变量可以在哪些地方赋值1次：
1.定义的时候赋值一次。
2.可以在实例代码块中赋值一次。
3.可以在每个构造器中赋值一次。

成员变量的分类和访问

按照有无static修饰成员变量分为：

（1）静态成员变量：

​ 有static修饰，属于类本身与类一起加载一次，直接用类名访问即可。

（2）实例成员变量：无static修饰，属于类的每个对象的，必须先创建对象，再用对象来访问。

​ 成员变量的访问语法：
​ 静态成员变量访问：
​ 类名.静态成员变量。
​ 对象.静态成员变量。（不推荐）
​ 实例成员变量的访问：
​ 对象.实例成员变量。

成员方法的分类和访问

成员方法按照有无static修饰可以分为：

​ （1）静态方法：

有static修饰，属于类，直接用类名访问即可

（2）实例方法：

无static修饰，属于对象的，必须用对象来访问。

成员方法的访问语法：
静态方法的访问格式：
类名.静态方法
对象.静态方法（不推荐）
实例方法的访问格式：
对象.实例方法

小结：

静态方法属于类，有static修饰，直接用类名访问即可。

实例方法属于对象，无static修饰，必须先创建对象，然后用对象来访问。

静态方法也可以被对象共享访问，但是不推荐，因为静态方法直接用类名访问即可。

成员变量和成员方法访问的拓展

面试常考

方法：实例方法，静态方法。
成员变量：实例成员变量，静态成员变量。
8种访问形式的问答：
a.实例方法是否可以直接访问实例成员变量？可以的，因为它们都属于对象。
b.实例方法是否可以直接访问静态成员变量？可以的，静态成员变量可以被共享访问。
c.实例方法是否可以直接访问实例方法? 可以的，实例方法和实例方法都属于对象。 d.实例方法是否可以直接访问静态方法？可以的，静态方法可以被共享访问！

​ a.静态方法是否可以直接访问实例变量？ 不可以的，实例变量必须用对象访问！！
​ b.静态方法是否可以直接访问静态变量？ 可以的，静态成员变量可以被共享访问。
​ c.静态方法是否可以直接访问实例方法? 不可以的，实例方法必须用对象访问！！
​ d.静态方法是否可以直接访问静态方法？可以的，静态方法可以被共享访问！！

抽象类

抽象类的概述

什么是抽象类

父类知道子类一定要完成某个功能，但是每个子类实现的情况都不一样.
子类都会用自己重写的功能了，父类的该功能就可以定义成抽象的方法。

什么是抽象方法

没有方法体，只有方法签名，必须用abstract修饰的方法就是抽象方法。
拥有抽象方法的类必须定义成抽象类

抽象类：必须用abstract关键字修饰

抽象类的使用

抽象类的作用：为了被子类继承。

抽象类是为了被子类继承,约束子类要重写抽象方法！

注意：一个类继承了抽象类，必须重写完抽象类的全部抽象方法，否则这个类必须定义成抽象类。

抽象类的特征研究和深入

抽象类的特征：有得有失。
有得：抽象类拥有了得到抽象方法的能力。
失去：抽象类失去了创建对象的能力

面试题：抽象类是否有构造器，是否可以创建对象，为什么?
答：抽象类作为类一定有构造器，而且必须有构造器。
提供给子类继承后调用父类构造器使用的。抽象类虽然有构造器，但是抽象类绝对不能创建对象。抽象类中可能存在抽象方法，抽象方法不能执行。抽象在学术上本身意味着不能实例化。

抽象类除了有得有失之外，类的其他成分人家都具备！！抽象类中也可以没有抽象方法！！

抽象类的意义

抽象类存在的意义有两点：
（1）被继承，抽象类就是为了被子类继承，(为了派生子类)否则抽象类将毫无意义。(核心意义)
（2）抽象类体现的是”模板思想”：部分实现，部分抽象。（拓展）
– 可以使用抽象类设计一个模板模式。

抽象类的注意事项和总结

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。 理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2. 抽象类一定有而且是必须有构造器，是供子类创建对象时，初始化父类成员使用的。
   理解：子类的构造器中，有默认的super()，需要访问父类构造器。

3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类。

5. 抽象类存在的意义是为了被子类继承，抽象类体现的是模板思想。
   理解：抽象类中已经实现的是模板中确定的成员，
   抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。

代码块

代码块是类的成分之一：
成员变量，成员方法，构造器，代码块，内部类。

​ 代码块按照有无static修饰分为：
​ 1.静态代码块。
​ 2.实例代码块

​ 静态代码块的格式：
​ static {

​ }

静态代码块

静态代码块特点：
– 必须有static修饰。
– 会与类一起优先加载，且自动触发执行一次。
静态代码块作用：
– 可以在执行类的方法等操作之前先在静态代码块中进行静态资源的初始化操作。(拓展)

实例代码块

实例代码块的格式：

{

}

实例代码块的特点：
– 无static修饰。
– 会与类的对象一起加载，每次创建类的对象的时候，
实例代码块都会被加载且自动触发执行一次。
– 实例代码块的代码在底层实际上是提取到每个构造器中去执行的！

实例代码块的作用：

– 实例代码块可以在创建对象之前进行实例资源的初始化操作。

枚举

枚举的概述和作用

枚举是Java中的一种特殊类型。
枚举的作用：是为了做信息的标志和信息的分类

定义枚举的格式：

​ 修饰符 enum 枚举名称{
​ 第一行都是罗列枚举实例的名称。
​ }

枚举类的编译以后源代码

1
2
3
4
5
6
7
8
9

public final class Season extends java.lang.Enum<Season> {
            public static final Season SPRING = new Season();
            public static final Season SUMMER = new Season();
            public static final Season AUTUMN = new Season();
            public static final Season WINTER = new Season();

            public static Season[] values();
            public static Season valueOf(java.lang.String);
        }

枚举的特点：
1.枚举类是用final修饰的，枚举类不能被继承！
2.枚举类默认继承了java.lang.Enum枚举类。
3.枚举类的第一行都是常量,存储都是枚举类的对象。
4.枚举类的第一行必须是罗列枚举类的实例名称。
所以：枚举类相当于是多例设计模式。

常量做信息分类和信息标志：
虽然可以实现可读性，但是入参不受限制！！！

Java建议做信息标志和信息分类应该使用枚举实现：最优雅的方式。
可以实现可读性，而且入参受限制，不能乱输入！！！

内部类

什么是内部类

定义在一个类里面的类就是内部类

内部类有什么用

​ 可以提供更好的封装性, 内部类有更多权限修饰符 , 封装性有更多的控制。
​ 可以体现出组件的思想

内部类的分类

1）静态内部类。
（2）实例内部类。（成员内部类）
（3）局部内部类。
（4）匿名内部类。（重点）

静态内部类

什么是静态内部类？
有static修饰，属于外部类本身，会加载一次。
静态内部类中的成分研究：
类有的成分它都有，静态内部类属于外部类本身，只会加载一次
所以它的特点与外部类是完全一样的，只是位置在别人里面而已。

静态内部类中的成分研究：
类有的成分它都有，静态内部类属于外部类本身，只会加载一次
所以它的特点与外部类是完全一样的，只是位置在别人里面而已。

​ 外部类=宿主
​ 内部类=寄生

静态内部类的访问格式：
外部类名称.内部类名称

静态内部类创建对象的格式：
外部类名称.内部类名称 对象名称 = new 外部类名称.内部类构造器;

静态内部类的访问拓展：
静态内部类中是否可以直接访问外部类的静态成员?可以的，外部类的静态成员只有一份，可以被共享！
静态内部类中是否可以直接访问外部类的实例成员?不可以的,外部类的是成员必须用外部类对象访问！！

小结：
静态内部类属于外部类本身，只会加载一次
所以它的特点与外部类是完全一样的，只是位置在别人里面而已。

实例内部类

​ 什么是实例内部类：
​ 无static修饰的内部类，属于外部类的每个对象的，跟着对象一起加载的。
​ 实例内部类的成分特点：
​ 实例内部类中不能定义静态成员，其他都可以定义。
​ 可以定义常量。
​ 实例内部类的访问格式：
​ 外部类名称.内部类名称。
​ 创建对象的格式：
​ 外部类名称.内部类名称 对象名称 = new 外部类构造器.new 内部构造器;
​ 拓展：

​ 实例内部类中是否可以直接访问外部类的静态成员？可以的，外部类的静态成员可以被共享访问！

实例内部类中是否可以访问外部类的实例成员？可以的，实例内部类属于外部类对象，可以直接访问当前外部类对象的实例成员！
小结：
实例内部类属于外部类对象，需要用外部类对象一起加载，
实例内部类可以访问外部类的全部成员！

局部内部类（几乎不用）

定义在方法中，在构造器中，代码块中，for循环中定义的内部类
就是局部内部类。
局部内部类中的成分特点： 只能定义实例成员，不能定义静态成员
可以定义常量的。
小结：
局部内部类没啥用。

匿名内部类(重点)

什么是匿名内部类？
就是一个没有名字的局部内部类。
匿名内部类目的是为了：简化代码，也是开发中常用的形式。
匿名内部类的格式：
new 类名|抽象类|接口(形参){
方法重写。
}
匿名内部类的特点：
1.匿名内部类是一个没有名字的内部类。
2.匿名内部类一旦写出来，就会立即创建一个匿名内部类的对象返回。
3.匿名内部类的对象的类型相当于是当前new的那个的类型的子类类型。

包和权限修饰符

包

分门别类的管理各种不同的技术。 企业的代码必须用包区分。便于管理技术，扩展技术，阅读技术。
定义包的格式：package 包名; 必须放在类名的最上面。
一般工具已经帮我们做好了。
包名的命名规范：
一般是公司域名的倒写+技术名称：
http://www.itheima.com => com.itheima.技术名称

​ 包名建议全部用英文，多个单词用”.“连接，必须是合法标识符，不能用关键字
​ ## 注意：
​ 相同包下的类可以直接访问。
​ 不同包下的类必须导包,才可以使用！
​ 导包格式：import 包名.类名;

权限修饰符

权限修饰符：有四种（private -> 缺省 -> protected - > public ） 可以修饰成员变量，修饰方法，修饰构造器，内部类，不同修饰符修饰的成员能够被访问的权限将受到限制!
四种修饰符的访问权限范围：

接口的概述

什么是接口

接口是更加彻底的抽象，接口中全部是抽象方法和常量，没有其他成分。（JDK 1.8之前）

接口有啥用

接口体现的是规范思想，实现接口的类必须重写完接口中全部的抽象方法。

规范 == 约束。
接口称为被实现，实现接口的类称为实现类。

定义接口的格式

修饰符 interface 接口名称{

​ }

interface: 定义接口的关键字

接口中的成分研究（JDK 1.8之前）

1. 抽象方法

   a.接口中的抽象方法默认会加上public abstract修饰,所以可以省略不写。

2. 常量

   常量：是指有public static final修饰的成员变量，有且仅能被赋值一次，值不能改变

   常量的名称规范上要求全部大写，多个单词下划线连接。

   常量修饰的public static final 可以省略不写，默认会加上。

小结

1. 定义接口使用的关键字：interface
2. 接口中的成分在JDK 1.8之前只能有：常量和抽象方法！！！！
3. 在接口中常量的修饰符：public static final 可以省略不写，默认会加上。
4. 在接口中抽象方法的修饰符：public abstract 可以省略不写，默认会加上。

接口的基本实现

接口是用来被类实现的

引入

1. 类与类是继承关系：一个类只能直接继承一个父类

2. 类与接口是实现关系：一个类可以实现多个接口

3. 实现接口的类称为“实现类”

   ​ 子类 继承 父类
   ​ 实现类 实现 接口

实现类实现接口的格式

修饰符 class 实现类名称 implements 接口1,接口2,接口3,….{

}

implements:实现的含义。

接口是可以被多实现的：一个类可以实现多个接口

注意：一个类实现接口必须重写完接口中全部抽象方法，否则这个类必须定义成抽象类！！

接口的多实现

引入

​ 类与类是单继承。
​ 类与接口是多实现

小结

1. 一个类可以实现多个接口
2. 一个类如果实现了多个接口，必须重写完全部接口中的全部抽象方法， 否则这个类必须定义抽象类

接口与接口的多继承

引入

1. 类与类是单继承关系：一个类只能继承一个直接父类
2. 类与接口是多实现关系：一个类可以实现多个接口
3. 接口与接口是多继承关系：一个接口可以继承多个接口

JDK 1.8开始(包括JDK1.8）之后接口新增

引入

​ JDK 1.8之前接口中只能是抽象方法，常量。
​ JDK 1.8开始之后接口不再纯洁了。
​ JDK 1.8开始之后接口新增了如下三种方法。

表现

• 默认方法（就是之前写的普通实例方法）

  – 必须用default修饰，默认会public修饰

  – 必须用接口的实现类的对象来调用。

• 静态方法

  –可以直接加static修饰

  – 默认会public修饰

  – 注意：接口的静态方法必须用接口的类名本身来调用。

• 私有方法（就是私有的实例方法）: JDK 1.9才开始有的

  – 必须加private修饰。

  – 只能在本类中被其他的默认方法或者私有方法访问。

实现多个接口的使用注意实现

1. 如果实现了多个接口，多个接口中存在同名的静态方法并不会冲突

   原因是只能通过各自接口名访问静态方法。

2. 当一个类，既继承一个父类，又实现若干个接口时，(重点)

   父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法

3. 当一个类实现多个接口时，多个接口中存在同名的默认方法

   实现类必须重写这个方法。

4. 接口中，没有构造器，不能创建对象。(重点)

   接口是更彻底的抽象，连构造器都没有，自然不能创建对象！！

封装

封装的哲学思维

合理隐藏，合理暴露

封装最初的目的

提高代码的安全性和复用性,组件化。

封装的步骤

1. 成员变量应该私有。用private修饰，只能在本类中直接访问。
2. 提供成套的getter和setter方法暴露成员变量的取值和赋值

继承

什么是继承

​ 继承是Java中一般到特殊的关系，是一种子类到父类的关系。

​ 例如：学生类继承了人类。 猫类继承了动物类。

​ 被继承的类称为：父类/超类。继承父类的类称为：子类。

继承的特点

1. 单继承：一个类只能继承一个直接父类

   为什么Java是单继承的？

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   答:反证法，假如Java可以多继承，请看如下代码： class A{ public void test(){ System.out.println("A"); } } class B{ public void test(){ System.out.println("B"); } } class C A , B { public static void main(String[] args){ C c = new C(); c.test(); // 出现了类的二义性！所以Java不能多继承！！ } }

2. 多层继承：一个类可以间接继承多个父类。（家谱）

3. 一个类可以有多个子类

4. 个类要么默认继承了Object类，要么间接继承了Object类，Object类是Java中的祖宗类！！

5. 子类继承了一个父类，子类就可以直接得到父类的属性（成员变量）和行为（方法）了

继承的作用

1. “可以提高代码的复用”，相同代码可以定义在父类中。然后子类直接继承父类，就可以直接使用父类的这些代码了。(相同代码重复利用）
2. 子类更强大：子类不仅得到了父类的功能，它还有自己的功能.

继承的格式

​ 子类 extends 父类{

​ }

小结

1. 继承是子类到到父类的一种关系
2. 子类继承了一个父类，子类就可以直接得到父类的属性和行为了。
3. 在Java中继承是 “is a” 的关系。Cat extends Animal：猫是一个动物。
4. 在Java中，子类是更强大的，子类不仅继承了父类的功能，自己还可以定义自己的功能。
5. 继承的优势可以把相同的代码定义在父类中，子类可以直接继承使用
6. 这样就可以提高代码的复用性：相同代码只需要在父类中写一次就可以了

子类不能继承父类的内容

引入

1. 子类继承父类，子类就得到了父类的属性和行为。
2. 但是并非所有父类的属性和行为等子类都可以继承。

子类不能继承父类的东西

1. 子类不能继承父类的构造器:子类有自己的构造器。（没有争议的）

2. 有争议的观点（拓展）

   1. 子类是否可以继承父类的私有成员（私有成员变量，私有成员方法）?

      – 我认为子类是可以继承父类的私有成员的，只是不能直接访问而已。

      – 以后可以暴力去访问继承自父类的私有成员~~~

   2. 子类是否可以继承父类的静态成员？

      – 我认为子类是不能继承父类的静态成员的

      – 子类只是可以访问父类的静态成员，父类的静态成员只有一份可以被子类共享访问。共享并非继承。

继承后-成员变量的访问特点

就近原则

子类有找子类，子类没有找父类，父类没有就报错。

小结

1. this代表了当前对象的引用，可以用于访问当前子类对象的成员变量。
2. super代表了父类对象的引用，可以用于访问父类中的成员变量。

继承后-成员方法的访问特点

就近原则

子类有找子类，子类没有找父类，父类没有就报错。

小结

子类对象优先使用子类已有的方法。

方法重写

方法重写的概念

1. 子类继承了父类，子类就得到了父类的某个方法,但是子类觉得父类的这个方法不好用或者无法满足自己的需求
2. 子类重写一个与父类申明一样的方法来覆盖父类的该方法，子类的这个方法就进行了方法重写。

方法重写的校验注解: @Override

Java建议在重写的方法上面加上一个@Override注解。
方法一旦加了这个注解，那就必须是成功重写父类的方法，否则报错！
@Override优势：可读性好，安全，优雅！！

方法重写的具体要求

1. 子类重写方法的名称和形参列表必须与父类被重写方法一样。
2. 子类重写方法的返回值类型申明要么与父类一样，要么比父类方法返回值类型范围更小。
3. 子类重写方法的修饰符权限应该与父类被重写方法的修饰符权限相同或者更大。
4. 子类重写方法申明抛出的异常应该与父类被重写方法申明抛出的异常一样或者范围更小！

方法重写的规范

1. 加上@Override注解
2. 建议“申明不变，重新实现”

小结

1. 方法重写是子类重写一个与父类申明一样的方法覆盖父类的方法
2. 方法重写建议加上@Override注解
3. 方法重写的核心要求：方法名称形参列表必须与被重写方法一致！！
4. 建议“申明不变，重新实现”

super调用父类被重写的方法

super:代表了父类引用。
super可以用在子类的实例方法中调用父类被重写的方法

静态方法和私有方法是否可以被重写（拓展语法）

可以吗? 都不可以.

继承后-构造器的特点

子类的全部构造器默认一定会先访问父类的无参数构造器，再执行子类自己的构造器。

为什么子类构造器会先调用父类构造器？

1. 子类的构造器的第一行默认有一个super()调用父类的无参数构造器，写不写都存在!
2. 子类继承父类，子类就得到了父类的属性和行为, 当我们调用子类构造器初始化子类对象数据的时候，必须先调用父类构造器初始化继承自父类的属性和行为

super调用父类构造器

子类的全部构造器默认一定会调用父类的无参数构造器。

super(…):可以根据参数选择调用父类的某个构造器。

小结

可以在子类构造器中通过super(…)根据参数选择调用父类的构造器，以便调用父类构造器初始化继承自父类的数据

多态

多态的形式

​ 父类类型 对象名称 = new 子类构造器;

​ 接口 对象名称 = new 实现类构造器;

​ 父类类型的范围 > 子类类型范围的。

多态的概念

同一个类型的对象，执行同一个行为，在不同的状态下会表现出不同的行为特征

多态的识别技巧

1. 对于方法的调用：编译看左边，运行看右边
2. 对于变量的调用：编译看左边，运行看左边

多态的使用前提

1. 必须存在继承或者实现关系
2. 必须存在父类类型的变量引用子类类型的对象
3. 需要存在方法重写

多态的优劣势

优势:

1. 在多态形式下，右边对象可以实现组件化切换，业务功能也随之改变，便于扩展和维护。可以实现类与类之间的解耦
2. 实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法.可以传入一切子类对象进行方法的调用，更能体现出多态的扩展性与便利

劣势:

1. 多态形式下，不能直接调用子类特有的功能。编译看左边!! 左边
2. 父类中没有子类独有的功能，所以代码在编译阶段就直接报错了！

引用数据类型的自动类型转换

基本数据类型的转换

1. 小范围类型的变量或者值可以直接赋值给大范围类型的变量。
2. 大范围类型的变量或者值必须强制类型转换给小范围类型的变量

引用数据类型转换的思想(一样)

父类类型的范围 > 子类类型的范围

​ Animal Cat

语法

1. 子类类型的对象或者变量可以自动类型转换赋值给父类类型的变量

引用类型的自动类型转换并不能解决多态的劣势

引用类型强制类型转换

语法

父类类型的变量或者对象必须强制类型转换成子类类型的变量，否则报错!

格式

类型 变量名称 = (类型)(对象或者变量)

注意：有继承/实现关系的两个类型就可以进行强制类型转换，编译阶段一定不报错！但是运行阶段可能出现：类型转换异常 ClassCastException

Java建议在进行强制类型转换之前先判断变量的真实类型，再强制类型转换!
变量 instanceof 类型： 判断前面的变量是否是后面的类型或者其子类类型才会返回true,

什么是泛型？

1 2	泛型就是一个标签：<数据类型> 泛型可以在编译阶段约束只能操作某种数据类型

注意：JDK 1.7开始之后，泛型后面的申明可以省略不写!!

​ 泛型和集合都只能支持引用数据类型，不支持基本数据类型!

泛型的好处

1 2	泛型在编译阶段约束了操作的数据类型，从而不会出现类型转换异常。 体现的是Java的严谨性和规范性，数据类型,经常需要进行统一！

自定义泛型类

泛型类的概念

1	使用了泛型定义的类就是泛型类

泛型类的格式

1 2 3 4

修饰符 class 类名<泛型变量>{ } 泛型变量建议使用 E , T , K , V

需求

1	模拟ArrayList集合自定义一个集合MyArrayList集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

public class GenericDemo {
    public static void main(String[] args) {
        MyArrayList<String> lists = new MyArrayList<String>();

        MyArrayList<String> lists1 = new MyArrayList<>();
        lists1.add("java");
        lists1.add("mysql");
        lists1.remove("java");
        System.out.println(lists1);
    }
}

class MyArrayList<E>{

    private ArrayList lists = new ArrayList();

    public void add(E e){
        lists.add(e);
    }

    public void remove(E e){
        lists.remove(e);
    }
    @Override
    public String toString() {
        return lists.toString();
    }
}

泛型类的核心思想

1	是把出现泛型变量的地方全部替换成传输的真实数据类型。

自定义泛型方法

什么是泛型方法？

1	定义了泛型的方法就是泛型方法

泛型方法的定义格式

1 2 3

修饰符 <泛型变量> 返回值类型 方法名称(形参列表){ }

注意：方法定义了是什么泛型变量，后面就只能用什么泛型变量。

泛型类的核心思想

1	是把出现泛型变量的地方全部替换成传输的真实数据类型。

需求

1	给你任何一个类型的数组，都能返回它的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class GenericDemo {
    public static void main(String[] args) {
        Integer[] nums = {10 , 20 , 30 , 40 , 50};
        String rs1  = arrToString(nums);
        System.out.println(rs1);

        String[] names = {"贾乃亮","王宝绿","陈羽凡"};
        String rs2  = arrToString(names);
        System.out.println(rs2);
    }

    public static <T> String arrToString(T[] nums){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        if(nums!=null && nums.length > 0){
            for(int i = 0 ; i < nums.length ; i++ ){
                T ele = nums[i];
                sb.append(i == nums.length-1 ? ele : ele+", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

泛型接口

什么是泛型接口

1	使用了泛型定义的接口就是泛型接口

泛型接口的格式

1 2 3

修饰符 interface 接口名称<泛型变量>{ }

需求

1	教务系统，提供一个接口可约束一定要完成数据（学生，老师）的增删改查操作

1
2
3
4
5
6

public interface Data<E> {
    void add(E stu);
    void delete(E stu);
    void update(E stu);
    E query(int id);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 操作学生数据
public class StudentData implements Data<Student> {
    @Override
    public void add(Student stu) {
        System.out.println("添加学生！");
    }

    @Override
    public void delete(Student stu) {
        System.out.println("删除学生！");
    }

    @Override
    public void update(Student stu) {

    }

    @Override
    public Student query(int id) {
        return null;
    }
}

1
2

public class Student {
}

1
2
3
4
5
6
7
8
9
10
11

public class GenericDemo {
    public static void main(String[] args) {
        StudentData data = new StudentData();
        data.add(new Student());
        data.delete(new Student());

        TeacherData data1 = new TeacherData();
        data1.add(new Teacher());
        data1.delete(new Teacher());
    }
}

泛型通配符

通配符

1 2	?可以用在使用泛型的时候代表一切类型。 E , T , K , V是在定义泛型的时候使用代表一切类型。

注意：虽然BMW和BENZ都继承了Car,但是ArrayList和ArrayList与ArrayList没有关系的！泛型没有继承关系！

泛型的上下限

1 2	? extends Car : 那么?必须是Car或者其子类。(泛型的上限) ? super Car :那么?必须是Car或者其父类。（泛型的下限。不是很常见）

需求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

public class GenericDemo {
    public static void main(String[] args) {
        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        bmws.add(new BMW());
        run(bmws);

        ArrayList<BENZ> benzs = new ArrayList<>();
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        run(benzs);

        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());
        dogs.add(new Dog());
        dogs.add(new Dog());
        // run(dogs); // 就进不来了！
    }

    // 定义一个方法，可以让很多汽车一起进入参加比赛
    public static void run(ArrayList<? extends Car> cars){

    }
}

class Car{
}
class BMW extends Car{

}
class BENZ extends Car{

}
class Dog{

}

设计模式概述

软件设计模式的产生背景

“设计模式”最初并不是出现在软件设计中，而是被用于建筑领域的设计中。

1977年美国著名建筑大师、加利福尼亚大学伯克利分校环境结构中心主任克里斯托夫·亚历山大（Christopher Alexander）在他的著作《建筑模式语言：城镇、建筑、构造》中描述了一些常见的建筑设计问题，并提出了 253 种关于对城镇、邻里、住宅、花园和房间等进行设计的基本模式。

1990年软件工程界开始研讨设计模式的话题，后来召开了多次关于设计模式的研讨会。直到1995 年，艾瑞克·伽马（ErichGamma）、理査德·海尔姆（Richard Helm）、拉尔夫·约翰森（Ralph Johnson）、约翰·威利斯迪斯（John Vlissides）等 4 位作者合作出版了《设计模式：可复用面向对象软件的基础》一书，在此书中收录了 23 个设计模式，这是设计模式领域里程碑的事件，导致了软件设计模式的突破。这 4 位作者在软件开发领域里也以他们的“四人组”（Gang of Four，GoF）著称。

软件设计模式的概念

软件设计模式（Software Design Pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。也就是说，它是解决特定问题的一系列套路，是前辈们的代码设计经验的总结，具有一定的普遍性，可以反复使用。

学习设计模式的必要性

设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解。

正确使用设计模式具有以下优点。

• 可以提高程序员的思维能力、编程能力和设计能力。
• 使程序设计更加标准化、代码编制更加工程化，使软件开发效率大大提高，从而缩短软件的开发周期。
• 使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。

设计模式分类

• 创建型模式

  用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。GoF（四人组）书中提供了单例、原型、工厂方法、抽象工厂、建造者等 5 种创建型模式。

• 结构型模式

  用于描述如何将类或对象按某种布局组成更大的结构，GoF（四人组）书中提供了代理、适配器、桥接、装饰、外观、享元、组合等 7 种结构型模式。

• 行为型模式

  用于描述类或对象之间怎样相互协作共同完成单个对象无法单独完成的任务，以及怎样分配职责。GoF（四人组）书中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等 11 种行为型模式。

UML图

统一建模语言（Unified Modeling Language，UML）是用来设计软件的可视化建模语言。它的特点是简单、统一、图形化、能表达软件设计中的动态与静态信息。

UML 从目标系统的不同角度出发，定义了用例图、类图、对象图、状态图、活动图、时序图、协作图、构件图、部署图等 9 种图。

类图概述

类图(Class diagram)是显示了模型的静态结构，特别是模型中存在的类、类的内部结构以及它们与其他类的关系等。类图不显示暂时性的信息。类图是面向对象建模的主要组成部分。

类图的作用

• 在软件工程中，类图是一种静态的结构图，描述了系统的类的集合，类的属性和类之间的关系，可以简化了人们对系统的理解；
• 类图是系统分析和设计阶段的重要产物，是系统编码和测试的重要模型。

类图表示法

类的表示方式

在UML类图中，类使用包含类名、属性(field) 和方法(method) 且带有分割线的矩形来表示，比如下图表示一个Employee类，它包含name,age和address这3个属性，以及work()方法。

属性/方法名称前加的加号和减号表示了这个属性/方法的可见性，UML类图中表示可见性的符号有三种：

• +：表示public

• -：表示private

• #：表示protected

属性的完整表示方式是： 可见性 名称 ：类型 [ = 缺省值]

方法的完整表示方式是： 可见性 名称(参数列表) [ ： 返回类型]

注意：

1，中括号中的内容表示是可选的

2，也有将类型放在变量名前面，返回值类型放在方法名前面

举个栗子：

上图Demo类定义了三个方法：

• method()方法：修饰符为public，没有参数，没有返回值。
• method1()方法：修饰符为private，没有参数，返回值类型为String。
• method2()方法：修饰符为protected，接收两个参数，第一个参数类型为int，第二个参数类型为String，返回值类型是int。

类与类之间关系的表示方式

关联关系

关联关系是对象之间的一种引用关系，用于表示一类对象与另一类对象之间的联系，如老师和学生、师傅和徒弟、丈夫和妻子等。关联关系是类与类之间最常用的一种关系，分为一般关联关系、聚合关系和组合关系。我们先介绍一般关联。

关联又可以分为单向关联，双向关联，自关联。

单向关联

在UML类图中单向关联用一个带箭头的实线表示。上图表示每个顾客都有一个地址，这通过让Customer类持有一个类型为Address的成员变量类实现。

双向关联

从上图中我们很容易看出，所谓的双向关联就是双方各自持有对方类型的成员变量。

在UML类图中，双向关联用一个不带箭头的直线表示。上图中在Customer类中维护一个List<Product>，表示一个顾客可以购买多个商品；在Product类中维护一个Customer类型的成员变量表示这个产品被哪个顾客所购买。

自关联

自关联在UML类图中用一个带有箭头且指向自身的线表示。上图的意思就是Node类包含类型为Node的成员变量，也就是“自己包含自己”。

聚合关系

聚合关系是关联关系的一种，是强关联关系，是整体和部分之间的关系。

聚合关系也是通过成员对象来实现的，其中成员对象是整体对象的一部分，但是成员对象可以脱离整体对象而独立存在。例如，学校与老师的关系，学校包含老师，但如果学校停办了，老师依然存在。

在 UML 类图中，聚合关系可以用带空心菱形的实线来表示，菱形指向整体。下图所示是大学和教师的关系图：

组合关系

组合表示类之间的整体与部分的关系，但它是一种更强烈的聚合关系。

在组合关系中，整体对象可以控制部分对象的生命周期，一旦整体对象不存在，部分对象也将不存在，部分对象不能脱离整体对象而存在。例如，头和嘴的关系，没有了头，嘴也就不存在了。

在 UML 类图中，组合关系用带实心菱形的实线来表示，菱形指向整体。下图所示是头和嘴的关系图：

依赖关系

依赖关系是一种使用关系，它是对象之间耦合度最弱的一种关联方式，是临时性的关联。在代码中，某个类的方法通过局部变量、方法的参数或者对静态方法的调用来访问另一个类（被依赖类）中的某些方法来完成一些职责。

在 UML 类图中，依赖关系使用带箭头的虚线来表示，箭头从使用类指向被依赖的类。下图所示是司机和汽车的关系图，司机驾驶汽车：

继承关系

继承关系是对象之间耦合度最大的一种关系，表示一般与特殊的关系，是父类与子类之间的关系，是一种继承关系。

在 UML 类图中，泛化关系用带空心三角箭头的实线来表示，箭头从子类指向父类。在代码实现时，使用面向对象的继承机制来实现泛化关系。例如，Student 类和 Teacher 类都是 Person 类的子类，其类图如下图所示：

实现关系

实现关系是接口与实现类之间的关系。在这种关系中，类实现了接口，类中的操作实现了接口中所声明的所有的抽象操作。

在 UML 类图中，实现关系使用带空心三角箭头的虚线来表示，箭头从实现类指向接口。例如，汽车和船实现了交通工具，其类图如图 9 所示。

软件设计原则

在软件开发中，为了提高软件系统的可维护性和可复用性，增加软件的可扩展性和灵活性，程序员要尽量根据6条原则来开发程序，从而提高软件开发效率、节约软件开发成本和维护成本。

开闭原则

对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。

想要达到这样的效果，我们需要使用接口和抽象类。

因为抽象灵活性好，适应性广，只要抽象的合理，可以基本保持软件架构的稳定。而软件中易变的细节可以从抽象派生来的实现类来进行扩展，当软件需要发生变化时，只需要根据需求重新派生一个实现类来扩展就可以了。

下面以 搜狗输入法 的皮肤为例介绍开闭原则的应用。

【例】搜狗输入法 的皮肤设计。

分析：搜狗输入法 的皮肤是输入法背景图片、窗口颜色和声音等元素的组合。用户可以根据自己的喜爱更换自己的输入法的皮肤，也可以从网上下载新的皮肤。这些皮肤有共同的特点，可以为其定义一个抽象类（AbstractSkin），而每个具体的皮肤（DefaultSpecificSkin和HeimaSpecificSkin）是其子类。用户窗体可以根据需要选择或者增加新的主题，而不需要修改原代码，所以它是满足开闭原则的。

里氏代换原则

里氏代换原则是面向对象设计的基本原则之一。

里氏代换原则：任何基类可以出现的地方，子类一定可以出现。通俗理解：子类可以扩展父类的功能，但不能改变父类原有的功能。换句话说，子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。

如果通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大。

下面看一个里氏替换原则中经典的一个例子

【例】正方形不是长方形。

在数学领域里，正方形毫无疑问是长方形，它是一个长宽相等的长方形。所以，我们开发的一个与几何图形相关的软件系统，就可以顺理成章的让正方形继承自长方形。

代码如下：

长方形类（Rectangle）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public class Rectangle {
    private double length;
    private double width;

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }
}

正方形（Square）：

由于正方形的长和宽相同，所以在方法setLength和setWidth中，对长度和宽度都需要赋相同值。

1
2
3
4
5
6
7
8
9
10
11
12

public class Square extends Rectangle {
    
    public void setWidth(double width) {
        super.setLength(width);
        super.setWidth(width);
    }

    public void setLength(double length) {
        super.setLength(length);
        super.setWidth(length);
    }
}

类RectangleDemo是我们的软件系统中的一个组件，它有一个resize方法依赖基类Rectangle，resize方法是RectandleDemo类中的一个方法，用来实现宽度逐渐增长的效果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class RectangleDemo {
    
    public static void resize(Rectangle rectangle) {
        while (rectangle.getWidth() <= rectangle.getLength()) {
            rectangle.setWidth(rectangle.getWidth() + 1);
        }
    }

    //打印长方形的长和宽
    public static void printLengthAndWidth(Rectangle rectangle) {
        System.out.println(rectangle.getLength());
        System.out.println(rectangle.getWidth());
    }

    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setLength(20);
        rectangle.setWidth(10);
        resize(rectangle);
        printLengthAndWidth(rectangle);

        System.out.println("============");

        Rectangle rectangle1 = new Square();
        rectangle1.setLength(10);
        resize(rectangle1);
        printLengthAndWidth(rectangle1);
    }
}

我们运行一下这段代码就会发现，假如我们把一个普通长方形作为参数传入resize方法，就会看到长方形宽度逐渐增长的效果，当宽度大于长度,代码就会停止，这种行为的结果符合我们的预期；假如我们再把一个正方形作为参数传入resize方法后，就会看到正方形的宽度和长度都在不断增长，代码会一直运行下去，直至系统产生溢出错误。所以，普通的长方形是适合这段代码的，正方形不适合。
我们得出结论：在resize方法中，Rectangle类型的参数是不能被Square类型的参数所代替，如果进行了替换就得不到预期结果。因此，Square类和Rectangle类之间的继承关系违反了里氏代换原则，它们之间的继承关系不成立，正方形不是长方形。

如何改进呢？此时我们需要重新设计他们之间的关系。抽象出来一个四边形接口(Quadrilateral)，让Rectangle类和Square类实现Quadrilateral接口

依赖倒转原则

高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

下面看一个例子来理解依赖倒转原则

【例】组装电脑

现要组装一台电脑，需要配件cpu，硬盘，内存条。只有这些配置都有了，计算机才能正常的运行。选择cpu有很多选择，如Intel，AMD等，硬盘可以选择希捷，西数等，内存条可以选择金士顿，海盗船等。

类图如下：

代码如下：

希捷硬盘类（XiJieHardDisk）:

1
2
3
4
5
6
7
8
9
10
11

public class XiJieHardDisk implements HardDisk {

    public void save(String data) {
        System.out.println("使用希捷硬盘存储数据" + data);
    }

    public String get() {
        System.out.println("使用希捷希捷硬盘取数据");
        return "数据";
    }
}

Intel处理器（IntelCpu）：

1
2
3
4
5
6

public class IntelCpu implements Cpu {

    public void run() {
        System.out.println("使用Intel处理器");
    }
}

金士顿内存条（KingstonMemory）：

1
2
3
4
5
6

public class KingstonMemory implements Memory {

    public void save() {
        System.out.println("使用金士顿作为内存条");
    }
}

电脑（Computer）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

public class Computer {

    private XiJieHardDisk hardDisk;
    private IntelCpu cpu;
    private KingstonMemory memory;

    public IntelCpu getCpu() {
        return cpu;
    }

    public void setCpu(IntelCpu cpu) {
        this.cpu = cpu;
    }

    public KingstonMemory getMemory() {
        return memory;
    }

    public void setMemory(KingstonMemory memory) {
        this.memory = memory;
    }

    public XiJieHardDisk getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(XiJieHardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public void run() {
        System.out.println("计算机工作");
        cpu.run();
        memory.save();
        String data = hardDisk.get();
        System.out.println("从硬盘中获取的数据为：" + data);
    }
}

测试类（TestComputer）：

测试类用来组装电脑。

1
2
3
4
5
6
7
8
9
10

public class TestComputer {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.setHardDisk(new XiJieHardDisk());
        computer.setCpu(new IntelCpu());
        computer.setMemory(new KingstonMemory());

        computer.run();
    }
}

上面代码可以看到已经组装了一台电脑，但是似乎组装的电脑的cpu只能是Intel的，内存条只能是金士顿的，硬盘只能是希捷的，这对用户肯定是不友好的，用户有了机箱肯定是想按照自己的喜好，选择自己喜欢的配件。

根据依赖倒转原则进行改进：

代码我们只需要修改Computer类，让Computer类依赖抽象（各个配件的接口），而不是依赖于各个组件具体的实现类。

类图如下：

电脑（Computer）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public class Computer {

    private HardDisk hardDisk;
    private Cpu cpu;
    private Memory memory;

    public HardDisk getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public Cpu getCpu() {
        return cpu;
    }

    public void setCpu(Cpu cpu) {
        this.cpu = cpu;
    }

    public Memory getMemory() {
        return memory;
    }

    public void setMemory(Memory memory) {
        this.memory = memory;
    }

    public void run() {
        System.out.println("计算机工作");
    }
}

面向对象的开发很好的解决了这个问题，一般情况下抽象的变化概率很小，让用户程序依赖于抽象，实现的细节也依赖于抽象。即使实现细节不断变动，只要抽象不变，客户程序就不需要变化。这大大降低了客户程序与实现细节的耦合度。

接口隔离原则

客户端不应该被迫依赖于它不使用的方法；一个类对另一个类的依赖应该建立在最小的接口上。

下面看一个例子来理解接口隔离原则

【例】安全门案例

我们需要创建一个黑马品牌的安全门，该安全门具有防火、防水、防盗的功能。可以将防火，防水，防盗功能提取成一个接口，形成一套规范。类图如下：

上面的设计我们发现了它存在的问题，黑马品牌的安全门具有防盗，防水，防火的功能。现在如果我们还需要再创建一个传智品牌的安全门，而该安全门只具有防盗、防水功能呢？很显然如果实现SafetyDoor接口就违背了接口隔离原则，那么我们如何进行修改呢？看如下类图：

代码如下：

AntiTheft（接口）：

1
2
3

public interface AntiTheft {
    void antiTheft();
}

Fireproof（接口）：

1
2
3

public interface Fireproof {
    void fireproof();
}

Waterproof（接口）：

1
2
3

public interface Waterproof {
    void waterproof();
}

HeiMaSafetyDoor（类）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class HeiMaSafetyDoor implements AntiTheft,Fireproof,Waterproof {
    public void antiTheft() {
        System.out.println("防盗");
    }

    public void fireproof() {
        System.out.println("防火");
    }


    public void waterproof() {
        System.out.println("防水");
    }
}

ItcastSafetyDoor（类）：

1
2
3
4
5
6
7
8
9

public class ItcastSafetyDoor implements AntiTheft,Fireproof {
    public void antiTheft() {
        System.out.println("防盗");
    }

    public void fireproof() {
        System.out.println("防火");
    }
}

迪米特法则

迪米特法则又叫最少知识原则。

只和你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）。

其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。

迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。

下面看一个例子来理解迪米特法则

【例】明星与经纪人的关系实例

明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，如和粉丝的见面会，和媒体公司的业务洽淡等。这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则。

类图如下：

代码如下：

明星类（Star）

1
2
3
4
5
6
7
8
9
10
11

public class Star {
    private String name;

    public Star(String name) {
        this.name=name;
    }

    public String getName() {
        return name;
    }
}

粉丝类（Fans）

1
2
3
4
5
6
7
8
9
10
11

public class Fans {
    private String name;

    public Fans(String name) {
        this.name=name;
    }

    public String getName() {
        return name;
    }
}

媒体公司类（Company）

1
2
3
4
5
6
7
8
9
10
11

public class Company {
    private String name;

    public Company(String name) {
        this.name=name;
    }

    public String getName() {
        return name;
    }
}

经纪人类（Agent）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Agent {
    private Star star;
    private Fans fans;
    private Company company;

    public void setStar(Star star) {
        this.star = star;
    }

    public void setFans(Fans fans) {
        this.fans = fans;
    }

    public void setCompany(Company company) {
        this.company = company;
    }

    public void meeting() {
        System.out.println(fans.getName() + "与明星" + star.getName() + "见面了。");
    }

    public void business() {
        System.out.println(company.getName() + "与明星" + star.getName() + "洽淡业务。");
    }
}

合成复用原则

合成复用原则是指：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

通常类的复用分为继承复用和合成复用两种。

继承复用虽然有简单和易实现的优点，但它也存在以下缺点：

1. 继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为“白箱”复用。
2. 子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化，这不利于类的扩展与维护。
3. 它限制了复用的灵活性。从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不可能发生变化。

采用组合或聚合复用时，可以将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点：

1. 它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。
2. 对象间的耦合度低。可以在类的成员位置声明抽象。
3. 复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。

下面看一个例子来理解合成复用原则

【例】汽车分类管理程序

汽车按“动力源”划分可分为汽油汽车、电动汽车等；按“颜色”划分可分为白色汽车、黑色汽车和红色汽车等。如果同时考虑这两种分类，其组合就很多。类图如下：

从上面类图我们可以看到使用继承复用产生了很多子类，如果现在又有新的动力源或者新的颜色的话，就需要再定义新的类。我们试着将继承复用改为聚合复用看一下。

创建者模式

创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。

这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。

创建型模式分为：

• 单例模式
• 工厂方法模式
• 抽象工程模式
• 原型模式
• 建造者模式

单例设计模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式的结构

单例模式的主要有以下角色：

• 单例类。只能创建一个实例的类
• 访问类。使用单例类

单例模式的实现

单例设计模式分类两种：

饿汉式：类加载就会导致该单实例对象被创建	

懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

1. 饿汉式-方式1（静态变量方式）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   /** * 饿汉式 * 静态变量创建类的对象 */ public class Singleton { //私有构造方法 private Singleton() {} //在成员位置创建该类的对象 private static Singleton instance = new Singleton(); //对外提供静态方法获取该对象 public static Singleton getInstance() { return instance; } }

   说明：

   该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。
   

2. 饿汉式-方式2（静态代码块方式）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

   /** * 恶汉式 * 在静态代码块中创建该类对象 */ public class Singleton { //私有构造方法 private Singleton() {} //在成员位置创建该类的对象 private static Singleton instance; static { instance = new Singleton(); } //对外提供静态方法获取该对象 public static Singleton getInstance() { return instance; } }

   说明：

   该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。
   

3. 懒汉式-方式1（线程不安全）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   /** * 懒汉式 * 线程不安全 */ public class Singleton { //私有构造方法 private Singleton() {} //在成员位置创建该类的对象 private static Singleton instance; //对外提供静态方法获取该对象 public static Singleton getInstance() { if(instance == null) { instance = new Singleton(); } return instance; } }

   说明：

   从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量，并没有进行对象的赋值操作，那么什么时候赋值的呢？当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现线程安全问题。
   

4. 懒汉式-方式2（线程安全）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   /** * 懒汉式 * 线程安全 */ public class Singleton { //私有构造方法 private Singleton() {} //在成员位置创建该类的对象 private static Singleton instance; //对外提供静态方法获取该对象 public static synchronized Singleton getInstance() { if(instance == null) { instance = new Singleton(); } return instance; } }

   说明：

   该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。
   

5. 懒汉式-方式3（双重检查锁）

   再来讨论一下懒汉模式中加锁的问题，对于 getInstance() 方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。由此也产生了一种新的实现模式：双重检查锁模式

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

   /** * 双重检查方式 */ public class Singleton { //私有构造方法 private Singleton() {} private static Singleton instance; //对外提供静态方法获取该对象 public static Singleton getInstance() { //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例 if(instance == null) { synchronized (Singleton.class) { //抢到锁之后再次判断是否为null if(instance == null) { instance = new Singleton(); } } } return instance; } }

   双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

   要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

   /** * 双重检查方式 */ public class Singleton { //私有构造方法 private Singleton() {} private static volatile Singleton instance; //对外提供静态方法获取该对象 public static Singleton getInstance() { //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实际 if(instance == null) { synchronized (Singleton.class) { //抢到锁之后再次判断是否为空 if(instance == null) { instance = new Singleton(); } } } return instance; } }

   小结：

   添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。

6. 懒汉式-方式4（静态内部类方式）

   静态内部类单例模式中实例由内部类创建，由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   /** * 静态内部类方式 */ public class Singleton { //私有构造方法 private Singleton() {} private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton(); } //对外提供静态方法获取该对象 public static Singleton getInstance() { return SingletonHolder.INSTANCE; } }

   说明：

   第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用getInstance，虚拟机加载SingletonHolder
   

   并初始化INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。

   小结：

   静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。
   

7. 枚举方式

   枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

   1 2 3 4 5 6 7 8 9 10

   /** * 枚举方式 */ public enum Singleton { INSTANCE; public void doSomething() { System.out.println("doSomething"); } }

   说明：

   枚举方式属于恶汉式方式。
   

存在的问题

问题演示

破坏单例模式：

使上面定义的单例类（Singleton）可以创建多个对象，枚举方式除外。有两种方式，分别是序列化和反射。

• 序列化反序列化

  Singleton类：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  public class Singleton implements Serializable { //私有构造方法 private Singleton() {} private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton(); } //对外提供静态方法获取该对象 public static Singleton getInstance() { return SingletonHolder.INSTANCE; } }

  Test类：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

  public class Test { public static void main(String[] args) throws Exception { //往文件中写对象 //writeObject2File(); //从文件中读取对象 Singleton s1 = readObjectFromFile(); Singleton s2 = readObjectFromFile(); //判断两个反序列化后的对象是否是同一个对象 System.out.println(s1 == s2); } private static Singleton readObjectFromFile() throws Exception { //创建对象输入流对象 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\a.txt")); //第一个读取Singleton对象 Singleton instance = (Singleton) ois.readObject(); return instance; } public static void writeObject2File() throws Exception { //获取Singleton类的对象 Singleton instance = Singleton.getInstance(); //创建对象输出流 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\a.txt")); //将instance对象写出到文件中 oos.writeObject(instance); } }

  上面代码运行结果是false，表明序列化和反序列化已经破坏了单例设计模式。

• 反射

  Singleton类：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  public class Singleton { //私有构造方法 private Singleton() {} private static volatile Singleton instance; //对外提供静态方法获取该对象 public static Singleton getInstance() { if(instance != null) { return instance; } synchronized (Singleton.class) { if(instance != null) { return instance; } instance = new Singleton(); return instance; } } }

  Test类：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  public class Test { public static void main(String[] args) throws Exception { //获取Singleton类的字节码对象 Class clazz = Singleton.class; //获取Singleton类的私有无参构造方法对象 Constructor constructor = clazz.getDeclaredConstructor(); //取消访问检查 constructor.setAccessible(true); //创建Singleton类的对象s1 Singleton s1 = (Singleton) constructor.newInstance(); //创建Singleton类的对象s2 Singleton s2 = (Singleton) constructor.newInstance(); //判断通过反射创建的两个Singleton对象是否是同一个对象 System.out.println(s1 == s2); } }

  上面代码运行结果是false，表明序列化和反序列化已经破坏了单例设计模式