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

难度等级： 菜鸟

null

预测以下Java程序的输出。

方案1

                     // filename Main.java                   
                     class                               Test {                   
                                         protected                               int                               x, y;                   
                     }                   
                             
                     class                               Main {                   
                                         public                               static                               void                               main(String args[]) {                   
                                         Test t =                               new                               Test();                   
                                         System.out.println(t.x +                               " "                               + t.y);                   
                                         }                   
                     }                   

输出

0 0

在Java中，受保护的成员可以在同一个包的所有类中以及在其他包的继承类中访问。由于Test和Main在同一个包中，因此上述程序中没有与访问相关的问题。此外，默认构造函数在Java中将整型变量初始化为0（参见这 GFact了解更多细节）。这就是为什么我们的输出为0。

方案2

                     // filename Test.java                   
                     class                               Test {                   
                                         public                               static                               void                               main(String[] args) {                   
                                         for                               (                               int                               i =                               0                               ;                               1                               ; i++) {                   
                                         System.out.println(                               "Hello"                               );                   
                                         break                               ;                   
                                         }                   
                                         }                   
                     }                   

输出：编译器错误 for循环的条件检查表达式中存在错误。在这里，Java不同于C++（或C）。C++认为所有非零值为真，0为假。与C++不同，不能在java中期望布尔值的地方放置整数值表达式。下面是正确的程序。

                     // filename Test.java                   
                     class                               Test {                   
                                         public                               static                               void                               main(String[] args) {                   
                                         for                               (                               int                               i =                               0                               ;                               true                               ; i++) {                   
                                         System.out.println(                               "Hello"                               );                   
                                         break                               ;                   
                                         }                   
                                         }                   
                     }                   
                     // Output: Hello                   

方案3

                     // filename Main.java                   
                     class                               Main {                   
                                         public                               static                               void                               main(String args[]) {                   
                                         System.out.println(fun());                   
                                         }                   
                                         int                               fun() {                   
                                         return                               20                               ;                   
                                         }                   
                     }                   

输出：编译器错误与C++一样，在java中，非静态方法不能用静态方法调用。如果我们将fun（）设为static，那么程序可以很好地编译，没有任何编译器错误。下面是正确的程序。

                     // filename Main.java                   
                     class                               Main {                   
                                         public                               static                               void                               main(String args[]) {                   
                                         System.out.println(fun());                   
                                         }                   
                                         static                               int                               fun() {                   
                                         return                               20                               ;                   
                                         }                   
                     }                   
                     // Output: 20                   

方案4

                     // filename Test.java                   
                     class                               Test {                   
                                         public                               static                               void                               main(String args[]) {                   
                                         System.out.println(fun());                   
                                         }                   
                                         static                               int                               fun() {                   
                                         static                               int                               x=                               0                               ;                   
                                         return                               ++x;                   
                                         }                   
                     }                   

输出：编译器错误与C++不同，java中不允许使用静态本地变量。看见这详情请联系我们。我们可以使用类静态成员来计算函数调用的数量和C++局部静态变量服务的其他目的。下面是正确的程序。

                     class                               Test {                   
                                         private                               static                               int                               x;                   
                                         public                               static                               void                               main(String args[]) {                   
                                         System.out.println(fun());                   
                                         }                   
                                         static                               int                               fun() {                   
                                         return                               ++x;                   
                                         }                   
                     }                   
                     // Output: 1                   

如果您发现任何答案/解释不正确，或想分享有关上述主题的更多信息，请发表评论。

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

THE END

Java