public class  Base
    {
        public virtual void test()
        {
            Console.WriteLine("这是父类方法!");         }
    }    public class Class1:Base 
    {
        public override void test()
        {
            Console.WriteLine("这是CLASS1方法"); 
            //base.test();
        }
    }    public class Class2 : Base 
    {
        public new  void test()
        {
            Console.WriteLine("这是Class2方法!");
            //base.test();
        }
    }        Base b = new Base();
            Class1 class1 = new Class1();
            Class2 class2 = new Class2();
            b.test(); //输出 这是父类方法
            class1.test();  //输出 这是CLASS1方法
            class2.test(); //输出 这个 Class2 方法 
---上面的结果 说明 override 和 new 有达到了 重写的目的 
参考 msdn
          Base[] b = new Base[2];
            b[0] = new Class1();
            b[1] = new Class2();
            foreach (Base bb in b)
            {
                bb.test(); 
            }
输出结果是 : 这是CLASS1方法
              这是父类方法  //主要 是这里不明白,为什么 又是调用的父类方法呢 ,明明 实列化 的new class2()
请高手释疑???
            

解决方案 »

  1.   

    因为你定义的是Base类型的对象,class1()重写了父类中的test()方法,而class2()没有重写.就这么简单.
      

  2.   

    因为这句Base[] b = new Base[2];
      

  3.   

    因为这句Base[] b = new Base[2];
    ---
    因为这句什么,能否说清楚点 
      

  4.   

    当定义为override,Base[] b 引用的是子类实例的方法
    当定义为new,Base[] b 引用的是本身的方法
      

  5.   

    new  ----- 执行申明类型方法
    overwrite  ----- 执行实例类型方法
      

  6.   

    这是编译器优先级的原因,public new  void test()是覆盖父类public virtual void test()方法.
    而public override void test()是重写父类public virtual void test()方法.当new class1()这个对象的时候,不论如何,都会先执行重写父类中test()方法的语句.
    new class2()的时候不会执行public new  void test()这句.因为你并没有调用真正意义上的class2()对象.
    而是一个base对象而已...最起码编译译器的开发人员应该是这么理解的...所以你问的问题只有一个答案,就是你这么写编译器不会先覆盖父类中的方法,如果你一定要问为什么..那么就要到微软去把那个开发C#的人拖出来打一顿.
      

  7.   

    因为定义了父类的引用b,初始化的时候并不知道父类的引用b指向父类的方法还是子类的方法,所以使用关键字override和new来加以区分
      

  8.   

    Base b = new Base(); 的时候在内存中这个b的首地址已经被保存了,用override的时候把原来的对象覆盖了,而用new的时候是新创建了一个对象,当b[1] = new Class2(); 时只是在原内存中添加了一个对象的地址,这个时候b的引用没变,依然是原来的b的地址,而不是新增的对象的地址.所以有了以上的结果.