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#就這幾種容易混亂的函式！就這樣。