C#类的方法：重载，从写，虚函数，抽象函数，隐藏基类方法！

    CSDN广告是越来越多了，所有博客笔记不再更新，新网址 DotNet笔记

1：重载   方法重载的主要好处就是,不用为了对不同的参数类型或参数个数,而写多个函数。

      特点：函数名称必须一样，返回类型可以不一样，参数可以不一样。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DeepCopy
{
    class A
    {
        private int a;
        public int aa
        {
            set { a = value; }
            get
            {

                if (a > 0)
                    return a;
                else
                {
                    return a = a + 1;
                }
            }
        }
        public void Get_A()
        {
            Console.WriteLine("重载（1）:" + this.aa.ToString());
        }
        public void Get_A(int i)
        {
            Console.WriteLine("重载（2）:" + (this.aa * i).ToString());
        }
    }
    class Program
    {
        static void Main(string[] args)
        {

            A testA1 = new A();
            testA1.Get_A();
            testA1.Get_A(4);
            Console.Read();

        }
    }
}

结果：

 

2：虚函数（virtual），重写（override）

      virtual关键字说明了这个函数可以被子类从写。

      override关键字说明了这是从写的父类的函数。

      从写将替换父类中的函数的实现代码。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DeepCopy
{
    class A
    {
        private int a;
        public int aa
        {
            set { a = value; }
            get
            {

                if (a > 0)
                    return a;
                else
                {
                    return a = a + 1;
                }
            }
        }
        public virtual void Get_A()//说明此函数为虚函数，说明可以在子类中从写！
        {
            Console.WriteLine("我是父类的:" + this.aa.ToString());
        }
    }

    class B : A
    {

        public override void Get_A()//重写父类的虚函数
        {
            Console.WriteLine("重写父类的函数:" + (this.aa + this.aa).ToString());
        }
    }
    class Program
    {
        static void Main(string[] args)
        {

            //父类先调用被重写的方法（虚函数），
            A testA1 = new A();
            testA1.Get_A();


            //通过自身调用重写的方法
            B testB = new B();
            testB.Get_A();


            //转换成父类的类型，通过父类类型对象调用，发现也被修改了！
            A testA2 = testB;
            testA2.Get_A();
            Console.Read();

        }
    }
}

结果：

 

3：隐藏函数

     从父类继承的函数没有像预期的那样工作的时候，我们就可以隐藏它，从新进行实现。被隐藏的函数不需要用virtual关键字指明，从新实现也不需要用override

     隐藏函数，如名，父类的函数并没有被覆盖。通过父类对象仍然可以调用。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DeepCopy
{
    class A
    {
        private int a;
        public int aa
        {
            set { a = value; }
            get
            {

                if (a > 0)
                    return a;
                else
                {
                    return a = a + 1;
                }
            }
        }
        public void Get_A()
        {
            Console.WriteLine("我是父类的:" + this.aa.ToString());
        }
    }

    class B : A
    {

        new public void Get_A()  //如果没有new关键字，会发生警告！不过即使没有new关键字，也不影响使用。
        {
            Console.WriteLine("我是隐藏父类后的函数:" + (this.aa + this.aa).ToString());
        }
    }
    class Program
    {
        static void Main(string[] args)
        {

            //父类先调用被重写的方法（虚函数），
            A testA1 = new A();
            testA1.Get_A();


            //通过自身调用重写的方法
            B testB = new B();
            testB.Get_A();


            //转换成父类的类型，通过父类类型对象调用，发现也被修改了！
            A testA2 = testB;
            testA2.Get_A();
            Console.Read();

        }
    }
}

结果：

 

4: 抽象函数

    抽象类中通过abstract定义抽象函数，抽象函数不能再抽象类中进行实现，并且必须在非抽象类的子类中实现。

    子类需要通过override关键字指定这是从写的父类的函数。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DeepCopy
{
    abstract class A//不能实例化对象！
    {
        private int a;
        public int aa
        {
            set { a = value; }
            get
            {

                if (a > 0)
                    return a;
                else
                {
                    return a = a + 1;
                }
            }
        }
        public abstract void Get_A();//抽象函数在父类中，不能实现；
       
    }

    class B : A
    {

        public override void Get_A()  //必须从写抽象父类的抽象函数
        {
            Console.WriteLine("我是从写抽象父类的抽象函数后的:" + (this.aa + this.aa).ToString());
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            B testB = new B();
            testB.Get_A();
            Console.Read();

        }
    }
}

结果：

 

好了。大概C#就这几种容易混乱的函数！就这样。