Java基础知识面试题，咱不得在秋招前一起办办它？（2020秋招）

final修饰的类不能被继承；修饰的方法不能被重写；修饰的变量不能被修改
finally用在try-catch代码块儿后，finally中的代码无论如何都会被执行
finalize是Object类的方法，该方法由垃圾回收器来调用，当我们调用System,gc()方法的时候，由垃圾回收器调用finalize()方法，是一个对象是否被回收的最后判断

6. this和super的区别

super：它引用当前对象的直接父类中的成员（super.变量名 super.成员方法（参数））；this:它引用当前类的变量（用于区别二义性的问题）
super() 在子类中调用父类构造方法；this() 在本类调用其自身的其他构造方法，不能调用两个
this() 和super() 指的是对象，不可以在static代码块儿中使用

7. static关键字

修饰类
修饰代码块儿
修饰方法
修饰变量

7.1 注意事项

静态只能访问静态
非静态既可以访问静态又可以访问非静态

7.2 静态变量和实例变量的区别

静态变量又叫类变量，属于类，在内存中只有一份，在类的加载过程中，JVM只为静态变量分配一次内存空间
实例变量，它是属于对象的，根据对象的个数，在内存中存储的个数也不同，创建几个对象，就要分配几次内存空间

7.3 静态方法和实例方法的区别

在外部调用静态方法的时候，既可以用类名.方法名，也可以用对象名.方法名（一般不这么用）；实例方法只能用后者进行调用
静态方法在访问本类的成员时，只能访问静态变量和静态方法；实例方法都可以访问呐

8. 流程控制语句

break 直接跳出循环体，不再执行循环
continue 结束本次循环，进行下一次循环
return 结束当前方法，直接返回值

面向对象

1. 面向对象的利弊

优点：易维护，易复用，易扩展，具有封装、继承和多态三大特性
缺点：性能相比于面向过程低

2. 面向对象的三大特性

2.1 封装

将一个对象的属性私有化，并且提供一些可以被外界访问的方法

2.2 继承

子类以父类为基础，可以增加新得数据或扩展

子类继承的是非private的属性和方法
子类可以拥有自己的属性和方法，即扩展
子类可以对父类的方法进行重写

2.3 多态

百度百科：在面向对象语言中，接口的多种不同的实现方式即为多态。更好理解就是：你可以把父对象设置成它的子对象，根据实际的对象进行操作，再简单就是可以将子类赋值给父类。

3. 类与接口

3.1 抽象类和接口的区别

大家可以参考下面这篇文章
接口和抽象类的不同，就像你和我的不同一样

3.2 抽象类能被final修饰吗？

当然是大大的不能了！定义出抽象类就是准备要被其他类继承的，如果被final修饰了这不就自我矛盾了嘛！

4. 构造方法

4.1 在调用子类的构造方法的时候，会先向上调用父类的无参构造，目的是什么？

帮助子类完成初始化工作。

4.2 构造方法的特性是什么？

名字与类名相同
没有返回值，也不用void修饰
生成类的对象时自动执行，不需要调用

5. 内部类

5.1 内部类有哪些？

成员内部类
静态内部类
局部内部类
匿名内部类

5.1.1 成员内部类

public class Outer {

    private static  int radius = 1;
    private int count =2;
    
     class Inner {
        public void visit() {
            System.out.println("visit outer static  variable:" + radius);
            System.out.println("visit outer   variable:" + count);
        }
    }
}

成员内部类可以访问外部类的所有变量和方法，不论静态与非静态，公有和私有。成员内部类依赖于外部类的实例，它的创建方式如下

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.visit();

5.1.2 静态内部类

public class Outer {

    private static int radius = 1;

    static class StaticInner {
        public void visit() {
            System.out.println("visit outer static  variable:" + radius);
        }
    }
}

静态内部类可以访问外部类所有的静态变量，而不可以访问外部类的非静态变量；静态内部类的创建方式如下

Outer.StaticInner inner = new Outer.StaticInner();
inner.visit();

5.1.3 局部内部类

public class Outer {

    private  int out_a = 1;
    private static int STATIC_b = 2;

    public void testFunctionClass(){
        int inner_c =3;
        class Inner {
            private void fun(){
                System.out.println(out_a);
                System.out.println(STATIC_b);
                System.out.println(inner_c);
            }
        }
        Inner  inner = new Inner();
        inner.fun();
    }
    public static void testStaticFunctionClass(){
        int d =3;
        class Inner {
            private void fun(){
            	//编译错误，定义在静态方法中的局部类不可以访问外部类的实例变量
                // System.out.println(out_a); 
                System.out.println(STATIC_b);
                System.out.println(d);
            }
        }
        //局部内部类创建对象的方式
        Inner  inner = new Inner();
        inner.fun();
    }
}

