【思维导图】Java基础笔记整理_java思维导图笔记

一、 类

1. 成员变量 : 三种访问修饰符 ＋static、final。
   方法 : 五种访问修饰符 ＋ static、final 、局部变量。

2. 构造器：构造器不能有返回值，所以不能写void、int之类的关键字。

3. this关键字：表示当前对象，如：System.out.println("this = " + this);

4. 初始化块 : 优先级比构造器高。

5. 内部类 :
       1) 可以定义在类的任何位置，包括类的方法内。
       2) 可以用static修饰。

6. 创建对象的两种方式 :
   方式一：声明并实例化对象：类名称 对象名称 = new 类名称()。
   方式二：先声明，再实例化：类名称 对象名称 = null; 对象名称 = new 类名称()。
   注意：
       (1) 方式二中未实例化就使用：编译不会报错，但是运行会报错
       2) 任何情况下，只要看见关键字new，都表示要分配新的堆内存空间

7. 继承与实现 :
   1) 一个子类只能继承一个父类，但可以多层继承 (想象一下链表)。即如果父类也继承了一个类，那么子类可以继承到父类的父类，依次类推。
   2) 继承关系中的构造方法：
       (1)子类进行初始化时，默认会先执行父类的构造方法，为父类属性进行初始化，然后再调用子类构造。
       (2) 默认条件下执行的是父类的无参构造方法，即相当于子类的构造方法中调用了super()。
       (3) 如果父类中没有无参构造，那么子类需要调用父类的构造方法，即在构造方法的首行明确写出super(参数类型 参数 , …);
   3) 重写/覆写：
       (1) 覆写方法不能拥有比父类方法更严格的访问控制权，例：父类方法是public的，那么覆写方法只能是public的
       (2) 如果返回基本类型，覆写方法必须跟父类一致。如果返回引用类型，覆写方法的返回值类型应该小于等于父类方法。
       (3) 覆写方法抛出异常的范围应该小于等于父类方法。
       (4) 使用了private定义的操作不能被覆写。
       注意 : 重载与覆写不同，只要两个同名方法的参数个数、或参数类型、或参数顺序不一致就说是重载方法。

8. 抽象类与接口 :
   1) 抽象类 :

• 定义：含有抽象方法的类。注意：抽象类中也可以有普通方法 (即有方法体的方法)。

• 访问权限：
      (1) 抽象类 : ①只能定义为public、protected、缺省 (默认为public)。②不能使用final，因为抽象类必须被继承。③外部抽象类不允许使用static修饰，内部抽象类可以。
      (2) 抽象方法 : 必须是public或protected。可以有default (不是指缺省，default是一个关键字)实现的方法。
      (3) 成员变量 :

• 注意 :
      (1) 抽象类不能直接被实例化 (必须通过子类向上转型)。
      (2) 可以直接调用抽象类的static方法。

2) 接口 :

• 接口是一种特殊的抽象类。

• 访问权限 :
      (1) 接口 :
      (2) 接口方法 : 只能是public abstract的。可以有default (不是指缺省，default是一个关键字)实现的方法。
      (3) 成员变量 : 只能是public static final的，就算不写修饰符，在编译的时候也会自动加上。

• 建议接口中的方法和属性不要加任何修饰符号。

3) 两者的区别 :
    (1) 抽象类是对本质的抽象，如男人和女人都是人类。接口是对动作的抽象，如人跟猫都会“吃东西”。
    (2) Java的类只能单继承，但接口可以多继承多个其他接口，此外，类可以实现多个接口。
    (3) 接口中的成员变量只能是public static final的，抽象类则没有这个限制。
    (4) 接口中不能有静态代码块以及静态方法。
    (5) 接口中的方法不能有方法体。

如何选择 : 当关注一个事物的本质的时候，用抽象类。当关注一个操作的时候，用接口。

参考资料 :

• https://blog.csdn.net/wei_zhi/article/details/52736350?spm=1001.2014.3001.5502

9. 多态 :
   1) 定义：同一个接口，使用不同的实例而执行不同操作。参考资料：https://www.runoob.com/java/java-polymorphism.html
   2) 多态存在的必要条件：
       (1) 存在继承或实现的关系。
       (2) 子类或实现类重写了父类中的方法。
       (3) 父类用了子类或实现类进行实例化，即向上转型。如：Parent A = new Child();
       注意：
       (1) 使用多态调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
       (2) 多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
   比如父类中有一个draw方法，虽然用不同子类实例化后draw()的功能不同，但调用的时候都是使用draw()。

10. 访问控制权限
    

二、字符串

1. 存储字符串的三种形式 : String、StringBuffer、StringBuilder :

