## 定义接口(⻜翔功能) 

```c#
public interface IFlyHandler{
public void Fly();
}  
```


## 实现接口  

```c#
public class Type1Enemy:IFlyHandler{
} 
```
 

USB接⼝，⽿机接⼝。只提供了接⼝，没有提供实现，让其他开发商实现。  
定义⼀个接⼝在语法上跟定义⼀个抽象类完全相同，但不允许提供接⼝中任何成员的实现⽅式，⼀般情况下，接⼝只能包含⽅法，属性，索引器和事件的声明。  
**接⼝不能有构造函数，也不能有字段，接⼝也不允许运算符重载**。  
接⼝定义中不允许声明成员的修饰符，**接⼝成员都是公有的**  

## 派⽣的接⼝
接⼝可以彼此继承，其⽅式和类的继承⽅式相同  

```c#
public interface A{
void Method1();
}
public interface B:A{
void Method2();
} 
```
 

⻜翔功能示例代码

```c#
//添加接口  IFly.cs
interface IFly {
  void Fly();
  void FlyAttack();
}
```

```c#
//添加飞机 类 Plane.cs
class Plane: IFly //光标定位到改行会警示  右键 💡   实现接口
{
  public void Fly() {
    Console.WriteLine("飞机在空中飞");
  }

  public void FlyAttack() {
    Console.WriteLine("在空中攻击");
  }
    }
``` 

```c#
//添加小鸟  类 Bird.cs
class Bird: IFly {
  public void Fly() {
    Console.WriteLine("小鸟在空中飞");
  }

  public void FlyAttack() {
    Console.WriteLine("小鸟在空中攻击");
  }
}
```

```c#
//使用Program.cs
//使用1
Plane p = new Plane();
p.Fly();
p.FlyAttack();

//使用2  多态
IFly fly;
fly = new Plane();
fly.Fly();
fly.FlyAttack();

fly = new Bird();
fly.Fly();
fly.FlyAttack();
```

接口

## 修饰符
修饰符，⽤来类型或者成员的关键字。修饰符可以指定⽅法的可⻅性。  
**public**: 同⼀程序集(DLL或EXE)中的任何其他代码或引⽤该程序集的其他程序集都可
以访问该类型或成员。**同一项目**  
**private**: 只有同⼀类或结构中的代码可以访问该类型或成员。**类中访问**  
**protected**: 只有同⼀类或结构或者此类的派⽣类中的代码才可以访问该类型或成员。**子类中访问**  
**internal**: 同⼀程序集中的任何代码都可以访问该类型或成员，但的代码不可以。  
**protected internal**: 在⼀程序集中，protected internal体现的是internal的性质；在其他程序集中，protected internal体现的是protected的性质。  
public 和private修饰字段和⽅法的时候，表⽰该字段或者⽅法能不能通过对象去访问，只
有public的才可以通过对象访问，private（私有的）只能在类模板内部访问。  
protected 保护的，当没有继承的时候，它的作⽤和private是⼀样的，当有继承的时候，
protected表⽰可以被⼦类访问的字段或者⽅法  

## 类的修饰符
public class ...  
class ...  
  

:::info{title="相关信息"}
**前者可以在别的项⽬下访问**，后者不⾏  
 1、添加别的项目的引用 using System.Collections.Generic;  
 2、引入命名空间  
 3、把类设置为public
:::
## 其他修饰符

**new**  
隐藏继承的成员  

**abstract**
使⽤abstract修饰的类为**抽象类**，抽象类只能是其他类的基类，不能与sealed、static⼀起使⽤。  

**abstract**可以修饰抽象**类中的⽅法或属性**，此时，⽅法或属性不能包含实现，且访问级别不能为私有。  
**抽象类不能被实例化**。  

**sealed**  
使⽤sealed修饰的类为密封类，**密封类⽆法被继承**，不能和abstract、static⼀起使⽤。
当sealed⽤于⽅法或属性时，必须**始终与override⼀起使⽤**。  

**static**  
使⽤static修饰的类为**静态类**，静态类所有成员都必须是静态的，不能与abstract、sealed
⼀起使⽤。  

static可以修饰⽅法、字段、属性或事件，始终通过类名⽽不是实例名称访问静态成员，静态字段只有⼀个副本。  
**静态类不能被实例化**。  

**const**
使⽤const关键字来声明某个常量字段或常量局部变量，**必须在声明常量时赋初值**。  
不能与static⼀起使⽤，**常量默认是static**的，常量字段只有⼀个副本。  

**readonly**  
使⽤readonly关键字来**声明只读字段**。  
只读字段可以在声明或构造函数中初始化，每个类或结构的实例都有⼀个独⽴的副本。  
可以与static⼀起使⽤，声明静态只读字段。  
静态只读字段可以在声明或静态构造函数中初始化，静态常量字段只有⼀个副本。  

示例代码

```c#
//base.cs 基类
class Base {
  public readonly int hp = 100;
  public Base() {
  }
  public Base(int hp) {
    this.hp = hp;
  }
}
```

```c# 
//使用  Program.cs
Base b = new Base(200);
Console.WriteLine(b.hp);

b.hp = 300;
```
**virtual**  
virtual关键字⽤于修饰⽅法、属性、索引器或事件声明，并使它们可以在**派⽣类中被重写**。  
默认情况下，⽅法是⾮虚拟的。 不能重写⾮虚⽅法。  
virtual修饰符不能与static、abstract、private或override修饰符⼀起使⽤。  

**override**  
要扩展或修改继承的⽅法、属性、索引器或事件的抽象实现或虚实现，必须使⽤override
修饰符。  
**重写的成员必须是virtual、abstract或override**的。  

