Java三十个常见面试题总结（二）

比眉伴天荒 2022-07-14 08:14 196阅读 0赞

**16.ArrayList list = new ArrayList(20);中的list扩充几次（）**

A 0 B 1 C 2 D 3

答案：A

解析：这里有点迷惑人，大家都知道默认ArrayList的长度是10个，所以如果你要往list里添加20个元素肯定要扩充一次（扩充为原来的1.5倍，每次扩充一半的容量），但是*这里显示指明了需要多少空间*，所以就一次性为你分配这么多空间，也就是不需要扩充了。

**17.下面哪些是对称加密算法（）**

A DES B AES C DSA D RSA

答案：AB

解析：常用的对称加密算法有：DES、3DES、RC2、RC4、AES

常用的非对称加密算法有：RSA、DSA、ECC

使用单向散列函数的加密算法：MD5、SHA

没技巧，死记。

**18.新建一个流对象，下面哪个选项的代码是错误的？（）**

A）new BufferedWriter(new FileWriter(“a.txt”));

B）new BufferedReader(new FileInputStream(“a.dat”));

C）new GZIPOutputStream(new FileOutputStream(“a.zip”));

D）new ObjectInputStream(new FileInputStream(“a.dat”));

答案：B

解析：请记得13题的那个图吗？Reader只能用FileReader进行实例化。

**19.下面程序能正常运行吗（）**

public class NULL {
        public static void haha(){
            System.out.println("haha");
        }
        public static void main(String[] args) {
            ((NULL)null).haha();
        }
    }

答案：能正常运行

解析：输出为haha，因为null值可以强制转换为任何java类类型,(String)null也是合法的。但null强制转换后是无效对象，其返回值还是为null，而static方法的调用是和类名绑定的，不借助对象进行访问所以能正确输出。反过来，没有static修饰就只能用对象进行访问，使用null调用对象肯定会报空指针错了。这里和C++很类似。这里感谢@Florian网友解答。

**20. 下面程序的运行结果是什么（）**

class HelloA {
    
        public HelloA() {
            System.out.println("HelloA");
        }
    
        { System.out.println("I'm A class"); }
    
        static { System.out.println("static A"); }
    
    }
    
    public class HelloB extends HelloA { 
        public HelloB() {
            System.out.println("HelloB");
        }
    
        { System.out.println("I'm B class"); }
    
        static { System.out.println("static B"); }
    
        public static void main(String[] args) { 
    　　　　 new HelloB(); 
    　　 }
    }

答案：

static A
    static B
    I'm A class
    HelloA
    I'm B class
    HelloB

解析：说实话我觉得这题很好，考查静态语句块、构造语句块（就是只有大括号的那块）以及构造函数的执行顺序。  
对象的初始化顺序：  
1. 类加载之后，按从上到下（从父类到子类）执行被static修饰的语句；  
2. 当static语句执行完之后,再执行main方法；  
3. 如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者可以说绑定在一起）。

**21. getCustomerInfo()方法如下，try中可以捕获三种类型的异常，如果在该方法运行中产生了一个IOException，将会输出什么结果（）**

public void getCustomerInfo() {
    
            try {
    
                // do something that may cause an Exception
    
            } catch (java.io.FileNotFoundException ex) {
    
                System.out.print("FileNotFoundException!");
    
            } catch (java.io.IOException ex) {
    
                System.out.print("IOException!");
    
            } catch (java.lang.Exception ex) {
    
                System.out.print("Exception!");
    
            }
    
        }

AIOException!

BIOException!Exception!

CFileNotFoundException!IOException!

DFileNotFoundException!IOException!Exception!

答案：A  
解析：考察多个catch语句块的执行顺序。当用多个catch语句时，catch语句块在次序上有先后之分。从最前面的catch语句块依次先后进行异常类型匹配，这样如果父异常在子异常类之前，那么首先匹配的将是父异常类，子异常类将不会获得匹配的机会，也即子异常类型所在的catch语句块将是不可到达的语句。所以，一般将父类异常类即Exception老大放在catch语句块的最后一个。

**22. 下面代码的运行结果为：（）**

