前言

本专题系列文章仅用于个人学习总结,从零开始逐步到常见服务框架。觉得基础的大佬可以提前离开。本专栏工作之余抽空更新面试题...
ps: CSDN地址 https://blog.csdn.net/evelynnJava/article/details/116063246?spm=1001.2014.3001.5501

java基础

1.什么是面向对象?

面向对象是更注重事情有哪些参与者（对象）、及各自需要做什么。(面向过程更注重事情的每一个步骤及顺序) 其四大特征如下：

封装：封装的意义，在于明确标识出允许外部使用的所有成员函数和数据项（内部细节对外部调用透明，外部调用无需修改或者关心内部实现）
继承: 继承基类（父类）的方法，并做出自己的改变和/或扩展（子类共性的方法或者属性直接使用父类的，而不需要自己再定义，只需扩展自己个性化的）
多态: 基于对象所属类的不同，外部对同一个方法的调用，实际执行的逻辑不同。（继承和接口可以实现多态）
抽象: 抽取关键相关特性（属性和方法）构成对象，用程序的方法逻辑和数据结构属性模拟现实的世界对象。（所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。）

2.JDK JRE JVM

JDK：Java Develpment Kit java 开发工具（程序员所需的各开发工具，包含 JRE JVM等）
JRE：Java Runtime Environment java运行时环境（运行java程序）
JVM：java Virtual Machine java 虚拟机（编译，解释.class文件，操作系统才能够执行）

在这里插入图片描述

3.==和equals比较

== : 对比的是栈中的值，基本数据类型是变量值，引用类型是堆中内存对象的地址

equals: Object中默认也是采用==比较（通常开发者要自己重写，改为比较属性内容）

ps: 初学者可能没注意到这点，平时使用String比的也是内容，根本没有去重写它呀。实际上String类中，已经帮我们重写了equals方法。

下面我们来看一个例子：


/**

* @author wook

* @date 2021/4/23 21:35

*/

public class WookTest {

    private Integer id;

    private String name;

    public WookTest(Integer id,String name){

        this.id = id;

        this.name = name;

    }

    public static void main(String[] args) {

        WookTest wook = new WookTest(1, "wook");

        WookTest wook2 = new WookTest(1, "wook");

        System.out.println(wook.equals(wook2));

    }

}

根据开头的概念，所有类都继承Object，而Object的equals采用==比较内存地址，所以此处结果为：false 。那如果想让结果返回：true 呢？


  @Override

  public boolean equals(Object o) {

      if (this == o) return true;

      if (o == null || getClass() != o.getClass()) return false;

      WookTest wookTest = (WookTest) o;

      return Objects.equals(id, wookTest.id) &&

              Objects.equals(name, wookTest.name);

    }

只需要在WookTest中重写equals即可（快捷键 ctrl + insert，选择equals...）。

ps: 细心的同学肯定发现了，equals和hashCode一般是成对出现的，equals搞明白了，那hashCode是干什么的呢？别着急，后面的文章会讲到。(着急请翻到第9点=。=）

4.为什么局部内部类和匿名内部类只能访问局部final变量？

首先回顾下 final修饰基本类型数据和引用类型数据的情况

如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；
如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。但是引用的值是可变的。


  public static void main() {

        final int[] iArr = {1, 2, 3, 4};

        iArr[2] = -3;//合法

        iArr = null;//非法，对iArr不能重新赋值(不能重新指向）

        final Person p = new Person(25);

        p.setAge(24);//合法

        p = null;//非法

    }

回到正题为什么局部内部类和匿名内部类只能访问局部final变量？


/**

* @author wook

* @date 2021/4/23 22:35

*/

public class Test {

    //局部final变量a,b

    //jdk8在此处做了优化(语法糖),可不写final,但实际上也是有的，参数a,b在内部类中不能修改

    public void test(final int b) {

        final int a = 10;

        //匿名内部类

        new Thread() {

            public void run() {

                System.out.println(a);

                System.out.println(b);

            }

        }.start();

    }

}

class OutClass {

    private int age = 12;

    public void outPrint(final int x) {

        //局部内部类

        class InClass {

            public void InPrint() {

                System.out.println(x);

                System.out.println(age);

            }

        }

        new InClass().InPrint();

    }

}

ps:程序编译后的文件共有4个（内部类生成的class为原类名+$1...2...3）

Test.class 、 Test$1.class
ps: 再有匿名内部类则为 Test$2.class)
OutClass.class 、 OutClass$1InClass.class
ps: 再有局部内部类则为 OutClass$1其他内部类名

首先需要知道的一点: 内部类和外部类是处于同一个级别的，内部类不会因为定义在方法中就会随着方法的执行完毕就被销毁（例如开了线程跑匿名内部类）。