:::info{title="相关信息"}
引⽤⾃：https://www.cnblogs.com/zhouzl/archive/2019/04/13/10701476.html
:::

修饰符

## 虚⽅法
**把⼀个基类函数声明为virtual,就可以在任何派⽣类中重写该函数**:  

```c#
class MyBaseClass{
public virtual string VirtualMethod(){
return "Method is called in base class";
}
}  
```


**在派⽣类中重写另外⼀个函数时，要使⽤override关键字显⽰声明**  

```c#
class MyDerivedClass:MyBaseClass{
public override string VirtualMethod(){
return "Method is called in derivedclass.";
}
}  

```
示例代码

```c#
// Enemy.cs 基类
class Enemy {
  public virtual void Move() {
    Console.WriteLine("敌人进行移动");
  }
}
```
```c#
// Boss.cs 派生类
class Boss: Enemy {
  public override void Move() {
    Console.WriteLine("Boss特有的移动方法");
  }
  public void BossSkill() {
    Console.WriteLine("Boss特有的技能");
  }
}
```
```c#
// Program.cs 使用
Boss b = new Boss();
b.Move();

//虚函数
Enemy b2 = new Boss();
b2.Move();
```
:::info{title="相关信息"}
我们在⼦类⾥⾯重写虚函数之后，不管在哪⾥调⽤都是调⽤重写之后的⽅法   
**可以把子类赋值于父类，不能把父类赋值于子类**
:::
 


## 隐藏⽅法
如果签名相同的⽅法在基类和派⽣类中都进⾏了声明，但是该⽅法没有分别声明为virtual
和override，派⽣类就会隐藏基类⽅法。（**要使⽤new关键字进⾏声明**）  

基类

```c#
class MyBaseClass{
public int MyMethod(){
}
}  

```

派⽣类(在派⽣类中把基类同名的⽅法隐藏掉了)

```c#
class MyDerivedClass :MyBaseClass{
public new void MyMethod() {
}
}  
```

示例代码

```c#
// Enemy.cs 基类
class Enemy {
  public void AI() {
    Console.WriteLine("敌人的AI");
  }
}
```
```c#
// Boss.cs 派生类
class Boss: Enemy {
  public new void AI() {
    Console.WriteLine("Boss自己的AI");
  }
}
```
```c#
// Program.cs 使用
Boss b = new Boss();
b.AI();

Enemy b = new Boss();
b.AI();
```
## 抽象类
C#允许把类和函数声明为 abstract。 **抽象类不能实例化**,抽象类可以包含普通函数和抽象函数，抽象函数就是**只有函数定义没有函数体**。 显然,抽象函数本⾝也是虚拟的Virtual(只
有函数定义，没有函数体实现)。  
类是⼀个模板，那么抽象类就是⼀个不完整的模板，我们不能使⽤不完整的模板去构造对
象。  

```c#
abstract class Building{
public abstract decimal CalculateHeatingCost();
}  

```
示例代码

```c#
// Enemy.cs 抽象类
public abstract class Enemy {
  private int hp;
  private int speed;

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

}
```
```c#
// Boss.cs 派生类
    public class Boss : Enemy  //光标定位到这一行，右键 💡 实现抽象类
    {
        public override void Attack()
        {
            Console.WriteLine("Boss进行攻击");
        }
    }
```
```c#
// Program.cs 使用
Enemy e = new Boss();
e.Attack();
```
## 密封类和密封⽅法
C#允许把类和⽅法声明为 sealed。 对于类 ,这表⽰不能继承该类；对于⽅法表⽰不能重
写该⽅法。 

```c#
sealed FinalClass
{
// etc
}
```
  

:::note{title="什么时候使⽤ 密封类和密封⽅法？ "}
 
- 防⽌重写某些类导致代码混乱  
- 商业原因  
:::


## 派⽣类（⼦类）的构造函数
1,**在⼦类中调⽤⽗类**的默认构造函数（⽆参）（**会先调⽤⽗类的，然后是⼦类**的）

```c#
public class MyDerivedClass{
public MyDerivedClass():base(){
//do something
}
}  
```


在这⾥ ：**base()可以直接不写，因为默认会调⽤**⽗类中的默认构造函数  

2，调⽤有参数的构造函数

```c#
public class MyDerivedClass{
public MyDerivedClass(string name):base(name){
//do something
}
}
```

示例代码

```c#
// BaseClass.cs 父类
class BaseClass {
  private int hp;
  private int speed = 900;
  public BaseClass(int hp, int speed) {
    this.hp = hp;
    this.speed = speed;
  }
  public BaseClass() {
    Console.WriteLine("构造函数：BaseClass");
  }
}
```
```c#
// DrivedClass.cs 子类
class DrivedClass: BaseClass {
  private int attack;

  public DrivedClass() {
    Console.WriteLine("构造函数：DrivedClass");
  }

  public DrivedClass(int attack) {
    this.attack = attack;
  }
  public DrivedClass(int attack, int hp, int speed): base(hp, speed) {
    this.attack = attack;
  }
}
```
```c#
// Program.cs 使用
DrivedClass dc = new DrivedClass(100, 80, 10);
Boss b = new Boss();

// 1、添加别的项目的引用 using System.Collections.Generic;
// 2、引入命名空间  
// 3、把类设置为public
```

虚方法与隐藏方法

继承是什么？  
在上⼀节课中学习了如何定义类，⽤类当做模板来声明我们的数据。  
很多类中有相似的数据，⽐如在⼀个游戏中，有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.5 f;
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)

程序内存区域

msvalidate.01

360-site-verification

sogou_site_verification

baidu-site-verification

95f521bf6bd97279d4c7d479ce66ad91_1745636273

shenma-site-verification

script

link

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