import java.io.*;
    import java.util.*;
    
    public class foo{
    
        public static void main (String[] args){
    
            String s;
    
            System.out.println("s=" + s);
    
        }
    
    }

A 代码得到编译，并输出“s=”

B 代码得到编译，并输出“s=null”

C 由于String s没有初始化，代码不能编译通过

D 代码得到编译，但捕获到 NullPointException异常  
答案：C

解析：开始以为会输出null什么的，运行后才发现Java中所有定义的基本类型或对象都必须初始化才能输出值。

**23. System.out.println(“5” + 2);的输出结果应该是（）**

A 52 B7 C2 D5

答案：A

解析：没啥好说的，Java会自动将2转换为字符串。

**24. 指出下列程序运行的结果 （）**

public class Example {
    
        String str = new String("good");
    
        char[] ch = { 'a', 'b', 'c' };
    
        public static void main(String args[]) {
    
            Example ex = new Example();
    
            ex.change(ex.str, ex.ch);
    
            System.out.print(ex.str + " and ");
    
            System.out.print(ex.ch);
    
        }
    
        public void change(String str, char ch[]) {
    
            str = "test ok";
    
            ch[0] = 'g';
    
        }
    }

A、 good and abc

B、 good and gbc

C、 test ok and abc

D、 test ok and gbc  
答案：B

解析：大家可能以为Java中String和数组都是对象所以肯定是对象引用，然后就会选D，其实这是个很大的误区：**因为在java里没有引用传递，只有值传递**

这个值指的是实参的地址的拷贝，得到这个拷贝地址后，你可以通过它修改这个地址的内容（引用不变），因为此时这个内容的地址和原地址是同一地址，但是你不能改变这个地址本身使其重新引用其它的对象，也就是值传递。

因为：  
str是按值传递，所以在函数中对它的操作只生效于它的副本，与原字符串无关。  
ch是按址传递，在函数中根据地址，可以直接对字符串进行操作。  
str指向的是String类的引用，保存的是地址。当新的“test good ”产生的时候，会在内存中新建String对象，将地址复制给changes方法的str。而ch不会产生新的char数组，直接对原来的数组进行更改。

public class Example\{ // 我来分析一下内存分配情况吧！

String str= new String(“good”);  
//String str 时,把str引用放在栈空间，值为null , 当new String 时 ，在堆空间生成一个 good ,并且Str指向它！

char\[\]ch=\{‘a’,’b’,’c’\};  
//char\[\]ch 时,把ch 引用放在栈空间，在堆空间生成一个数组 a,b,c 并且ch 指向它们

public static void main(String args[]){
    
        Example ex=new Example();
          //Example ex 时,把 ex 引用放在栈空间， 当new Example 时 , 
          //在堆空间生成一个对象 并且 ex 指向它 ，没有任何属性值，因为你没有写构造函数 
        ex.change(ex.str,ex.ch);
      // 调用 方法 ，看方法分析！ 
    
        System.out.print(ex.str+"and");
        System.out.print(ex.ch);
        }
    public void change(String str,char ch[]){
    
        // 可能这里你会误会 ，这里的str 不同于 外面的 str ,
        // 这里的意思是, String str 在栈空间 '新建' 一个str ， 其实那里已有一个 str ，就是上面那个
        // 他们两个并不一样 ，这个str 是局部变量,依赖于方法 , 只要方法结束，它就自动消亡，而外面那个还在，
        // 所以这里就是 ，把外面的 str 传进来，把值赋给 这个 str ，此时两个都是 ''good''
    
        // 而char [] 分析则不同 ， 
        // 请先 记住 ，ch [0]，ch[1] ,ch[2] ...都是存在堆空间的 ，即是他们的地址空间， 
        // 对于这种引用类型的变量（例如数组，对象）,他们其实是把传进来的值直接放在引用地址.
        // 即 ch[0] 始终只有一 个，并且指向堆空间，参数传进来也是在堆空间里面。 
    
          str="test ok";
          // 然后执行这一步时 ， 这里面的str值就变化了 ，即变为 test ok ， 请记住此时在栈空间是有两个 str 哦 
          // 外面依然是 good , 可里面的 变成 test ok , 好的 ，继续 ...
    
          ch[0]='g';
    
          // 据上面分析，很显然 ， ch[0] 始终是一个 ，并且存放和修改都是直接在堆空间， 所以这里ch[0]变成 'g'
    
    } // 好，这个方法终于运行结束 ， 重点来了， 到这里 谁 死掉了 , 就是这里面那个 依赖于方法存在的局部变量 str
        // 那么现在一共就只有一个 str ，并且它的值为 good ,当接下去控制台输出的时候调用 str ，
        // 你说还会调用那个死了的 str 吗， 显然 调用 还存在的 str 即是 good
    }
    
      // 其实 , 假如想看明白，你可以这样 ， 把方法里面的 str , 改为 this.str . 
       // 你就能够区分 : 原来他们真是 两个 str ，而使用 this （本类) 调用的才是成员变量! 
       // 不依赖方法 ，就是命硬 ， 死不了 ！
       // 这样分析， 你懂了吗 ？

