Java基础面试题(一)

最新推荐文章于 2022-02-20 16:14:53 发布

原创最新推荐文章于 2022-02-20 16:14:53 发布 · 226 阅读

1 ·

CC 4.0 BY-SA版权

Java基础专栏收录该内容

14 篇文章

订阅专栏

本文深入解析Java中的构造函数、构造函数重载、方法重写与重载、==与equals的区别、浅拷贝与深拷贝、final关键字、static关键字、finally、finalize与final的区别、接口与抽象类的区别以及序列化与反序列化等核心概念。

1.什么是构造函数？什么是构造函数重载？

每一个类都有构造方法,是Java类里面的成员方法（成员属性）,他是用来实例化对象，
方法名称一样,参数列表不一样

访问修饰符:
java的四个关键字：public、protected、default、private
访问权限类包子类其他包

public ∨ ∨ ∨ ∨ （对任何人都是可用的）

protect ∨ ∨ ∨ × （继承的类可以访问以及和private一样的权限）

default ∨ ∨ × × （包访问权限，即在整个包内均可被访问）

private ∨ × × × （除类型创建者和类型的内部方法之外的任何人都不能访问的元素）

2.方法重写(Overriding)和方法重载(Overloading)

方法重写:子类实现父接口

方法重载:方法名称一样,参数列表不一样

重载：方法名字相同，而参数不同。返回类型可以相同也可以不同

重写：子类定义的方法与父类中的方法具有相同的方法名字，相同的参数表和相同的返回类型

方法重载和方法重写（覆盖）的区别?
（1）相同点：
①方法名称相同。
②都属于多态机制。

（2）不同点：位置、参数列表、权限修饰符、返回值类型、抛出异常不同。

重载(overload)：发生在同一个类中，方法名相同，参数列表不同，与权限修饰、返回值类型、抛出异常无关。

重写(override): 发生在继承类中，方法名和参数列表相同，权限修饰符大于等于父类、返回值类型小于等于父类、抛出异常小于等于父类。

3.== 和 equals区别

==要是基本数据类型所判断的是值是否相同,要是引用类型是判断地址值,
一般情况下引用数据类型是通过equals进行判断,判断的是值是否相同.
equals是:先判断值再判断类型，如果相同地址值就相当于相等了

4.为什么重写equals还要重写hashCode()

hashCode 方法用于散列集合的查找，equals 方法用于判断两个对象是否相等。

hashCode()返回对象的hashCode(哈希码)值
重写目的是提高性能

重写equals()方法同时重写hashcode()方法，就是为了保证当两个对象通过equals()方法比较相等时，那么他们的hashCode值也一定要保证相等

因为HashSet、HashMap以及HashTable中在比较key值时我们认为只要两个key的equals()相等就算是同一key。但实际比较时还要满足两者hashCode()相等才认为是同一key，本来Object类中equals()相等,hashCode()必然相等，但仅仅重写equals()打破了这种逻辑。

5.浅拷贝和深拷贝

深拷贝和浅拷贝都是对象拷贝

二、浅拷贝

（1）、定义

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。

简而言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象

（2）、浅拷贝实例

public class ShallowCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher();
        teacher.setName("riemann");
        teacher.setAge(27);

        Student2 student1 = new Student2();
        student1.setName("edgar");
        student1.setAge(18);
        student1.setTeacher(teacher);

        Student2 student2 = (Student2) student1.clone();
        System.out.println("拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());

        System.out.println("修改老师的信息后-------------");
        // 修改老师的信息
        teacher.setName("Games");
        System.out.println(student1.getTeacher().getName());
        System.out.println(student2.getTeacher().getName());

}
}

class Teacher implements Cloneable {
private String name;
private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

class Student2 implements Cloneable {
    private String name;
    private int age;
    private Teacher teacher;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    public Object clone() throws CloneNotSupportedException {
        Object object = super.clone();
        return object;
    }
}

输出结果：

拷贝后
edgar
18
riemann
27
修改老师的信息后-------------
Games
Games

结果分析：两个引用student1和student2指向不同的两个对象，但是两个引用student1和student2中的两个teacher引用指向的是同一个对象，所以说明是浅拷贝。

深拷贝

（1）、定义

深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

（2）、深拷贝实例

public class DeepCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher2 teacher = new Teacher2();
        teacher.setName("riemann");
        teacher.setAge(27);

        Student3 student1 = new Student3();
        student1.setName("edgar");
        student1.setAge(18);
        student1.setTeacher(teacher);

