java基础面试题1

2020-05-19 16:07:18来源：博客园阅读 ()

java基础面试题1

&和&&的区别？

& 无论左边表达式执行结果如何，都会执行右边

&& 左边执行不符合条件时，右边不执行

 1     public static void main(String[] args) {
 2         int i = 1;
 3         int j = 2;
 4         
 5         // &
 6         if(++i==10 & ++j==10) { //false
 7             System.out.println(i);
 8             System.out.println(j);
 9         }
10         System.out.println(i); //2
11         System.out.println(j); //3
12         
13         // &
14         if(++i==10 && ++j==10) {  //false
15             System.out.println(i);
16             System.out.println(j);
17         }
18         System.out.println(i); //3
19         System.out.println(j); //3
20     }

int 和 Integer 有什么区别？（基本数据类型有哪些？）（String不是基本数据类型）

Java 为每个基本类型都提供了包装类，int 的包装类就是 Integer，并且从 jdk1.5 引入了自动拆箱、装箱机制，使得二者可以相互转换。

原始类型：boolean，char，byte，short，int，long，float，double

包装类型： Boolean，Character，Byte，Short，Integer，Long，Float，Double

String、StringBuffer、 StringBuilder 的区别？

String 用于字符串操作，不可改变类型，每次值发生改变，都会创建一个新的对象，底层使用 char 数组实现，因为使用 final，所以 String 不可以被继承

StringBuffer 用于字符串操作，可变类型，对方法增加了同步锁，线程安全

StringBuilder 和 StringBuffer 类似，都是字符串缓冲区，线程不安全

执行效率：StringBuilder（线程不安全）>StringBuffer（线程安全）>String

String 类的常用方法都有那些？

indexOf()：返回指定字符得索引

charAt()：返回指定索引处得字符

repalce()：字符串替换

trim()：去除字符串两端的空白

split()：分割字符串返回分割后的字符串数组

getBytes()：返回字符串的 byte 类型数组

length()：返回字符串的长度

toLowerCase()：字符串转小写

toUpperCase()：字符串转大写

substring()：截取字符串

equals()：字符串比较

final 修饰 StringBuffer 后还可以 append 吗？

可以，final 修饰的是一个引用变量，那么这个引用始终指向这个对象，但这个对象内部的属性是可以改变的。

1     public static void main(String[] args) {
2         final StringBuffer sb = new StringBuffer();
3         sb.append("a");
4         sb.append("b");
5         sb.append("c");
6         
7         System.out.println(sb); //abc
8         
9     }

String 字符串修改实现的原理？

当 String 修改字符串的时候会创建一个 StringBuilder 对象，接下来调用 append 方法，最后通过 toString 方法返回。

什么是值传递和引用传递？

值传递：基本类型的一个概念，传递的是该变量的一个副本，改变副本不影响原变量

引用传递：对象型变量而言，传递的是该对象地址的一个副本，所以对引用对象操作影响原变量

== 比较的是什么？

== 比较两个对象基本内存引用，如果两个对象的引用完全相同，返回 true，否则返回 false，如果两个对象是基本数据类型，则比较值是否相等。

1     public static void main(String[] args) {
2         int i = 10;
3         int j = 10;
4         System.out.println(i==j);
5         
6         String a = new String("hello");
7         String b = new String("hello");
8         System.out.println(a==b);
9     }

两个对象的 hashCode() 相同，则 equals() 也一定为 true 吗？

如果两个对象相等，则 hashCode 一定也是相同的；反之不成立。

1     public static void main(String[] args) {
2         String str1 = "通话";
3         String str2 = "重地";
4         System.out.println(str1.hashCode());//1179395
5         System.out.println(str2.hashCode());//1179395
6         
7         System.out.println(str1.equals(str2));//false
8     }

Java 里面的 final 关键字是怎么用的？

final关键字修饰的变量，只能进行一次赋值操作，并且在生存期内不可以改变它的值。

final关键字修饰的参数，在此方法中，不可更改该参数的值。

final关键字修饰的方法，该方法不能被重写。

final关键字修饰的类，该类不能被继承。

解释下什么是面向对象？面向对象和面向过程的区别？

面向对象的程序是由对象组成的，每个对象包含用户公开的特定功能部分和隐藏的实现部分。结构清晰，程序便于模块化，结构化，抽象化，更加符合人类的思维方式。

面向过程的程序通过设计一系列的过程来解决问题。面向过程侧重整个问题的解决步骤，着眼局部或者具体。

面向对象的三大特性？分别解释下？

封装：通常认为封装是把数据和操作数据的方法封装起来，对数据的访问只能通过已定义的接口。

继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类/基类），得到继承信息的被称为子类（派生类）。

多态：分为编译时多态（方法重载）和运行时多态（方法重写）。

要实现多态需要做两件事：一是子类继承父类并重写父类中的方法，二是用父类型引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为。主要由以下三种方式实现：

通过子类对父类的覆盖实现

通过在一个类中对方法的重载来实现

通过将子类对象作为父类对象使用来实现

Java 类初始化采用什么顺序呢？

初始化父类中的静态成员变量和静态代码块

初始化子类中的静态成员变量和静态代码块

初始化父类中的普通成员变量和代码块，再执行父类的构造方法

初始化子类中的普通成员变量和代码块，再执行父子类的构造方法

Java 是否支持多继承？

Java不支持多继承，但Java可以实现多个接口，从而达到类似多继承的目的。

