Java面试题一

待我称王封你为后i 2023-05-22 12:30 16阅读 0赞

# 一. 知识笔记 #

#### 1. String类可以被继承吗？ ####

不可以。String类是被final修饰的，被final修饰的类不可被继承。

（被final修饰的方法不可重写却可重载）

#### 2. 被final修饰的变量会有什么作用？ ####

*  如果被修饰的是基本数据类型变量（如int，long，char）或String，其值在初始化后就不可更改了，如下：

public class Demo1_final { 
        public static void main(String[] args) { 
            String a = "helloworld";
            final String b = "hello";
            String c = "hello";
            String d = b + "world";
            String e = c + "world";
            System.out.println(a == d); //true
            System.out.println(a == e); //false
        }
    }

**解释：** **final作用于基本数据类型（如int，long，char等）或String时，如果在编译期间就知道它的确切值，编译器会直接拿它的值进行使用（如\`\`\`b=“hello”，直接拿“hello”）。即直接拿final的值使用。对于d的访问却需要运行时通过链接进行。**

*  final如果修饰的是引用类型的变量（如StringBuffer，StringBuilder，或者自定义的类的实例变量）  
    对其初始化后不能再指向另一个对象，对象内容是可变的， 如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70]  
    ![在这里插入图片描述][2020041720550264.PNG]

#### 3. 为什么Java语言的开发者把String类定义为final？ ####

因为这样才能实现字符串池。不同的字符串变量都指向池中的同一个字符串，可以大大节约了heap(堆)的空间。如果字符串可变，则会引起非常严重的安全问题。比如，数据库中的密码和账户都用了字符串的形式传入来获得数据库的连接。因为字符串是不可变的，所以这些值都是不可改变。否则黑客可以想办法改变字符串指向的对象的值造成安全漏洞。

#### 4. final除了修饰类外，还有什么用法？ ####

修饰方法：该方法无法被覆盖  
修饰实例变量：必须手动赋值，不能系统默认值；一般和static联用用来声明常量。

总结：final表示最终的，不可变的

#### 5. &和&&的区别？ ####

&是逻辑与，&&是短路与。  
&&运算符左边的表达式为false则不再继续判断运算符右边的表达式。  
&逻辑可以进行二进制与运算

#### 6. 两个对象值相同equals结果为true，但却可有不同的 hashCode，这句话对不对？ ####

[解释][Link 1]

#### 7. 在 Java 中，如何跳出当前的多重嵌套循环？ ####

在最外层循环前加一个标记如outfor，然后用break outfor;可以跳出多重循环。例如以下代码：

public class TestBreak { 
        public static void main(String[] args) { 
            outfor: for (int i = 0; i < 10; i++){ 
                for (int j = 0; j < 10; j++){ 
                    if (j == 5){ 
                        break outfor;
                    }
                    System.out.println("j = " + j);
                }
            }
        }
    }

#### 8. 重载（overload）和重写（override）的区别？重载的方法能否根据返回类型进行区分？ ####

*  **重载：**  
    方法名相同，参数列表不同（参数类型，参数个数，参数顺序）。  
    重载与方法的返回值无关，存在于父类和子类，同类中。  
    可以抛出不同的异常，可以有不同修饰符。
 *  **重写：** 两同两小一大原则：  
    方法名，参数列表相同。  
    子类方法返回类型小于等于父类方法返回类型；  
    子类方法抛出异常小于等于父类方法抛出的异常；  
    子类方法访问权限大于等于父类方法访问权限；

#### 9. 当一个对象被当作参数传递到一个方法后，方法可以改变这个对象的属性，可返回变化后的结果，那么这里是值传递还是引用传递？ ####

值传递。 Java语言的调用只支持参数的值传递。当一个对象被当作参数传递到一个方法里面，该参数的值就是对该对象的内存地址。这个值（内存地址）被传递后，同一个内存地址指向堆内存当中的同一个对象。所以通过哪个引用去操作这个对象，对象的属性都是改变的。

#### 10. 为什么方法不能根据返回值区分重载？ ####

如下代码：

public void testMethod(){ 
       doSome();
    }
    public void doSome(){ 
    
    }
    public int doSome(){ 
    
    }

**解释：** Java中，调用一个方法，我可以不接收它的返回值。所以在testMethod()中调用doSome()，编译器是无法区分调用的具体是哪个方法。对编译器来说，doSome()方法不是重载而是重复了，编译器报错。所以区分重载不能依靠方法的返回值类型。

#### 11. char 型变量中能不能存储一个中文汉字，为什么？ ####

char 类型可以存储一个中文汉字，因为Java中使用的编码是Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个char 类型占2个字节（16 比特），所以放一个中文是没问题的。

补充：使用Unicode 意味着字符在JVM内部和外部有不同的表现形式，在JVM内部都是 Unicode，当这个字符被从JVM内部转移到外部时（例如存入文件系统中），需要进行编码转换。所以 Java 中有字节流和字符流，以及在字符流和字节流之间进行转换的转换流，如 InputStreamReader和OutputStreamReader，这两个类是字节流和字符流之间的适配器类，承担了编码转换的任务。

#### 12. 抽象的(abstract)方法是否可同时是静态的(static)， 是否可同时是本地方法(native)，是否可同时被 synchronized？ ####

都不能。  
● 抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。  
● 本地方法是由本地代码（如 C++ 代码）实现的方法，而抽象方法是没有实现的，也是矛盾的。  
● synchronized 和方法的实现细节有关，抽象方法不涉及实现细节，因此也是相互矛盾的。

#### 13. ==和equals的区别？ ####

equals和`==`最大的区别是一个是方法一个是运算符。  
● `==`：如果比较的对象是基本数据类型，则比较的是数值是否相等；如果比较的是引用数据类型，则比较的是对象的地址值是否相等。  
● equals()：用来比较方法两个对象的内容是否相等。equals方法不能用于基本数据类型的变量，如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址。

#### 14. 阐述静态变量和实例变量的区别？ ####

不管创建多少个对象，静态变量在内存中有且仅有一个；实例变量必须依存某一实例，需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享。

#### 15. break和continue的区别 ####

● break和continue 都是用来控制循环的语句。  
● break 用于完全结束一个循环，跳出循环体执行循环后面的语句。  
continue 用于跳过本次循环，继续下次循环

#### 16. String s = “Hello”;s = s + " world!";这两行代码执行后，原始的 String 对象中的内容变了没有？ ####

没有。

因为 String被设计成不可变类，所以它的所有对象都是不可变对象。

在这段代码中，s原先指向一个 String 对象，内容是 “Hello”，然后我们对 s 进行了“+”操作，那么 s 所指向的那个对象是否发生了改变呢？

答案是没有。这时s不指向原来那个对象了，而指向了另一个 String 对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是 s 这个引用变量不再指向它了。

通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用 String 来代表字符串的话会引起很大的内存开销。因为 String 对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个 String 对象来表示。这时，应该考虑使用 StringBuffer/StringBuilder类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都 new 一个 String。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70]: /images/20230521/9c405a81a1df43828ddc46620b291ec6.png
[2020041720550264.PNG]: /images/20230521/bd063546136b4b608de2a152ba1d0596.png
[Link 1]: https://www.cnblogs.com/tomj/p/6700510.html