解析一下这段程序的输出结果？

Question

7.写出程序的输出结果
public abstract class A  
{
        public A()  
       {
            Console.WriteLine('A');
        }
        public virtual void Fun()  
       {
            Console.WriteLine("A.Fun()");
        }
}
public class B: A  
{
        public B() 
       {
            Console.WriteLine('B');
        }
        public new void Fun()  
       {
            Console.WriteLine("B.Fun()");
        }
        public static void Main()  
       {
           A a = new B();//A  
           a.Fun();//B 
        }
}
7.  A
    B
A.Fun()//解析一下这些输出结果8.      写出程序的输出结果：
public class A  
{
        public virtual void Fun1(int i) 
       {
            Console.WriteLine(i);
        }
        public void Fun2(A a)   
       {
            a.Fun1(1);
            Fun1(5);
        }
}public class B : A  
{
        public override void Fun1(int i)    
       {
            base.Fun1 (i + 1);
        }
        public static void Main()   
       { 
            B b = new B();//2     解析一下这些输出结果
            A a = new A();//5 
            a.Fun2(b);//1
            b.Fun2(a);   // 6   
        }
} 

Answer 1

7.写出程序的输出结果
public abstract class A  
{
        public A()  
       {
            Console.WriteLine('A');
        }
        public virtual void Fun()  
       {
            Console.WriteLine("A.Fun()");
        }
}
public class B: A  
{
        public B() 
       {
            Console.WriteLine('B');
        }
        public new void Fun()  
       {
            Console.WriteLine("B.Fun()");
        }
        public static void Main()  
       {
           A a = new B();//A  
           a.Fun();//B 
        }
}7.
  A
   B
A.Fun()A a = new B();--〉创建子类B 对象，先调用父类无参数构造函数，
然后调用自己的无参数构造函数.就是说先是调用父类构造，然后是子类。
A.Fun()--〉Fun()是一个重写方法，重写方法的调用只与生明类型有关，
因为a对象的声明是A类，虽然他使用B类构造。而覆盖方法，也就是说虚方法是跟调用者的运行时类型有关，
如果 Fun 在B里面override的话，那么a.Fun()输出结果是B.Fun()。
//解析一下这些输出结果8.      写出程序的输出结果：
public class A  
{
        public virtual void Fun1(int i) 
       {
            Console.WriteLine(i);
        }
        public void Fun2(A a)   
       {
            a.Fun1(1);
            Fun1(5);
        }
}public class B : A  
{
        public override void Fun1(int i)    
       {
            base.Fun1 (i + 1);
        }
        public static void Main()   
       { 
            B b = new B();    
              A a = new A(); 
            a.Fun2(b);
    a.Fun2(b):
    首先走到a.Fun2, 调用 a.Fun1(1)的时候，因为当前对象a是用B构造的，Fun1是一个override方法，所以调到
    B 里面的 base.Fun1 (i + 1); 输出2。然后走到Fun1(5)，这个是直接调用的，就说前面没有a.或者b.
    所以就调用A的方法，输出5。
                b.Fun2(a);  
   b 对象的 Fun2是从a继承过来的，没有覆盖，所以他将执行a.Fun1(1);和Fun1(5);
   a.Fun1(1) 的时候，因为当前Fun2(A a)方法的a是用 A构造，所以调用A.Fun1(),输出1。
           Fun1(5)的时候，因为当前调用者对象是B,而Fun1是覆盖方法，所以到 override void Fun1(int i)
          调用base.Fun1 (i + 1);输出6。
          
 
        }
}//以下是添加debug信息的 程序
 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;namespace ConsoleApplication2
{
    public class A
    {
        public virtual void Fun1(int i)
        {
            Console.WriteLine(i);
            Console.WriteLine("A-virtual void Fun1");
        }
        public void Fun2(A a)
        {
            a.Fun1(1);
            Console.WriteLine("A- Fun2");
            Fun1(5);
        }
    }    public class B : A
    {
        public override void Fun1(int i)
        {
            Console.WriteLine("B- override void Fun1");
            base.Fun1(i + 1);
        }
        
    }
    class Program
    {
        static void Main(string[] args)
        {
            B b = new B();//2    
            A a = new A();//5 
             a.Fun2(b);//1
            b.Fun2(a);   // 6 
            Console.ReadKey();
        }
    }
}