重载可以发生在子父类

原则：

1、继承来的成员函数就像自个定义的一样，所以能构成重载

 

        class BaseClass
        {
            public void fun()
            {
                Console.WriteLine("base fun !");
            }
        }

 

        class ChildClass:BaseClass
        {
            public void fun(int i)
            {
                Console.WriteLine("child fun !" + i);
            }
            
        }

 

        static void Main(string[] args)
        {
            ChildClass ccObject = new ChildClass();
            BaseClass bcObject = new BaseClass();

            ccObject.fun();
            ccObject.fun(1);
        }

 

2、不适用new关键字，且不重载的时候，直接覆盖父类的函数（就近原则）

virtual和override只是为了语法上让人能看读清代码，了解发生了重写函数

 

        class BaseClass
        {
            public void fun()
            {
                Console.WriteLine("base fun !");
            }
        }

 

        class ChildClass:BaseClass
        {
            public void fun(int i)
            {
                Console.WriteLine("child fun !" + i);
            }

            public void fun()
            {
                Console.WriteLine("child fun");
            }
          
        }

 

        static void Main(string[] args)
        {
            ChildClass ccObject = new ChildClass();
            BaseClass bcObject = new BaseClass();

            ccObject.fun();
            ccObject.fun(1);
  
        }

 

3、new关键字不能构成重载，重载需不同的参数表，new关键字指明的取代函数可以构成重载

            public void fun()
            {
                Console.WriteLine("chile fun");
            }
           
            public new void fun()
            {
                Console.WriteLine("new child fun !");
            }

 

        class BaseClass
        {
            public void fun()
            {
                Console.WriteLine("base fun !");
            }
        }

        class ChildClass:BaseClass
        {
            public void fun(int i)
            {
                Console.WriteLine("child fun !" + i);
            }

            
            public new void fun()
            {
                Console.WriteLine("new child fun !");
            }
           
            public new void fun(int i, int j)
            {
                Console.WriteLine("child fun i + j!");
            }
 
        }

        static void Main(string[] args)
        {
            ChildClass ccObject = new ChildClass();
            BaseClass bcObject = new BaseClass();

            ccObject.fun();
            ccObject.fun(1);
            ccObject.fun(1, 2);
            ccObject.fun(1);
  
        }

 

实际上从上面的代码可以看出，不适用new关键字，子类成员函数的同样覆盖父类的相同声明（未构成的重载）的函数，适用new关键字

在语法形式上，可以指出这种情况的发生，是一个好习惯，但是并不是必须的这么适用