当我们有很多类型⼀样的数据的时候，前⾯我们⼀般使⽤数组来进⾏管理，但是这样有个
缺点就是数组的⼤⼩是固定的。  
如果我们很多类型⼀样的数据，⽐如游戏得分，我们可以集合类来进⾏管理，⽐如列表List，我们可以使⽤列表List很⽅便的添加数据，删除数据
还有其他对数据的操作。  

## 列表List的创建和使用
1、**创建列表**    
列表可以存储任何类型的数据，在创建列表对象的时候⾸先要指定你要创建的这个列表要存储什么类型的（**泛型**）  

```c#
List<int> scoreList = new List<int>();
new List<int>(){1,2,3}
new List<string>(){"one","two"}
var scoreList = new List<int>();
```

**2、往列表中插⼊数据**  

```c#
scoreList.Add(12);
scoreList.Add(45);
```

**3、如何取得列表中的数据？**  
列表中的数据跟数组有点相似，索引从0开始 ，可以通过索引来访问  

```c#
Console.WriteLine(scoreList[0]);//访问添加到列表中的第⼀个数据
List<int> list = new List<int>() { 56, 23, 894, 32, 5623, 32,4573 };
list.Insert(3, 800); //在索引3的位置前插入800
list.RemoveAt(2);    //移除索引2的位置元素
```
 

:::tip{title="提示"}
当把一个对象当作字符串来使用时，就会调用字符串ToString方法     
比如：命名空间.类

```c#
Program p = new Program();
//输出都一样
Console.WriteLine(p.ToString());
Console.WriteLine(p);
```
:::
## 关于列表的更多内容

1、列表内部数据是使⽤数组进⾏的存储，**⼀个空的列表内部会有⼀个⻓度为0的数组**，当给列表中添加元素的时候，列表的容量会扩⼤为4，如果添加第5个的时候，列表的⼤⼩会重新设置为8，如果添加第9个元素，列表容量会扩⼤为16，依次增加。  

![image.png](/static/img/bed470a01b33c183398080e2df1ea1af.image.png)  
**当列表的中的容量发⽣改变的时候，它会创建⼀个新的数组，使⽤Array.Copy()⽅法将旧数组中的元素复制到新数组中**。  
为了节省时间，如果事先知道要存储的数据的个数，就可以利⽤列表的构造函数指定列表的容量⼤⼩，⽐如

```c#
List<int> intlist = new List<int>(10);//创建了⼀个初始容量为10的列表
```
当容量不够⽤的时候，每次都会按照原来容量的2倍进⾏扩容。  
**我们可以通过Capacity属性获取和设置容量**  

```c#
intList.Capacity = 100;
```

2、**注意容量和列表中元素个数的区别，容量是列表中⽤于存储数据的数组的⻓度通过capacity获取，列表中的元素是我们添加进去需要管理的数据，通过Count获取**  

:::info{title="相关信息"}
容量：存储数据大小  
元素个数：添加了多少个数据
:::
## 列表的遍历
遍历列表有两种⽅式：  
**1、for循环**  
遍历所有的索引，通过索引访问列表中的元素

```c#
for(int i=0;i<list.Count;i++){
//循环体list[i]
}
```

**2、foreach遍历**  

```c#
foreach(int temp in list){ //依次取得list中的每⼀个元素赋值给temp，并执⾏循环体
//循环体 temp
}
```

:::note{title="操作列表的属性和⽅法"}
1. Capacity获取容量⼤⼩
2. Add()⽅法添加元素
3. Insert()⽅法插⼊元素
4. [index]访问元素
5. Count属性访问元素个数
6. RemoveAt()⽅法移除指定位置的元素
7. IndexOf()⽅法取得⼀个元素所在列表中的索引位置  
LastIndexOf()上⾯的⽅法是从前往后搜索，这个是从后往前搜索，搜索到满⾜条件的就停⽌  
上⾯的两个⽅法，如果没有找到指定元素就返回-1
8. Sort()对列表中是元素进⾏从⼩到⼤排序
:::

列表List

11．在C#的语法中，（ a ）关键字可以实现在派生类中对基类的虚函数进行重载（选一项）
- [ ] a.	override
- [ ] b.	new
- [ ] c.	static
- [ ] d.	virtual  

