继承是什么？  
在上⼀节课中学习了如何定义类，⽤类当做模板来声明我们的数据。  
很多类中有相似的数据，⽐如在⼀个游戏中，有Boss类，⼩怪类Enemy，这些类他们有
很多相同的属性，也有不同的，这个时候我们可以使⽤**继承来让这两个类继承⾃同⼀个类**。  

## 继承的类型
**实现继承：**  

表⽰⼀个类型派⽣于⼀个基类型,它拥有该基类型的所有成员字段和函数。 在实现继承中,派⽣类型采⽤基类型的每个函数的实现代码,除⾮在派⽣类型的定义中指定重写某个函数的实现代码。 在需要给现有的类型添加功能,或许多相关的类型共享⼀组重要的公共功能时,这种类型的继承⾮常有⽤。  

**接⼝继承：**  

表⽰⼀个类型只继承了函数的签名,没有继承任何实现代码。 在需要指定该类型具有某些可⽤的特性时,最好使⽤这种类型的继承。  

**多重继承**  

⼀些语⾔(C++)⽀持所谓的 “多重继承”,即⼀个类派⽣⾃多个类。   
使⽤**多重继承的优点**是有争议的:  
1. 可以使⽤多重继承编写⾮常复杂、但很紧凑的代码。  
2. 使⽤多重实现继承的代码常常很难理解和调试。   

如前所述,简化健壮代码的编写⼯作是开发 C#的重要设计⽬标。因此,**C#不⽀持多重实现继承**。  ⽽ **C#允许类型派⽣⾃多个接口— — 多重接⼝继承**。 这说明,C#类可以派⽣⾃另⼀个类和任意多个接⼝。  
更准确地说,
**System.Object 是⼀个公共的基类,所以每个C#(除了Object类之外)都有⼀个基类,还可以有任意多个基接⼝。**  

## 实现继承
如果要声明派⽣⾃另⼀个类的⼀个类,就可以使⽤下⾯的语法:  

```c#
class MyDerivedClass : MyBaseclass
{
// functions and data members here
}  
```

如果类(或 结构)也 **派⽣ ⾃ 接⼝,则⽤逗号分隔列表中的基类和接口**:  

```c#
public class MyDerivedClass: MyBaseClass , IInterface1 , IInterface2
{
// etc.
}** **
```

```c#
//基类 BaseClass.cs
    class BaseClass
    {
        public int data1;
        public string data2;

        public void Function1()
        {
            Console.WriteLine("BaseClass:Function1");
        }
        public void Function2()
        {
            Console.WriteLine("BaseClass:Function2");
        }
    }
```  

```c#
//派生类 DrivedClass1.cs
    class DrivedClass1:BaseClass
    {
        public int data3;

        public void FunctionDrivedClass1()
        {
            Console.WriteLine("FunctionDrivedClass1");
        }
    }
``` 

```c# 
//使用  Program.cs
            BaseClass bc = new BaseClass();
            bc.Function1();
            bc.Function2();

            DrivedClass1 dc1 = new DrivedClass1();
            dc1.Function1();
            dc1.Function2();
``` 

**案例实现**  

基类敌⼈类( hp speed ⽅法 ai move )  

```c#  
//新建基类 Enemy.cs
    class Enemy
    {

        protected int hp;// private protected public 
        protected int speed;

        public void AI()
        {
            Console.WriteLine("AI");
        }
        public void Move()
        {
            Console.WriteLine("Move");
        }

    }
```
派⽣出来两个类
- boss类
- type1enemy类
- type2enemy类  

```c# 
//新建类 boss.cs
    class Boss:Enemy
    {
        private int attack;
        private int hp;
        
        public Boss(int attack,int hp,int speed)
        {
            this.attack = attack;
            base.hp = hp;
            base.speed = speed;            
        }

        public void Skill()
        {
            Console.WriteLine("Boss Skill");
        }

        public void Print()
        {
            Console.WriteLine("HP:" + hp);
            Console.WriteLine("Base.HP:" + base.hp);
            Console.WriteLine("Speed:" + speed);
            Console.WriteLine("Attack:" + attack);
        }
    }
```

