新手C#构造函数、继承、组合的学习2018.08.06/07

时间 2019-11-08

标签新手 c# 构造函数继承组合学习 2018.08.06 栏目 C# 繁體版

原文原文链接

　　构造函数，是一种特殊的方法。主要用来在建立对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一块儿使用在建立对象的语句中。特别的一个类能够有多个构造函数，可根据其参数个数的不一样或参数类型的不一样来区分它们即构造函数的重载。写一个类，若是没有写任何的构造函数，那么这个类有一个默认的无参数的构造函数。若是写了构造函数，那么在这个类中就有两个构造函数，一个默认的，一个是本身写的，不过，本身写了构造函数，以前默认的那个构造函数就不能用了，若是还想用以前的那个默认的构造函数，就必须再从新写一个无参数的构造函数。函数

　　构造函数的命名与类名相同，没有返回值，也不能用void修饰，只有访问修饰符public等。this

    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（））一个类时，就会调用构造函数。spa

　　继承是根据一个类来定义另外一个类，子类包含父类中全部字段，例如，哺乳动物为一个类，人为哺乳动物的一个派生类。指针

    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。code

    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("子类");
        }
    }
}

最后执行代码的结果为blog

这是由于你声明了哪一个类型，类型指针就肯定了是哪个，声明了Person父类，就算实例化new为子类Human，类型指针仍是父类。继承

　　多重继承C#中不支持，只能使用接口才能实现，如今还没学会，留待之后补全。接口

执行子类的构造函数时，会自动先执行父类的构造函数，当父类中的构造函数为无参时，子类也为无参，当父类中构造函数为有参构造函数时，子类须要添加以下所示get

        //父类中
        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