:::info{title="相关信息"}
**子类对父类进行重写**
:::

12.请问，此程序输出结果是( C )  

```c#
abstract class BaseClass{  //抽象类父类
public virtual void MethodA(){Console.WriteLine("BaseClass");} //方法A 输出BaseClass
public virtual void MethodB(){}   //方法B  什么都不干
}
class Class1: BaseClass{  //子类1 
public void MethodA(){Console.WriteLine("Class1");} //方法A 隐藏方法输出 Class1
public override void MethodB(){}  //方法B 重写父类方法B
}
class Class2: Class1{  //子类2
new public void MethodB(){}  //把子类1中的B方法隐藏
}
class MainClass{
public static void Main(string[] args){Class2 o = new Class2();o.MethodA(); }
}
```

- [ ] A. BaseClass
- [ ] B. BassClass Class1
- [ ] C. Class1
- [ ] D. Class1 BassClass  

13.请问，此程序输出结果是( a )  

```c#
public abstract class A { public A() { Console.WriteLine('A'); }  //构造函数输出A
public virtual void Fun() { Console.WriteLine("A.Fun()"); } }  //虚方法输出A.Fun()
public class B: A { public B() { Console.WriteLine('B'); }  //B类构造函数输出B
public new void Fun() { Console.WriteLine("B.Fun()"); } //隐藏方法 把B.Fun() 隐藏
public static void Main() { A a = new B();a.Fun(); } } 
```

- [ ] A. A B A.Fun() 
- [ ] B. A B B.Fun()
- [ ] C. B A A.Fun()
- [ ] D. B A B.Fun()  

:::info{title="相关信息"}
* B对象，A声明，调用啥 则输出啥
* 构造 newB 时，构造函数被调用，先调用父类再调用子类
:::
14.以下叙述正确的是( bc )：   
- [ ] A. 接口中可以有虚方法。   
- [ ] B. 一个类可以实现多个接口。 
- [ ] C. 接口不能被实例化。       
- [ ] D. 接口中可以包含已实现的方法。  

15．以下关于C#代码的说法正确的是（ a ）。（选择一项）  

```c#
Public abstract class Animal   //抽象类 Animal
{
Public abstract void Eat(); //抽象方法
Public void Sleep()
{
}
}
```


- [ ] a.	该段代码正确
- [ ] b.	代码错误，因为类中存在非抽象方法
- [ ] c.	代码错误，因为类中的方法没有实现
- [ ] d.	通过代码“Animal an = new Animal();”可以创建一个Animal对象  


16.在c#中，关于继承和接口，以下说法正确的是( b ) （单选）  
- [ ] a.c#允许许多接口实现,也允许多重继承
- [ ] b.c#允许多接口实现，但不允许多重继承
- [ ] c.c#不允许多接口实现，但允许多重继承
- [ ] d.c#不允许多重接口实现，也不允许多重继承  

17. 在C#中，已知下列代码的运行结果是“老虎吃动物”，请问在空白处1和空白处2分别应该填写的代码是( c )  

```c#
Public class Animal //父类
{
  Public 空白处1 void Eat() {
    Consone.WriteLine(“我要吃”)；
  }
}
Public class Tiger: Animal //子类继承父类
{
  Public 空白处2 void Eat() {
    Consone.WriteLine(“老虎吃动物”)；
  }
  Public calssTest {
    Static void Main() {
      Animal an = new Tiger(); //父类声明
      an.Eat; //调用重写方法
    }
  }
}
```

- [ ] a.	Virtual , new
- [ ] b.	override , virtual
- [ ] c.	virtual , override
- [ ] d.	new , virtual    

18. 在C#中，下列关于抽象类和接口的说法，正确的是( b )（选择一项）  
- [ ] 	a. 在抽象类中，所以的方法都是抽象方法
- [ ] 	b. 继承自抽象类的子类必须实现起父类（抽象类）中的所以抽象方法
- [ ] 	c. 在接口中，可以有方法实现，在抽象类中不能有方法实现
- [ ] 	d. 一个类可以从多个接口继承，也可以从多个抽象类继承  
	
19. 关于以下C#代码的说法正确的是( b )  

