【面试题每日学习】8

1. 类的组成部分有哪些？

答：在 Java 语言中，类主要是由方法和变量两部分组成。

2. 类与对象有哪些区别？

答：类是一个抽象的概念，是对某一事物的描述；而对象是类的实例，是实实在在存在的个体。好比，“人”就是一个类（一个概念），而老王就是实实在在的一个“对象”。

3. Java 中能够多继承吗？

答：Java 中只能单继承，但能够实现多接口。

4. Java 中为何不能实现多继承？

答：从技术的实现角度来讲，是为了下降编程的复杂性。假设 A 类中有一个 m() 方法，B 类中也有一个 m() 方法，若是 C 类同时继承 A 类和 B 类，那调用 C 类的 m() 方法时就会产生歧义，这无疑增长了程序开发的复杂性，为了不这种问题的产生，Java 语言规定不能多继承类，但能够实现多接口。

5. 覆盖和重载有哪些区别？

答：覆盖和重载的区别以下：

• 覆盖（Override）是指子类对父类方法的一种重写，只能比父类抛出更少的异常，访问权限不能比父类的小，被覆盖的方法不能是 private，不然只是在子类中从新定义了一个方法；
• 重载（Overload）表示同一个类中能够有多个名称相同的方法，但这些方法的参数列表各不相同。

6. 如下不属于重载特性的是？

A：方法的参数类型不一样 B：方法的返回值不一样 C：方法的参数个数不一样 D：方法的参数顺序不一样

答：B

7. 为何方法不能根据返回类型来区分重载？

答：由于在方法调用时，若是不指定类型信息，编译器就不知道你要调用哪一个方法了。好比，如下代码：

float max(int x,int y);
int max(int x,int y);
// 方法调用
max(1,2);

由于 max(1,2) 没有指定返回值，编译器就不知道要调用哪一个方法了。

8. 构造方法有哪些特征？

答：构造方法的特征以下：

• 构造方法必须与类名相同；
• 构造方法没有返回类型（void 也不能有）；
• 构造方法不能被继承、覆盖、直接调用；
• 类定义时提供了默认的无参构造方法；
• 构造方法能够私有，外部没法使用私有构造方法建立对象。

9. 构造函数能不能被覆盖？能不能被重载？

答：构造函数能够重载，但不能覆盖。

10. 如下说法正确的是？

A：类中的构造方法不能忽略 B：构造方法能够做为普通方法被调用 C：构造方法在对象被 new 时被调用 D：一个类只能有一个构造方法

答：C

11. 如下程序执行的结果是？

class ExecTest {
    public static void main(String[] args) {
        Son son = new Son();
    }
}
class Parent{
    {
        System.out.print("1");
    }
    static{
        System.out.print("2");
    }
    public Parent(){
        System.out.print("3");
    }
}
class Son extends Parent{
    {
        System.out.print("4");
    }
    static{
        System.out.print("5");
    }
    public Son(){
        System.out.print("6");
    }
}

答：打印的结果是：251346

加载顺序以下：

• 执行父类的静态成员；
• 执行子类的静态成员；
• 父类的实例成员和实例初始化；
• 执行父类构造方法；
• 子类的实例成员和实例初始化；
• 子类构造方法。

12. 如下程序执行的结果是？

class A {
    public int x = 0;
    public static int y = 0;
    public void m() {
        System.out.print("A");
    }
}
class B extends A {
    public int x = 1;
    public static int y = 2;
    public void m() {
        System.out.print("B");
    }
    public static void main(String[] args) {
        A myClass = new B();
        System.out.print(myClass.x);
        System.out.print(myClass.y);
        myClass.m();
    }
}

答：打印的结果是：00B

题目解析：在 Java 语言中，变量不能被重写。

13. 如下程序执行的结果是？

class A {
    public void m(A a) {
        System.out.println("AA");
    }
    public void m(D d) {
        System.out.println("AD");
    }
}
class B extends A {
    @Override
    public void m(A a) {
        System.out.println("BA");
    }
    public void m(B b) {
        System.out.println("BD");
    }
    public static void main(String[] args) {
        A a = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        a.m(a);
        a.m(b);
        a.m(c);
        a.m(d);
    }
}
class C extends B{}
class D extends B{}