定义在实例方法中的局部内部类可以访问外部类的所有变量和方法，定义在静态方法中的局部内部类只能访问外部类的静态变量和方法。

5.1.4 匿名内部类

public class Outer {

    private void test(final int i) {
        new Service() {
            public void method() {
                for (int j = 0; j < i; j++) {
                    System.out.println("匿名内部类" );
                }
            }
        }.method();
    }
 }
 //匿名内部类必须继承或实现一个已有的接口 
 interface Service{
    void method();
}

匿名内部类的特点

匿名内部类必须继承一个抽象类或者实现一个接口
匿名内部类不能定义任何静态成员和静态方法
当所在的方法的形参需要被匿名内部类使用时，必须声明为final
匿名内部类不能是抽象的，它必须要实现继承的类或者实现接口的所有方法

匿名内部类的创建方式

new 类/接口{ 
  //匿名内部类实现部分
}

5.2 内部类的优点

内部类对象可以访问创建它的外部类的所有对象，包括私有
内部类不被同一包的其他类所见，具有很好的封装性

5.3 局部内部类和匿名内部类访问局部变量的时候，为什么要加上final？

public class Outer {

    void outMethod(){
        final int a =10;
        class Inner {
            void innerMethod(){
                System.out.println(a);
            }

        }
    }
}

因为生命周期不一致，局部变量直接存储在栈中，当方法执行结束后，非final的局部变量就被销毁。而局部内部类对局部变量的引用依然存在，如果局部内部类要调用局部变量时，就会出错。加了final，可以确保局部内部类使用的变量与外层的局部变量区分开，解决了这个问题。

6. 重写和重载

6.1 构造器可以重载吗？

构造器可以重载，不能被重写

6.2 重载和重写的区别

重载：在同一个类中，只有方法名相同，参数不同（顺序，个数，类型），与方法的返回值和权限修饰符无关
重写：发生在继承或实现中，方法名、参数列表必须相同，返回值小于等于父类，异常小于等于父类，访问权限大于等于父类

7. 对象相等的判断

7.1 == 和equals的区别是什么？

== 基本数据类型比较的是值，引用数据类型比较的是地址
equals 在类重写equals方法的情况下，比较的是内容；在没有被重写的情况下，功能和==一样。

7.2 hashCode和equals

7.2.1 为什么要有hashCode？

我们以向HashSet中插入值，检查重复为例子，HashSet会计算对象的哈希值来确定它的位置，同时也会将其哈希值与其他的对象做比较，如果没有一样的，那么HashSet会认为新加入的对象没有重复；若发现了它的哈希值和其他对象相同，那么会调用equals方法再比较它们的内容是否一致，若不同，则添加成功，否则认为对象重复，添加失败。这样可以减少equals的执行次数，加快效率。

7.2.2 hashCode与equals的相关规定

equals返回true的两个对象，hashCode一定相等
hashCode相等的两个对象，equals不一定相等

所以，equals方法被重写，hashCode方法也要被重写。

8. 值传递

Java语言总是采用按值调用。也就是说，方法得到的是值的拷贝。

方法可以修改引用数据类型的参数状态
方法不可以修改基本数据类型的值，也不可以让对象引用新的对象

反射

大家有时间可以看一下这篇文章
注解和反射详解

String

1. String

1.1 什么是字符串常量池？

字符串常量池位于堆内存中，专门用来存储字符串常量，可以提高内存的使用率，避免开辟多块儿内存空间存储相同的字符串。在创建字符串的时候，JVM会首先检查字符串常量池，如果该字符串已经在常量池中，则返回它的引用，否则创建一个新的字符串加入到常量池中。

1.2 String不是基本数据类型

String底层是char类型的数组。

1.3 String类型为什么是不可以改变的？

我们不妨看一下源码

/** The value is used for character storage. */
private final char value[];

大大的眼睛有没有看见final修饰？

而且String类是被final修饰的，不能被继承

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence

1.3.1 String str="i"与 String str=new String(“i”)一样吗？

不一样啊。String str="i"是将字符串分配到常量池中；String str=new String(“i”)是将其分配到了堆中。

1.4 String作为Map的key有什么好呢？

因为String是不可变的类型，所以它的hashCode不会改变，这样就相比于其他类型的对象更好。

1.5 StringBuffer和StringBuilder的区别是什么？

StringBuffer对方法加了synchronized同步锁，是线程安全的。
StringBuilder是非线程安全的。

参考文献

Java基础知识面试题（2020最新版）

笔者水平有限，还需大家批评指正，共同进步！