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");
        }
    }