这里就会产生问题：

当外部类的方法结束时，局部变量（a）就会被销毁了，但是内部类对象可能还存在(只有没有人再引用它时，才会死亡)。这里就出现了一个矛盾：内部类对象访问了一个不存在的变量。为了解决这个问题，就将局部变量复制了一份作为内部类的成员变量，这样当局部变量死亡后，内部类仍可以访问它，实际访问的是局部变量的"copy"。这样就好像延长了局部变量的生命周期。
将局部变量复制为内部类的成员变量时，必须保证这两个变量是一样的，也就是如果我们在内部类中修改了成员变量，方法中的局部变量也得跟着改变，怎么解决问题呢？
就将局部变量设置为final，对它初始化后，我就不让你再去修改这个变量，就保证了内部类的成员变量和方法的局部变量的一致性。这实际上也是一种妥协。使得局部变量与内部类内建立的拷贝保持一致。

答：因为内部类复制了一份作为内部类的成员变量，为保证复制的与原先的值一致，只能妥协，使用final修饰，不让别人修改。

5.String、StringBuffer、StringBuilder

String是final修饰的，不可变，每次操作都会产生新的String对象
StringBuffer和StringBuilder都是在原对象上操作
StringBuffer是线程安全的(方法都是synchronized修饰的)
StringBuilder线程不安全的

性能： StringBuilder > StringBuffer > String

场景： 经常需要改变字符串内容时使用后面两个优先使用StringBuilder，多线程使用共享变量时使用StringBuffer。

6.重载和重写的区别

重载： 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。

重写： 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private则子类就不能重写该方法。


public int add(int a,String b)

//编译报错（非重载）

public String add(int a,String b)

7.接口和抽象类的区别

抽象类可以存在普通成员函数，而接口中只能存在public abstract 方法。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的。
抽象类只能继承一个，接口可以实现多个。

详细说明：（赶时间知道上面三点即可）

接口的设计目的，是对类的行为进行约束（更准确的说是一种“有”约束，因为接口不能规定类不可以有什么行为），也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，但不对如何实现行为进行限制。

抽象类的设计目的，是代码复用。当不同的类具有某些相同的行为(记为行为集合A)，且其中一部分行为的实现方式一致时（A的真子集，记为B），可以让这些类都派生于一个抽象类。在这个抽象类中实现了B，避免让所有的子类来实现B，这就达到了代码复用的目的。而A减B的部分，留给各个子类自己实现。正是因为A-B在这里没有实现，所以抽象类不允许实例化出来（否则当调用到A-B时，无法执行）。

ps: 真子集就是一个集合中的元素全部是另一个集合中的元素。

解释一下抽象类的话：

①A类和B类都有action()方法，但实现不同
②A类和B类都有fun()方法，且实现相同
③可将A类和B类的fun()方法提取到抽象类C，A和B去继承C
④而action则作为C类的抽象方法，由A和B去重写

总结：

抽象类是对类本质的抽象，表达的是 is a 的关系，比如：宝马是一辆车。抽象类包含并实现子类的通用特性，将子类存在差异化的特性进行抽象，交由子类去实现。

而接口是对行为的抽象，表达的是 like a 的关系。比如：鸟像飞行器一样可以飞，但其本质上 is a Bird 。接口的核心是定义行为，即实现类可以做什么，至于实现类主体是谁、是如何实现的，接口并不关心。

使用场景： 当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。

ps:抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度。（Java 8 接口default method不讨论）

8.List 和 Set的区别

List：有序，按对象进入的顺序保存对象，可重复，允许多个Null元素对象，可以使用Iterator取出所有元素，在逐一遍历，还可以使用get(int index)获取指定下标的元素
Set：无序，不可重复，最多允许有一个Null元素对象，取元素时只能用Iterator接口取得所有元素，在逐一遍历各个元素 （没有get方法）

9.hashCode与equals

hashCode介绍：

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，Java中的任何类都包含有hashCode() 函数。

