C#基础试题（选填错题本铭记68分选择错十一个填空错三个）

最新推荐文章于 2024-09-10 21:41:16 发布

小超崽子

最新推荐文章于 2024-09-10 21:41:16 发布

阅读量1.8k

点赞数 30

分类专栏： C#试题错题集文章标签： c# 数据库开发语言

本文链接：https://blog.csdn.net/weixin_64505310/article/details/140879030

版权

C#试题错题集专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、单选题（每题2分，共40分）（错十个）

1.下列关于重载的说法,错误的是（ D ）

A. 方法可以通过指定不同的参数个数重载
B. 方法可以通过指定不同的参数类型重载
C. 方法可以通过指定不同的参数顺序重载
D. 方法可以通过指定不同的返回值类型重载

在 C# 中，方法重载（Overloading）是指在同一个类中可以定义多个同名的方法，但这些方法必须具有不同的参数列表。方法重载的有效方式包括：
不同的参数个数
不同的参数类型
不同的参数顺序

A. 方法可以通过指定不同的参数个数重载
这是正确的。方法重载可以通过不同的参数个数来实现。例如：

public class Example
{
    public void Print(int a)
    {
        Console.WriteLine(a);
    }

    public void Print(int a, int b)
    {
        Console.WriteLine(a + " " + b);
    }
}

B. 方法可以通过指定不同的参数类型重载
这是正确的。方法重载可以通过不同的参数类型来实现。例如：

public class Example
{
    public void Print(int a)
    {
        Console.WriteLine(a);
    }

    public void Print(string a)
    {
        Console.WriteLine(a);
    }
}

C. 方法可以通过指定不同的参数顺序重载
这是正确的。方法重载可以通过不同的参数顺序来实现。例如：

public class Example
{
    public void Print(int a, string b)
    {
        Console.WriteLine(a + " " + b);
    }

    public void Print(string a, int b)
    {
        Console.WriteLine(a + " " + b);
    }
}

D.方法重载仅通过不同的返回值类型是无效的，因为编译器无法通过返回值类型来区分方法。方法签名必须通过参数列表来区分。

        public int GetValue()
        {
            return 1;
        }

        // 编译错误：方法具有相同的签名
        public string GetValue()
        {
            return "One";//这里会报错的
        }

注意事项：
方法重载与方法重写不同：

方法重载是同一个类中方法名称相同，但参数列表不同。
方法重写是子类重新定义基类中的虚方法（使用 override 关键字）。
避免过度重载：

过多的重载方法可能会使代码难以维护和理解。应合理使用重载，确保每个重载版本有明确的用途。
总结：
方法重载通过提供多个具有不同参数列表的同名方法，增强了代码的灵活性和可读性。理解方法重载的原理和应用场景，有助于编写更简洁和高效的代码。

3.下列正确的标识符是（）

A.–a1 B. a[i] C. a2_i D. int

在 C# 中，标识符是用于命名变量、方法、类等的有效名称。标识符必须遵循以下规则：

标识符必须以字母（大写或小写）或下划线（_）开头。
后续字符可以是字母、数字或下划线。
标识符不能是 C# 的关键字。
标识符中不能包含空格和特殊字符（例如 -, [, ], 等）。
让我们逐一分析选项：

A. –a1

不正确。标识符不能以 - 开头。
B. a[i]

不正确。标识符中不能包含方括号 []，这是数组元素访问符。
C. a2_i

正确。符合所有标识符规则。
D. int

不正确。int 是 C# 的关键字，不能用作标识符。

7. class MyClass { public static int Count=0; static MyClass(){ Count++; } public MyClass(){ Count++; } } MyClass c1 = new MyClass(); MyClass c2 = new MyClass(); 请问 MyClass.Count 的值是多少（） A. 1 B. 2 C. 3 D. 4

class MyClass
{
    public static int Count = 0;
    // 静态构造函数
    static MyClass()
    {
        Count++;
    }
    // 实例构造函数
    public MyClass()
    {
        Count++;
    }
}

静态构造函数 static MyClass()

静态构造函数在类的第一次被使用时（例如实例化第一个对象或访问第一个静态成员时）调用，并且只调用一次。
**因此，当第一个 MyClass 对象 c1 被创建时，静态构造函数会被调用一次，将 Count 从 0 增加到 1。

