JAVA 面试题

摘自
https://www.cnblogs.com/huangjialin/p/12411842.html
https://www.runoob.com/java/java-encapsulation.html

(一)、java基础面试题整合

（1）什么是面向对象

 其本质是以建立模型体现出来的抽象思维过程和面向对象的方法,是一种编程思维，也是一种思考问题的方式。面向对象的三大特性：封装，继承，多态。

（2）==与equles和hashCode的区别

 ==
 比较基本数据类型，比较存储的“值”是否相等
 比较引用数据类型，比较的是对象的地址值
 equles
 equles 不能作用与基本数据类型
 比较两个对象的引用是否相等，即是否指向同一个对象
 如果没有对equles进行重写，则比较的是引用类型所指的地址，反之比较就是对象内容
 hashCode
 用来鉴定两个对象是否相等，Object类中的hashCode方法返回对象在内存中地址转换成的一个int值，所以如果没有重写hashCode方法，任何对象的hashCode方法是不相等的。
 如果重写了equals方法就必须要重写hashCode方法，以便用户将对象插入到散列表中。
 equals相等的两个对象，hashCode一定相等，equals不相等的两个对象，却并不能证明他们的hashCode不相等。
 equals方法不相等的两个对象，hashCode有可能相等。
 在每个覆盖了equals方法的类中，也必须覆盖hashCode方法，如果不这样做的话，就会违反Object.hashCode的通用约定。从而导致该类无法结合所有基于散列的集合一起正常运作。

（3）数据类型

 数据类型：

•  基本数据类型：
•  引用数据类型：

  扩展知识点：
  所谓的占用字节数 就是申请内存的时候所占的空间大小
  bit：
  字节（byte）：
  基本数据类型：

基本数据类型
  英文字母：
  字节数 : 1;编码：GB2312
  字节数 : 1;编码：GBK
  字节数 : 1;编码：ISO-8859-1
  字节数 : 1;编码：UTF-8

  中文汉字：
  字节数 : 2;编码：GB2312
  字节数 : 2;编码：GBK
  字节数 : 1;编码：ISO-8859-1
  字节数 : 3;编码：UTF-8

public class MainActivity extends AppCompatActivity {
    private byte aByte;
    private short aShort;
    private int aInt;
    private long aLong;
    private float aFloat;
    private double aDouble;
    private char aChar;
    private String a = "A";
    private String b = "字";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.i("tag", "byte 默认值"+aByte);
        Log.i("tag", "short 默认值"+aShort);
        Log.i("tag", "int 默认值"+aInt);
        Log.i("tag", "long 默认值"+aLong);
        Log.i("tag", "float 默认值"+aFloat);
        Log.i("tag", "double 默认值"+aDouble);
        Log.i("tag", "char 默认值"+aChar);
        Log.i("tag", "byte 默认值"+a.getBytes().length);
        Log.i("tag", "byte 默认值"+b.getBytes().length);
    }
}

2020-10-12 08:15:16.010 3509-3509/com.example.shortvideo I/tag: byte 默认值0
2020-10-12 08:15:16.010 3509-3509/com.example.shortvideo I/tag: short 默认值0
2020-10-12 08:15:16.010 3509-3509/com.example.shortvideo I/tag: int 默认值0
2020-10-12 08:15:16.010 3509-3509/com.example.shortvideo I/tag: long 默认值0
2020-10-12 08:15:16.010 3509-3509/com.example.shortvideo I/tag: float 默认值0.0
2020-10-12 08:15:16.010 3509-3509/com.example.shortvideo I/tag: double 默认值0.0
2020-10-12 08:15:16.010 3509-3509/com.example.shortvideo I/tag: char 默认值��
2020-10-12 08:15:16.010 3509-3509/com.example.shortvideo I/tag: byte 默认值1
2020-10-12 08:15:16.010 3509-3509/com.example.shortvideo I/tag: byte 默认值3

  引用数据类型：

引用数据类型

（4）int 和 integer 的区别

•  int 是常量，默认值为0，不能为null。
•  integer 是对象，是 int 的包装类，默认值为null。
   int a = 0; Integer b = 0; Integer c = new Integer(0);  (a==b&&a==c)→true

（5）浅谈面向对象的三大特性

  封装：
  是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。
  优点：
   ● 良好的封装能够减少耦合。
   ● 类内部的结构可以自由修改。
   ● 可以对成员变量进行更精确的控制。
   ● 4. 隐藏信息，实现细节。
  实现Java封装的步骤：
   1.修改属性的可见性来限制对属性的访问（一般限制为private），例如：

public class Person {
    private String name;
    private int age;
}

   2.对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

