一个简单的问题

[jianjialin]

public class A{
        public virtual void fun1(int i){
            Console.WriteLine(i);
        }
        public void fun2(A a){
            fun1(5);
        }
    }
    public class B:A{
        public override void fun1(int i)
        {
            base.fun1(i+1);
        }
    }
static void Main(string[] args)
        {
            B b = new B();
            A a = new A();
            b.fun2(a);
}

为什么最后会输出6
在

public void fun2(A a){
            fun1(5);
        }

中， A类不是自己有fun1方法吗？为什么会去调用B的fun1方法呢？
基础不好，请朋友们详细解释一下

谢谢~

[hitlcyu19]

是这样的 先会执行 fun2(A a) 这个不用说吧 fun1(5) 会因为override而执行B中的fun1() fun1()中Base.fun1(5+1)就是要在执行A中的fun1(6) 然后打印出来 就是这么个执行的过程

[Snowdust]

原因很简单，因为子类重写了父类的方法，调用父类的方法时是以子类的身份进入的，如果子类已经在重写的方法，将调用子类的方法。上面的程序相当于：

public class A
{
	public virtual void fun1(int i)
	{
		Console.WriteLine(i);
	}
	public virtual void fun2(A a)
	{
		fun1(5);
	}
}
public class B : A
{
	public override void fun2(A a)
	{
		fun1(5);
	}
	public override void fun1(int i)
	{
		base.fun1(i + 1);
	}
}

[Sunpire]

由于A.fun1 是virtual的，所以根据调用者的实际类型（B），检查是否重写了 fun1，如果没有重写则调用A.fun1，反之则调用 调用者自己的fun1。
由于检查到 B 重写了 fun1() ，所以就调用了 B.fun1()。

virtual 和 abstract 可以理解为：
abstract -- Must Override ，子类必须重写，否则出错，因为基类中没有默认实现；
virtual -- Can Override ，子类可以重写，如果重写了效果和abstract相同，如果不重写则使用基类中的默认实现

[chinnel]

楼上几个,先看清楚. 他这个写法
class B 中,不管有没有 overrided fun1(int i);

他的这个结果一定会是 6.

注意
B b = new B();
。。
b.fun2(a);

又不是 A a = new B();
a.fun2

[jianjialin]

哦 我明白了 ，刚刚做了个实验
A类改为

public class A{
        public virtual void fun1(int i){
            Console.WriteLine(i);
        }
        public void fun2(A a){
            this.fun1(5);// this.getType().Name=="B"
        }
    }

这个this的B的实例。这样，自然就调用B的fun1方法了
如果B类没有fun1方法，那么调用基类的。
-----------------------------------------------------

貌似这个this和javascript的this类似呀，都表示调用者的实例？

我这样理解对吗

[allen3010]

mark

[jianjialin]

修改一下

public class A{
        public virtual void fun1(int i){
            Console.WriteLine(i);
            fun1(i);
//虽然是使用base关键字进入这里，但是该环境下 this.getType().Name依然是B
//所以会调用b.fun1 然后再进入这里。 溢出了~~~~~~~~~~~~~~~~~~
        }
        public void fun2(A a){
            this.fun1(5);
        }
    }
    public class B:A{
        public override void fun1(int i)
        {
            base.fun1(i + 1);//进入基类fun1
        }
    }
B b = new B();
            A a = new A();
            //b.fun2(a);
            b.fun1(5);

[chinnel]

this 是指向当前实例的. new B();
现在你理解的比较清晰了.

简单来说你的问题,
你使用的是 B b = new B();
直接就是个B的实例.
所以你这个用法, B 中的fun1(int i)是否重写. 跟基类一点关系都没有.