实例构造函数 public MyClass()**

每次创建 MyClass 的实例时，实例构造函数都会被调用。

因此，当 c1 被创建时，实例构造函数将 Count 从 1 增加到 2。
当第二个 MyClass 对象 c2 被创建时，实例构造函数再次被调用，将 Count 从 2 增加到 3。
计算过程：
类第一次被使用时，静态构造函数被调用：Count = 1
创建第一个实例 c1，实例构造函数被调用：Count = 2
创建第二个实例 c2，实例构造函数被调用：Count = 3
所以，MyClass.Count 的值是 3。

8. 以下的C#程序：

static void Main(string[] args)
{
int[] A = new int[5] { 1, 2, 3, 4, 5 };
object[] B = new object[5] { 6, 7, 8, 9, 10 };
Array.Copy(A,B,2);
Console.ReadLine();
}
运行后数组B中的数值为（）
A. 1、2、3、4、5
B. 1、2、8、9、10
C. 1、2、3、9、10
D. 6、7、8、9、10**

在 C# 中，Array.Copy 方法用于从一个数组复制元素到另一个数组。其语法如下：
Array.Copy(Array sourceArray, Array destinationArray, int length);
其中：
sourceArray 是要复制元素的源数组。
destinationArray 是要接收复制元素的目标数组。
length 是要复制的元素数目。//主要由于是数目不是索引出的错误一定记住是数目

然后调用 Array.Copy(A, B, 2);：
该方法会从数组 A 的开头开始，复制 2 个元素到数组 B 的开头。
具体来说，A[0] 和 A[1] 会复制到 B[0] 和 B[1]。
让我们看看复制之后数组 B 的内容：
在复制之前，数组 B 的初始内容是：6, 7, 8, 9, 10
Array.Copy(A, B, 2) 将数组 A 的前两个元素 1 和 2 复制到数组 B 的前两个位置。
复制之后，数组 B 的内容将变成：1, 2, 8, 9, 10
因此，正确答案是：
B. 1、2、8、9、10

9. 在C#语言中，下面的运算符中，优先级最高的是（） A. % B. ++ C. *= D. >

运算符优先级（从高到低）

1.自增、自减运算符：++，–
2.乘法、除法、取模运算符：*，/，%
3.加法、减法运算符：+，-
4.关系运算符：<，>，<=，>=
5.赋值运算符：=, +=, -=, *=, /=, %=, 等

11. 阅读下面的程序，程序的运行e结果为（）

int a = 10, b = 4, c = 20,d=6;
int e = a++b+c–d;
A. 144 B. 160 C. 140 D. 164

让我们详细分析这个表达式 int e = a++ * b + c * --d;。
初始值：
a = 10
b = 4
c = 20
d = 6
按照运算符的优先级和操作顺序计算：

a++: 自增运算符（后缀），先使用 a 的当前值，然后再自增。

先使用 a 的值 10，然后 a 变为 11。
–d: 自减运算符（前缀），先自减 d，然后使用自减后的值。

先将 d 减 1，即 d 变为 5，然后使用 d 的值 5。
乘法运算：

计算 a++ * b，即 10 * 4 = 40。 //计算时候，使用a当前的值不是运算后的值。变量最终值a还是变了a++ a=11；
计算 c * --d，即 20 * 5 = 100。 //就是从左往右看的话 a当时10（就要计算了） --d d变了5 在计算因为–再前
加法运算：

最后计算 40 + 100 = 140。
所以，e 的值是 140。因此，正确答案是：C. 140

14. 关于循环语句下列错误的是（）

A. for语句while语句与do while语句可以相互替换。
B. while(5){Console.WriteLine(“Hello!”);}将无限输出字符串Hello。
C. for(int i=5;i<13;i++){}这个语句将运行8次
D. while语句中的条件必须是布尔类型的结果

while 语句的条件必须是布尔值表达式。while(5) 是不合法的，因为 5 是一个整数而不是布尔值。编译器将报错，因此这段代码不能编译执行。
A：例子：do-while 可以与 for 循环相互替换（0次循环）
do-while 循环示例
如果你希望 do-while 循环在某些条件下不执行循环体，可以设置循环条件为初始值 false，这样循环体只会执行一次或不执行。

