【烈日炎炎战后端】JAVA基础（3.4万字）

1. 如何理解面向对象?

参考链接：link1，link2

我认为可以从三个层面来解释：

第一个层面（基本概念）：面向对象 ( Object Oriented ) 是将现实问题构建关系，然后抽象成 类 ( class )，给类定义属性和方法后，再将类实例化成 实例 ( instance ) ，通过访问实例的属性和调用方法来进行使用。

第二个层面（三大特性）：三大特性：封装，继承，多态（重载和重写）。

第三个层面（设计模式）：设计模式的六大原则可以更详细的去解释面向对象及其三大特性的规则。六大原则有：开闭原则，单一指责原则，里氏替换原则，依赖倒置原则，接口隔离原则，迪米特法则。

2. Java和C++的区别?

链接：https://www.nowcoder.com/discuss/406755

1. Java是解释型语言，所谓的解释型语言，就是源码会先经过一次编译，成为中间码，中间码再被解释器解释成机器码。对于Java而言，中间码就是字节码(.class)，而解释器在JVM中内置了。

2. C++是编译型语言，所谓编译型语言，就是源码一次编译，直接在编译的过程中链接了，形成了机器码。

3. C++比Java执行速度快，但是Java可以利用JVM跨平台。

4. Java是纯面向对象的语言，所有代码（包括函数、变量）都必须在类中定义。而C++中还有面向过程的东西，比如是全局变量和全局函数。

5. C++中有指针，Java中没有，但是有引用。

6. C++支持多继承，Java中类都是单继承的。但是继承都有传递性，同时Java中的接口是多继承，类对接口的实现也是多实现。

7. C++中，开发需要自己去管理内存，但是Java中JVM有自己的GC机制，虽然有自己的GC机制，但是也会出现OOM和内存泄漏的问题。C++中有析构函数，Java中Object的finalize方法。

8. C++运算符可以重载，但是Java中不可以。同时C++中支持强制自动转型，Java中不行，会出现ClassCastException（类型不匹配）。

面向对象和面向过程有什么区别?

面向对象和面向过程最本质的区别在于考虑问题的出发点不同，面向过程是以事件流程为考虑问题的出发点，而面向对象则是以参与事件的角色（对象）为考虑问题的出发点，所以面向对象在处理问题时更加灵活。目前，面向过程的语言更多被用于处理底层业务，而面向对象编程则更多用于实现一些业务逻辑复杂的大型系统。

面向过程：摇（狗尾巴）
面向对象：狗.摇尾巴（）

面向过程是编年史。
面向对象是纪传史。

3. Java面向对象的三大特性?

三大特性：封装，继承，多态（重载和重写）

封装：把事物用类封装起来，保留特定的接口与外界联系，可减少耦合，隐藏细节；

继承：子类继承父类，子类可以拥有已知父类的行为和属性；通过继承创建的新类称为「子类」或「派生类」，被继承的类称为「基类」、「父类」或「超类」。

多态：多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单说就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态的本质就是一个程序中存在多个同名的不同方法，分为重载和重写。

【拓展】Java中实现多态的机制是什么？

多态就是指一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

特点：

1. 指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。
2. 若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。

Java实现多态有三个必要条件：继承、重写、向上转型。

调用的优先级方法，该优先级为：this.show(O)、super.show(O)、this.show((super)O)super.show((super)O)。多态的实现原理

Java 里对象方法的调用是依靠类信息里的方法表实现的。总体而言，当调用对象某个方法时，JVM查找该对象类的方法表以确定该方法的直接引用地址，有了地址后才真正调用该方法。Overriding该方法，那么调用时会指向父类的方法。如果Overrding该方法，那么指向该类的代码区。但是超类会存有父类的方法表。

我们知道java程序运行时，类的相关信息放在方法区，在这些信息中有个叫方法表的区域，该表包含有该类型所定义的所有方法的信息和指向这些方法实际代码的指针。

当Bird、Cock、Parrot和CrazyParrot这四个类被加载到 Java 虚拟机之方法区后，方法区中就包含了这四个类的信息，下图示例了各个类的方法表。

