final、finally、finalize的区别？

== 和 equals() 的区别？

:::success 一、回顾 == 的使用：
== ：运算符

    1. 可以使用在基本数据类型变量和引用数据类型变量中
    1. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）

    如果比较的是引用数据类型变量：比较两个对象的地址值是否相同，即两个引用 是否指向同一个对象实体
    * 补充： == 符号使用时，必须保证符号左右两边的变量类型一致。

二、equals()方法的使用：

    1. 是一个方法，而非运算符
    1. 只能适用于引用数据类型
    1. Object类中equals()的定义：

public boolean equals(Object obj){
return (this == obj)
}
* 说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

    1. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的”实体内容”是否相同。
    1. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的”实体内容”是否相同。那么，我们就需要对Object类中的equals()进行重写.

    *重写的原则：比较两个对象的实体内容是否相同。 :::

多态是编译时行为还是运行时行为？

image.png

  1. package com.atguigu.test;
  3. import java.util.Random;
  5. //面试题：多态是编译时行为还是运行时行为？
  6. //证明如下：
  7. class Animal  {
  9.     protected void eat() {
  10.         System.out.println("animal eat food");
  11.     }
  12. }
  14. class Cat  extends Animal  {
  16.     protected void eat() {
  17.         System.out.println("cat eat fish");
  18.     }
  19. }
  21. class Dog  extends Animal  {
  23.     public void eat() {
  24.         System.out.println("Dog eat bone");
  26.     }
  28. }
  30. class Sheep  extends Animal  {
  33.     public void eat() {
  34.         System.out.println("Sheep eat grass");
  36.     }
  39. }
  41. public class InterviewTest {
  43.     public static Animal  getInstance(int key) {
  44.         switch (key) {
  45.         case 0:
  46.             return new Cat ();
  47.         case 1:
  48.             return new Dog ();
  49.         default:
  50.             return new Sheep ();
  51.         }
  53.     }
  55.     public static void main(String[] args) {
  56.         int key = new Random().nextInt(3);
  58.         System.out.println(key);
  60.         Animal  animal = getInstance(key);
  62.         animal.eat();
  64.     }
  66. }
  1. package com.atguigu.test;
  2. //考查多态的笔试题目：
  3. public class InterviewTest1 {
  5.     public static void main(String[] args) {
  6.         Base base = new Sub();
  7.         base.add(1, 2, 3);
  9. //        Sub s = (Sub)base;
  10. //        s.add(1,2,3);
  11.     }
  12. }
  14. class Base {
  15.     public void add(int a, int... arr) {
  16.         System.out.println("base");
  17.     }
  18. }
  20. class Sub extends Base {
  22.     public void add(int a, int[] arr) {
  23.         System.out.println("sub_1");
  24.     }
  26. //    public void add(int a, int b, int c) {
  27. //        System.out.println("sub_2");
  28. //    }
  30. }

关于包装类使用的面试题

image.png
image.png

  1. package com.atguigu.java2;
  3. import org.junit.Test;
  5. /*
  6.  * 关于包装类使用的面试题
  7.  * 
  8.  * 
  9.  */
  10. public class InterviewTest {
  12.     @Test
  13.     public void test1() {
  14.         Object o1 = true ? new Integer(1) : new Double(2.0);
  15.         System.out.println(o1);// 1.0
  17.     }
  19.     @Test
  20.     public void test2() {
  21.         Object o2;
  22.         if (true)
  23.             o2 = new Integer(1);
  24.         else
  25.             o2 = new Double(2.0);
  26.         System.out.println(o2);// 1
  28.     }
  30.     @Test
  31.     public void test3() {
  32.         Integer i = new Integer(1);
  33.         Integer j = new Integer(1);
  34.         System.out.println(i == j);//false
  36.         //Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],
  37.         //保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在
  38.         //-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率
  40.         Integer m = 1;
  41.         Integer n = 1;
  42.         System.out.println(m == n);//true
  44.         Integer x = 128;//相当于new了一个Integer对象
  45.         Integer y = 128;//相当于new了一个Integer对象
  46.         System.out.println(x == y);//false
  47.     }
  49. }