public class Person{
    private String name;
    private int age;
​
    public int getAge(){
      return age;
    }
​
    public String getName(){
      return name;
    }
​
    public void setAge(int age){
      this.age = age;
    }
​
    public void setName(String name){
      this.name = name;
    }
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。
public方法是外部类访问该类成员变量的入口，通常情况下，这些方法被称为getter和setter方法。

  继承：
  继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承关系图
  兔子和羊属于食草动物类，狮子和豹属于食肉动物类。
  食草动物和食肉动物又是属于动物类。
  所以继承需要符合的关系是：is-a，父类更通用，子类更具体。（is-a 指的是类的父子继承关系）
  虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。
  继承格式：在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

class 父类 {
}
class 子类 extends 父类 {
}

  为什么要继承呢？
  看代码就知道了

企鹅类
public class Penguin { 
    private String name; 
    private int id; 
    public Penguin(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

老鼠类
public class Mouse { 
    private String name; 
    private int id; 
    public Mouse(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

从这两段代码可以看出来，代码存在重复了，导致后果就是代码量大且臃肿，而且维护性不高(维护性主要是后期需要修改的时候，就需要修改很多的代码，容易出错)，所以要从根本上解决这两段代码的问题，就需要继承，将两段代码中相同的部分提取出来组成 一个父类：

public class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

这个Animal类就可以作为一个父类，然后企鹅类和老鼠类继承这个类之后，就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码） 继承之后的代码：

public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}

public class Mouse extends Animal { 
    public Mouse(String myName, int myid) { 
        super(myName, myid); 
    } 
}

  优点：
   ● 提高代码的复用性。
   ● 提高代码的维护。
   ● 类与类之间发生关系是多态的前提（继承是多态的前提）。

  继承类型：需要注意的是 Java 不支持多继承，但支持多重继承。

继承类型图

  继承特性：
   ● 子类拥有父类非 private 的属性、方法。
   ● 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
   ● 子类可以用自己的方式实现父类的方法。
   ● Java 的继承是单继承，但是可以多重继承。
   ● 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

  继承关键字：
  继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

  extends关键字：在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

  implements关键字：使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

  super 与 this 关键字：

  super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
  this关键字：指向自己的引用。

public class Animal {
    void eat() {
        Log.i("tag", "animal : eat");
    }
}

public class Dog extends Animal{
    void eat() {
        Log.i("tag", "dog : eat");
    }
    void eatTest() {
        this.eat();   // this 调用自己的方法
        super.eat();  // super 调用父类方法
    }
}

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        new Animal().eat();
        new Dog().eat();
        new Dog().eatTest();
    }
}

2020-10-12 10:17:04.653 3669-3669/com.example.shortvideo I/tag: animal : eat
2020-10-12 10:17:04.653 3669-3669/com.example.shortvideo I/tag: dog : eat
2020-10-12 10:17:04.653 3669-3669/com.example.shortvideo I/tag: dog : eat
2020-10-12 10:17:04.653 3669-3669/com.example.shortvideo I/tag: animal : eat

  final关键字：final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

声明类：
final class 类名 {//类体}

声明方法：
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final

  多态：（其实就是为了解决类与类继承所带来的耦合性）
  Java实现多态有三个必要条件：继承、重写、向上转型。
  多态是同一个行为具有多个不同表现形式或形态的能力。
  多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

image.png
  多态性
  是对象多种表现形式的体现。
  优点：
    1. 消除类型之间的耦合关系
    2. 可替换性
    3. 可扩充性
    4. 接口性
    5. 灵活性
    6. 简化性

  多态的好处：
    可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

  多态存在三个必要条件：
    继承
    重写
    父类引用指向子类对象（ Animal = new Dog(); ）

（6）抽象类

  在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
  抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
  由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
  父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
  在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

  抽象类总结规定
    1.抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
    2.抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
    3.抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
    4.构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
    5.抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

（7）接口

  在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
  接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
  除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
  接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

  接口与类的区别：
  1.接口不能用于实例化对象。
  2.接口没有构造方法。
  3.接口中所有的方法必须是抽象方法。
  4.接口不能包含成员变量，除了 static 和 final 变量。
  5.接口不是被类继承了，而是要被类实现。
  6.接口支持多继承。

  抽象类和接口的区别：
  1.抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
  2.抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
  3.接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
  4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

（8）String、StringBuffer、StringBuilder区别

  https://blog.csdn.net/itchuxuezhe_yang/article/details/89966303
  String：不可变字符序列，初始化可以null，操作少量数据用String。
  StringBuffer：可变字符序列，效率低，线程安全，初始化不可以null，多线程操作大量数据用StringBuffer。
  StringBuilder：可变字符序列，效率高，线程不安全，初始化不可以null，单线程操作大量数据用StringBuilder。

（9）父类的静态方法能否被子类重写