从图我们可以看到Cock、Parrot和CrazyParrot的类信息方法表包含了继承自Bird的方法。CrazyParrot的方法表包含了继承自Parrot的方法。此外各个类也有自己的方法。

注意看，方法表条目指向的具体方法代码区。对于多态Overriding的方法courtship()，虽然Cock、Parrot和CrazyParrot的方法表里的courtship()条目所在位置是属于继承自Bird方法表的部分，但指向不同的方法代码区了。

继承和多态有什么区别？

继承是子类获得父类的成员，重写是继承后重新实现父类的方法，重载是在一个类里一系列参数不同名字相同的方法。多态则是为了避免在父类里大量重载引起代码臃肿且难于维护。

4. Java中重载和重写

重载(overloading)：编译时多态， 在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

重写(Override)：运行时多态，如果一个子类继承了一个父类，子类中拥有和父类相同方法名称，返回值，参数类型的话，就是重写，会执行子类中的方法。

重载：

public class 重载 {
     
    public static void sayhello(int s){
     
        System.out.println("这是int类型的参数");
    }
    public static void sayhello(char s){
     
        System.out.println("这是char类型的参数");
    }

    public static void main(String[] args) {
     
        sayhello(1);
        sayhello('a');
    }
}

重写：

class Animal{
     