**25. 要从文件”file.dat”中读出第10个字节到变量c中,下列哪个方法适合? （）**  
A FileInputStream in=new FileInputStream(“file.dat”); in.skip(9); int c=in.read();

B FileInputStream in=new FileInputStream(“file.dat”); in.skip(10); int c=in.read();

C FileInputStream in=new FileInputStream(“file.dat”); int c=in.read();

D RandomAccessFile in=new RandomAccessFile(“file.dat”); in.skip(9); int c=in.readByte();

答案：A?D?

解析：long skip(long n)作用是跳过n个字节不读，主要用在包装流中的，因为一般流（如FileInputStream）只能顺序一个一个的读不能跳跃读，但是包装流可以用skip方法跳跃读取。那么什么是包装流呢？各种字节节点流类，它们都只具有读写字节内容的方法，以FileInputStream与FileOutputStream为例，它们只能在文件中读取或者向文件中写入字节，在实际应用中我们往往需要在文件中读取或者写入各种类型的数据，就必须先将其他类型的数据转换成字节数组后写入文件，或者从文件中读取到的字节数组转换成其他数据类型，想想都很麻烦！！因此想通过FileOutputStream将一个浮点小数写入到文件中或将一个整数写入到文件时是非常困难的。这时就需要包装类DataInputStream/DataOutputStream，它提供了往各种输入输出流对象中读入或写入各种类型的数据的方法。

DataInputStream/DataOutputStream并没有对应到任何具体的流设备，一定要给它传递一个对应具体流设备的输入或输出流对象，完成类似 DataInputStream/DataOutputStream功能的类就是一个包装类，也叫过滤流类或处理流类。它对InputOutStream/OutputStream流类进行了包装，使编程人员使用起来更方便。其中DataInputStream包装类的构造函数语法：public DataInputStream(InputStream in)。包装类也可以包装另外一个包装类。

**26. 下列哪种异常是检查型异常，需要在编写程序时声明 （）**

ANullPointerException BClassCastException CFileNotFoundException D IndexOutOfBoundsException

答案：C

解析：看第2题的解析。

**27. 下面的方法，当输入为2的时候返回值是多少?（）**

public static int getValue(int i) {
            int result = 0;
            switch (i) {
            case 1:
                result = result + i;
            case 2:
                result = result + i * 2;
            case 3:
                result = result + i * 3;
            }
            return result;
        }

A0 B2 C4 D10

答案：D

解析：注意这里case后面没有加break，所以从case 2开始一直往下运行。

**28. 选项中哪一行代码可以替换题目中//add code here而不产生编译错误？（）**

public abstract class MyClass {
    
         public int constInt = 5;
         //add code here
         public void method() {
         }
    }

Apublic abstract void method(int a);

B constInt = constInt + 5;

C public int method();

D public abstract void anotherMethod() \{\}

答案：A

