两道小题目！

Question

对于第一个程序段:
CCC
BBB
123呵呵.
分算什么东西.快乐才是最重要的!还有一个100分的问题,其实 不是问题,只是一个咨询,参与有分!
http://www.csdn.net/Expert/topic/497/497690.shtm

Answer 1

1. 456
   AAA
   123
   CCC
   BBB
2.AAA
  BVar=0
  BBB
  BVar=222
  AVar=0

Answer 2

Patrick_DK(疾风摩郎)
1。为什么不是先执行constructor而是先执行一个{}?直接写一个{}有什么特殊含义吗？
2。super_class constructor中调用的doSomething()为什么执行的是sub_class中的doSomething()?

Answer 3

这好象是THINK IN JAVA里面的例子吗?!

Answer 4

tpProgramer(tp编程者)看来你也有待学习啊！

Answer 5

to night_knight(黑夜骑士只抽红河)　{ }语法块是在一个类的实例创建的时候第一个执行的至于完整的初始化顺序，你可以查找论坛，我曾经提过这个问题

Answer 6

System.out.println("A.doSomething()");??
  

Answer 7

去这里看看吧http://www.csdn.net/expert/topic/458/458987.shtm

Answer 8

Patrick_DK(疾风摩郎)　第一个问题我明白了，但是第二个为什么不输出A.doSomething()?

Answer 9

多态Ｏｖｅｒｒｉｄｉｎｇ是Runtime动态绑定的，ＣｏｍｐｉｌｅＴｉｍｅ不确定。
规则比较多，应该看看入门的书

Answer 10

class A {
   public int Avar;
   public A() {
      System.out.println("AAA");
      doSomething();
   }
   public void doSomething() {
      Avar = 1111;
      System.out.println("A.doSomething()");
   }
}public class B extends A {
   public int Bvar = 2222;
   public B() {
      System.out.println("BBB");
      doSomething();
      System.out.println("Avar=" + Avar);
   }
   public void doSomething() {
  super.doSomething();
      System.out.println("Bvar=" + Bvar);
   }
   public static void main(String[] args) {
      new B();
   }
}Patrick_DK(疾风摩郎) 你有没有这样试过？在sub_class里用super.doSomething();结果执行了A.doSomething();
按照你的说法，A.doSomething()已经被B.doSomething()覆盖了，那怎么还会执行呢？并且我看到有人说初始化的顺序是：继承类的静态变量、基类的静态变量、继承类的变量、基类的变量、基类的构造函数、继承类的构造函数，我觉得不太对，找不到你原来的帖子，贴个地址出来吧！

Answer 11

class A {
   public int Avar;
   public A() {
      System.out.println("AAA");
      doSomething();
   }
   public void doSomething() {
      Avar = 1111;
      System.out.println("A.doSomething()");
   }
}public class B extends A {
   public int Bvar = 2222;
   public B() {
      System.out.println("BBB");
      doSomething();
      System.out.println("Avar=" + Avar);
   }
   public void doSomething() {
  super.doSomething();
      System.out.println("Bvar=" + Bvar);
   }
   public static void main(String[] args) {
      new B();
   }
}
输出结果：
AAA
A.doSomet
Bvar=0
BBB
A.doSomet
Bvar=2222
Avar=1111

Answer 12

你自己运行一下就行了，来考大家？还是想显示自己牛，能写java程序

Answer 13

oldcat0076(jeff) 正是因为我不太清楚，所以我希望有人可以给我解答！
我牛什么！？菜鸟一个而已，呵呵

Answer 14

Patrick_DK(疾风摩郎) 帮我解开这个疑团，就结帐！
class A                                    class A
{                                          {
  public A()                                  public A()
  {                                           {
     Print();                                    Print();
  }                                           }
  public Print()                              public Print()
  {                                           {                       
    System.out.println("A");                     System.out.println("A");
   }                                          }
}                                           }
public class B                              public class B     
{                                           {
   Print()                                    Print()
   {                                          {
      System.out.println("B");                  super.Print(); 
    }                                         }
public static void main(String args[])   public static void main(String args[])
    {                                      {
        new B();                             new B();
     }                                     }
}                                        }
输出结果：
    B                                               A为什么？这不能用覆盖来解释吧？

Answer 15

Patrick_DK(疾风摩郎) 帮我解开这个疑团，就结帐！
class A                                    class A
{                                          {
  public A()                                  public A()
  {                                          {
    Print();                                    Print();
  }                                          }
  public Print()                              public Print()
  {                                          {                      
    System.out.println("A");                    System.out.println("A");
  }                                          }
}                                          }
public class B extends A                   public class B extends A   
{                                          {
  Print()                                    Print()
  {                                          {
      System.out.println("B");                  super.Print(); 
    }                                        }
public static void main(String args[])  public static void main(String args[])
    {                                      {
        new B();                            new B();
    }                                    }
}                                        }
输出结果：
    B                                              A为什么？这不能用覆盖来解释吧？ 

Answer 16

我说得很清楚了啊，首先你必须要看懂Ｊａｖａ的多态－编译期绑定和运行期绑定的概念（随便哪本入门书里有）一句话
　　Overriding的方法（不包括ｓｔａｔｉｃ，ｐｒｉｖａｔｅ和ｆｉｎａｌ修饰的方法）是多态的运行期动态绑定。１．你左边这个例子，父类的ｐｒｉｎｔ（）方法被子类的ｐｒｉｎｔ（）方法覆盖了，在运行期绑定为子类的那个，所以输出Ｂ２．这个和左边那个不是一样啊，在运行期绑定了子类的ｐｒｉｎｔ（）方法，执行的时候，方法里调用了ｓｕｐｅｒ。ｐｒｉｎｔ（），也就是父类的ｐｒｉｎｔ（）方法。所以输出是Ａ其实这两个程序完全一样的嘛，只不过子类中ｐｒｉｎｔ（）方法中的内容不同而已。
现在应该明白了吧，结账哦。