什么是构造函数？什么是构造函数重载？
新对象被创建的时候会调用构造函数，每个类都有构造函数，如果没有显式的创建构造函数，Java 编译器会自动为该类创建一个默认的构造函数。

若该类已经创建非空参构造函数，默认的无参构造函数就会失效。

构造函数重载和方法重载类似，可以为一个类创建多个构造函数，但是要保证每个构造函数都有唯一的参数列表。

重载和重写的区别？

重载，编译时多态，在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

重写，也叫覆盖，运行时多态，重写发生在子类与父类之间，重写要求子类与父类具有相同的参数列表和返回类型。重写的方法调用时会覆盖父类的方法。

请说明 Comparable 和 Comparator 接口的作用以及它们的区别？

Comparable：

它是一个排序接口，只包含一个函数 compareTo()

一个类实现了 Comparable 接口，就意味着该类本身支持排序，它可以直接通过 Arrays.sort() 或 Collections.sort() 进行排序

 1 public class Human implements Comparable<Human> {
 2     public Integer id;
 3     public Integer age;
 4     
 5     @Override
 6     public int compareTo(Human o) {
 7         if(this.age > o.age) {
 8             return 1;
 9         }else if(this.age < o.age) {
10             return -1;
11         }else{
12             return 0;
13         }
14     }
15     
16 }

Comparator：

它是一个比较器接口，包括两个函数：compare() 和 equals()

一个类实现了Comparator接口，那么它就是一个比较器，其它的类，可以根据该比较器去排序

综上所述：Comparable 是内部比较器，而 Comparator 是外部比较器。

public class Man implements Comparator<Man>{
    public Integer id;
    public Integer age;

    @Override
    public int compare(Man o1, Man o2) {
        if(o1.age > o2.age) {
            return 1;
        }else if(o1.age < o2.age) {
            return -1;
        }else{
            return 0;
        }
    }
}

抽象类和接口有什么区别？

抽象类中可以定义构造函数，接口不能定义构造函数；

抽象类中可以有抽象方法和具体方法，而接口中只能有抽象方法（public abstract）；

抽象类中的成员权限可以是 public、默认、protected（抽象类中抽象方法就是为了重写，所以不能被 private 修饰），而接口中的成员只可以是 public（方法默认：public abstrat、成员变量默认：public static final）；

抽象类中可以包含静态方法，而接口中不可以包含静态方法。

static 关键字的作用？Java 中是否可以重写一个 private 或者是 static 的方法？

static 关键字表明一个成员变量或成员方法可以在没有所属类的情况下被访问。

重写是基于运行时动态绑定的，而 static 方法是编译时静态绑定的，static 方法与任何实例都不相关，所以不能重写一个 static 方法

成员变量和局部变量的区别？

生命周期不同

成员变量：

类成员变量是从该类的准备阶段开始，直到系统完全销毁这个类，类变量的作用域与这个类的生存范围相同

实例变量是从该类的实例被创建开始存在，直到系统完全销毁这个实例，实例变量的作用域与对应实例的生存范围相同

局部变量根据定义形式的不同，又可以分为如下三种：

形参，形参的作用域在整个方法中都有效

方法局部变量，作用域从定义这个变量的位置到方法结束时都有效

代码块局部变量，作用域从定义这个变量的位置到代码块结束时都有效

super 关键字的作用？

super 关键字可以在子类构造方法中显式调用父类构造，但是必要处于第一行。

super 关键字可以在子类中显式调用父类方法或变量。

有时候可以使用这个关键字扩展从父类继承过来的方法。

请说明类和对象的区别？

类是对某一类事物的描述，是抽象的；而对象是表示的一个具体的个体，是类的一个实例。

对象是函数、变量的集合体，而类是一组函数、变量的集合体，即类是一组具有相同属性的对象集合体。

（class修饰的是类，new出来的是对象）

finally 块中的代码什么时候被执行？

在 Java 语言的异常处理中，finally 块的作用就是为了保证无论出现什么情况，finally 块里的代码一定会被执行。由于程序执行 return 就意味着结束对当前函数的调用并跳出这个函数体，因此任何语句要执行都只能在 return 前执行（除非碰到 exit 函数），因此 finally 块里的代码也是在 return 之前执行的。

此外，如果 try-finally 或者 catch-finally 中都有 return，那么 finally 块中的 return 将会覆盖别处的 return 语句，最终返回到调用者那里的是 finally 中 return 的值。

finally 是不是一定会被执行到？

不一定，下面列举两种执行不到的情况：

当程序进入 try 块之前就出现异常时，会直接结束，不会执行 finally 块中的代码；

当程序在 try 块中强制退出时也不会去执行 finally 块中的代码，比如在 try 块中执行 exit 方法。

try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？

会，程序在执行到 return 时会首先将返回值存储在一个指定的位置，其次去执行 finally 块，最后再返回。因此，对基本数据类型，在 finally 块中改变 return 的值没有任何影响，直接覆盖掉；而对引用类型是有影响的，返回的是在 finally 对前面 return 语句返回对象的修改值。

throw 和 throws 的区别？

throw：在方法体内部，表示抛出异常，由方法体内部的语句处理；throw 是具体向外抛出异常的动作，所以它抛出的是一个异常实例；

throws：在方法声明后面，表示如果抛出异常，由该方法的调用者来进行异常的处理；表示出现异常的可能性，并不一定会发生这种异常。

常见的异常类有哪些？

ArithmeticExecption

NullPointerException

ClassCastException

ArrayIndexOutOfBoundsException

FileNotFoundException

NumberFormatException

SQLException

IOException