类的复习

类的继承

  通过继承,我们可以定义一个新类,新类纳入一个已经声明的类并进行扩展.

 ■可以使用一个已经存在的类作为新类的基础,已经存在的类称为基类(base class),新类称为派生类(derived class).派生类的组成成员如下.

   □自己声明中的成员

   □基类的成员

 ■要声明一个派生类,需要在类名后加入基类规格说明,基类规格说明由冒号和后面跟着用作基类的类的名称.派生类被描述为直接继承自列出的基类.

 ■派生类被描述为扩展它的基类,因为它包含了基类的成员,加上在它自己的声明中的任何附加功能.

 ■派生类不能删除它所继承的任何成员.

 ■在c#中,所有的类都直接或间接的继承自object类.(当我们定义一个类的时候,如果没有写:继承一个类,那么这个类就继承了object类,这就是为什么C#的所有类都有Equal()方法的原因,因为Equal()方法是Object类的成员)

 ■c#中类都是单继承,不允许某个类同时继承两个及以上的类.可以这样理解,父类(基类)就是父亲,一个人只有一个父亲.一个父亲能有多个小孩,所以一个基类可以派生多个子类

例如,下面展示了类和继承的例子:

class Person//基类,或称为父类
    {
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        private int age;
        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        private char gender;
        public char Gender
        {
            get { return gender; }
            set { gender = value; }
        }
    }

class Student : Person//继承类Student
    {
        private int classId;
        public int ClassId
        {
            set { classId = value; }
            get { return classId; }
        }
        private string hobby;
        public string Hobby
        {
            set { hobby = value; }
            get { return hobby; }
        }
        public void SayHello()
        {
            Console.WriteLine("大家好,我是{0},我今年{1}岁了,我是{2}生,我是{3}班级的,我喜欢{4}", Name, Age, Gender, classId, hobby);//包含基类的成员,加自己的成员,除了基类的私有成员外,其余成员都能访问到
        }
    }

class Teacher:Person//继承类,或称子类
    {
        private string course;
        public string Cource
        {
            set{course=value;}
            get{return course;}
        }
        private int yearsOfService;
        public int YearsOfService
        {
            set { yearsOfService = value; }
            get { return yearsOfService; }
        }
    
        public void SayHello()
        {
            Console.WriteLine("你好,我是{0},我今年{1}岁了,教书{2}年了,我是{3}老师",Name,Age,yearsOfService,course);
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            Teacher t = new Teacher();
            //初始化
            t.Name = "翟群";
            t.Age = 23;
            t.YearsOfService = 2;
            t.Cource = "c#";
            t.SayHello();

            Student s = new Student();
            //初始化
            s.Name = "何雄军";
            s.Age = 24;
            s.Gender = '男';
            s.ClassId = 2;
            s.Hobby = "玩计算机";
            s.SayHello();
            Console.ReadKey();
        }
    }

 父类构造方法的调用顺序

class Person//基类,或称为父类
    {
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        private int age;
        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        private char gender;
        public char Gender
        {
            get { return gender; }
            set { gender = value; }
        }
        public Person()//会在子类构造方法之前执行
      {
            Console.WriteLine("我是父类");
        }
    }

class Student : Person//继承类Student
    {
        private int classId;
        public int ClassId
        {
            set { classId = value; }
            get { return classId; }
        }
        private string hobby;
        public string Hobby
        {
            set { hobby = value; }
            get { return hobby; }
        }
        public void SayHello()
        {
            Console.WriteLine("大家好,我是{0},我今年{1}岁了,我是{2}生,我是{3}班级的,我喜欢{4}", Name, Age, Gender, classId, hobby);//包含基类的成员,加自己的成员,除了基类的私有成员外,其余成员都能访问到
        }
        public Student()//父类构造方法执行之后才执行
        {
            Console.WriteLine("我是子类Student");
        }
     
        }

class Program
    {
        static void Main(string[] args)
        {
            Student s1 = new Student();
            //单步调试,发现,创建对象时,首先找到Student()无参构造函数,但暂不会执行Student()构造函数,而是找到父类Person()无参构造方法并执行,然后返回执行Student()构造函数

            Teacher t1 = new Teacher("翟群", 23, '女', "c#", 1);
            t1.SayHello();
        }
    }

---

 以上例子调用的是无参数构造方法,下面的例子调用的是有参构造方法

 class Person//基类,或称为父类
    {
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        private int age;
        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        private char gender;
        public char Gender
        {
            get { return gender; }
            set { gender = value; }
        }
        public Person()//建议只要自己声明了无参构造方法,务必再声明一个无参构造方法.系统默认会调用无参构造方法
        {
            Console.WriteLine("我是父类");
        }
        public Person(string name, int age, char gender)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }
    }

  class Teacher:Person//继承类,或称子类
    {
        private string course;
        public string Cource
        {
            set{course=value;}
            get{return course;}
        }
        private int yearsOfService;
        public int YearsOfService
        {
            set { yearsOfService = value; }
            get { return yearsOfService; }
        }
    
        public void SayHello()
        {
            Console.WriteLine("你好,我是{0},我今年{1}岁了,教书{2}年了,我是{3}老师", Name, Age, yearsOfService, course);
        }
        public Teacher(string name,int age,char gender,string course,int yearsOfService):base( name, age, gender)//此处若没写base(name,age,gender)构造方法,便是默认调用Person的无参构造方法即base()
        {
            this.course = course;
            this.yearsOfService = yearsOfService;
        }
        public Teacher()//建议只要自己声明了无参构造方法,务必再声明一个无参构造方法.系统默认会调用无参构造方法
        {

        }
    }

---

构造函数的调用图解过程:

注:若在同时调用一个类中的两个重载构造方法,比如同时调用Person的构造方法Person()和person(string name,int age,char gender)构造方法,代码实现为:Person(string name,int age,char gender):this().这样调用Person(string name,int age,char gender)构造方法之前会先执行person()构造方法