do
{
    // 循环体
} while (false); // 条件始终为 false，循环体不会执行

for 循环示例
for (int i = 0; false; i++)
{
    // 循环体
}

总结
1.do-while 循环至少执行一次，因为条件在循环体之后检查。
2.for 循环可以设置条件以决定是否执行循环体。条件可以设置为 false，从而实现零次循环。

因此，尽管在特定情况下可以用 do-while 循环来模拟 for 循环的零次执行（和相反的情况），它们的执行逻辑有所不同，因此不能完全替换。在设计时需要根据具体的需求选择适合的循环结构。

15. 下列关于数组访问的描述中，哪些选项是错误的（）

A. 数组元素索引是从0开始的
B. 对数组元素的所有访问都要进行边界检查
C. 如果使用的索引小于0，或大于数组的大小，编译器将抛出一IndexOutOfRangeException异常；
D. 数组元素的访问是从1开始，到Length结束；

D. 数组元素的访问是从1开始，到Length结束
错误。数组元素的访问是从索引 0 开始，到 Length - 1 结束，而不是从 1 开始到 Length 结束。

17. C#的构造函数分为实例构造函数和静态构造函数，实例构造函数可以对（）进行初化，静态构造函数只能对静态成员进行初始化。

A. 静态成员
B. 静态成员和非静态成员
C. 非静态成员
D. 动态成员

在 C# 中，构造函数的目的是初始化类的成员。根据问题描述：

实例构造函数：用于创建类的实例，并且可以对实例成员（非静态成员）进行初始化。
静态构造函数：用于初始化类的静态成员，仅在类第一次被加载时执行一次。
根据这些定义：

实例构造函数可以对非静态成员进行初始化，同时也可以对静态成员进行初始化，因为静态成员属于类本身，并且所有实例共享静态成员。
静态构造函数只能对静态成员进行初始化。

下面是一个例子，展示了实例构造函数和静态构造函数分别初始化静态成员和非静态成员。

using System;

public class MyClass
{
    // 静态成员
    public static int StaticCount;
    
    // 实例成员
    public int InstanceCount;
    
    // 静态构造函数
    static MyClass()
    {
        StaticCount = 0;
        Console.WriteLine("静态构造函数被调用");
    }
    
    // 实例构造函数
    public MyClass()
    {
        StaticCount++;
        InstanceCount = StaticCount;
        Console.WriteLine("实例构造函数被调用");
    }
}
public class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine("创建第一个实例");
        MyClass obj1 = new MyClass();
        Console.WriteLine($"StaticCount: {MyClass.StaticCount}, InstanceCount: {obj1.InstanceCount}");
        Console.WriteLine("创建第二个实例");
        MyClass obj2 = new MyClass();
        Console.WriteLine($"StaticCount: {MyClass.StaticCount}, InstanceCount: {obj2.InstanceCount}");
    }
}

代码解释
静态成员：StaticCount

这是一个静态成员，属于类本身，并且所有实例共享这个成员。
实例成员：InstanceCount

这是一个实例成员，每个实例都有自己独立的副本。
静态构造函数：static MyClass()

这个构造函数在类第一次被使用时调用（例如创建第一个实例或访问第一个静态成员时）。
它初始化静态成员 StaticCount 并输出消息。
静态构造函数只执行一次。
实例构造函数：public MyClass()

这个构造函数在每次创建类的实例时调用。
它增加静态成员 StaticCount 的值，并将 StaticCount 的值赋给实例成员 InstanceCount。
输出消息显示实例构造函数被调用。

 创建第一个实例
静态构造函数被调用
实例构造函数被调用
StaticCount: 1, InstanceCount: 1
创建第二个实例
实例构造函数被调用
StaticCount: 2, InstanceCount: 2

总结
1.构造函数必须与类名相同
2.静态构造函数用于初始化静态成员，并且只在类第一次被使用时调用一次。
3.实例构造函数用于初始化非静态成员（实例成员），每次创建类的新实例时都会调用。
4.实例构造函数也可以初始化静态成员，因为静态成员是所有实例共享的

19. 下列关于构造函数的描述正确的是？（）

