class Base {
int i;
Base() {
add(1);
}
void add(int v) {
i += v;
}
void print() {
System.out.println(i);
}
}
class Extension extends Base {
Extension() {
add(2);
}
void add(int v) {
i += v*2;
}
}
public class jtest {
public static void main(String args[]) {
bogo(new Extension());
}
static void bogo(Base b) {
b.add(8);
b.print();
}
}
给出结果，并解释之

22吧，i应该被初始化成0，先是
Base() {
add(1);
}
然后i=2
Extension() {
add(2);
}
在i=6
class Extension extends Base {
void add(int v) {
i += v*2;
}
}
i=22

Example:
A extends B；B extends C

程序运行顺序：C中的interface/static-->B中的interface/static-->A中的interface/static-->C中的instance variable/constructor-->B中的instance variable/constructor-->A中的instance variable/constructor-->A中的main()

里面还有更深的概念，自己写程序去试：System.out.println("check: "+ variable)：

结果是：22
Extension类从Base类继承了i,但覆盖了add方法，所以两个类中的i是同一个。
在jtest类中，new Extension()创建了一个新的子类对象，首先执行父类的构造方法，其中的方法add指的是子类的add（多态性），i变成2，再执行子类的构造方法，i变成6
然后并作为参数传递给方法bogo,bogo的参数是Base类的（把子类对象的引用赋给了参数b）
b.add(8)调用的是子类的add方法，因此为22

主要是 1.构建器的初始化顺序:父类构建器->子类构建器
        2.方法覆盖:在类Base中add(int v)方法被覆盖

流程是这样的，先初始化
static void bogo(Base b) {
b.add(8);
b.print();
}
然后才开始main()方法，但当bogo方法调用到 Base类的变量时，又要先初始化Base类，然后在类推，太烦了，你自己推吧！