C#与Java实例化对象时的差异

先来看看一段Java代码：package example;class Print { public Print（String info） {
System.out.println（"测试信息----" + info）;
}
}class BaseA { private Print p = new Print（"实例变量A"）;
private static Print p1 = new Print（"静态变量A"）; static {
System.out.println（"BaseA静态块"）;
} public BaseA（） {
System.out.println（"BaseA构造方法"）;
} public void Invoke（） {
System.out.append（"Invoke----BaseA"）;
}
}class BaseB extends BaseA { private Print p = new Print（"实例变量B"）;
private static Print p1 = new Print（"静态变量B"）; static {
System.out.println（"BaseB静态块"）;
} public BaseB（） {
System.out.println（"BaseB构造方法"）;
} @Override
public void Invoke（） {
System.out.append（"Invoke----BaseB"）;
}
}class BaseC extends BaseB { private Print p = new Print（"实例变量C"）;
private static Print p1 = new Print（"静态变量C"）; static {
System.out.println（"BaseC静态块"）;
} public BaseC（） {
System.out.println（"BaseC构造方法"）;
} @Override
public void Invoke（） {
System.out.append（"Invoke----BaseC"）;
}
}public class Test { public static void main（String[] args） {
BaseC bc = new BaseC（）;
bc.Invoke（）;
}
}run:
测试信息----静态变量A
BaseA静态块
测试信息----静态变量B
BaseB静态块
测试信息----静态变量C
BaseC静态块
测试信息----实例变量A
BaseA构造方法
测试信息----实例变量B
BaseB构造方法
测试信息----实例变量C
BaseC构造方法
Invoke----BaseC成功构建（总时间: 0 秒）由此可见：Java在实例化对象的时候有几个规律1、静态的肯定在前面：静态变量>静态块代码2、总是从最底层的类开始实例化，从父类开始把所有静态的加载完，然后从父类开始把所有实例的东东加载完执行顺序：1. 初始化ParentClass的静态字段（按声明顺序）
2. 初始化ParentClass的静态块
3. 初始化ChildClass的静态字段（按声明顺序）4. 初始化ChildClass的静态块5. 初始化ParentClass的实例字段（按声明顺序）
6. 初始化ParentClass的构造方法
7. 初始化ChildClass的实例字段（按声明顺序）8. 初始化ChildClass的构造方法再来看看C#的代码：using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;namespace ConsoleApplication1
{
class Print
{
public Print（string info）
{
Console.WriteLine（"测试信息---" + info）;
}
} class BaseA
{
private Print p = new Print（"实例变量A"）;
private static Print p1 = new Print（"静态变量A"）; static BaseA（）
{
Console.WriteLine（"静态构造方法A"）;
} public BaseA（）
{
Console.WriteLine（"构造方法A"）;
} public virtual void Invoke（）
{
Console.WriteLine（"Invoke---BaseA"）;
}
} class BaseB : BaseA
{
private Print p = new Print（"实例变量B"）;
private static Print p1 = new Print（"静态变量B"）; static BaseB（）
{
Console.WriteLine（"静态构造方法B"）;
} public BaseB（）
{
Console.WriteLine（"构造方法B"）;
}
public override void Invoke（）
{
Console.WriteLine（"Invoke---BaseB"）;
}
} class BaseC : BaseB
{
private Print p = new Print（"实例变量C"）;
private static Print p1 = new Print（"静态变量C"）; static BaseC（）
{
Console.WriteLine（"静态构造方法C"）;
} public BaseC（）
{
Console.WriteLine（"构造方法C"）;
}
public new void Invoke（）
{
Console.WriteLine（"Invoke---BaseC"）;
}
} class Program
{
static void Main（string[] args）
{
BaseC bc = new BaseC（）;
bc.Invoke（）;
}
}
}测试信息---静态变量C
静态构造方法C
测试信息---实例变量C
测试信息---静态变量B
静态构造方法B
测试信息---实例变量B
测试信息---静态变量A
静态构造方法A
测试信息---实例变量A
构造方法A
构造方法B
构造方法C
Invoke---BaseC1、先静态的东东在前面，静态变量>静态构造方法2、从子类到父类（非静态构造方法除外，确实从父类到子类，与Java一样）；先子类的静态——>实例，在父类静态——>实例…………父类构造方法——>子类构造方法执行顺序：1. 初始化ChildClass的静态字段（按声明顺序）

2. 初始化ChildClass的静态构造函数

3. 初始化ChildClass的实例字段

4. 调用ChildClass的构造函数,并在此中断, 调用ParentClass的构造函数, 导致ParentClass开始初始化

5. 初始化ParentClass的静态字段

6. 初始化ParentClass的静态构造函数

7. 初始化ParentClass的实例字段

8. 调用ParentClass的实例构造函数

9.ParentClass初始化完毕, 调用ChildClass的构造函数,完成创建