```c#
Public abstract class Animal { //抽象类父类  Animal
  Public abstract void Eat(); //抽象方法
}
Public class Tiger: Animal { //子类1 继承父类
  Public override void Eat() { //重写方法
    Console.WriteLine(“老虎吃动物”);
  }
}
Public class Tigress: Tiger { //子类2 继承父类
  Static void Main() {
    Tigress tiger = new Tigress(); //子类构造
    tiger.Eat();
  }
}
```

- [ ] a.	代码正确,但没有输出
- [ ] b.	代码正确,并且输出为”老虎吃动物”;
- [ ] c.	代码错误,因为Tigress类没有实现抽象基类Animal中的抽象方法
- [ ] d.	代码错误,因为抽象基类Animal的Eat方法没有实现

:::info{title="相关信息"}
**子类构造函数被调用，都为调用重写后的方法**
:::

20. 在c#中 某程序员定义了一个IDataBase接口，以及实现该接口的类CDataBase ,下列关于该段代码说法正确的是（ d ）（选择一项）

```c#
public interface IDataBase //接口
{
  void OpenTable(string tableName); //打开
  void UpdataTable(string tableName); //更新
}
public class CDataBase: IDataBase //子类继承接口
{
  public void OpenTable(string tableName) //打开方法
  {
    Console.WriteLine("打开数据表");

  }
  public void UpdataTable(string tableName) //更新方法
  {
    Console.WriteLine("更新数据表");

  }
  static void Main() {
    CDataBase db = new CDataBase(); //声明子对象 然后子类构造
    db.OpenTable("Customers");
  }
}
```


- [ ] a.该段代码错误，因为在定义接口时，接口中的方法没有提供实现
- [ ] b.该段代码错误，因为接口中声明的方法不是公有的，应此在CDataBase类中不能访问接口中的方法
- [ ] c.该段代码正确，同时由于客户没有调用UpdataTable方法，可以把CDataTable类中的UpdataTable去掉，代码仍然正确
- [ ] d.该段代码正确，但是如果在IDataBase 接口中声明一个方法void Execute(string sql); 则必须在CDataBase中实现该方法  

:::info{title="相关信息"}
a.接口中方法不需要提供实现   
b.默认为public  
c.即使没有调用，也要实现方法
:::
21.c#中  下列代码运行结果是（ a ）（选择一项）  

```c#
public class Student { //父类
  public virtual void Exam() { //虚方法
    Console.WriteLine("学生都要考试");
  }
}
public class Undergraduate: Student { //子类继承父类
  public new void Exam() { //隐藏父类
    base.Exam(); //调用父类里的方法
    Console.WriteLine("大学生有选择考试科目的权利");
  }
}
public class Test {
  static void Main() {
    Student stu = new Undergraduate(); //父类声明对象，子类构造
    stu.Exam();
  }
}
```

- [ ] a.学生都要考试
- [ ] b.大学生有选择考试科目的权利
- [ ] c.大学生都要考试
  大学生有选择考试科目的权利
- [ ] d.学生都要考试 学生都要考试  

:::info{title="相关信息"}
**隐藏方法只有在子类声明才会调用隐藏方法**
:::

22.c#中 下列代码的运行结果是（ a ）（选择一项）  

```c#
struct Student { //声明学生结构体
  public int age;
  public string name;
  public Student(int age, string name) { //构造函数（年龄、名字）
    this.age = age;
    this.name = name;
  }
}
public class Test {
  static void Mian() {
    Student stu1 = new Student(18, "小方"); //创建2名学生
    Student stu2 = new Student(24, "小刚");
    stu2 = stu1; //在c#中 结构体是值类型，在这里赋值只会赋值其中变量的值
    stu1.age = 30;
    stu1.name = "小燕";
    Console.WriteLine(stu2.age);
    Console.WriteLine(st2.name);
  }
}
```

- [ ] a.18 小方
- [ ] b.18 小燕
- [ ] c.30 小燕
- [ ] d.30 小方

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

面向对象-编程题2

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"]);
```

索引器

msvalidate.01

360-site-verification

sogou_site_verification

baidu-site-verification

95f521bf6bd97279d4c7d479ce66ad91_1745636273

shenma-site-verification

script

link

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