解析：考察抽象类的使用。  
抽象类遵循的原则：  
（1）abstract关键字只能修饰类和方法，不能修饰字段。  
（2）抽象类不能被实例化（无法使用new关键字创建对象实例），只能被继承。  
（3）抽象类可以包含属性，方法，构造方法，初始化块，内部类，枚举类，和普通类一样，普通方法一定要实现，变量可以初始化或不初始化但不能初始化后在抽象类中重新赋值或操作该变量（只能在子类中改变该变量）。  
（4）抽象类中的抽象方法（加了abstract关键字的方法）不能实现。  
（5）含有抽象方法的类必须定义成抽象类。

扩展：抽象类和接口的区别，做个总结吧：  
（1）接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。

（2）abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。

（3）在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的。

（4）abstract class和interface所反映出的设计理念不同。其实abstract class表示的是”is-a”关系，interface表示的是”has-a”关系。

（5）实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。抽象类中可以有非抽象方法。接口中则不能有实现方法。

（6）接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以在子类中重新赋值。

**29. 阅读Shape和Circle两个类的定义。在序列化一个Circle的对象circle到文件时，下面哪个字段会被保存到文件中？ ( )**

class Shape { 
    
           public String name;
    
    }
    
    class Circle extends Shape implements Serializable{ 
    
           private float radius;
    
           transient int color;
    
           public static String type = "Circle";
    
    }

Aname

B radius

C color

D type

答案：B

解析：  
1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。

2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。

3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。  
这里有详细的解释：[http://www.cnblogs.com/lanxuezaipiao/p/3369962.html][http_www.cnblogs.com_lanxuezaipiao_p_3369962.html]

**30.下面是People和Child类的定义和构造方法，每个构造方法都输出编号。在执行new Child(“mike”)的时候都有哪些构造方法被顺序调用？请选择输出结果 ( )**

class People { 
        String name;
    
        public People() {
            System.out.print(1);
        }
    
        public People(String name) {
            System.out.print(2);
            this.name = name;
        }
    }
    
    class Child extends People { 
        People father;
    
        public Child(String name) {
            System.out.print(3);
            this.name = name;
            father = new People(name + ":F");
        }
    
        public Child() {
            System.out.print(4);
        }
    
    }

A312 B 32 C 432 D 132

答案：D

解析：考察的又是父类与子类的构造函数调用次序。在Java中，子类的构造过程中必须调用其父类的构造函数，是因为有继承关系存在时，子类要把父类的内容继承下来。但如果父类有多个构造函数时，该如何选择调用呢？

第一个规则：子类的构造过程中，必须调用其父类的构造方法。一个类，如果我们不写构造方法，那么编译器会帮我们加上一个默认的构造方法（就是没有参数的构造方法），但是如果你自己写了构造方法，那么编译器就不会给你添加了，所以有时候当你new一个子类对象的时候，肯定调用了子类的构造方法，但是如果在子类构造方法中我们并没有显示的调用基类的构造方法，如：super(); 这样就会调用父类没有参数的构造方法。

第二个规则：如果子类的构造方法中既没有显示的调用基类构造方法，而基类中又没有无参的构造方法，则编译出错，所以，通常我们需要显示的：super(参数列表)，来调用父类有参数的构造函数，此时无参的构造函数就不会被调用。

总之，一句话：子类没有显示调用父类构造函数，不管子类构造函数是否带参数都默认调用父类无参的构造函数，若父类没有则编译出错。

**最后，给大家出个思考题：下面程序的运行结果是什么？**

public class Dervied extends Base { 
    
        private String name = "dervied";
    
        public Dervied() {
            tellName();
            printName();
        }
    
        public void tellName() {
            System.out.println("Dervied tell name: " + name);
        }
    
        public void printName() {
            System.out.println("Dervied print name: " + name);
        }
    
        public static void main(String[] args){
    
            new Dervied();    
        }
    }
    
    class Base {
    
        private String name = "base";
    
        public Base() {
            tellName();
            printName();
        }
    
        public void tellName() {
            System.out.println("Base tell name: " + name);
        }
    
        public void printName() {
            System.out.println("Base print name: " + name);
        }
    }

[http_www.cnblogs.com_lanxuezaipiao_p_3369962.html]: http://www.cnblogs.com/lanxuezaipiao/p/3369962.html