Java程序的输出|设置 7

难度级别：中级

预测以下Java程序的输出。

程序 1：

public class Calculator
{
    int num = 100;
    public void calc(int num)  { this.num = num * 10;  }
    public void printNum()     { System.out.println(num); }
  
    public static void main(String[] args)
    {
        Calculator obj = new Calculator();
        obj.calc(2);
        obj.printNum();
    }
}

选项：
一）20
B) 100
三）1000
D) 2
答案：A) 20
解释：这里的类实例变量 name(num) 与calc()方法局部变量 name(num) 相同。因此，对于从calc()方法引用类实例变量，使用this关键字。所以在语句this.num = num * 10中， num表示方法的局部变量，其值为 2， this.num表示类实例变量，其初始值为 100。现在在printNum()方法中，因为它没有局部变量name 与类实例变量相同，所以我们可以直接使用num来引用实例变量，虽然this.num可以使用。

方案二：

public class MyStuff
{
    String name;
  
    MyStuff(String n) {  name = n;  }
  
    public static void main(String[] args)
    {
        MyStuff m1 = new MyStuff("guitar");
        MyStuff m2 = new MyStuff("tv");
        System.out.println(m2.equals(m1));
    }
  
    @Override
    public boolean equals(Object obj)
    {
        MyStuff m = (MyStuff) obj;
        if (m.name != null)  { return true;  }
        return false;
    }
}

选项：
A) 输出为真并且 MyStuff 满足 Object.equals() 合约。
B) 输出为假，MyStuff 满足 Object.equals() 合约。
C) 输出为真并且 MyStuff 不满足 Object.equals() 合约。
D) 输出为假并且 MyStuff 不履行 Object.equals() 合同。

答案： C) 输出为真并且 MyStuff 不履行 Object.equals() 合同。
解释：作为 Object 类中的equals(Object obj)方法，根据等价关系比较两个对象。但是这里我们只是确认对象是否为空，所以它不履行 Object.equals() 合同。由于m1不为 null，因此将打印 true。

程序 3：

class Alpha
{
    public String type = "a ";
    public Alpha() {  System.out.print("alpha "); }
}
  
public class Beta extends Alpha
{
    public Beta()  {  System.out.print("beta ");  }
  
    void go()
    {
        type = "b ";
        System.out.print(this.type + super.type);
    }
  
    public static void main(String[] args)
    {
        new Beta().go();
    }
}

选项：
A) 阿尔法贝塔 bb
B) 阿尔法贝塔 ab
C) beta alpha bb
D) beta alpha ab

答案： A) alpha beta bb
解释：语句new Beta().go()分两个阶段执行。在第一阶段Beta类构造函数被调用。 Beta类中不存在实例成员。所以现在执行Beta类构造函数。由于Beta类扩展了Alpha类，因此调用Alpha类构造函数作为默认的第一条语句（由编译器放置）是Beta类构造函数中的super() 。现在，由于Alpha类中存在一个实例变量（ type ），所以它将获取内存，现在执行Alpha类构造函数，然后调用 return to Beta类构造函数下一条语句。所以打印了alpha beta 。
在第二阶段，对该对象调用go()方法。因为对象中只有一个变量（ type ），其值为a 。所以会改成b ，打印两次。这里的 super 关键字没有用。

程序 4：

public class Test
{
    public static void main(String[] args)
    {
        StringBuilder s1 = new StringBuilder("Java");
        String s2 = "Love";
        s1.append(s2);
        s1.substring(4);
        int foundAt = s1.indexOf(s2);
        System.out.println(foundAt);
    }
}

选项：
一）-1
B) 3
三）4
D) 在运行时抛出StringIndexOutOfBoundsException 。
答案： C) 4
说明： append(String str)方法，将 str 连接到s1 。 substring(int index)方法将字符串从给定索引返回到末尾。但是由于没有任何 String 变量来存储返回的字符串，所以它会被销毁。现在indexOf(String s2)方法返回第一次出现s2的索引。所以 4 打印为 s1=”JavaLove”。

方案 5：

class Writer
{
    public  static void write()
    {
        System.out.println("Writing...");
    }
}
class Author extends Writer
{
    public  static void write()
    {
        System.out.println("Writing book");
    }
}
  
public class Programmer extends Author
{
    public  static void write()
    {
        System.out.println("Writing code");
    }
  
    public static void main(String[] args)
    {
        Author a = new Programmer();
        a.write();
    }
}

选项：
A) 写作……
B) 写书
C) 编写代码
D) 编译失败

答案： B) 写书
解释：由于静态方法不能被覆盖，所以创建哪个类对象并不重要。由于a是Author引用类型，所以总是调用Author类方法。如果我们从Author类中删除write()方法，则会调用Writer类方法，因为Author类扩展了Writer类。