```c#
//新建类 Type1Enemy.cs
    class Type1Enemy:Enemy
    {
    }
```

```c#
//新建类 Type2Enemy.cs
    class Type2Enemy:Enemy
    {
    }
```

```c#
//使用  Program.cs
            Boss boss1 = new Boss(100,100000,20);
            boss1.Print();
```
## this和base关键字
this（base）作⽤：
- IDE给提⽰
- 区分局部变量和字段  

**this可以访问当前类中定义的字段,属性和⽅法**，有没有this都可以访问，有this以让IDE VS编译器给出提⽰，另外当⽅法的参数跟字段重名的时候，使⽤this可以表明访问的是类中的字段，**base只可以调⽤⽗类中的公有⽅法和字段**,有没有base都可以访问，但是加上base.IED⼯具会给出提⽰，把所有可以调⽤的字段和⽅法罗列出来⽅便选择

⾯向对象-继承

程序内存区域：**堆 栈 静态存储区**  
- 程序所有的数据，也就是所有的变量，都是存储在内存中的。  
- 栈空间⽐较⼩，但是读取速度快  
- 堆空间⽐较⼤，但是读取速度慢  

商店和仓库  

![image.png](/static/img/e22335489a56a4d42387f38193a6579f.image.png)  

## 栈
  
栈的特征：  
**数据只能从栈的顶端插⼊和删除**  
- 把数据放⼊栈顶称为⼊栈（push）  
- 从栈顶删除数据称为出栈（pop）  
  

![image.png](/static/img/7ad4b37c10b5f0609a74bd391bbf722f.image.png)  

内存中的栈，是由系统管理（.Net框架）。  

我们之后会在数据结构中学习写⼀个⾃⼰的栈结构，保存数据。  

## 堆
堆是⼀块内存区域，与栈不同，**堆⾥的内存能够以任意顺序存⼊和移除** 

![image.png](/static/img/acd692e52e1af27ddeebcd0200662ce5.image.png)  

GC Garbage Collector垃圾回收器  
CLR的GC就是内存管理机制，我们写程序不需要关⼼内存的使⽤，因为这些都是CLR帮我们做了。类似新生宿舍楼

![image.png](/static/img/11bba734862dffdc71267c4e21e77a0d.image.png)  

这⾥的某些概念，只需要了解和知道的，不需要知道内在核⼼原理，我们知道汽⻋的引擎
是汽⻋的核⼼动⼒来源，我们不需要知道引擎是怎么造。  
同样，上述是编译器开发者的事情。  

## 值类型和引⽤类型
类型被分为两种：  
- **值类型(整数，bool struct char ⼩数)**   😀 默认值为0
- **引⽤类型（string 数组 ⾃定义的类，内置的类）** 😀 默认值为null 

**值类型**只需要⼀段单独的内存
- ⽤于存储实际的数据，（单独定义的时候放在栈中）  

**引⽤类型**需要两段内存  
- 第⼀段存储实际的数据，它总是位于堆中
- 第⼆段是⼀个引⽤，指向数据在堆中的存放位  （这里的引用是内存地址，类似酒店房间号）


![image.png](/static/img/3ac5380e562a0e17b2f63dae660ce967.image.png)  

:::warning{title="注意"}
当我们**使⽤引⽤类型赋值的时候**，其实是**赋值的引⽤类型的引⽤**  
如果数组是⼀个值**类型的数组**，那么数组中直接存储值，如果是⼀个引⽤类型的数组（数组中存储的是引⽤类型），那么数组中存储的是**引⽤（内存地址）**
:::
  

```c#
//新建类 Customer.cs
    class Customer
    {
        public string name;
        public string address;
        public int age;
        public string createTime;

        public Customer(string name, string address, int age, string createTime)
        {
            this.name = name;
            this.address = address;
            this.age = age;
            this.createTime = createTime;
        }

        public void Show()
        {
            Console.WriteLine("名字：" + name);
            Console.WriteLine("地址：" + address);
            Console.WriteLine("年龄：" + age);
            Console.WriteLine("创建时间：" + createTime);
        }
    }
```