• 1) String、StringBuffer、StringBuilder都是用字符数组来保存字符串。其中，String是不可变的，另外两个可变。
• 2) String和StringBuffer是线程安全的。
• 3) StringBuilder性能比StringBuffer更好。

2. 如何选择 :
       (1) 少量数据 : String。
       (2) 单线程、大量数据 : StringBuilder。
       (3) 多线程、大量数据 : StringBuffer。
3. 字符串拼接 :
       (1) 使用 "+"进行拼接的方式，实际上是通过StringBuilder调用append(0实现的，拼接完成后调用toString()得到String对象。
       (2) 使用 "+"的缺点 : 在循环中反复使用的话，会创建多个StringBuilder对象从而浪费资源。如果直接使用StringBuilder就不会有这个问题。
4. 字符串比较 : String中的equals方法是被重写过的，比较的是引用地址保存的值。

三、异常

1. Exception与Error :
       1) 都是继承自Throwable类。
       2) Exception 通常与代码逻辑有关，是程序正常运行时可以预料的意外情况，应该被捕获并进行处理。
       3) Errror通常是脱离程序员控制的问题，一般不容易也不需要被捕获。比如内存溢出Error。
2. 检查性异常Checked Exception : 必须捕获并进行处理，否则编译会报错。
3. 不检查性异常Unchecked Exception : 通常是可以避免的逻辑错误，根据具体需要来判断是否需要捕获，即使不捕获也能通过编译。
4. Throwable类 : 常用方法 :

• getMessage()。
• toString()。
• getLocalizedMessage()
• printStackTrace()。

5. try-catch-finally
6. try-with-resource
7. throw和throws

四、容器

1. 什么是容器 : 如果有一个类专门用来存放和管理其他类的对象，这个类就叫做容器。
2. 容器中的有序与无序 :
       1) 有序指存进去的顺序与取出来的顺序一致，会有索引表示存进去的顺序。
       2) 无序指存进去的顺序与取出来的顺序无关，没有索引。
3. 容器与数组的区别 :
   1) 数组长度固定，容器长度可变。
   2) 数组能存基本数据类型，容器只能存储引用数据类型。
   3) 数组存储的元素必须是同一个数据类型；容器存储的对象可以是不同数据类型。
4. hashCode()与equals() :
   ① 如果两个对象相等，则hashcode一定相同。但是，有相同hashcode值的两个对象不一定是相等的。
   ② 如果两个对象相等，equals() 方法返回true。
   ③ equals方法被覆盖过，则hashCode()方法也必须被覆盖。
   ④ hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等。
5. Collection :
   1) List (有序、可重复) :

• LinkedList : 基于双向链表实现的 :
      ① 特点同链表，插入和删除方便，不能随机访问。
      ② 比ArrayList更占内存，因为链表结点不止存储数据。
• ArrayList : 基于数组实现的 : ① 特点同数组，访问快，添加和删除慢。
• Vector : 基于数组实现，线程安全，不常用

2) Queue (有序FIFO、可重复) :

• PriorityQueue
• Deque : (1) ArrayDeque : 基于数组实现。(2) LinkedList : 基于链表实现

3) Set (无序、不可重复) :

• HashSet : 基于HashMap实现的，值存在key中，value全部存为PRESENT。
• SortedSet
• TreeSet : 红黑树
  

6. Map :

• 1) Key : 无序、不可重复。Value : 无序、可重复。
• 2) HashMap : 数组 + 链表、拉链法实现
• 3) HashTable : HashMap的线程安全版
• 4) TreeMap : 红黑树

五、I/O

1. 序列化与反序列化 :

• 序列化 : 将数据结构或对象转换成二进制字节流的过程。
• 反序列化 : 将在序列化过程中生成的二进制字节流转换成数据结构或对象的过程。

补充 : 序列化的主要目的是通过网络传输对象，或者将对象存储到文件系统、数据库、内存中。

2. Scanner用法 : https://blog.csdn.net/weixin_41262453/article/details/88815173
3. BIO和NIO :

六、代理
4. 什么是代理 :
1) 代理模式是一种设计模式。我们为委托对象提供一个代理，通过代理调用委托对象的方法，且可以对功能进行扩展，即添加一些自定义操作 (而不影响委托对象)。
2) 代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。
5. 静态代理 :
1) 实现 : 1) 委托对象 : 定义好委托接口及其实现类。 2) 进行代理 : 定义一个代理类，代理类中实例化了委托接口的实现类，并调用这个实现类的方法；此外，可以在调用方法前后添加自定义的操作。
2) 缺点 : 1) 每个委托对象需要代理时，都需要定义一个委托类。
2) 如果在委托接口中新增加了一个方法，那么委托接口的实现类 (包括代理类)都要实现这个方法。
6. 动态代理
1) 与静态代理的联系与区别 : 静态代理中，如果要实现代理，需要先定义一个代理类去实现委托接口。而在动态代理中，我们不需要这样做，而是通过“反射”来得到委托接口及其实现类并生成对应的代理类。当然了，要达到反射的效果，也需要写一些类，不过这些类就像是一个工厂，会自动帮我们生成对应的代理类，是为许多个委托接口服务的，而不是单一服务于某个委托接口。