A. 构造函数可以声明返回值类型
B. 构造函数必须与类名相同
C. 构造函数不能带参数
D. 构造函数需要调用才能执行

A. 构造函数可以声明返回值类型
错误。构造函数不能声明返回值类型，包括 void。

B. 构造函数必须与类名相同
正确。构造函数的名称必须与类名完全相同，以便编译器可以识别它们。

C. 构造函数不能带参数
错误。构造函数可以带参数，这样的构造函数称为参数化构造函数。
参数化构造函数。例子：

using System;

public class Person
{
    // 实例变量
    public string Name { get; set; }
    public int Age { get; set; }

    // 参数化构造函数
    public Person(string name, int age)
    {
        Name = name; // 使用参数初始化实例变量
        Age = age;
    }
}

class Program
{
    static void Main()
    {
        // 创建Person类的实例，并通过参数化构造函数初始化
        Person person = new Person("Alice", 30);

        // 输出实例的属性值
        Console.WriteLine($"Name: {person.Name}");
        Console.WriteLine($"Age: {person.Age}");
    }
}

代码解释
定义类 Person：
类 Person 包含两个属性：Name 和 Age。
参数化构造函数：
构造函数 Person(string name, int age) 接受两个参数：name 和 age。
在构造函数内部，参数 name 被用来初始化 Name 属性，参数 age 被用来初始化 Age 属性。
创建对象并初始化：
在 Main 方法中，创建了一个 Person 类的实例，并通过参数化构造函数传递 name 和 age 的值。
输出属性值：
使用 Console.WriteLine 输出 Person 对象的 Name 和 Age 属性值。
通过参数化构造函数，你可以在创建对象时提供初始值，这样对象在创建时就会被初始化为所需的状态

D. 构造函数需要调用才能执行
错误。构造函数是在创建对象时自动调用的，而不是显式调用。

让我们逐步分析表达式 int c = a++ + a++ + --a + a / b; 计算的每一步，以确定其结果。

初始值
a = 5
b = 4
逐步计算
a++: 后缀自增运算符使用当前值 5，然后 a 增加到 6。
a++: 后缀自增运算符使用当前值 6，然后 a 增加到 7。
–a: 前缀自减运算符首先将 a 减少到 6，然后使用新值 6。
a / b: a 现在是 6，b 是 4，整数除法结果为 6 / 4 = 1。
我们可以逐步计算每个操作的结果：

第一次 a++ 结果为 5，a 变为 6。
第二次 a++ 结果为 6，a 变为 7。
–a 结果为 6，a 变为 6。
a / b 结果为 1（整数除法）。

二、填空题

2. 操作符_________被用来说明两个条件同为真的情况

在 C# 中，用于表示两个条件都为真的操作符是逻辑与操作符 &&。

 using System;

class Program
{
    static void Main()
    {
        bool condition1 = true; // 第一个条件
        bool condition2 = true; // 第二个条件

        // 检查两个条件是否都为真
        if (condition1 && condition2)
        {
            Console.WriteLine("两个条件都为真。"); // 如果两个条件都为真，输出这条消息
        }
        else
        {
            Console.WriteLine("至少有一个条件为假。"); // 如果至少有一个条件为假，输出这条消息
        }
    }
}

在这个示例中，if 语句中的条件 condition1 && condition2 只有在 condition1 和 condition2 都为 true 时才为 true。
如果其中任何一个条件为 false，整个表达式的值就是 false，并且将执行 else 部分的代码。因此，表示两个条件都为真的操作符是：&&

4. 设x=10; 则表达式 x < 10 ? x = 0 : x++ 的值为_________

x++ 是后缀自增运算符，返回 x 当前的值，然后将 x 增加 1。 X=10

10. 用代码生成11（包含）到20（包含）之间的随机整数__________________

 // 创建一个Random类的实例
       Random random = new Random();
        
// 生成11到20之间的随机整数，包括11和20
       int randomNumber = random.Next(11, 21);

random.Next(11, 21) 方法生成一个范围在 11 到 20（包含）的随机整数。random.Next(minValue, maxValue) 方法生成的随机数包括 minValue 但不包括 maxValue，所以我们将 maxValue 设置为（maxValue +1）21 来包含 20。