C#编程入门10_面向对象之继承

继承概念

在C#中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有的类被称作父类，子类会自动拥有父类除构造方法和析构方法以外的所有成员。 
继承关系的相关语法： 
class 子类：父类 
{

}

对于继承父类的子类来说，子类可以使用父类中公有的成员。

对于C#来说，子类单继承一个父类，也就是说，C#继承具有单一性。 
多个类可以同时继承同一个父类。

在C#中，多层继承是可以的，即一个类的父类可以再去继承其他类，例如C类继承自B类，B类又继承自A类，这时，C类也可称作A类的子类。

在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。例如猫和狗都属于动物，在程序中便可认为猫和狗继承自动物，同理波斯猫和巴厘猫继承自猫，而沙皮狗和斑点狗继承自狗，这些动物之间会形成一个继承体系，具体如图 

---

---

子类都继承了父类哪些内容？

公有的字段是可以被继承的 
公有的属性是可以被继承的 
公有的方法可以被继承 
构造方法是不可以被继承的 
【注意】所有公有的方法是可以被继承的 说法是错误的，因为公有的构造方法是不能被继承的

---

base关键字

---

父子类之间构造方法执行的顺序

---

装箱拆箱操作

在实际开发过程中，某些方法的参数类型为引用类型，但是如果调用时传入的是值类型，此时需要进行装箱操作。同样当一个方法的返回值类型为值类型，但实际方法返回值为引用类型，那么就需要进行拆箱操作。简单来说，装箱就是将值类型转换为引用类型，拆箱就是将引用类型转换为值类型

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

namespace 装箱拆箱操作
{
    class Program
    {
        static void Main(string[] args)
        {
            //装箱拆箱操作是在值类型和引用类型之间进行转化
            int num1 = 100;
            //装箱操作
            //将值类型转化成引用类型
            object obj1 = num1;

            object obj2 = 12;
            //拆箱操作
            //将引用类型转化成值类型
            int num2 = (int)obj2;
        }
    }
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

装箱和拆箱过程本质上是数据存储在栈与堆之间变更，因此频繁的装箱、拆箱操作会影响运算效率，所以要尽量减少相关操作。

---

里氏转换原则

子类：

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

namespace 里氏转换原则
{
    class Dog:Animal
    {

        public Dog()
        {

        }
        public Dog(string name, int age, char gender):base(name,age,gender)
        {

        }

        public void Bark()
        {
            Console.WriteLine("吠");
        }


    }
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

父类：

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

namespace 里氏转换原则
{
    class Animal
    {
        private string name;
        private int age;
        private char gender;

        public string Name
        {
            get
            {
                return name;
            }

            set
            {
                name = value;
            }
        }

        public int Age
        {
            get
            {
                return age;
            }

            set
            {
                age = value;
            }
        }

        public char Gender
        {
            get
            {
                return gender;
            }

            set
            {
                gender = value;
            }
        }

        public Animal()
        {

        }
        public Animal(string name, int age, char gender)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }

        public void Eat()
        {
            Console.WriteLine("吃");
        }
    }
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

Program类

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

namespace 里氏转换原则
{
    class Program
    {
        static void Main(string[] args)
        {

            //里氏转换原则  是在父子类之间进行转化
            //向上转型 类似隐式类型转换
            Animal anial = new Dog();
            anial.Eat();
            //向下转型 类似强制类型转换
            Dog dog = (Dog)anial;
            dog.Eat();
            dog.Bark();
        }
    }
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

---

is和as的区别

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

namespace is和as的区别
{
    class Program
    {
        static void Main(string[] args)
        {
            Animal[] animals = new Animal[5];
            animals[0] = new Dog("小黑",1,'公');
            animals[1] = new Cat("小白", 1, '母');
            animals[2] = new Dog("小灰", 1, '母');
            animals[3] = new Cat("小花", 1, '公');
            animals[4] = new Dog("小纯", 1, '母');

            for (int i = 0; i < animals.Length; i++)
            {
                //is关键字
                //is不会讲对象直接进行转化 会在转化之前 进行一次判断 如果类型匹配则返回true  类型不匹配 则返回false  然后需要根据返回值进行适当操作
                //bool ret = animals[i] is Dog;
                //if (ret)
                //{
                //    ((Dog)animals[i]).Bark();
                //}
                //else
                //{
                //    ((Cat)animals[i]).Bark();
                //}

                //as  
                //as 可以将animals[i]直接转化  转化成功  返回一个Dog实例  否则返回null

                Dog dog = animals[i] as Dog;
                if (dog !=null)
                {
                    dog.Bark();
                }

                Cat cat = animals[i] as Cat;
                if (cat != null)
                {
                    cat.Bark();
                }
            }
        }
    }
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

---

对父类的公有字段、方法、属性进行隐藏

子类在继承父类时可以对父类的成员进行扩展，如果子类中出现与父类同名的方法，那么在调用该方法时程序就不能明确该方法是属于父类还是子类，这时编译器就会提示使用new关键字隐藏基类方法。

在子类的字段、属性、方法的访问修饰符(一般是public)之后添加new即可 
示例代码如下

public new void Eat()
{
     Console.WriteLine("猫在食物");
}
   
   
1
2
3
4

---

密封类：

在C#中，使用sealed关键字修饰的类不可以被继承，也就是说不能派生子类，这样的类通常被称作密封类。 
我们经常使用的string类型就是一个密封类

---