```c#
//使用   Program.cs
            int a = 123;
            float b = 34.5f;
            bool c = true;

            string name = "zhangsan";

            int[] array1 = new int[] { 23, 23, 11, 32, 4, 2435 };
            string[] array2 = new string[] { "www", "baidu", "com" };

            Customer c1 = new Customer("张三", "上海", 13, "2022");
            
            //引用对象的改变
            Customer c2 = c1;
            c1.Show(); //输出中文张三
            c2.Show(); //输出中文张三
            
            c2.name = "zhangsan";
            c2.Show(); //输出zhangsan
            c1.Show(); //输出zhangsan

//将地址清空
            c1 = null;//空 空引用 空对象
            c2 = null;
```  

![image.png](/static/img/f24a1e3edbea536dbf10c8a54f188f3e.image.png)

程序内存区域

## 构造对象
我们构造对象的时候，对象的初始化过程是⾃动完成的，但是在初始化对象的过程中有的
时候需要做⼀些额外的⼯作，例如需要初始化对象存储的数据，**构造函数就是⽤于初始化数据的函数**。  

声明基本的构造函数的语法就是声明⼀个和所在类同名的⽅法，但是该⽅法没有返回类型。 
```c#
public class MyClass{  
public MyClass(){  
这个构造函数的函数体  
}  
}  
``` 

当我们**使⽤new关键字创建类的时候，就会调⽤构造⽅法**。  
我们⼀般会使⽤构造⽅法进⾏初始化数据的⼀些操作。  
构造函数可以进⾏重载，跟普通函数重载是⼀样的规则  


:::warning{title="注意"}
 当我们不写，任何构造函数的时候，编译器会提供给我们⼀个默认的 **⽆参的构造函数**，但是如果我们定义了⼀个或者多个构造函数，编译器就不会再提供默认的构造函数  
:::



## 属性的定义
**属性的定义结构**：  

```c#
public int MyIntProp{
get{
// get code
}
set{
//set code
}
} 
```
 
- 定义属性需要名字和类型  
- 属性包含两个块 get块和set块  
- 访问属性和访问字段⼀样，当取得属性的值的时候，就会调⽤属性中的get块，所以
get块，类型需要⼀个返回值就是属性的类型；当我们去给属性设置值的时候，就会调⽤属性中的set块，我们可以在set块中通过value访问到我们设置的值。  

**通过属性来访问字段**   

我们习惯上把字段设置为私有的，这样外界不能修改字段的值，然后我们可以通过定义属
性来设置和取得字段中的值。 

```c#
private int age;  
public int Age{//习惯上属性⼤写 字段⼩写
 
 set{
if(value<0)return;
age = value;
}
get{
return age;
}
} 
```
 

1、设置属性的只读或者只写  

```c#
private string name;
public string name{
get{
return name;
}
}  
```


属性可以值只提供⼀个set块或者get块 

2、属性的访问修饰符  

```c#
public string name{
get{
return name;
}
private set{
name = value;
}
} 
```
 

3、⾃动实现的属性  

```c#
public int Age{get;set;}  
```

编译器会⾃动创建private int age属性  


## 匿名类型
我们创建变量（对象的时候），必须指定类型，其实我们也可以**不去指定类型，这个就是匿名类型**，我们可以使⽤var声明⼀个匿名类型。  
**使⽤var声明的匿名类型，当初始化的时候，这个变量的类型就被确定下来，并且以后不可以修改。**  

```c#
var var1 = 34;
```

构造函数

**类的定义和声明**   

定义⼀个⻋辆（Vehicle）类，具有Run、Stop等⽅法，具有Speed（速度）、
MaxSpeed（最⼤速度）、Weight（重量）等域（也叫做字段）。
使⽤这个类声明⼀个变量（对象）  

```c#
//新建类  Vehicle.cs
    class Vehicle
    {
        public string brand;
        public int speed;
        public int maxSpeed;
        public float weight;

        public void Run()
        {
            Console.WriteLine("车辆跑起来了");
        }
        public void Stop()
        {
            Console.WriteLine("车辆停止了");
        }
    }
```  

```c#
//使用   Program.cs
            Vehicle car1 = new Vehicle();

            car1.Run();
            car1.Stop();
```
定义⼀个向量（Vector3）类，⾥⾯有x，y，z三个字段，有取得⻓度的⽅法，有设置属性
（Set）的⽅法
使⽤这个类声明⼀个变量（对象）  