        Student3 student2 = (Student3) student1.clone();
        System.out.println("拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());

class Teacher2 implements Cloneable {
private String name;
private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Student3 implements Cloneable {
    private String name;
    private int age;
    private Teacher2 teacher;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Teacher2 getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher2 teacher) {
        this.teacher = teacher;
    }

    public Object clone() throws CloneNotSupportedException {
        // 浅复制时：
        // Object object = super.clone();
        // return object;

        // 改为深复制：
        Student3 student = (Student3) super.clone();
        // 本来是浅复制，现在将Teacher对象复制一份并重新set进来
        student.setTeacher((Teacher2) student.getTeacher().clone());
        return student;

}
}

输出结果：

拷贝后
edgar
18
riemann
27
修改老师的信息后-------------
Games
riemann

结果分析：
两个引用student1和student2指向不同的两个对象，两个引用student1和student2中的两个teacher引用指向的是两个对象，但对teacher对象的修改只能影响student1对象,所以说是深拷贝。

6.关键字final

final 修饰的类叫最终类，该类不能被继承。
final 修饰的方法不能被重写。
final 修饰的变量叫常量，常量必须初始化，初始化之后值就不能被修改。

7.关键字static

作用:

1)为特定数据类型或对象分配单一的存贮空间，而与创建对象的个数无关。

2）希望某个方法或属性与类而不是对象关联在一起，也就是说，
在不创建对象的情况下就可以通过类来直接调用方法或使用类的属性。具体而言，static在java中主要有四种使用情况：成员变量、成员方法、代码块及内部类。

（1）static成员变量

虽然java语言中没有全局的概念，但可以通过static关键字来达到全局的效果。java类提供了两种类型的变量：用static关键字修饰的静态变量和没有static关键字修饰的实例变量。静态变量
属于类，在内存中只有一个副本（所有实例都指向同一个内存地址）。只要静态变量所在的类被加载，这个静态类就会被分配空间，因此就可以被使用。对静态变量的引用有两种方式，分别为“类.静态变量”和“对象.静态变量”。

实例变量属于对象，只有对象被创建后，实例变量才会被分配空间，才能被使用，他在内存中存在多个副本，只能用“对象.静态变量”的方式来引用。

静态变量只有一个，被类所拥有，所有的对象都共享这个静态变量，而实例对象与具体对象有关。

（2） static成员方法
与变量类似，java类同时也提供了static方法与非static方法。static方法是类的方法，不需要创建对象就可以被使用，而非static方法是对象的方法，只有对象被创建出来后才可以被使用。

static 方法中不能使用this和super关键字，不能调用非static方法，只能访问所属类的静态成员变量和成员方法，因为当static方法被调用的时候，这个类的对象可能还没有被创建，即使已经被创建，
也无法确定调用哪个对象的方法。同理static方法也不能访问非static类型的变量。

static的一个很重要的的用途的是实现单例模式。单例模式的特点是该类只能有一个实例，为了实现这功能，必须隐藏类的构造方法，即把构造方法声明为private，并提供一个创建对象的方法。由于构造方法被声明为private，外界无法直接创建这个类型对象，只能通过该类提供的方法来获取类的对象，要达到这样的目的只能把创建
对象的方法声明为static：

(3) static 代码块

static代码块在类中是独立与成员变量和成员函数的代码块，他不在任何一个方法体内，JVM在加载里的时候会执行static代码块，如果有多个static代码块，JVM将会按顺序来执行，static代码块经常会被用来初始化静态变量，需要注意的是static代码块只会被执行一次。

（4）static内部类

static内部类是指被申明为static的内部类，他可以不依赖于外部类实例对象而被实例化，而通常的内部类需要外部类实例化后才能实例化。静态内部类不能与外部类有相同的名字，不能访问外部类的普通成员变量，只能访问外部类中的静态成员和静态成员方法，只有内部类才能被申明为static。

8.finally、finalize、final区别

final

final关键字可以用于类，方法，变量前，用来表示该关键字修饰的类，方法，变量具有不可变的特性。

（1）final关键字用于基本数据类型前：这时表明该关键字修饰的变量是一个常量，在定义后该变量的值就不能被修改。

（2）final关键字用于方法声明前：这时意味着该方法时最终方法，只能被调用，不能被覆盖，但是可以被重载。

（3）final关键字用于类名前：此时该类被称为最终类，该类不能被其他类继承。

finalize

finalize方法来自于java.lang.Object，用于回收资源。

可以为任何一个类添加finalize方法。finalize方法将在垃圾回收器清除对象之前调用。

在实际应用中，不要依赖使用该方法回收任何短缺的资源，这是因为很难知道这个方法什么时候被调用。

finally

当代码抛出一个异常时，就会终止方法中剩余代码的处理，并退出这个方法的执行。假如我们打开了一个文件，但在处理文件过程中发生异常，这时文件还没有被关闭，此时就会产生资源回收问题。对此，java提供了一种好的解决方案，那就是finally子句，finally子句中的语句是一定会被执行的，所以我们只要把前面说的文件关闭的语句放在finally子句中无论在读写文件中是否遇到异常退出，文件关闭语句都会执行，保证了资源的合理回收。

9.接口和抽象类的区别

接口和抽象类的区别：

（1）抽象类可以有构造方法，接口中不能有构造方法。

（2）抽象类中可以有普通成员变量，接口中没有普通成员变量

（3）抽象类中可以包含静态方法，接口中不能包含静态方法

（4）一个类可以实现多个接口，但只能继承一个抽象类。

（5）接口可以被多重实现，抽象类只能被单一继承

（6）如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为抽象方法而不必实现，而在抽象类的子类中实现接口中方法

接口和抽象类的相同点：

(1) 都可以被继承

(2) 都不能被实例化

(3) 都可以包含方法声明