2) JDK动态代理 :
(1) 实现 :

• 实现委托对象 : 定义委托接口及其实现类。

• 定义一个JDK动态代理类 : 实现InvocationHandler接口并重写invoke()方法。
      这个invoke()方法用于实现代理逻辑 (即静态代理中调用委托实现类方法即功能扩展的部分)。
  cinvoke()的3个参数 :
          ① proxy指动态生成的代理类。
          ② method : 指委托接口实现类中的对应的方法，即要调用的方法。
          ③ args : 指调用method需要的参数。
      重写invoke :
          ① 在实现invoke逻辑的时候，会通过以下代码调用委托接口实现类中的方法 : method.invoke(target, args);
          ② 这条代码中的invoke指相应的方法，因为我们并不知道具体的方法名称，所以规定了用“invoke”代替。
          ③ target是这个代理类中的一个成员变量，是委托代理类的实例对象，在使用代理类的时候要传进来的。

• 定义工厂类，用于生成代理对象 : 这个工厂类 (实现了一个方法) 接受一个参数 : 委托接口的实现类，然后调用Proxy类的newProxyInstance()方法生成对应的代理类。
      newProxyInstance()的3个参数 :
          ① loader : 委托接口的实现类的类加载 (通过委托接口的实现类进行“反射”得到)。
          ② interfaces : 代理需要实现的接口，即委托接口，通过委托接口实现类“反射”得到。
          ③ h : 实现了InvocationHandler接口的对象 (即new一个第二步中的JDK动态代理类)。

(2) 缺点 : 要代理的类 (即上面提到的委托接口实现类) 必须实现了接口。有时候我们要代理的类并没有接口，也就是说委托接口并不是一定要有的。

3) CGLIB动态代理。

补充 :

1. 浅拷贝和深拷贝 :
   
   
2. hashCode和equals :
   hashCode用于在散列存储结构中快速地查找对象。
   在散列存储结构中，比如哈希表，并不是一个位置存一个对象。哈希表中的一个位置就像一个桶，每个对象在被添加到哈希表中的时候，都会先计算一下这个对象属于哪个桶，然后再把它放到相应的桶里去。而hashCode就是这个桶的位置。
   理解了这一点之后，就很容易理解hashCode的特性了，它是用来提升查找效率的。此外，如果两个对象的hashCode相同，只能证明这两个对象在同个桶里，不能证明他们相等。而如果两个对象相等，他们必定在同个桶里，所以他们的hashCode必定相等。
   那么如何判断两个对象相等呢，那就要用到equals方法。
   总结一下就是 :
   
   通常，hashCode会返回一个int (桶的位置)，而equals会返回一个boolean (判断的结果，即两个对象是否相等)。
   hashCode和equals一般都可以被重写，为保证前文提到的两个性质，我们在重写equals之后最好把hashCode也重写。
   有一句话总结得很好 : hashCode用来在最短时间内判断两个对象是否相等并定位索引位置 (即桶的位置)，但可能出现误差；equals方法用来判断两个对象是否绝对相等。hashCode用来保证性能，equals用来保证可靠。

参考资料 :

• https://www.bilibili.com/video/BV1Y44y1P7d5/?spm_id_from=333.788
• https://blog.csdn.net/fenglibing/article/details/8905007?spm=1001.2014.3001.5502
• https://javazhiyin.blog.csdn.net/article/details/91922340?spm=1001.2014.3001.5502

3. 自定义排序 :
   Java自带了一些实现了排序的API，但这些API通常只能对int和string进行排序，而且是升序排序。如果我们需要对其他数据类型 (比如对象)进行排序，或者进行降序排序等，就需要自定义排序方式。
   首先我们需要先了解两个方法 : compareTo()方法和compare()方法。
   compareTo(Object obj) 方法 : 要求传入一个参数，比较规则如下 :
   compare(Object o1, Object o2)方法 : 要传入两个参数，比较规则 :
   实现自定义排序 : 当我们重写排序API中的compareTo()方法或compare()方法之后，就能改变排序的规则。
   重写compareTo() :
   
   重写compare() :
   
   参考资料 : https://blog.csdn.net/weixin_43955170/article/details/121891330

以改变Arrays.sort()排序规则为例 :

只要在调用Arrays.sort()的时候传入第二个参数。第二个参数传入的内容为重写了cmpare()方法的类 (这里用了匿名类，如果单独写一个类并new一个对象作为参数传进去也是一样的)。