Java程序的输出|设置 11

预测以下Java程序的输出：

问题一：

public class Base
{
    private int data;
  
    public Base()
    {
        data = 5;
    }
  
    public int getData()
    {
        return this.data;
    }
}
  
class Derived extends Base
{
    private int data;
    public Derived()
    {
        data = 6;
    }
    private int getData()
    {
        return data;
    }
  
    public static void main(String[] args)
    {
        Derived myData = new Derived();
        System.out.println(myData.getData());
    }
}

一）6
b) 5
c) 编译时错误
d) 运行时错误

答案（c）
说明：当覆盖超类的方法时，子类中的方法声明不能比超类中声明的更严格。

问题2 ：

public class Test
{
    private int data = 5;
  
    public int getData()
    {
        return this.data;
    }
    public int getData(int value)
    {
        return (data+1);
    }
    public int getData(int... value)
    {
        return  (data+2);
    }
  
    public static void main(String[] args)
    {
        Test temp = new Test();
        System.out.println(temp.getData(7, 8, 12));
    }
}

a) 编译时或运行时错误
b) 8
三）10
d) 7

答案（d）
解释：当您不知道输入参数的数量但知道参数的类型（在本例中为 int）时，（int ... values）作为参数传递给方法。当在 main 方法中创建一个新对象时，变量 data 被初始化为 5。使用属性 (7, 8 ,12) 调用 getData() 方法，调用第三个 getData() 方法，该方法增加值数据变量乘以 2 并返回 7。

问题 3：

public class Base
{
    private int multiplier(int data)
    {
        return data*5;
    }
}
  
class Derived extends Base
{
    private static int data;
    public Derived()
    {
        data = 25;
    }
    public static void main(String[] args)
    {
        Base temp = new Derived();
        System.out.println(temp.multiplier(data));
    }
}

一）125
b) 25
c) 运行时错误
d) 编译时错误

答案（d）
说明：由于方法乘数被标记为私有，它不是继承的，因此对派生不可见。

问题4：
关于 finally 块，下列哪项是错误的？
a) 对于每个 try 块，只能有 1 个 finally 块。
b) 如果程序通过调用 System.exit() 退出，finally 块将不会被执行；
c) 如果catch语句中没有处理异常，在终止程序之前，JVM会执行finally块
d) finally 块包含重要的代码段，因此 finally 块中的代码在Java代码中是否存在 try 块的情况下执行。

答案（d）
解释：语句 (d) 是错误的，因为 finally 块只有在 try 或 catch 块成功时才能存在。在没有 try 块的情况下使用 finally 块会产生编译时错误。

问题 5：

import java.io.IOException;
import java.util.EmptyStackException;
  
public class newclass
{
    public static void main(String[] args)
    {
        try
        {
            System.out.printf("%d", 1);
            throw(new Exception());
        }
        catch(IOException e)
        {
            System.out.printf("%d", 2);
        }
        catch(EmptyStackException e)
        {
            System.out.printf("%d", 3);
        }
        catch(Exception e)
        {
            System.out.printf("%d", 4);
        }
        finally
        {
            System.out.printf("%d", 5);
        }
    }
}

一）12345
b) 15
三）135
d) 145

答案（d）
说明： catch 语句的编写顺序是：从更具体到更一般。在上面的代码中，抛出了一个 Exception 类型的新异常。首先，代码跳转到第一个 catch 块以查找异常处理程序。但是由于 IOException 不是
相同类型的它向下移动到第二个 catch 块，最后到第三个，其中
捕获异常并打印 4。因此，答案是 145，因为顺序
块的执行是：try->catch->finally。

问题 6：

public class javaclass
{
    static
    {
        System.out.printf("%d", 1);
    }
    static
    {
        System.out.printf("%d", 2);
    }
    static
    {
        System.out.printf("%d", 3);
    }
    private static int myMethod()
    {
        return 4;
    }
    private int function()
    {
        return 5;
    }
  
    public static void main(String[] args)
    {
        System.out.printf("%d", (new javaclass()).function() + myMethod());
    }
}

一）123
b) 45
c) 12345
d) 1239

答案（d）
说明： Java中的静态块甚至在编译器调用 main 之前就已执行。在main方法中，新建了一个javaclass对象，调用了它的函数()方法，返回5，静态方法myMethod()返回4，即4+5 = 9。所以程序的输出是1239，因为 123 甚至在 main 方法执行之前就打印在控制台上，并且 main 方法在执行时返回 9。