新手C#構造函數、繼承、組合的學習2018.08.06/07

　　構造函數，是一種特殊的方法。主要用來在建立對象時初始化對象，即爲對象成員變量賦初始值，總與new運算符一塊兒使用在建立對象的語句中。特別的一個類能夠有多個構造函數，可根據其參數個數的不一樣或參數類型的不一樣來區分它們即構造函數的重載。寫一個類，若是沒有寫任何的構造函數，那麼這個類有一個默認的無參數的構造函數。若是寫了構造函數，那麼在這個類中就有兩個構造函數，一個默認的，一個是本身寫的，不過，本身寫了構造函數，以前默認的那個構造函數就不能用了，若是還想用以前的那個默認的構造函數，就必須再從新寫一個無參數的構造函數。

　　構造函數的命名與類名相同，沒有返回值，也不能用void修飾，只有訪問修飾符public等。

    class Program
    {
        static void Main(string[] args)
        {
            Pet p1 = new Pet();//此處執行構造函數Pet()
            Pet p2 = new Pet(100);//此處執行構造函數Pet(int)
            Console.WriteLine(p1.Health);
            Console.WriteLine(p2.Health);
            Console.ReadKey();
        }
    }
    class Pet
    {
        private int health;
        private int fulllevel;
        //構造函數沒有返回值，名字和類名相同
        //構造函數在對象被new的時候調用
        //若是不指定構造函數，即註釋掉下面的Pet()函數，類中會默認建立一個無參的構造函數
        //當制定了一個構造函數，就不會有默認的無參構造函數，若須要無參構造函數則須要本身寫
        public Pet()
        {
            this.health = 20;
            this.fulllevel = 100;
        }
        public Pet(int health)
        {
            this.health = health;//後一個health是形參的health
        }
        public int Health
        {
            get
            {
                return health;
            }
        }
    }

一個類能夠有多個構造函數,可根據其參數個數的不一樣或參數類型的不一樣來區分它們 即構造函數的重載。構造函數不能被直接調用，必須經過new運算符在建立對象時纔會自動調用；而通常的方法是在程序執行到它的時候被調用的；每次實例化（既上面的new A（））一個類時，就會調用構造函數。

　　繼承是根據一個類來定義另外一個類，子類包含父類中全部字段，例如，哺乳動物爲一個類，人爲哺乳動物的一個派生類。

 

    class Person//父類
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public Person()
        {
            Console.WriteLine("A構造");
        }
    }
    class Chinese:Person//派生類，包含有Person類中的Name，Age字段和自生的gender字段
    {
        public string gender
        {
            get;
            set;
        }
        public Chinese()
        {
            Console.WriteLine("B構造");
        }
    }

 

 

 

　　子類對象能夠指向父類中的變量，顯式轉換轉換失敗會報錯，而as轉換失敗不會報錯，會使結果爲null。還有個類型的判斷符爲is，用於判斷一個類型是否爲指定類型，返回值爲true或者false。

    class Program
    {
        static void Main(string[] args)
        {
            Chinese chi=new Chinese();//一個new就是一個對象
            //chi.gender="man";
            //chi.Age = 15;
            //Console.WriteLine(chi.Age);
            Person people = chi;//父類變量能夠指向子類的變量
            chi.gender="man";
            //Chinese ch = people;//沒法把子類變量指向父類的變量
            Chinese ch = (Chinese)people;//經過顯式轉換能夠使子類變量指向父類的變量,若是轉換失敗就拋異常
            Chinese ch1 = people as Chinese;//若是轉換失敗不報錯，結果爲null
            if (ch1 is Chinese)
            {
                Console.WriteLine(ch1.Name);
            }
            Console.ReadKey();
        }
    }

 

　父類和子類中，你聲明的是哪個，調用時就調用哪個，以下面的例子

        static void Main(string[] args)
        {
            //子類和父類的調用時，前面聲明的是子類就調用子類，聲明的是父類就調用父類
            //由於聲明瞭哪個，類型指針就是哪個
            Human xiaoming=new Human();
            xiaoming.Age=20;
            xiaoming.Gender=true;
            xiaoming.Name="小明";
            xiaoming.SayHi();
            Console.WriteLine();

            Person xiaohong=new Human();
            xiaohong.Age = 25;
            xiaohong.Gender = false;
            xiaohong.Name = "小紅";
            xiaohong.SayHi();

            Console.ReadKey();
        }
    }

    class Person
    {
        #region 姓名
        /// <summary>
        /// 姓名
        /// </summary>
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        } 
        #endregion
        #region 年齡
        /// <summary>
        /// 年齡
        /// </summary>
        private int age;
        public int Age
        {
            get { return age; }
            set { age = value; }
        } 
        #endregion
        #region 性別
        /// <summary>
        /// 性別
        /// </summary>
        private bool gender;
        public bool Gender
        {
            get { return gender; }
            set { gender = value; }
        } 
        #endregion

        public virtual void SayHi()//虛方法，用於重寫
        {
            Console.WriteLine("父類");
        }
    }

    class Human:Person
    {
        public void SayHi()
        {
            Console.WriteLine("子類");
        }
    }
}

 

 

最後執行代碼的結果爲

 

 

這是由於你聲明瞭哪一個類型，類型指針就肯定了是哪個，聲明瞭Person父類，就算實例化new爲子類Human，類型指針仍是父類。

　　多重繼承C#中不支持，只能使用接口才能實現，如今還沒學會，留待之後補全。

 執行子類的構造函數時，會自動先執行父類的構造函數，當父類中的構造函數爲無參時，子類也爲無參，當父類中構造函數爲有參構造函數時，子類須要添加以下所示

        //父類中
        public Person(int b)
        {
            Console.WriteLine("A構造");
        }
        //子類中
        public Chinese():base(1)
        {
            Console.WriteLine("B構造");
        }

子類中的構造函數既能夠有參也能夠無參。而若是Person還有父類，則會先調用Person的父類的構造函數。構造函數調用老是從最年長的開始調用，即最老的父類。protected的函數只能在子類及本身中調用，主函數中不可調用。

 　　類的組合：當你須要用到某一個類中的部分對象，只須要把須要的對象加入到你的類中便可。

        static void Main(string[] args)
        {
            Monkey houzi=new Monkey();
            houzi.PS=new Person();
            houzi.吃香蕉();
            Console.ReadKey();
        }
    }

    class Person//父類
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public void 吃飯()
        {
            Console.WriteLine("飯好吃");
        }
    }

    class Monkey//組合，若只想使用一個類中的部分動做，不用繼承，而用組合，是讓另一個類幫助你完成這個動做
    {
        public Person PS//定義一個PS爲Person類
        { get; set; }
        public void 吃香蕉()//吃香蕉這個動做由Person類中的吃飯完成
        {
            PS.吃飯();
        }
    }

 

 

2018.08.06/07