  https://www.jianshu.com/p/15e21428d884
  不能，父类的静态方法能够被子类继承，但是不能够被子类重写，即使子类中的静态方法与父类中的静态方法完全一样，也是两个完全不同的方法。

（10）进程和线程的区别

  https://blog.csdn.net/ThinkWon/article/details/102021274
  本质区别：进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位
  资源开销：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。
  包含关系：如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。
  内存分配：同一进程的线程共享本进程的地址空间和资源，而进程之间的地址空间和资源是相互独立的
  影响关系：一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。
  执行过程：每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行

（11）final，finally，finalize的区别

  final：修饰符
  1. final 修饰的类不能被继承、修饰的变量不能被改变、修饰的方法不能重写，能使用。
  final：异常处理机制的一部分
  1. finally 结构使代码总会执行，而不管是否有异常。
  2. 使用 finally 常用于释放资源。

try {
    System.out.println();
} catch (Exception e) {
    e.printStackTrace();
} finally {
    //释放资源
}

  finalize：Java中垃圾回收器执行的方法
  1. 属于java.lang.Object类的一个函数
  2. 在垃圾收集器执行的时候会调用的此方法，进行对象的回收，但在调用垃圾回收gc()后，并不能立即执行回收，JVM根据算法定时执行。

（12）序列化的方式以及区别

  https://blog.csdn.net/chun_long/article/details/79539917
  序列化：序列化就是将对象或者数据结构转化成特定的格式，使其可在网络中传输，或者可存储在内存或者文件中
  反序列化：反序列化则是相反的操作，将对象从序列化数据中还原出来

  为什么需要序列化？
   Android开发的时候，不能直接将对象的引用传给Activity/Fragment，需要将这些对象放到一个Intent或者Bundle里面，然后再传递（直接放进去是不行的，序列化之后在传）。
   1. 永久性保存对象，保存对象的字节序列到本地文件中
   2. 通过序列化对象在网络中传递对象
   3. 通过序列化在进程间传递对象

   序列化方式： Serializable 和 Parcelable
   1. Serializable ：
   Serializable 是Java自带的实现序列化的方式，实现Serializable接口的对象，会被转化为流数据的形式，在进程间/网络/本地磁盘传递和存储。
   2. Parcelable：
   Parcelable 是Android独有的实现序列化的方式，Parcelable 接口的对象则是通过将一个完整的对象进行分解，分解后的每一部分都是Intent所支持的数据类型。

   Serializable 和 Parcelable区别：
   ● Serializable 代码量少 ，只需时间接口即可，Parcelable的话重写两个函数。
   ● Serializable代码执行速度比Parcelable慢
   ● Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。

（13）Java注解的理解

   https://blog.csdn.net/zhenliangit0918/article/details/81427994
  常见的有方法重写@Override 与重载的时候见到...

（14）哪些情况下的对象会被垃圾回收机制处理掉？

  https://cloud.tencent.com/developer/article/1332790
  GC要回收内存，怎么判断哪些对象可回收，哪些不可回收？
   1. 引用算法（标记计数法）
   给内存中的对象给打上标记，对象被引用一次，计数就加1，引用被释放了，计数就减一，当这个计数为0的时候，这个对象就可以被回收了。缺点就是循环引用的对象是无法被识别出来并且被回收的。因此GC会调用可达性分析算法。
   2. 可达性分析算法
   虚拟机会先将一些对象定义为GC Roots，从GC Roots出发一直沿着引用链向下寻找，如果某个对象不能通过GC Roots寻找到，那么虚拟机就认为该对象可以被回收。

image.png
   当对象D不在引用对象A时，尽管A、B、C互相还持有引用，GC依然会回收ABC所占用的内存。相对引用算法而言他就回收不了了。
   什么样的对象可以被看做是GC Roots呢？
   1. 虚拟机栈(栈桢中的本地变量表)中的引用的对象
   2. 方法区中的类静态属性引用的对象
   3. 方法区中的常量引用的对象
   4. 本地方法栈中JNI（Native方法）的引用的对象

（15）常见编码方式？

  https://blog.csdn.net/byf0521hlyp/article/details/80365045
  1. ASCII编码：用来表示英文，它使用1个字节表示，其中第一位规定为0，其他7位存储数据，一共可以表示128个字符。
  2. 拓展ASCII编码：用于表示更多的欧洲文字，用8个位存储数据，一共可以表示256个字符。
  3. GBK/GB2312/GB18030：表示汉字。GBK/GB2312表示简体中文，GB18030表示繁体中文。
  4. Unicode编码：包含世界上所有的字符，是一个字符集。
  5. UTF-8：是Unicode字符的实现方式之一，它使用1-4个字符表示一个符号，根据不同的符号而变化字节长度。其他实现方式还包括UTF-16和UTF-32。