Java程序的输出|设置 19

预测以下Java程序的输出。

程序一：

public class RuntimePolymorphism
{
    public static void main(String[] args)
    {
        A a = new B();
        B b = new B();
          
        System.out.println(a.c + " " + a.getValue() 
            + " " + b.getValue() + " " + b.getSuperValue());
    }
}
  
class A
{
    protected char c = 'A';
    char getValue()
    {
        return c;
    }
}
  
class B extends A
{
    protected char c = 'B';
    char getValue()
    {
        return c;
    }
    char getSuperValue()
    {
        return super.c;
    }
}

输出： ABBA
说明：这里没有多态的魔力；来自 A 的实例变量 c 只是隐藏在 B 中
– ac 是“A”，因为它在 A 类中如此设置
– a.getValue() 返回 'B' 因为对象是 B 类型

方案二：

public class RuntimePolymorphism
{
    public static void main(String[] args)
    {
        A a = new B();
        B b = new B();
        System.out.println(a.c + " " + a.getValue() + 
            " " + b.getValue() + " " + b.getSuperValue());
    }
}
  
class A
{
    protected char c = 'A';
    char getValue()
    {
        return c;
    }
}
class B extends A
{
    protected char c = 'B';
    char getSuperValue()
    {
        return super.c;
    }
}

输出： AAAA
说明：此处不能使用方法的多态性概念，因为在 B 类中没有函数重载 A 类中的方法。有关更多详细信息，请参阅运行时多态性

程序 3 :

class test
{
    public static int y = 0;
}
  
class HasStatic
{
    private static int x = 100;
      
    public static void main(String[] args)
    {
        HasStatic hs1 = new HasStatic();
        hs1.x++;
          
        HasStatic hs2 = new HasStatic();
        hs2.x++;
          
        hs1 = new HasStatic();
        hs1.x++;
          
        HasStatic.x++;
        System.out.println("Adding to 100, x = " + x);
          
        test t1 = new test();
        t1.y++;
          
        test t2 = new test();
        t2.y++;
          
        t1 = new test();
        t1.y++;
          
        System.out.print("Adding to 0, ");
        System.out.println("y = " + t1.y + " " + t2.y + " " + test.y);
    }
}

输出：

Adding to 100, x = 104
Adding to 0, y = 3 3 3

说明：本例显示了静态的属性。当变量被声明为静态时，将创建一个变量副本并在类级别的所有对象之间共享。静态变量本质上是全局变量。类的所有实例共享相同的静态变量。查看更多：静态关键字

程序四：

public class Except 
{
    public static void main(String[] args) 
    {    
        try 
        {
            throw new Error();
        }
        catch (Error e) 
        {
            try 
            {
                throw new RuntimeException();
            }
            catch (Throwable t) 
            {
  
            }
        }
            System.out.println("phew");
    }
}

输出：呸
说明：抛出和处理错误和运行时异常是合法的。 RuntimeException 是 Throwable 的子类。有关更多详细信息，请参阅例外情况

程序 5 :

public class Boot 
{
    static String s;
    static
    {
        s = "";
    }
    {
        System.out.println("GeeksforGeeks ");
    }
    static
    {
        System.out.println(s.concat("practice.GeeksforGeeks "));
    } 
    Boot() 
    { 
        System.out.println(s.concat("Quiz.GeeksforGeeks"));
    }
    public static void main(String[] args) 
    {
        new Boot();
        System.out.println("Videos.GeeksforGeeks");
    }
}

输出：

practice.GeeksforGeeks 
GeeksforGeeks 
Quiz.GeeksforGeeks
Videos.GeeksforGeeks

说明：静态 init 块在实例 init 块之前运行（分别按照它们出现的顺序）。初始化构造函数和初始化块的顺序无关紧要，初始化块总是在构造函数之前执行。有关详细信息，请参阅静态块