考点：
对类初始化(<clinit>())，类实例化(<init>())和方法重写(override)的理解。
题目：
main方法的输出结果是什么？
/*
* 父类的初始化<clinit>：
* （1）j = method();
* （2）父类的静态代码块
*
* 父类的实例化方法：
* （1）super()（最前）
* （2）i = test();
* （3）父类的非静态代码块
* （4）父类的无参构造（最后）
*
* 非静态方法前面其实有一个默认的对象this
* this在构造器（或<init>）它表示的是正在创建的对象，因为这里是在创建Son对象，所以
* test()执行的是子类重写的代码（面向对象多态）
*
* 这里i=test()执行的是子类重写的test()方法
*/
public class Father{
private int i = test();
private static int j = method();
static{
System.out.print("(1)");
}
Father(){
System.out.print("(2)");
}
{
System.out.print("(3)");
}
public int test(){
System.out.print("(4)");
return 1;
}
public static int method(){
System.out.print("(5)");
return 1;
}
}
/*
* 子类的初始化<clinit>：
* （1）j = method();
* （2）子类的静态代码块
*
* 先初始化父类：(5)(1)
* 初始化子类：（10）(6)
*
* 子类的实例化方法<init>：
* （1）super()（最前） （9）（3）（2）
* （2）i = test(); （9）
* （3）子类的非静态代码块 （8）
* （4）子类的无参构造（最后） （7）
*
* 因为创建了两个Son对象，因此实例化方法<init>执行两次
*
* （9）（3）（2）（9）（8）（7）
*/
public class Son extends Father{
private int i = test();
private static int j = method();
static{
System.out.print("(6)");
}
Son(){
// super();//写或不写都在，在子类构造器中一定会调用父类的构造器
System.out.print("(7)");
}
{
System.out.print("(8)");
}
public int test(){
System.out.print("(9)");
return 1;
}
public static int method(){
System.out.print("(10)");
return 1;
}
public static void main(String[] args) {
Son s1 = new Son();
System.out.println("---");
Son s2 = new Son();
}
}
分析：
一个类要创建实例，首先要加载和初始化该类：
1、main方法所在的类需要先加载和初始化
2、子类初始化之前要先执行父类，一个类的初始化就是<clinit>()方法()
3、初始化的内容：static静态，按顺序初始化即(5)(1)(10)(6)
下一步就是创建实例，创建实例需要对实例初始化：
前方高能预警------->
1、实例初始化就是执行<init>()方法。
2、<init>()方法可能有多个，有几个构造器就有几个<init>()方法。
3、<init>()方法由（1）非静态实例变量，（2）非静态代码块，（3）对应构造器代码组成。
4、<init>()方法的首行是super(),即对应父类的<init>()方法。
5、super一定第一个执行，对应构造器一定最后执行，其它两个按照代码的顺序执行。
根据上面的步骤，先执行的是super(),也就是对应父类的<init>
先执行父类的super，没有输出
然后执行父类的private int i = test();
按理说改输出(4)的，但是子类对test()这个方法重写了，
所以需要执行的test()方法是子类的test方法，而非父类的test()方法。
所以输出了(9)
然后执行父类的{
System.out.print("(3)");
}
输出(3)
最后是父类的构造器
Father(){
System.out.print("(2)");
}
输出(2)
至此，父类的<init>()方法执行完了，也就是子类的super()执行完了。
然后该执行子类的private int i = test();
输出(9)
然后执行子类的{
System.out.print("(8)");
}
输出(8)
最后执行子类的无参构造
Son(){
System.out.print("(7)");
}
输出(7)
最终的结果是：(5)(1)(10)(6)(9)(3)(2)(9)(8)(7)---(9)(3)(2)(9)(8)(7)
如果对上述的分析还是不理解，就再做一题！
public class Father{
private static int j = method();
static{
System.out.print("(1)");
}
Father(){
System.out.print("(2)");
}
{
System.out.print("(3)");
}
private int i = test();
public int test(){
System.out.print("(4)");
return 1;
}
public static int method(){
System.out.print("(5)");
return 1;
}
}
public class Son extends Father{
private int i = test();
private static int j = method();
static{
System.out.print("(6)");
}
Son(){
System.out.print("(7)");
}
{
System.out.print("(8)");
}
public int test(){
System.out.print("(9)");
return 1;
}
public static int method(){
System.out.print("(10)");
return 1;
}
public static void main(String[] args) {
Son s1 = new Son();
System.out.println("---");
Son s2 = new Son();
}
}
答案是：(5)(1)(10)(6)(3)(9)(2)(9)(8)(7)---(3)(9)(2)(9)(8)(7)
你会发现(9)(3)换了位置，这就是之前所说的顺序问题：
5、super一定第一个执行，对应构造器一定最后执行，其它两个按照代码的顺序执行。
针对方法的重写Override
哪些方法不能被重写？
1、final
2、private
3、静态方法
哪些方法能被重写？
除了上述的情况，剩下的都能被重写！
