Program.cs

```c#
using System;

namespace Equals判断相等 {
  class Program {
    static void Main(string[] args) {
      //ToString Equals Object
      int a = 12;
      int b = 34;
      Console.WriteLine(a.Equals(b)); // 值为Flase  a == b

      string str1 = "siki";
      string str2 = "siki";
      Console.WriteLine(str1.Equals(str2));

      Student stu1 = new Student(18, "小芳");
      Student stu2 = new Student(18, "小芳");
      //默认方法值为Flase         重写Equals方法后值为True
      Console.WriteLine(stu1.Equals(stu2));
      Console.WriteLine(stu1 == stu2);
    }
  }
}

```

:::tip{title="提示"}
- 所有值类型、字符串比较就相当于a==b  
- 引用类型用Equals作比较时，比较的是引用地址，若需比较引用地址中的数据值，则需重写Equals方法
:::
Student.cs

```c#
using System;
using System.Collections.Generic;
using System.Text;

namespace Equals判断相等 {
  class Student {
    private int age;
    private string name;

    public Student(int age, string name) {
      this.age = age;
      this.name = name;
    }

    public override bool Equals(object obj) //重写Equals方法
    {
      Student stu = (Student) obj; //强制转换
      if (age == stu.age && name == stu.name) {
        return true;
      }
      return false;
    }
  }
}

```

equals方法扩展

myList.cs
```c#     
using System;
using System.Collections.Generic;
using System.Text;

namespace MyList列表 {
  class MyList < T > {
    private T[] data = new T[0]; //data null
    private int count = 0; // 元素个数 数据个数

    public int Capacity //获取容量大小
    {
      get {
        return data.Length;
      }
    }
    public int Count //获取元素个数
    {
      get {
        return count;
      }
    }

    public void Add(T item) //添加元素
    {
      if (data.Length == 0) {
        data = new T[4];
      }
      if (data.Length == count) //添加元素之前 ，先判断数组是否已经满
      {
        T[] temp = new T[count * 2];
        for (int i = 0; i < data.Length; i++) {
          temp[i] = data[i];
        }
        data = temp;
      }
      data[count] = item;
      count++;
    }

    public T this[int index] //访问元素
    {
      get {
        if (index < 0 || index > count - 1) { //抛出异常
          throw new ArgumentOutOfRangeException("索引参数超出范围了");
        }
        return data[index];
      }
      set {
        data[index] = value;
      }
    }

    public void Insert(int index, T item) //插入元素
    {
      if (index < 0 || index > count - 1) //判断是否存在索引
      {
        throw new ArgumentOutOfRangeException("索引参数超出范围了");
      }

      for (int i = count - 1; i > index - 1; i--) {
        // count-1     index
        data[i + 1] = data[i];
      }
      data[index] = item;
      count++;
    }
    public void RemoveAt(int index) //移除指定位置元素
    {
      if (index < 0 || index > count - 1) {
        throw new ArgumentOutOfRangeException("索引参数超出范围了");
      }
      for (int i = index + 1; i < count; i++) {
        // index+1   count-1
        data[i - 1] = data[i];
      }
      count--;
    }
    public int IndexOf(T item) //从前往后获取元素所在的索引位置
    {
      int index = -1;
      for (int i = 0; i < count; i++) { // ToString Equals
        if (item.Equals(data[i])) {
          index = i;
          break;
        }
      }
      return index; //从前往后
    }

    public int LastIndexOf(T item) //从后往前获取元素所在的索引位置
    {
      int index = -1;
      for (int i = count - 1; i >= 0; i--) { // ToString Equals
        if (item.Equals(data[i])) {
          index = i;
          break;
        }
      }
      return index; //从后往前
    }

    public void Sort() //排序
    {
      Array.Sort(data, 0, count); //0, count  指范围
    }
  }
}
```  
Program.cs
```c#

using System;
using System.Collections.Generic;

namespace MyList列表 {
  class Program {
    static void Main(string[] args) {
      // 1.Capacity 获取容量⼤⼩
      MyList < int > list = new MyList < int > ();
      Console.WriteLine(list.Capacity);

      // 2.Add()⽅法添加元素
      list.Add(1);
      list.Add(2);
      list.Add(3);
      list.Add(4);
      list.Add(5);
      list.Add(4);

      // 5.Count属性访问元素个数
      Console.WriteLine(list.Count);
      //遍历集合
      for (int i = 0; i < list.Count; i++) {
        Console.Write(list[i] + " ");
      }

      // 3.Insert()⽅法插⼊元素
      list.Insert(2, 100);
      for (int i = 0; i < list.Count; i++) //遍历集合
      {
        Console.Write(list[i] + " ");
      }
      Console.WriteLine();

      // 4.[index]访问元素(索引器) 
      int temp1 = list[10];
      int temp2 = list[-1];
      List < int > l = new List < int > ();
      int temp = l[-1];

      // 6.RemoveAt()⽅法移除指定位置的元素
      list.RemoveAt(3);
      for (int i = 0; i < list.Count; i++) //遍历集合
      {
        Console.Write(list[i] + " ");
      }
      Console.WriteLine();

      // 7.IndexOf()⽅法取得⼀个元素所在列表中的索引位置
      Console.WriteLine(list.IndexOf(4)); //从前往后搜索
      Console.WriteLine(list.LastIndexOf(4)); //从后往前搜索

      // 8.Sort()对列表中是元素进⾏从⼩到⼤排序
      list.Sort();
      for (int i = 0; i < list.Count; i++) //遍历集合
      {
        Console.Write(list[i] + " ");
      }
      Console.WriteLine();
    }
  }
}

```

