java成神之路-基础篇

最近关注了个主播，Hollis 阿里巴巴的一位专家，该博主总结了一份java成神之路的知识图谱，基于图谱打算出几期总结文档也有助于自己巩固与学习。于是有了这篇文章。

图谱有着么几个阶段，附件我放到资源里
在这里插入图片描述
基础篇大概长这样

文章目录

java成神之路-基础篇
01面向对象
- - - **→ 什么是面向对象**
    - → 平台无关性
    - → 值传递
    - - 1、什么是[值传递](https://so.csdn.net/so/search?q=值传递&spm=1001.2101.3001.7020)，什么是引用传递？
      - 2.值传递和[引用传递](https://so.csdn.net/so/search?q=引用传递&spm=1001.2101.3001.7020)的区别是什么？
      - 3.为什么说 Java 中只有值传递
      - **3.1纠正一下大家以前的那些错误看法**
        **3.2 严格求值**
        **3.3 java 的求值策略**
    - → 封装、继承、多态
    - - 封装
      - 继承
      - 多态
      - 接口
02Java 基础知识
- - - → 基本数据类型
    - → 自动拆装箱
    - → String
    - → 熟悉 Java 中各种关键字
    - → 集合类
    - → 枚举
    - - 1.什么是枚举
      - 2.Java 枚举如何比较
      - 3.switch 对枚举的支持
    - → IO
    - → 反射
    - → 动态代理
    - → 序列化
    - ** **
    - **→ 注解**
    - → JMS
    - → JMX
    - → 泛型
    - → 单元测试
    - → 正则表达式
    - → 常用的 Java 工具库
    - → API & SPI
    - → 异常
    - → 时间处理
    - → 编码方式
    - → 语法糖
03 阅读源代码
04 Java 并发编程
- - - **→ 并发与并行**
    - **→ 什么是线程，与进程的区别**
    - → 线程池
    - → 线程安全
    - → 锁
    - → 死锁
    - → synchronized
    - → volatile
    - **→ sleep 和 wait**
    - **→ wait 和 notify**
    - **→ notify 和 notifyAll**
    - **→ ThreadLocal**
    - **→ 写一个死锁的程序**
    - **→ 写代码来解决生产者消费者问题**
    - **→ 并方包**

01面向对象

→ 什么是面向对象

1、面向对象、面向过程

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

2、面向对象的三大基本特征和五大基本原则

三大特性是：封装,继承,多态

所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

所谓继承是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

所谓多态就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。

五大基本原则
单一职责原则SRP(Single Responsibility Principle)
是指一个类的功能要单一，不能包罗万象。如同一个人一样，分配的工作不能太多，否则一天到晚虽然忙忙碌碌的，但效率却高不起来。

开放封闭原则OCP(Open－Close Principle)
一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。比如：一个网络模块，原来只服务端功能，而现在要加入客户端功能，
那么应当在不用修改服务端功能代码的前提下，就能够增加客户端功能的实现代码，这要求在设计之初，就应当将服务端和客户端分开，公共部分抽象出来。

替换原则(the Liskov Substitution Principle LSP)
子类应当可以替换父类并出现在父类能够出现的任何地方。比如：公司搞年度晚会，所有员工可以参加抽奖，那么不管是老员工还是新员工，
也不管是总部员工还是外派员工，都应当可以参加抽奖，否则这公司就不和谐了。

依赖原则(the Dependency Inversion Principle DIP) 具体依赖抽象，上层依赖下层。假设B是较A低的模块，但B需要使用到A的功能，
这个时候，B不应当直接使用A中的具体类：而应当由B定义一抽象接口，并由A来实现这个抽象接口，B只使用这个抽象接口：这样就达到
了依赖倒置的目的，B也解除了对A的依赖，反过来是A依赖于B定义的抽象接口。通过上层模块难以避免依赖下层模块，假如B也直接依赖A的实现，那么就可能造成循环依赖。一个常见的问题就是编译A模块时需要直接包含到B模块的cpp文件，而编译B时同样要直接包含到A的cpp文件。

接口分离原则(the Interface Segregation Principle ISP)
模块间要通过抽象接口隔离开，而不是通过具体的类强耦合起来

→ 平台无关性

Java 如何实现的平台无关

JVM 还支持哪些语言（Kotlin、Groovy、JRuby、Jython、Scala）

→ 值传递

值传递、引用传递

1、什么是值传递，什么是引用传递？

值传递（pass by value）是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递（pass by reference）是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

2.值传递和引用传递的区别是什么？

3.为什么说 Java 中只有值传递

3.1纠正一下大家以前的那些错误看法

错误理解一：值传递和引用传递，区分的条件是传递的内容，如果是个值，就是值传递。如果是个引用，就是引用传递

错误理解二：Java是引用传递。

错误理解三：传递的参数如果是普通类型，那就是值传递，如果是对象，那就是引用传递。

3.2 严格求值

在“严格求值”中，函数调用过程中，给函数的实际参数总是在应用这个函数之前求值。多数现存编程语言对函数都使用严格求值。所以，我们本文只关注严格求值。

在严格求值中有几个关键的求值策略是我们比较关心的，那就是传值调用（Call by value）、传引用调用（Call by reference）以及传共享对象调用（Call by sharing）

1.传值调用（值传递）：在传值调用中，实际参数先被求值，然后其值通过复制，在传递给被调函数的形式参数。因为形式参数拿到的只是一个"局部拷贝"，所以如果在被调函数中改变了形式参数的值，并不会改变实际参数的值。

2.传引用调用（引用传递）在传引用调用中，传递给函数的是它的实际参数的隐式引用而不是实参的拷贝。因为传递的是引用，所以，如果在被调函数中改变了形式参数的值，改变对于调用者来说是可见的。

3.传共享对象调用（共享对象传递）传共享对象调用中，先获取到实际参数的地址，然后将其复制，并把该地址的拷贝传递给被调函数的形式参数。因为参数的地址都指向同一个对象，所以我们也称之为"传共享对象"，所以，如果在被调函数中改变了形式参数的值，调用者是可以看到这种变化的。

不知道大家有没有发现，其实传共享对象调用和传值调用的过程几乎是一样的，都是进行"求值"、“拷贝”、“传递”。你品，你细品。

但是，传共享对象调用和内传引用调用的结果又是一样的，都是在被调函数中如果改变参数的内容，那么这种改变也会对调用者有影响。你再品，你再细品。

那么，共享对象传递和值传递以及引用传递之间到底有很么关系呢？

对于这个问题，我们应该关注过程，而不是结果，因为传共享对象调用的过程和传值调用的过程是一样的，而且都有一步关键的操作，那就是"复制"，所以，通常我们认为传共享对象调用是传值调用的特例

我们先把传共享对象调用放在一边，我们再来回顾下传值调用和传引用调用的主要区别：

传值调用是指在调用函数时将实际参数复制一份传递到函数中，传引用调用是指在调用函数时将实际参数的引用直接传递到函数中。

在这里插入图片描述

3.3 java 的求值策略

前面我们介绍过了传值调用、传引用调用以及传值调用的特例传共享对象调用，那么，Java中是采用的哪种求值策略呢？

很多人说Java中的基本数据类型是值传递的，这个基本没有什么可以讨论的，普遍都是这样认为的。

但是，有很多人却误认为Java中的对象传递是引用传递。之所以会有这个误区，主要是因为Java中的变量和对象之间是有引用关系的。Java语言中是通过对象的引用来操纵对象的。所以，很多人会认为对象的传递是引用的传递。

而且很多人还可以举出以下的代码示例：

输出结果：

print in pass , user is User{name=‘hollis’, gender=‘Male’}
print in main , user is User{name=‘hollischuang’, gender=‘Male’}：

可以看到，对象类型在被传递到pass方法后，在方法内改变了其内容，最终调用方main方法中的对象也变了。

所以，很多人说，这和引用传递的现象是一样的，就是在方法内改变参数的值，会影响到调用方。

但是，其实这是走进了一个误区。

**其实Java中使用的求值策略就是传共享对象调用，也就是说，Java会将对象的地址的拷贝传递给被调函数的形式参数。**只不过"传共享对象调用"这个词并不常用，所以Java社区的人通常说"Java是传值调用"，这么说也没错，因为传共享对象调用其实是传值调用的一个特例。

值传递和共享对象传递的现象冲突吗？

看到这里很多人可能会有一个疑问，既然共享对象传递是值传递的一个特例，那么为什么他们的现象是完全不同的呢？

难道值传递过程中，如果在被调方法中改变了值，也有可能会对调用者有影响吗？那到底什么时候会影响什么时候不会影响呢？

其实是不冲突的，之所以会有这种疑惑，是因为大家对于到底是什么是"改变值"有误解。

我们先回到上面的例子中来，看一下调用过程中实际上发生了什么？

以上说明值传递和引用传递总结引用于一篇写的比较好的文章：

值传递与引用传递

→ 封装、继承、多态

什么是多态、方法重写与重载

Java 的继承与实现

构造函数与默认构造函数

类变量、成员变量和局部变量

成员变量和方法作用域

封装

所谓的封装就是把类的属性和方法使用private修饰，不允许类的调用者直接访问，我们定义如下一个类，可以看到所有的成员变量和成员方法都使用private修饰了，我们现在来使用一下这个类。

在这里插入图片描述

当我们使用的时候编译器给出了下面这样的报错。在这里插入图片描述

告诉我们说是private访问控制，那么这是什么意思呢？我们来看看另外一张图，那么这张图代表这什么呢？在看这张图之前，我们先来看看四者都提到的包，那么包又是什么呢，包可以简单理解为一个文件夹，把类放到放到包里面，也就相当于是专门的文件夹里面，这不是我们说的重点，知道就行，类都知道吧，不知道的先去看看博主这篇博客类和对象再回来继续往下。
ps：稍微记一下这张图中的内容。

在这里插入图片描述

有了上面的基础我们现在再来看private，他的使用范围只有同一个包中的同一个类中使用（这个范围也就是他的权限），我们就记住只能在我们定义的那个类中使用就好了，别问为什么，因为这就是语法，记住就好了，记准确了是当前类中，不能外部引用，否则就会出现上面那样的报错。既然不能直接从外部引用，那么类的调用者总得有个办法使用吧，不然实现这个类干嘛，这个时候就是我们在设计类的时候要提供的公开的方法了，那么上述的代码应该写成如下形式。

在这里插入图片描述

ps：这里重写了toString方法才会是下面的输出形式。
上面就是调用了，那么有的读者可能就会问了，那你的eat方法还是private的呀，我还是不能调用啊，这里我解释一下，这是因为我是为了演示private的作用而在eat方法前面加的private，运行时我将它注释掉了，至于实际上像eat这样需要被类的调用者直接使用的方法，肯定是不能使用private修饰的，至于用什么访问权限修饰这就是类的设计者根据日后业务的需要而决定了。
封装的第一个作用就是为了不直接被外部使用，提高代码的安全性，第二个作用就是降低类的使用者的学习成本，不需要知道类的实现，只需要学会调用就好了，封装差不多就介绍完了，接下来聊聊继承。

继承

所谓继承本质就是实现代码的复用，防止重复的代码多次书写，当一个类继承一个类的时候，该类中就会拥有另外一个类中的所有代码，举个例子看下面代码

在这里插入图片描述

可以看到继承的语法形式是class 子类名 extends 父类名，继承类就是子类，也叫派生类，被继承的类称为父类，基类或者超类（名字一般不做区分，均可使用），语法形式很简单，我们来聊聊其中的细节，首先Java是单继承的，一个子类只能有一个父类，但是一个子类可以当作另外一个类的父类，即可以B继承A，然后C继承B，代码如下，那么B会拥有A中的代码，C会拥有A、B的代码。

在这里插入图片描述

下面讲的普通类继承知识都是基于父类是公开的并单独位于一个.java文件的。
我们定义一个这样的Animal类当作父类：

在这里插入图片描述

当访问使用private修饰的属性时就会报错，这个就是上面封装的知识了，只能在定义的类中使用。

在这里插入图片描述

当去掉private不加任何修饰符时为包访问权限（对应上面的default范围，至于default关键字的使用在接口当中会提到），当前包底下的类才能使用Animal中的属性。

在这里插入图片描述

当使用protected修饰时，是可以在子类中调用的，那么下面为什么会报错呢，那是因为调用的方式不对，这里我们需要改变访问方式并使用到super关键字。

在这里插入图片描述

改为如下调用，在子类中调用，并使用super关键字，而不是通过实例化对像调用，上面那张图除了提到包还提到了类，小伙伴们注意到了吗？不记得的小伙伴们就往上翻再看看那张图吧。

在这里插入图片描述

至于public没啥好说的，哪都能用。
上面呢介绍了继承普通类的知识，现在我们来看看不太正常的类，抽象类，抽象类是指被abstract修饰，包含抽象方法的类，如下就是一个抽象类，首先是类名前面添加了abstract关键字，其次是其中包含了一个抽象方法，什么是抽象方法，就是没有被具体实现的方法，如下图的work方法，没有方法体，并被abstract修饰，不加的话会报错，被abstract修饰的类中可以没有抽象方法，这是语法允许的（jdk1.8测出来的），但是建议同步使用，要么既有abstract修饰类又有abstract方法，要么都没有，不然使用了abstract修饰类又不加abstract方法这不是闹吗，除非你不想这个类直接被实例化，注意一点，abstract修饰的类不能直接被实例化，需要被继承之后通过子类调用父类的构造方法，对从父类继承过来的字段进行初始化，注意这些继承过来的字段和方法都到了子类中了，但是子类能不能使用和如何使用就和给的权限（使用了什么访问修饰符限定）相关了，并没有实例化产生一个父类对象，有些地方说会实例化一个父类对象这是不对的，说一个极端的说法，父类为抽象类你能实例化吗？

在这里插入图片描述

当一个普通类继承一个抽象类的时候需要重写抽象类的所有抽象方法，如果不想重写的话就需要声明为抽象类，看下面代码

在这里插入图片描述

继承主要是为了代码的复用，减少代码的重复书写和为多态打一个基础，接下来我们聊聊多态

多态

多态是一种思想，是同一份代码，不同的传参（子类）调用会产生不同的效果，绝对不是写死的代码
多态是建立在继承机制上的一种机制，想要了解多态就必须知道向上转型，那么什么是向上转型呢，所谓的向上转型就是使用父类对象的引用，引用子类对象看下面代码

在这里插入图片描述

Teacher是People的一个子类，使用People引用引用一个Teacher对象，向上转型是自动发生的，不需要进行强制类型转换，发生向上转型一般有三种情况
1.像上面代码一样，让父类引用直接引用子类对象时。
2.子类作为函数调用时的实参，使用父类形参接收时。
3.子类作为父类返回值函数的返回值时。
总的说就是父类引用引用了子类对象

在这里插入图片描述

红色的框表示第二种，橘黄色的框表示第三种
ps：不难理解吧QAQ
与向上转型对应的还有向下转型，就是将父类对象赋值给子类引用，一般很少用的，就简单的提一下吧，因为他发生条件比较严格，首先是不能直接强制类型转换，看下面代码（已经将People类变成了类）

在这里插入图片描述

其次是需要父类引用引用子类的对象（发生过向上转型），最后需要强制转换为对应的子类对象，像下面这样

在这里插入图片描述

ps：这东西用起来挺奇怪的，不太建议使用
到这里相信你应该知道什么叫做向上转型了，但是这还不足以接触多态，我们需要先来聊聊另外一个知识点，动态绑定，所谓动态绑定也叫运行时绑定，我们先来看看代码

在这里插入图片描述

首先可以看到三个输出，第一个输出睡觉，第三个输出教书没问题吧，问题就出在第二个上面，我明明调用的是people的work方法，为什么输出的不是睡觉，而是教书呢？这就是发生了动态绑定，所谓动态绑定就是使用父类引用引用子类对象然后（向上转型）去调用父类和子类相同的方法（返回值（构成父子类关系也可以，也就是协变类型），方法名，形参列表完全相同）换句话说也就是说在子类中重写了父类的方法，这样的重写需要注意一些点，那就是子类重写的方法的访问权限必须不小于父类的方法的权限也就是说父类为public子类就必须为public因为public是最大的权限，权限对应上图的 √ 的个数√越多权限越大，静态方法不能重写，被final修饰的方法（密封方法）不能重写。
ps：与动态绑定对应的还有静态绑定，这里就不多说了…
好了，知道了向上转型和动态绑定就可以了解多态了，看代码

在这里插入图片描述

是不是觉得很神奇，明明是指向了同一份代码却打印了不同的结果，这就是多态，我不管你怎么实现的方法，只要你有这个方法我就能帮你调用，并且这里如果是子类对象会发生向上转型，进而发生动态绑定，形成多态，上面是通过继承来实现的多态，接下来我们再来讲一个东西实现多态，接口

接口

那么接口是什么呢，接口也可以想象成一个类，但是它既然单独出现，肯定说明它和类有有所不同，首先接口由interface关键字定义，并且其中的所有方法都默认为public abstract的，所有字段都默认为public static final的，下面几种定义方式并无区别，

在这里插入图片描述

然后类似与继承，接口可以通过implements被实现，实现也很简单，和继承抽象类一样重写所有的抽象方法即可，同样接口不能被直接实例化。

在这里插入图片描述

有了上面的了解，我们来用接口实现多态，看下面代码，也和类实现多态没什么很大区别，也类似与发生了向上转型和动态绑定，实现接口和继承类的一个很大区别就是一个类只能继承一个类，但是一个类可以实现多个接口

在这里插入图片描述

其中接口也可以扩展接口，看下面代码

在这里插入图片描述

从jdk1.8开始接口中可以包含默认方法了需要使用default关键字修饰，和类的成员方法一样，看下面代码，到这里接口就差不多聊完了，小结一下

在这里插入图片描述

一些建议和小结
1.建议字段的访问权限能给小绝不给大，能使用private修饰的字段一定要用private，提高安全性。
2.继承的层次不要太深，建议最多继承三层，使用final修饰可以让类无法被继承。
3.抽象类的出现就是为了继承之后重写发生动态绑定。
4.能使用接口就不要使用抽象类，因为类只能单继承，但是接口可以“多继承”，更加的灵活。
5.多态的核心都是让调用者不必关注对象的具体类型. 这是降低用户使用成本的一种重要方式。
6.抽象类和接口的核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 接口中只能包含静态常量，子类必须重写所有的抽象方法。
7.接口中的方法和字段定义都只写必要部分，尽量简洁像博主上面一样

封装、多态、继承

02Java 基础知识

→ 基本数据类型

8 种基本数据类型：整型、浮点型、布尔型、字符型

整型中 byte、short、int、long 的取值范围

在这里插入图片描述

什么是浮点型？什么是单精度和双精度？为什么不能用浮点型表示金额？

剖析金额不能用浮点数表示的原因

→ 自动拆装箱

什么是包装类型、什么是基本类型、什么是自动拆装箱

Integer 的缓存机制

→ String

字符串的不可变性

JDK 6 和 JDK 7 中 substring 的原理及区别、

replaceFirst、replaceAll、replace 区别、

String 对“+”的重载、字符串拼接的几种方式和区别

String.valueOf 和 Integer.toString 的区别、

switch 对 String 的支持

字符串池、常量池（运行时常量池、Class 常量池）、intern

由浅入深完全讲解String

→ 熟悉 Java 中各种关键字

transient、instanceof、final、static、volatile、synchronized、const 原理及用法

→ 集合类

常用集合类的使用、ArrayList 和 LinkedList 和 Vector 的区别、SynchronizedList 和 Vector 的区别、HashMap、HashTable、ConcurrentHashMap 区别、

Set 和 List 区别？Set 如何保证元素不重复？

Java 8 中 stream 相关用法、apache 集合处理工具类的使用、不同版本的 JDK 中 HashMap 的实现的区别以及原因

Collection 和 Collections 区别

Arrays.asList 获得的 List 使用时需要注意什么

Enumeration 和 Iterator 区别

fail-fast 和 fail-safe

CopyOnWriteArrayList、ConcurrentSkipListMap

java容器相关

→ 枚举

枚举的用法、枚举的实现、枚举与单例、Enum 类

Java 枚举如何比较

switch 对枚举的支持

枚举的序列化如何实现

枚举的线程安全性问题

1.什么是枚举

Java中的枚举是一种类型，顾名思义：就是一个一个列举出来。所以它一般都是表示一个有限的集合类型，它是一种类型，在维基百科中给出的定义是：

在数学和计算机科学理论中，一个集的枚举是列出某些有穷序列集的所有成员的程序，或者是一种特定类型对象的计数。这两种类型经常（但不总是）重叠.。枚举是一个被命名的整型常数的集合，枚举在日常生活中很常见，例如表示星期的SUNDAY、MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY就是一个枚举。

public enum Season {
    SPRING(1), SUMMER(2), AUTUMN(3), WINTER(4);
 
    private int code;
    private Season(int code){
        this.code = code;
    }
 
    public int getCode(){
        return code;
    }
}
public class UseSeason {
    /**
     * 将英文的季节转换成中文季节
     * @param season
     * @return
     */
    public String getChineseSeason(Season season){
        StringBuffer result = new StringBuffer();
        switch(season){
            case SPRING :
                result.append("[中文：春天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
                break;
            case AUTUMN :
                result.append("[中文：秋天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
                break;
            case SUMMER : 
                result.append("[中文：夏天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
                break;
            case WINTER :
                result.append("[中文：冬天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
                break;
            default :
                result.append("地球没有的季节 " + season.name());
                break;
        }
        return result.toString();
    }
 
    public void doSomething(){
        for(Season s : Season.values()){
            System.out.println(getChineseSeason(s));//这是正常的场景
        }
        //System.out.println(getChineseSeason(5));
        //此处已经是编译不通过了，这就保证了类型安全
    }
 
    public static void main(String[] arg){
        UseSeason useSeason = new UseSeason();
        useSeason.doSomething();
    }
}

2.Java 枚举如何比较

可以通过三种方式比较两个枚举常量：

使用Enum类的compareTo()方法

使用Enum类的equals()方法

使用==运算符

enum Level {

		LOW, MEDIUM, HIGH, URGENT;

}

public class Main {

    public static void main(String[] args) {

        Level s1 = Level.LOW;

        Level s2 = Level.URGENT;

        // s1.compareTo(s2) returns s1.ordinal() - s2.ordinal()

        int diff = s1.compareTo(s2);

        System.out.println(diff);

    }

}

enum Level {

		LOW, MEDIUM, HIGH, URGENT;

}

public class Main {

    public static void main(String[] args) {

        Level s1 = Level.LOW;

        Level s2 = Level.URGENT;

        System.out.println(s1.equals(s1));
       	System.out.println(s1==s1);

    }

}

3.switch 对枚举的支持

package mark.demo;
 
import java.util.Random;
 
public class EnumDemo {
 
	public static void main(String[] args) {
		int len = Color.values().length;
		Color color = Color.getColor(len);
		switch (color) {
		case RED:
			System.out.println("select " + "RED");
			break;
		case GREEN:
			System.out.println("select " + "GREEN");
			break;
		case BLUE:
			System.out.println("select " + "BLUE");
			break;
		case YELLOW:
			System.out.println("select " + "YELLOW");
			break;
		default:
			System.out.println("select " + "unknow!!");
			break;
		}
	}
 
	public enum Color {
		RED("red color", 0), 
		GREEN("green color", 1),
		BLUE("blue color", 2), 
		YELLOW("yellow color", 3);
 
		Color(String name, int id) {
			_name = name;
			_id = id;
		}
 
		private String _name;
		private int _id;
 
		public String getName() {
			return _name;
		}
 
		public int getId() {
			return _id;
		}
 
		public static Color getColor(int max) {
			Random random = new Random(System.currentTimeMillis());
			int num = random.nextInt(max);
			switch (num) {
			case 0:
				return Color.RED;
			case 1:
				return Color.GREEN;
			case 2:
				return Color.BLUE;
			case 3:
				return Color.YELLOW;
			default:
				return Color.BLUE;
			}
		}
	}
}

→ IO

字符流、字节流、输入流、输出流、

同步、异步、阻塞、非阻塞、Linux 5 种 IO 模型

BIO、NIO 和 AIO 的区别、三种 IO 的用法与原理、netty

懒得自己写摘抄两个写的比较详细的文档：

写的很细致的io流文案

这个写的比较基础，主要是有几本的输入输出的小代码可以看下

BIO、NIO 和 AIO 的区别

→ 反射

反射与工厂模式、反射有什么用

Class 类、java.lang.reflect.*

→ 动态代理

静态代理、动态代理

动态代理和反射的关系

动态代理的几种实现方式

AOP

→ 序列化

什么是序列化与反序列化、为什么序列化、序列化底层原理、序列化与单例模式、protobuf、为什么说序列化并不安全

→ 注解

元注解、自定义注解、Java 中常用注解使用、注解与反射的结合

Spring 常用注解

→ JMS

什么是 Java 消息服务、JMS 消息传送模型

→ JMX

java.lang.management.、 javax.management.

→ 泛型

泛型与继承、类型擦除、泛型中 KTVE? object 等的含义、泛型各种用法

限定通配符和非限定通配符、上下界限定符 extends 和 super

List 和原始类型 List 之间的区别?

List<?> 和 List 之间的区别是什么?

→ 单元测试

junit、mock、mockito、内存数据库（h2）

→ 正则表达式

java.lang.util.regex.*

→ 常用的 Java 工具库

commons.lang、commons.*…、 guava-libraries、 netty

→ API & SPI

API、API 和 SPI 的关系和区别

如何定义 SPI、SPI 的实现原理

→ 异常

异常类型、正确处理异常、自定义异常

Error 和 Exception

异常链、try-with-resources

finally 和 return 的执行顺序

→ 时间处理

时区、冬令时和夏令时、时间戳、Java 中时间 API

格林威治时间、CET,UTC,GMT,CST 几种常见时间的含义和关系

SimpleDateFormat 的线程安全性问题

Java 8 中的时间处理

如何在东八区的计算机上获取美国时间

→ 编码方式

Unicode、有了 Unicode 为啥还需要 UTF-8

GBK、GB2312、GB18030 之间的区别

UTF8、UTF16、UTF32 区别

URL 编解码、Big Endian 和 Little Endian

如何解决乱码问题

→ 语法糖

Java 中语法糖原理、解语法糖

语法糖：switch 支持 String 与枚举、泛型、自动装箱与拆箱、方法变长参数、枚举、内部类、条件编译、断言、数值字面量、for-each、try-with-resource、Lambda 表达式

03 阅读源代码

String、Integer、Long、Enum、

BigDecimal、ThreadLocal、ClassLoader & URLClassLoader、

ArrayList & LinkedList、

HashMap & LinkedHashMap & TreeMap & CouncurrentHashMap、HashSet & LinkedHashSet & TreeSet

04 Java 并发编程

→ 并发与并行

什么是并发、什么是并行

并发与并行的区别

→ 什么是线程，与进程的区别

线程的实现、线程的状态、优先级、线程调度、创建线程的多种方式、守护线程

线程与进程的区别

→ 线程池

自己设计线程池、submit() 和 execute()、线程池原理

为什么不允许使用 Executors 创建线程池

→ 线程安全

死锁、死锁如何排查、线程安全和内存模型的关系

→ 锁

CAS、乐观锁与悲观锁、数据库相关锁机制、分布式锁、偏向锁、轻量级锁、重量级锁、monitor、

锁优化、锁消除、锁粗化、自旋锁、可重入锁、阻塞锁、死锁

→ 死锁

什么是死锁

死锁如何解决

→ synchronized

synchronized 是如何实现的？

synchronized 和 lock 之间关系、不使用 synchronized 如何实现一个线程安全的单例

synchronized 和原子性、可见性和有序性之间的关系

→ volatile

happens-before、内存屏障、编译器指令重排和 CPU 指令重

volatile 的实现原理

volatile 和原子性、可见性和有序性之间的关系

有了 symchronized 为什么还需要 volatile

→ sleep 和 wait

→ wait 和 notify

→ notify 和 notifyAll

→ ThreadLocal

→ 写一个死锁的程序

→ 写代码来解决生产者消费者问题

→ 并方包

Thread、Runnable、Callable、ReentrantLock、ReentrantReadWriteLock、Atomic*、Semaphore、CountDownLatch、ConcurrentHashMap、Executors

（io流之后的部分有时间再补充）