```c#
//新建类  Vehicle3.cs
    class Vector3
    {//基本类型 0   值类型的默认值0   引用类型的默认值是null
        private float x;
        private float y;
        private float z;

        public void SetX(float temp)
        {
            if (temp < 0)
            {
                return;
            }
            x = temp;
        }
        public void SetY(float temp)
        {
            if (temp < 0) return;
            y = temp;
        }
        public void SetZ(float temp)
        {
            if (temp < 0) return;
            z = temp;
        }
        public double Length()
        {
            return Math.Sqrt(x*x +y*y+z*z);
        }
    }
```  

```c#
//使用   Program.cs 
            Vector3 v1 = new Vector3();

            v1.SetX(-3);
            v1.SetY(4.5f);
            v1.SetZ(6.7f);

            Console.WriteLine(v1.getX());
            Console.WriteLine(v1.Length());
```

类的定义和声明

## 什么是⾯向对象编程？
为什么使⽤⾯向对象编程？    

为了让编程更加清晰**把程序中的功能进⾏模块化划分，每个模块提供特定的功能，⽽且每个模块都是孤⽴**的，这种模块化编程提供了⾮常⼤的多样性，⼤⼤增加了重⽤代码的机会。  
⾯向对象编程也叫做OOP编程   
简单来说**⾯向对象编程就是结构化编程，对程序中的变量结构划分，让编程更清晰**。   

注意：不要从字⾯意思理解⾯向对象编程  
我们把**类创建的变量叫做对象**，那么如何创建类呢？  

类是什么东⻄？  

**类实际上是创建对象的模板**，每个对象都包含数据，并提供了处理和访问数据的⽅法。
类定义了类的每个对象（称为实例）可以包含什么数据和功能。  
 
## 类的定义

**类中的数据和函数称为类的成员** 
-  数据成员  
-  函数成员  
 
数据成员：
 **数据成员是包含类的数据--字段，常量和事件的成员**。  
函数成员：
 **函数成员提供了操作类中数据的某些功能**。（⽅法，属性，构造⽅法和终结器（析构⽅法），运算符，和索引器）  

## 类的字段和⽅法

**字段的声明**  
 访问修饰符 类型 字段名称;    
 
**⽅法的声明**  
 访问修饰符 返回值类型 ⽅法名称(参数){  
 //⽅法体  
 }    
 
```c#
// 定义⼀个类来表⽰⼀个顾客  
class Customer{
                public string name;
                public string address;
                public int age;
                public string buyTime;
                public void Show()
                {
                Console.WriteLine("名字:"+name);
                Console.WriteLine("年龄:"+age);
                Console.WriteLine("地址:"+address);
                Console.WriteLine("购买时间:"+buyTime);
                }
               }  
```

在这⾥我们定义了⼀个类，叫做Customer（顾客），⾥⾯包含了四个字段，存储了顾客的名字，年龄，地址和购买时间，包含了⼀个**Show（）⽅法，⽤来输出⾃⾝的⼀些信息**的，在这⾥Customer就是⼀个新的数据类型  

类似于**结构体的定义** 

```c#
struct Customer......;  
```
如何利⽤类创建对象  
使⽤我们**⾃定义的类声明的变量也叫做对象**，这个过程也叫做**实例化**

```c#
ClassName myClass = new ClassName();  
```
其中ClassName是我们定义的类的名字，myClass是我们声明的变量（对象）的名字，后⾯的**new**是⼀个关键字，**使⽤new 加上类型名（）表⽰对该对象进⾏构造**，如果不进⾏构造的话，这个对象是⽆法使⽤的。

⾯向对象编程

msvalidate.01

360-site-verification

sogou_site_verification

script

《千纸鹤》是一个关于个人成长、心灵探索和生活哲学的博客。通过结合纸鹤的象征意义，博客传递着希望、自由、勇气和梦想的理念，分享作者在人生旅途中所遇到的挑战与感悟。每一篇文章都如同一只飞翔的纸鹤，轻盈地载着思想与情感，带领读者在迷茫与困顿中找到属于自己的方向。