1．C#中的方法重写使用关键字（ a ）。  
- [ ] a.override  
- [ ] b.overload  
- [ ] c.static  
- [ ] d.Inherit    

2．以下的C#代码，试图用来定义一个接口：

```c#
public interface IFile {
  int A; //不能包含数字成员
  int delFile() {
    A = 3; //方法不能有函数体
  }
  void disFile(); //方法声明
} 
```
 
关于以上的代码，以下描述错误的是（ d ）。（选择一项）  
- [ ] a.以上的代码中存在的错误包括：不能在接口中定义变量，所以int A代码行将出现错误  
- [ ] b.以上的代码中存在的错误包括：接口方法delFile是不允许实现的，所以不能编写具体的实现函数  
- [ ] c.代码void disFile();定义无错误，接口可以没有返回值  
- [ ] d.代码void disFile();应该编写为void disFile(){}; //接口中不能去实现函数

:::info{title="相关信息"}
**接口：只能包含函数声明，不能包含函数体**
:::
3．在C#中，接口与抽象基类的区别在于（ a ）。  
- [ ] a.抽象基类可以包含非抽象方法，而接口只能包含抽象方法  
- [ ] b.抽象基类可以被实例化，而接口不能被实例化  
- [ ] c.抽象基类不能被实例化，而接口可以被实例化  
- [ ] d.抽象基类就是接口，它们之间无差别  

4．在开发某图书馆的图书信息管理系统的过程中，开始为教材类图书建立一个TextBook类；现在又增加了杂志类图书，于是需要改变设计，则下面最好的设计应该是（ c ）。  
- [ ] a.建立一个新的杂志类Journal。  
- [ ] b.建立一个新的杂志类Journal，并继承TextBook类。  
- [ ] c.建立一个基类Book和一个新的杂志类Journal，并让Journal类和TextBoook类都继承于Book类。  
- [ ] d.不建立任何类，把杂志图书的某些特殊属性加到TextBoook类中。  

5．可以使用（ a ）关键字重写方法。  
- [ ] a.Override  
- [ ] b.New  

6．以下叙述正确的是：( bc )  
- [ ]  A．    接口中可以有虚方法。       
- [ ]  B.    一个类可以实现多个接口。  
- [ ]  C．    接口不能被实例化。          
- [ ]  D.    接口中可以包含已实现的方法。  
:::info{title="相关信息"}
**接口：只能包含函数声明，不能包含函数体**
:::      
7.下列代码输出为（ b）： 

```c#
class Father{   //父类
   public void F() { Console.WriteLine("A.F"); } //F方法输出A.F
   public virtual void G() { Console.WriteLine("A.G"); } //虚方法输出A.G
}
class Son: Father{   //子类继承父类
   new public void F() { Console.WriteLine("B.F"); }//隐藏了父类中的方法，父类中的F方法还存在
   public override void G() { Console.WriteLine("B.G"); }//重写了父类中的方法，父类中的G方法就不存在了
}
class override_new{
   static void Main() {
      Son b = new Son(); //子类声明
      Father a = b;  //父类声明
      a.F();//通过父类声明的对象 调用隐藏方法，会调用父类中的  A.F
      b.F();//通过子类声明的对象 调用隐藏方法，会调用子类中的  B.F
      a.G();// B.G
      b.G();//B.G
   }
}
```

- [ ]  A.	  A.F    B.F    A.G   B.G  
- [ ]  B.	  A.F    B.F    B.G   B.G  
- [ ]  C.	  A.F    A.F    B.G   B.G  
- [ ]  D.	  B.F    B.F    B.G   B.G  

:::info{title="相关信息"}
**子类构造函数被调用，都为调用重写后的方法**
:::
8．写出程序的输出结果：

```c#
public class A //父类
{
  public virtual void Fun1(int i) //虚方法Fun1
  {
    Console.WriteLine(i); //输出所给的参数
  }
  public void Fun2(A a) //普通方法Fun2
  {
    a.Fun1(1); //调用a对象里的Fun1
    Fun1(5); //再调用自身对象Fun1
  }
}
public class B: A { //子类继承父类 
  public override void Fun1(int i) 重写Fun1 {
    base.Fun1(i + 1); //调用父类Fun1(i+1) 即调用Console.WriteLine(i+1);
  }
  public static void Main() {
    B b = new B();
    A a = new A();
    a.Fun2(b); //b.Fun1(1) a.Fun1(5) //2  5
    b.Fun2(a); //a.Fun1(1) b.Fun1(5)// 1   6
  }
}
```

答案：2 5 1 6  

9．在C＃中，允许多接口继承，从多个接口时，使用“：”后跟继承的接口的名字，多个接口名称之间使用（ c ）符号进行分割。（选择一项）  
- [ ]   a.”.’  
- [ ]   b.”->”  
- [ ]   c.”,”  
- [ ]   d.”::”  
 
10．阅读以下的C#代码：

```c#
class A //父类
{
  public virtual void printStr(string str) //虚方法
  {
    Console.WriteLine(str); //打印传递的参数
  }
}
class B: A //子类继承父类
{
  public override void printStr(string str) //重写方法
  {
    str = str + " 重写的方法";
    Console.WriteLine(str); //把传递的参数和" 重写的方法"一起打印
  }
}
class DefaultInitializerApp {
  public static void Main() {
    B b = new B();
    A a = b;
    a.printStr("打印");
    b.printStr("打印");
    Console.ReadLine();
  }
}
```

运行程序后将在控制台窗口打印( a )。(选择一项)  
- [ ]  a.	打印 重写的方法 打印 重写的方法  
- [ ]  b.	打印 	打印 重写的方法  
- [ ]  c.	打印  
- [ ]  d.	程序有误，不能运行
:::info{title="相关信息"}
**子类构造函数被调用，都为调用重写后的方法**
:::

面向对象-编程题1

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

修饰符

msvalidate.01

360-site-verification

sogou_site_verification

baidu-site-verification

95f521bf6bd97279d4c7d479ce66ad91_1745636273

shenma-site-verification

script

link

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