   public void move(){
     
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
     
   public void move(){
     
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
     
   public static void main(String args[]){
     
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}

以上实例编译运行结果如下：

动物可以移动
狗可以跑和走

在上面的例子中可以看到，尽管 b 属于 Animal 类型，但是它运行的是 Dog 类的 move方法。这是由于在编译阶段，只是检查参数的引用类型。然而在运行时，Java 虚拟机(JVM)指定对象的类型并且运行该对象的方法。因此在上面的例子中，之所以能编译成功，是因为 Animal 类中存在 move 方法，然而运行时，运行的是特定对象的方法。

【拓展】多态的底层原理？

重载编译时多态和重写运行时多态的解释：link，link1，link2，link3

【拓展】Java中重载和重写的规则？

方法的重载规则

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。

方法的重写规则

• 参数列表必须完全与被重写方法的相同。

• 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。

父类返回值可能是复杂类型，如返回的是class A，那么重写返回值类型就要是class A或者是class A的子类

• 子类访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。

• 父类的成员方法只能被它的子类重写。

• 声明为 final 的方法不能被重写。

• 声明为 static 的方法不能被重写，但是能够被再次声明。

• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

• 构造方法不能被重写。

• 如果不能继承一个方法，则不能重写这个方法。

为什么Java中子类重写方法的访问权限不能低于父类中权限? link

该问题依赖于里氏代换原则, 先记录下该原则的原理，里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。

重载重写规则对比

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

• (1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
• (2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
• (3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

5. Java 中的访问修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

• public（公开） :任何位置都可见。使用对象：类、接口、变量、方法
• protected（受保护） : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
• default(默认） : 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
• private（私有） : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y（说明）	N
default	Y	Y	Y	N	N
private	Y	N	N	N	N

link

6. Java的8种基本类型与封装类？

整数类型：字节型（byte/8位）、短整型（short/16位）、整型（int/32位）、长整型（long/64位）

浮点类型：单精度型（float/32位）和双精度类型（double/64位）

字符类型：字符类型（char/16位）

布尔类型：布尔类型（boolean/1位），常量只有“真（true）”和“假（false）”这两个状态

一个字节为8位

---

Java中的封装类：

8种基本类型按照类型划分：byte，short，int，long，float，double，boolean，char。

8种基本类型的封装类：Byte,Short,Integer,Long,Float,Double,Boolean,Character.

• boolean类型占了单独使用是4个字节，在数组中又是1个字节
• 基本类型所占的存储空间是不变的。这种不变性也是Java具有可移植性的原因之一。
• 基本类型放在栈中，直接存储值。
• 所有数值类型都有正负号，没有无符号的数值类型。

为什么需要封装类？
因为泛型类包括预定义的集合，使用的参数都是对象类型，无法直接使用基本数据类型，所以Java又提供了这些基本类型的封装类。

基本类型和对应的封装类由于本质的不同。具有一些区别：
1.基本类型只能按值传递，而封装类按引用传递。
2.基本类型会在栈中创建，而对于对象类型，对象在堆中创建，对象的引用在栈中创建，基本类型由于在栈中，效率会比较高，但是可能存在内存泄漏的问题

包装类的缓存：

Boolean：全部缓存

Byte：全部缓存

Character：<= 127 缓存

Short：-128 — 127 缓存

Long：-128 — 127 缓存

Integer：-128 — 127 缓存

Float：没有缓存

Doulbe：没有缓存

自动装箱与自动拆箱：link

7. Java中“==”和equals的区别？

1. ==是基本运算符，可以对基本类型进行比较，比较的是对象的引用是否指向同一块内存地址。
2. equals()是一个方法，它不可以可以对基本类型进行比较。见源码1，equals()默认的方法中也使用了==，比较的也是对象的地址。见源码2，只不过equals()是一个方法可以对其进行重写，像String、Date、Math、File、包装类等大部分类都重写了Object的equals()方法。重写后的equals()将每个值取出依次对比其内存地址，也可以把它理解为比较整体值是否相等。

重写hashCode遵循的五个条件

在改写equals方法时，也要遵守他们的通用约定（equals方法实现了等价关系）：

​ \1. 自反性：x.equals(x) = true;

​ \2. 对称性：如果有x.equals(y) = true,那么一定有y.equals(x) = true;

​ \3. 传递性：对任意的x,y,z。如果有x.equals(y) = y.equals(z) = true,那么一定有x.equals(z)= true;

​ \4. 一致性：无论多少次调用，x.equals(y)总会返回相同的结果。

​ \5. 非空性（暂定）：所有的对象都必须！=null;

上面的只是理论性的说法，更加具体的做法如下：

​ \1. 使用==操作符检查“实参是否为指向对象的一个引用”，如果是则返回true；

​ \2. 使用instanceof操作符检查“实参是否为正确的类型”，如果不是，则返回false;

​ \3. 将实参装换为正确的类型；

​ \4. 对于该类中的每一个关键域，检查实参中的域与当前对象中对应的域是否匹配。如果所有测试都成功，则返回true，否则返回false。

​ \5. 方法完成之后，确定equals方法的对称性，传递性，一致性。

如何使用？

在java虚拟机中，基本类型存储在方法区中的常量池中，同属性同地址，用==即可。但是对于new出来的对象它们存储在堆中，==仅能比较其地址首相等。无法比较真正意义上的相等，用重写的equals方法即可。

public boolean equals(Object obj) {
     
    return (this == obj);
}

源码2. String类源码中重写的equals方法如下：

public boolean equals(Object anObject) {
     
// 1. 检查是否为同一个对象的引用，如果是直接返回 true；
        if (this == anObject) {
     
            return true;
        }
/*2.判断anObject是否为String类的实例，如果不是直接返回false，如果是则取值比较大小。
注：instanceof 测试一个对象是否为一个类的实例
 **/
        if (anObject instanceof String) {
     
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
     
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
     
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

为什么会出现以下现象？

        //1. 比较基本类型
        int m=1;
        int n=1;
        // System.out.println(m.equals(n)); // 报错
        System.out.println(m == n);  // true
        //System.out.println(m.hashCode());  // 报错
        //System.out.println(n.hashcode());  // 报错

        //2. 比较new出来的封装类型
        Integer x = new Integer(1);
        Integer y = new Integer(1);
        System.out.println(x.equals(y)); // true
        System.out.println(x == y);      // false

        //3. 比较非new封装类型 [-128, 127] 
        Integer x1 = 127;
        Integer y1 = 127;
        System.out.println(x1.equals(y1)); // true
        System.out.println(x1 == y1);      // true

        //4. 比较非new封装类型非[-128, 127] 
        Integer x2 = 128;
        Integer y2 = 128;
        System.out.println(x2.equals(y2)); // true
        System.out.println(x2 == y2);      // false
        
       //5. 比较非new字符串
        String s1="abc";
        String s2="abc";
        System.out.println(s1==s2);  // true
        System.out.println(s1.equals(s2));  // true

        //6. 比较new字符串
        String str1 = new String("hello");
        String str2 = new String("hello");
        System.out.println(str1.equals(str2)); //true
        System.out.println(str1==str2); //false

1. 比较基本类型
对于基本数据类型（byte，short，char，int，float，double，long，boolean）来说，他们是作为常量在方法区中的常量池里面以HashSet策略（HashSet中不允许有重复的元素）存储起来的。因此在常量池，一个常量只会对应一个地址。所以不管是再多的 1，其内存地址都为同一个。
2. 比较new出来的封装类型
new String(“hello”)会在堆内存中创建一个实例，开辟新的内存空间，故==为falsie。但是源码2中，String类源码中重写了equals方法，对单个值的进行比较。
3. 比较非new封装类型 [-128, 127]
4. 比较非new封装类型非[-128, 127]
对于两个非 new 生成的 Integer 对象进行比较时，如果两个变量的值在区间 [-128, 127] 之间，则比较结果为 true，否则为 false。Java 在编译 Integer i = 100 时，会编译成 Integer i = Integer.valueOf(100)，而 Integer 类型的 valueOf 的源码如下所示：

public static Integer valueOf(int var0) {
         
       return var0 >= -128 && var0 <= Integer.IntegerCache.high ? Integer.IntegerCache.cache[var0 + 128] : new Integer(var0);
}

从上面的代码中可以看出：Java 对于 [-128, 127] 之间的数会进行缓存，比如：Integer i = 127，会将 127 进行缓存，下次再写 Integer j = 127 的时候，就会直接从缓存中取出，而对于这个区间之外的数就需要 new 了。
5. 比较字符串
在Java执行时会维护一个String池（pool），对于一些可以共享的字符串对象，会先在String池中查找是否存在相同的String内容（字符相同），如果有就直接返回，不创建新对象。
6. 比较非new字符串常量
new String(“hello”)会在堆内存中创建一个实例，开辟新的内存空间，故==为falsie。但是，String类源码中重写了equals方法，对单个值的进行比较。

8. 为什么重写equals一定要重写hashcode？

link1，link2，link3，link4，link5，link6

主要是为了提升哈希表的性能。因为HashMap 集合类使用了 hashCode() 方法来计算对象在哈希表中应该存储的位置，如果不重写hashcode值一样的对象。因为new出来的对象即使值相同，存储地址必不相同。不重写 hashCode会导致为值相同的对象分别了两个存储空间，导致了空间浪费。因此要重写。

以下是关于hashcode的一些性质：

两个对象相等，hashcode一定相等

两个对象不等，hashcode不一定不等

hashcode相等，两个对象不一定相等

hashcode不等，两个对象一定不等

9. Java中抽象类和接口的区别？

link
从设计层面上看，抽象类提供了一种 IS-A 关系，需要满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。接口反应能力，抽象类提供默认实现，方便子类实现接口。

（1）抽象类中可以定义构造函数，接口不能定义构造函数；

（2）接口可以被看作是抽象类的变体，接口中所有的方法都是抽象的（Java 1.8中可以定义default方法体）。

（3）从使用上来看，一个类可以实现多个接口，但是不能继承多个抽象类。

（4）接口的字段只能是 static 和 final 类型的，而抽象类的字段没有这种限制。

（5）接口的成员只能是 public 的，而抽象类的成员除了不能被private修饰，可以有多种访问权限。

共同点：抽象类和接口都不能被实例化

什么是抽象类？什么是抽象方法？

抽象类：抽象类就是不能使用new方法进行实例化的类，即没有具体实例对象的类，抽象类有点类似于“模板”的作用,目的是根据其格式来创建和修改新的类，对象不能由抽象类直接创建，只可以通过抽象类派生出新的子类，再由其子类来创建对象，当一个类被声明为抽象类时，要在这个类前面加上修饰符abstract,在抽象类中的成员方法可以包括一般方法和抽象方法

抽象方法：抽象方法就是以abstract修饰的方法，这种方法只声明返回的数据类型，方法名称和所需要的参数，没有方法体，也就是说抽象方法只需要声明而不需要事先，当一个方法为抽象方法时，意味着这个方法必须被子类的方法所重写，否则其子类的该方法仍然是abstract的，而这个子类也必须是抽象的，即声明为abstract。

原文链接：https://blog.csdn.net/dulijie/article/details/88256415

构造函数 ，是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数 ，可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载。

为什么接口中的成员变量非得是public static final的呢？

首先明白一个原理，就是接口的存在意义。接口就是为了实现多继承的抽象类，是一种高度抽象的模板、标准或者说协议。规定了什么东西该是这样，如果你继承了我这接口，就必须这样。比如USB接口，就是小方口，两根电源线和两根数据线，不能多不能少。

public: 使接口的实现类可以使用这个常量
static：static修饰就表示它属于类的，随的类的加载而存在的，如果是非static的话，就表示属于对象的，只有建立对象时才有它，而接口是不能建立对象的，所以接口的常量必须定义为static。
final：final修饰就是保证接口定义的常量不能被实现类去修改，如果没有final的话，
由子类随意去修改的话，接口建立这个常量就没有意义了。

https://blog.csdn.net/u013682953/article/details/73699796

https://blog.csdn.net/piyongduo3393/article/details/85225294

10. final finally finalize 区别及用法?

(https://www.cnblogs.com/wisefulman/p/10584515.html)

final：可以用来修饰类、方法、变量，分别有不同的意义，final修饰的class代表不可以继承扩展，final的变量是不可以修改的，而final的方法也是不可以重写的（override）。

finally：则是Java保证重点代码一定要被执行的一种机制。我们可以使用try-finally或者try-catch-finally来进行类似关闭JDBC连接、保证unlock锁等动作。

finalize：是基础类java.lang.Object的一个方法，它的设计目的是保证对象在被垃圾收集前完成特定资源的回收。允许使用finalize（）方法在垃圾收集器将对象从内存中清楚出去之前做必要的清理工作。finalize机制现在已经不推荐使用，并且在JDK 9开始被标记为deprecated。
链接：https://www.jianshu.com/p/afaf54b9632e

**final实现原理：**https://www.cnblogs.com/hexinwei1/p/10025840.html

对于final域，编译器和处理器要遵守两个重排序规则：

1.在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序。（先写入final变量，后调用该对象引用）

**原因：**编译器会在final域的写之后，插入一个StoreStore屏障

2.初次读一个包含final域的对象的引用，与随后初次读这个final域，这两个操作之间不能重排序（先读对象的引用，后读final变量）

**原因：**编译器会在读final域操作的前面插入一个LoadLoad屏障

11. this和super的区别

https://www.cnblogs.com/newbie27/p/10437587.html

https://blog.csdn.net/lncsdn_123/article/details/79025525

this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针；

super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。

13 泛型

https://segmentfault.com/a/1190000014120746

泛型：把类型明确的工作推迟到创建对象或调用方法之后，简单来说，你有一个类，在使用时内部类型暂不确定，给使用给一个占位符给代替，在使用的时候可以给确定其定义的类型。例如HashMap等集合类中就用到了泛型：

ArrayList<String> stringValues=new ArrayList<String>();

有了泛型以后：

• 代码更加简洁【不用强制转换】
• 程序更加健壮【只要编译时期没有警告，那么运行时期就不会出现ClassCastException异常】
• 可读性和稳定性【在编写集合的时候，就限定了类型】

https://www.jianshu.com/p/2bfbe041e6b7

泛型底层如何实现？Java的泛型是使用类型擦除来实现的，意味着当你在使用泛型时，任何具体的类型信息都被擦除了，你唯一知道的就是你在使用一个对象。

泛型用于编译阶段，编译后的字节码文件不包含泛型类型信息，因为虚拟机没有泛型类型对象，所有对象都属于普通类。例如定义 List