集合类MyList 

## 重写ToString 方法
右键笔刷   生成重写（ToString()）
```c#
public override string ToString() {
 string result = age + ":" + name;
  return result;
  }
```   
## 泛型
泛型是什么？  
通过参数化类型来实现在同⼀份代码上操作多种数据类型。利⽤“**参数化类型**”将类型抽象化，从⽽实现灵活的复⽤。

## 泛型类定义
定义⼀个泛型类就是指的是，定义⼀个类，这个类中某些字段的类型是不确定的，这些类型可以在类构造的时候确定下来

创建⼀个类处理  int类型和double类型的相加  

```c#
class ClassA<T>{ //T  指类型   可为int、double、string
private T a; 
private T b; 
public ClassA(T a,T b){ 
this.a = a ;this.b = b; 
} 
//public T GetSum(){ 
//return a+“”+b; 
//注释部分可使用以下方式
 dynamic num1 = a;
 dynamic num2 = b;
 dynamic result = num1 + num2;
 return (T)result;
} 
}

//使用
ClassA<int> a = new ClassA<int>(45, 65);
Console.WriteLine(a.GetSum());  //👉   110
```
## 泛型⽅法
定义泛型⽅法就是定义⼀个⽅法，这个⽅法的参数的类型可以是不确定的，当调⽤这个⽅
法的时候再去确定⽅法的参数的类型。  

实现任意类型组拼成字符串的⽅法  

```c#
public static T GetSum<T>(T a,T b){
return a+""+b;}
GetSum<int>(23,12);
GetSum<double>(23.2,12);
```

使⽤泛型和索引器来实现⼀个我们⾃⼰的集合类MyList  
有下⾯的⽅法和属性  
1. Capacity获取容量⼤⼩  
2. Add()⽅法添加元素  
3. Insert()⽅法插⼊元素  
4. [index]访问元素(索引器)  
5. Count属性访问元素个数  
6. RemoveAt()⽅法移除指定位置的元素  
7. IndexOf()⽅法取得⼀个元素所在列表中的索引位置  
   LastIndexOf()上⾯的⽅法是从前往后搜索，这个是从后往前搜索，搜索到满⾜条件的就停⽌  
   上⾯的两个⽅法，如果没有找到指定元素就返回-1  
8. Sort()对列表中是元素进⾏从⼩到⼤排序  

索引器：通过[index]这种形式去访问数据，就是索引器

泛型⽅法

当我们有很多类型⼀样的数据的时候，前⾯我们⼀般使⽤数组来进⾏管理，但是这样有个
缺点就是数组的⼤⼩是固定的。  
如果我们很多类型⼀样的数据，⽐如游戏得分，我们可以集合类来进⾏管理，⽐如列表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

msvalidate.01

360-site-verification

sogou_site_verification

baidu-site-verification

95f521bf6bd97279d4c7d479ce66ad91_1745636273

shenma-site-verification

script

link

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