面试题小结--Java基础

1. 字符串：

1、"=="与.equals()

String str1 = "abc";
String str2 = "abc";
String str3 = "ab" + "c";
String str4 = new String("abc");
String str5 = new String("abc");
String str6 = new String("a") + "b" + "c";

System.out.println("1 and 2 : " + (str1 == str2) + " ; " + (str1.equals(str2)));
System.out.println("1 and 3 : " + (str1 == str3) + " ; " + (str1.equals(str3)));
System.out.println("1 and 4 : " + (str1 == str4) + " ; " + (str1.equals(str4)));
System.out.println("4 and 5 : " + (str4 == str5) + " ; " + (str4.equals(str5)));
System.out.println("4 and 6 : " + (str4 == str6) + " ; " + (str4.equals(str6)));

主要是在问“ ==”与“equals()”的区别以及常量池，以及使用new 获得的String对象和使用 “” 获得String对象的区别
对于String来说，如果使用"“方式获得的String对象，则是首先检查常量池中是否有”abc“这以字面量，有就返回它的引用，如果没有就在常量池中创建一个"abc”,并返回它的引用。对于new方式获得的String对象，则是在Heap(堆)上创建一个新的对象；而
" ==“对于String类型来说则是比较的对象的引用地址，因此当不同引用做对比时则返回"false”,同一引用时返回的则是”true“，
而equals(),比较的则是对象的实际数据内容，因此内容相同时，equals()返回是"true"。

2、常量池与堆上创建对象

问下列获得String对象的方法，分别创建了几次对象

String str1 = "abc";

0次或者1次：0次是Method Area(方法区)中的常量池中已经有了“abc”，虚拟机只是将引用赋给str1，并不创建新对象，而1次是常量池中不存在“abc”，则开辟空间，创建一个“abc’，发生在编译期。

String str2 = new String("abc");

1次或者2次：先说一定会有的一次 new String()，这是在运行时创建的，new 会在堆(Heap)上开辟一次空间，创建一个对象，另一个可能创建也可能不创建的是因为，String类的构造方法的参数也是一个String类型，因此在传入实参"abc"时就会进行一次类似String str = ”abc“的操作，这个操作就是上面的那种情况，可能创建也可能不创建。

3、String 是不可变类(被final修饰)

String str = "abc";
str += "d";

拼接前的str和拼接后的str并不是一个对象，它们有不同的hashCode()，String的实现是一个char数组，而这个数组是被final修饰的，在对它拼接后实际生成一个新的String对象，而不是原来的那个对象了

4、多态性与里氏替换原则

public class A {
    public String show(D obje) {
        int i = 1, j = 0;
        switch (i) {
            case 2:
                j += 6;
            case 4:
                j += 1;
            default:
                j += 2;
            case 0:
                j += 4;
        }
        return ("A and D") + j;
    }

    public String show(A obj) {
        return "A and A";
    }
}

public class B extends A{
    public String show(B obj) {
        String a = new String("abc");
        String b = new String("abc");

        String c = "abc";
        String d = "abc";

        return ""+(d == c)+";"+(a == b);
    }

    public String show(A obj) {
        return ("B and A");
    }
}

public class C extends B {}

public class D extends B {}

public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        
        System.out.println("①" + a1.show(b));
        System.out.println("⑥"+ a2.show(d));
        System.out.println("⑧"+ b.show(c));
        System.out.println("⑨"+ b.show(d));
}

①考察里氏替换原则：在A中并没有定义一个show(B obj)方法，但是因为B是A的子类，根据里氏替换原则，凡是父类出现的地方，都可以被其子类替代，因此可以进入show(A obj)方法，输出就是“A and A”；
⑥接口引用，实际执行的是B的show(D obj)方法，该方法是B继承自其父类A的方法，因此执行类B的show(D obj)方法；
⑧和①一样依旧是里氏替换原则，但是有个C是B的直接子类，C是A的孙子类，B中有show(B obj)和show(A obj)方法，优先替换到C的直接父类的位置，也就是show(B obj)。如果将B类中的show(B obj)方法注释掉，依旧可以执行不报错，但是执行B类中的show(A obj)方法；
⑨考察的则是B继承自A的show(D obj)方法。