Java程序|集7的输出-yiteyi-C++库

难度等级： 中间的

null

预测以下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();                   
                                         }                   
                     }                   

选项： A）二十 B）一百 C）一千 D）二, 答：A）20 说明： 这里的类实例变量名（num）与 calc（） 方法局部变量名（num）。因此，对于从 calc（） 方法这使用关键字。所以在声明中 这num=num*10 , 号码表示方法的局部变量，其值为2和 这号码 表示初始值为100的类实例变量。现在在 printNum（） 方法，因为它没有与类实例变量同名的局部变量，所以我们可以直接使用号码引用实例变量，尽管 这号码 可以使用。

项目2：

                     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）输出为true，MyStuff实现了该对象。等于合同。 B）输出为false，MyStuff实现了该对象。等于合同。 C）输出为true，MyStuff不满足该对象。等于合同。 D）输出为false，MyStuff无法实现该对象。等于合同。

答复: C）输出为true，MyStuff不满足该对象。等于合同。 说明： 像 等于（对象obj） 方法在对象类中，根据等价关系比较两个对象。但这里我们只是确认对象是否为null，所以它不满足对象等于合同像 m1 不为空，将打印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） α-βb B） α-βa B C） β-αb D） β-αa b

答复: A） α-βb 说明： 声明 新的Beta（）。go（） 分两个阶段执行。第一阶段贝塔类构造函数被调用。中没有实例成员贝塔班所以现在贝塔类构造函数被执行。像贝塔类扩展 阿尔法 同学们，所以电话转到 阿尔法 默认情况下，类构造函数作为第一条语句（由编译器放置）是 超级（） 在贝塔类构造函数。现在作为一个实例变量( 类型 )存在于 阿尔法 类，所以它将获得内存，现在 阿尔法 类构造函数被执行，然后调用return to 贝塔类构造函数的下一个语句。所以 α-β 是印刷的。第二阶段 go（） 方法对该对象调用。因为只有一个变量( 类型 )在值为 A. .所以会改成 B 打印了两次。这个超级关键字这里没有用。

方案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);                   
                                         }                   
                     }                   

选项： A） -1 B）三, C）四, D） A StringIndexOutOfBoundsException 在运行时抛出。 答复: C）四, 说明： 追加（字符串str） 方法，将str连接到 s1 这个 子字符串（整数索引） 方法返回从给定索引到结尾的字符串。但是由于没有任何字符串变量来存储返回的字符串，因此它将被销毁。现在 indexOf（字符串s2） 方法返回第一次出现的 s2 .So 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. 是一个著者引用类型，所以总是著者类方法被调用。如果我们移除 写（） 方法来自著者那就上课吧作家类方法被调用，如下所示：著者类扩展作家班

本文由 高拉夫·米格拉尼 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java