​class A { public int x = 10; public void printX() { System.out.print(" A"+x); } public static void printStaticX() { System.out.print(" StaticA"); } } class Elm extends A { public int x = 20; public void printX() { System.out.print("B"+x); } public static void printStaticX() { System.out.print("StaticB"); } public static void main(String[] args) { A a = new Elm(); a.printX(); a.printStaticX(); System.out.print("和"); System.out.print(a.x); } }详细解释并说明结果是什么

这段代码定义了两个类A和Elm，其中Elm继承了A。在类A中定义了一个实例变量x和一个实例方法printX()，并且还定义了一个静态方法printStaticX()。在类Elm中，也定义了一个实例变量x和一个实例方法printX()，并且还覆盖了从A继承来的printX()方法，同时也定义了一个静态方法printStaticX()。

在main方法中，首先创建了一个Elm类的实例a，并将其赋值给类型为A的引用变量a。然后，调用a的printX()方法和printStaticX()方法。由于printX()方法是一个实例方法，并且被覆盖了，因此实际上会调用Elm类中的printX()方法，并输出“B20”。而printStaticX()方法是一个静态方法，不会被覆盖，因此会调用A类中的printStaticX()方法，并输出“StaticA”。

最后，输出了一个“和”字符，再输出a的实例变量x，由于a的类型是A，因此访问的是A类中的实例变量x，输出“10”。

因此，程序的最终输出结果为“B20StaticA和10”。

相关问题

public class CCC { protected int x ; public CCC ( int x ){ this . x = x ; public ccc (){ this . x =0; public void printX ( int x ){ System . out . printin ( x ); public void printX (){ System . out . println ( x ); public class DDD extends CCC { private int x ; public DDD ( int x ){ super . x =0; this . x = x ;public void printX ( int x ){ System . out . printIn ( this . x ); System . out . println ( x ); public void printX (){ System . out . println ( x ); public void print (){ super . printX (); super . printX (2); this . printX (6); printX (); public static void main ( String args []){ DDD bb = new DDD (7); bb . print ();

这段代码存在一些语法错误。下面是修正后的代码：

public class CCC {
    protected int x;

    public CCC(int x) {
        this.x = x;
    }

    public CCC() {
        this.x = 0;
    }

    public void printX(int x) {
        System.out.println(x);
    }

    public void printX() {
        System.out.println(x);
    }
}

public class DDD extends CCC {
    private int x;

    public DDD(int x) {
        super();
        this.x = x;
    }

    public void printX(int x) {
        System.out.println(this.x);
        System.out.println(x);
    }

    public void printX() {
        System.out.println(x);
    }

    public void print() {
        super.printX();
        super.printX(2);
        this.printX(6);
        printX();
    }

    public static void main(String[] args) {
        DDD bb = new DDD(7);
        bb.print();
    }
}

修正后的代码定义了两个类：CCC 和 DDD。CCC 类有一个成员变量 x，一个带参数的构造函数、一个无参构造函数以及两个成员方法 printX。其中，一个 printX 方法带有一个 int 类型的参数，另一个不带参数。

DDD 类继承自 CCC 类，并添加了一个私有成员变量 x 和一个带参数的构造函数。DDD 类重写了 CCC 类的 printX 方法，并添加了一个叫做 print 的成员方法。

在 main 方法中，创建了一个 DDD 类的对象 bb，并调用了它的 print 方法。print 方法分别调用了父类 CCC 的 printX 方法、带参数的 printX 方法、自己的 printX 方法和不带参数的 printX 方法。

package demo2; public class A { int x=2; public void setx(int i) { x=i; } void printa() { System.out.println(x); } class B extends A{ int x=100; void printb() { super.x=super.x+10; System.out.println("super.x="+super.x+"x="+x); } } public static void main(String[] args) { A a1=new A(); a1.setx(4); a1.printa(); B b1=new B();/*主程序是静态，局部类是动态的，类中的静态方法不能直接调用动态方法 */ b1.printb(); b1.printa(); b1.setx(6); b1.printb(); b1.printa(); a1.printa(); } }这个代码哪里有问题

这个代码中有一个问题是在类B中的printb()方法中应该调用super.printa()方法而不是直接调用printa()方法，因为这样才能确保调用的是类A中的printa()方法，而不是类B中的printa()方法。另外，在类B中的x变量应该被声明为一个新的变量名，因为它隐藏了类A中的x变量。以下是修改后的代码：

package demo2;

public class A {
    int x = 2;

    public void setx(int i) {
        x = i;
    }

    void printa() {
        System.out.println(x);
    }

    class B extends A {
        int y = 100;

        void printb() {
            super.x = super.x + 10;
            System.out.println("super.x=" + super.x + " y=" + y);
            super.printa();
        }
    }

    public static void main(String[] args) {
        A a1 = new A();
        a1.setx(4);
        a1.printa();
        B b1 = a1.new B();
        b1.printb();
        b1.setx(6);
        b1.printb();
        b1.printa();
        a1.printa();
    }
}