散列表存储的是键值对(key-value)，它的特点是：能根据“键(索引）”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

ps: hashCode方法的主要作用是为了配合基于散列的集合一起正常运行，这样的散列集合包括HashSet、HashMap以及HashTable。

以“HashSet如何检查重复”为例子来说明为什么要有hashCode：

对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，看该位置是否有值，如果没有、HashSet会认为对象没有重复出现。但是如果发现有值（hash冲突了），这时会调用equals（）方法来检查两个对象是否真的相同。如果两者相同，HashSet就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样就大大减少了equals的次数（equals性能较差），相应就大大提高了执行速度。

如果两个对象相等，则hashcode一定也是相同的
两个对象相等,对两个对象分别调用equals方法都返回true
两个对象有相同的hashcode值，它们也不一定是相等的
equals方法被覆盖过，则hashCode方法也必须被覆盖
hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据（内容））

理论明白了，下面通过代码来说明：

ps：代码参照海子大佬 https://www.cnblogs.com/dolphin0520/p/3681042.html


import java.util.HashMap;

import java.util.HashSet;

import java.util.Set;

class People{

    private String name;

    private int age;

    public People(String name,int age) {

        this.name = name;

        this.age = age;

    } 

    public void setAge(int age){

        this.age = age;

    }

    @Override

    public boolean equals(Object obj) {

        // TODO Auto-generated method stub

        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;

    }

}

public class Main {

    public static void main(String[] args) {

        People p1 = new People("Jack", 12);

        System.out.println(p1.hashCode());

        HashMap hashMap = new HashMap();

        hashMap.put(p1, 1);

        System.out.println(hashMap.get(new People("Jack", 12)));

    }

}

这里我只重写了equals方法，也就说如果两个People对象，如果它的姓名和年龄相等，则认为是同一个人。

这段代码本来的意愿是想这段代码输出结果为“1”，但是事实上它输出的是“null”。为什么呢？原因就在于重写equals方法的同时忘记重写hashCode方法。

虽然通过重写equals方法使得逻辑上姓名和年龄相同的两个对象被判定为相等的对象（跟String类类似），但是要知道默认情况下，hashCode方法是将对象的存储地址进行映射。那么上述代码的输出结果为“null”就不足为奇了。原因很简单，p1指向的对象和System.out.println(hashMap.get(new People(“Jack”, 12)));这句中的new People(“Jack”, 12)生成的是两个对象，它们的存储地址肯定不同。下面是HashMap的get方法的具体实现：

所以在hashmap进行get操作时，因为得到的hashcdoe值不同（注意，上述代码也许在某些情况下会得到相同的hashcode值，不过这种概率比较小，因为虽然两个对象的存储地址不同也有可能得到相同的hashcode值），所以导致在get方法中for循环不会执行，直接返回null。

因此如果想上述代码输出结果为“1”，很简单，只需要重写hashCode方法，让equals方法和hashCode方法始终在逻辑上保持一致性。


import java.util.HashMap;

import java.util.HashSet;

import java.util.Set;

class People{

    private String name;

    private int age;

    public People(String name,int age) {

        this.name = name;

        this.age = age;

    } 

    public void setAge(int age){

        this.age = age;

    }

    @Override

    public int hashCode() {

        // TODO Auto-generated method stub

        return name.hashCode()*37+age;

    }

    @Override

    public boolean equals(Object obj) {

        // TODO Auto-generated method stub

        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;

    }

}

public class Main {

    public static void main(String[] args) {

        People p1 = new People("Jack", 12);

        System.out.println(p1.hashCode());

        HashMap hashMap = new HashMap();

        hashMap.put(p1, 1);

        System.out.println(hashMap.get(new People("Jack", 12)));

    }

}

这样一来的话，输出结果就为“1”了。

“设计hashCode()时最重要的因素就是：无论何时，对同一个对象调用hashCode()都应该产生同样的值。如果在讲一个对象用put()添加进HashMap时产生一个hashCdoe值，而用get()取出时却产生了另一个hashCode值，那么就无法获取该对象了。所以如果你的hashCode方法依赖于对象中易变的数据，用户就要当心了，因为此数据发生变化时，hashCode()方法就会生成一个不同的散列码”。


import java.util.HashMap;

import java.util.HashSet;

import java.util.Set;

class People{

    private String name;

    private int age;

    public People(String name,int age) {

        this.name = name;

        this.age = age;

    } 

    public void setAge(int age){

        this.age = age;

    }

    @Override

    public int hashCode() {

        // TODO Auto-generated method stub

        return name.hashCode()*37+age;

    }

    @Override

    public boolean equals(Object obj) {

        // TODO Auto-generated method stub

        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;

    }

}

public class Main {

    public static void main(String[] args) {

        People p1 = new People("Jack", 12);

        System.out.println(p1.hashCode());

        HashMap hashMap = new HashMap();

        hashMap.put(p1, 1);

        p1.setAge(13);

        System.out.println(hashMap.get(p1));

    }

}

这段代码输出的结果为“null”，想必其中的原因大家应该都清楚了。

因此，在设计hashCode方法和equals方法的时候，如果对象中的数据易变，则最好在equals方法和hashCode方法中不要依赖于该字段。

从零开始的java面试题（2021 java基础篇）