```c#
//新建类  Student.cs
class Student {
  private int age;
  private string name;
  private long id;

  public Student(int age, string name, long id) {
    this.age = age;
    this.name = name;
    this.id = id;
  }
  //  带函数方法开始  == !=
  public static bool operator == (Student s1, Student s2) {
    if (s1.age == s2.age && s1.name == s2.name && s1.id == s2.id) {
      return true;
    }
    return false;
  }
  public static bool operator != (Student s1, Student s2) {
    bool result = s1 == s2;
    return !result;
  }
  //  带函数方法结束
}
``` 
```c#
//使用  Program.cs
Student s1 = new Student(20, "张三", 12903);
Student s2 = new Student(20, "张三", 12903);

Student s3 = s1;
Console.WriteLine(s1 == s2);
Console.WriteLine(s1 == s3);
// 上面方法带函数方法  比较的是参数值   值都为True
// 上面方法不带函数方法  比较的是引用   值为 Flase   True
```

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

运算符重载

利用索引器取值  赋值  
**案例1**  
```c#
// 创建Test.cs  类
class Test {
  public string this[int index] {
    get {
      Console.WriteLine([index]);
      return 100；
    }
    set {
      Console.WriteLine([index]);
      Console.WriteLine(value);
    }
  }
}
```

```c#
//使用 Program.cs
Test t = new Test();

t[9] = 200;
Console.WriteLine(t[9]);
```
**案例2**
```c#
// 创建Test.cs  类
class Test {

  private string[] name = new string[10];

  public string this[int index] {
    get {
      return name[index];
    }
    set {
      name[index] = value;
    }
  }
}
```

```c#
//使用 Program.cs
Test t = new Test();
t[0] = "张三";
t[1] = "李四"; //赋值

Console.WriteLine(t[0]);
Console.WriteLine(t[1]); //取值
```
**案例3**
```c#
// 创建Week.cs  类
class Week {
  private string[] days = {
    "Mon",
    "Tues",
    "Wed",
    "Thu",
    "Fri",
    "Sat",
    "Sun"
  };

  // public int GetDay(string day)  //传递英文返回数值    
  private int GetDay(string day) //使用方法2索引时，需将public改为private
  {
    int i = 0; //开始传递
    foreach(string temp in days) {
      if (temp == day) return i + 1; //找到索引
      i++;
    }
    return -1;
  }

  public int this[string day] {
    get {
      return GetDay(day); //调用上面的方法
    }
  }
}
```

```c#
//使用 Program.cs
//方法1
Week w = new Week();
Console.WriteLine(w.GetDay("Thu"));
//方法2
Console.WriteLine(w["Sat"]);
```

索引器

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

```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
```

虚方法与隐藏方法

msvalidate.01

360-site-verification

sogou_site_verification

baidu-site-verification

95f521bf6bd97279d4c7d479ce66ad91_1745636273

shenma-site-verification

script

link

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