答：打印结果以下。

BA
BA
BA
AD

题目解析：

• 第一个 BA：由于 A 的 m() 方法，被子类 B 重写了，因此输出是：BA；
• 第二个 BA：由于 B 是 A 的子类，当调用父类 m() 方法时，发现 m() 方法被 B 类重写了，因此会调用 B 中的 m() 方法，输出就是：BA；
• 第三个 BA：由于 C 是 B 的子类，会直接调用 B 的 m() 方法，因此输出就是：BA；
• 第四个 AD：由于 D 是 A 的子类，因此会调用 A 的 m() 方法，因此输出就是：AD。

14. Java 中的 this 和 super 有哪些区别？

答：this 和 super 都是 Java 中的关键字，起指代做用，在构造方法中必须出如今第一行，它们的区别以下。

• 基础概念：this 是访问本类实例属性或方法；super 是子类访问父类中的属性或方法。
• 查找范围：this 先查本类，没有的话再查父类；super 直接访问父类。
• 使用：this 单独使用时，表示当前对象；super 在子类覆盖父类方法时，访问父类同名方法。

15. 在静态方法中能够使用 this 或 super 吗？为何？

答：在静态方法中不能使用 this 或 super，由于 this 和 super 指代的都是须要被建立出来的对象，而静态方法在类加载的时候就已经建立了，因此没办法在静态方法中使用 this 或 super。

16. 静态方法的使用须要注意哪些问题？

答：静态方法的使用须要注意如下两个问题：

• 静态方法中不能使用实例成员变量和实例方法；
• 静态方法中不能使用 this 和 super。

17. final 修饰符的做用有哪些？

答：final 修饰符做用以下：

• 被 final 修饰的类不能被继承；
• 被 final 修饰的方法不能被重写；
• 被 final 修饰的变量不能被修改。

18. 覆盖 equals() 方法的时候须要遵照哪些规则？

答：Oracle 官方的文档对于 equals() 重写制定的规则以下。

• 自反性：对于任意非空的引用值 x，x.equals(x) 返回值为真。
• 对称性：对于任意非空的引用值 x 和 y，x.equals(y) 必须和 y.equals(x) 返回相同的结果。
• 传递性：对于任意的非空引用值 x、y 和 z，若是 x.equals(y) 返回值为真，y.equals(z) 返回值也为真，那么 x.equals(z) 也必须返回值为真。
• 一致性：对于任意非空的引用值 x 和 y，不管调用 x.equals(y) 多少次，都要返回相同的结果。在比较的过程当中，对象中的数据不能被修改。
• 对于任意的非空引用值 x，x.equals(null) 必须返回假。

此题目不要求记忆，能知道大概便可，属于加分项题目。

19. 在 Object 中 notify() 和 notifyAll() 方法有什么区别？

答：notify() 方法随机唤醒一个等待的线程，而 notifyAll() 方法将唤醒全部在等待的线程。

20. 如何使用 clone() 方法？

答：若是是同一个类中使用的话，只须要实现 Cloneable 接口，定义或者处理 CloneNotSupportedException 异常便可，请参考如下代码：

class CloneTest implements Cloneable {
    int num;
    public static void main(String[] args) throws CloneNotSupportedException {
        CloneTest ct = new CloneTest();
        ct.num = 666;
        System.out.println(ct.num);
        CloneTest ct2 = (CloneTest) ct.clone();
        System.out.println(ct2.num);
    }
}

若是非内部类调用 clone() 的话，须要重写 clone() 方法，请参考如下代码：

class CloneTest implements Cloneable {
    int num;
    public static void main(String[] args) throws CloneNotSupportedException {
        CloneTest ct = new CloneTest();
        ct.num = 666;
        System.out.println(ct.num);
        CloneTest ct2 = (CloneTest) ct.clone();
        System.out.println(ct2.num);
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class CloneTest2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        CloneTest ct = new CloneTest();
        ct.num = 666;
        System.out.println(ct.num);
        CloneTest ct2 = (CloneTest) ct.clone();
        System.out.println(ct2.num);
    }
}