C#中的new以及类

new关键字的用法

1. 实例化对象：使用 new 关键字可以创建一个类的实例。例如：

   ​
   MyClass obj = new MyClass();

2. 指定构造函数：如果类有多个构造函数，可以使用 new 关键字指定使用哪一个构造函数来创建对象。例如：

   ​
   MyClass obj = new MyClass(10, "Hello");

3. 隐藏基类的成员：当派生类想要隐藏基类的同名成员时，可以使用 new 关键字。例如：

   ​
   public class BaseClass
   {public int Number { get; set; }
   }
   ​
   public class DerivedClass : BaseClass
   {new public int Number { get; set; }
   }

4. 隐藏基类的构造函数：使用 new 关键字可以隐藏基类的构造函数，使得派生类不能直接调用基类的构造函数。例如：

   ​
   public class BaseClass
   {public BaseClass() { }
   }
   ​
   public class DerivedClass : BaseClass
   {new public DerivedClass() { }
   }

5. 创建数组：new 关键字也用于创建数组。例如：

   ​
   int[] numbers = new int[10];

6. 创建委托实例：new 关键字可以用来创建委托实例。例如：

   ​
   Action action = new Action(Console.WriteLine);

7. 创建匿名类型实例：在查询表达式或对象初始化器中，可以使用 new 关键字创建匿名类型的实例。例如：

   ​
   var anonymousType = new { Name = "Kimi", Age = 25 };

静态类

在C#中，静态类是一种特殊的类，它只能包含静态成员，并且不能被实例化。静态类主要用于包含不依赖于对象实例状态的工具方法或常量。以下是静态类的一些关键特点：

1. 定义静态类：使用 static 关键字定义一个静态类。例如：

   ​
   public static class MathUtils
   {// 类成员
   }

2. 静态成员：静态类只能包含静态成员，如静态字段、静态方法、静态属性、静态事件和嵌套的静态类。

3. 不能实例化：由于静态类没有实例状态，因此不能创建其实例。尝试实例化静态类将导致编译错误。

4. 访问静态成员：静态类的成员可以通过类名直接访问，而不需要创建类的实例。例如：

   ​
   int result = MathUtils.Add(3, 5);

5. 静态构造函数：静态类可以有一个静态构造函数，它不带任何参数，并且仅在类第一次被访问时调用一次。例如：

   ​
   public static class MathUtils
   {static MathUtils(){// 初始化代码}
   }

6. 使用场景：静态类通常用于工具类，提供一组静态方法，如数学计算、字符串处理、日期时间操作等。

7. 继承：静态类不能被继承，也不能继承其他类或接口。

8. 泛型静态类：C# 2.0 以后，静态类也可以是泛型的。例如：

   ​
   public static class GenericMathUtils
   {public static T Add<T>(T a, T b) where T : IAddable<T>{// 实现添加逻辑}

密封类

在C#中，密封类（Sealed Class）是一种不能被继承的类。使用 sealed 关键字可以定义一个密封类。以下是密封类的一些关键特点：

1. 定义密封类：使用 sealed 关键字定义一个密封类。例如：

   ​
   public sealed class FinalClass
   {// 类成员
   }

2. 不能被继承：密封类不能被其他类继承。如果尝试从密封类派生，将导致编译错误。

3. 继承的成员：密封类可以继承其他类，但这些继承的成员可以被密封，使得派生类不能重写这些成员。

4. 重写方法：密封类可以重写基类的方法，但这些重写的方法不能被进一步重写。

5. 访问修饰符：密封类可以是 public 或 internal，但不能是 private。

6. 使用场景：密封类通常用于以下场景：

   • 当你不希望某个类被继承时。

   • 当你希望确保某个类的行为不被改变时。

7. 示例：以下是一个密封类的示例：

   public sealed class FinalClass
   {public void Display(){Console.WriteLine("This class cannot be inherited.");}
   }
   ​
   // 以下代码将导致编译错误，因为 FinalClass 是密封的
   // public class DerivedClass : FinalClass
   // {
   // }

8. 与静态类的区别：

   • 静态类不能被实例化，而密封类可以。

   • 静态类只能包含静态成员，而密封类可以包含非静态成员。

抽象类

抽象类在C#中是一种特殊的类类型，它不能被实例化，但可以被继承。抽象类主要用于定义一个基类，该基类为派生类提供一些共通的属性和方法，同时允许派生类提供具体的实现细节。

以下是抽象类的一些关键特点：

1. 定义抽象类：使用 abstract 关键字定义一个抽象类。例如：

   ​
   public abstract class Animal
   {// 抽象类成员
   }

2. 抽象成员：抽象类可以包含抽象方法、抽象属性、抽象索引器或抽象事件。这些成员在抽象类中没有实现，必须在派生类中提供具体实现。

3. 不能实例化：由于抽象类不包含完整的实现，因此不能直接创建其实例。尝试实例化抽象类将导致编译错误。

4. 派生类实现：从抽象类派生的类必须实现所有抽象成员，否则该派生类也必须被声明为抽象类。

5. 非抽象成员：抽象类也可以包含非抽象成员，这些成员在类中已经提供了具体的实现。

6. 构造函数：抽象类可以有构造函数，但这些构造函数只能在派生类中被调用。

7. 使用场景：抽象类通常用于以下场景：

   • 定义一个接口或一组接口，派生类必须实现这些接口。

   • 提供一些共通的实现代码，减少派生类的代码重复。

8. 示例：以下是一个抽象类的示例：

   ​
   public abstract class Animal
   {public abstract void MakeSound();
   ​public void Eat(){Console.WriteLine("Eating...");}
   }
   ​
   public class Dog : Animal
   {public override void MakeSound(){Console.WriteLine("Bark!");}
   }
   ​
   // 以下代码将导致编译错误，因为 Animal 是抽象类
   // Animal animal = new Animal();

9. 与接口的区别：

   • 抽象类可以包含抽象方法和非抽象方法，而接口只能包含抽象方法。

   • 接口可以被多个类实现，而抽象类只能被单个类继承。

多态，重载，重写，虚方法

在面向对象编程中，多态、重载、重写和虚方法是几个核心概念，它们允许程序具有更高的灵活性和可扩展性。下面是这些概念的简要解释：

1. 多态（Polymorphism）：多态是指允许不同类的对象对同一消息做出响应的能力，即同一个接口可以被不同的实例以不同的方式实现。多态有两种主要形式：编译时多态（方法重载）和运行时多态（方法重写）。

2. 重载（Overloading）：重载发生在同一个类中，当有两个或多个方法在类中具有相同的名称但参数列表不同（参数类型、数量或顺序不同）时。编译器根据方法调用时提供的参数来确定应该调用哪个方法。

   ​
   public class Example
   {public void Display(int a){Console.WriteLine(a);}
   ​public void Display(int a, int b){Console.WriteLine(a + b);}
   }

3. 重写（Overriding）：重写是运行时多态的一种形式，发生在继承体系中。当派生类提供一个与基类中具有相同名称、相同参数列表和相同返回类型的方法实现时，派生类的方法会覆盖基类的方法。

   ​
   public class BaseClass
   {public virtual void Show(){Console.WriteLine("BaseClass Show()");}
   }
   ​
   public class DerivedClass : BaseClass
   {public override void Show(){Console.WriteLine("DerivedClass Show()");}
   }

4. 虚方法（Virtual Method）：虚方法是在基类中使用 virtual 关键字声明的方法，允许在派生类中被重写。当通过基类的引用调用虚方法时，将调用对象实际类型的重写版本（如果存在），这是运行时多态的一个例子。

   ​
   public class BaseClass
   {public virtual void Method(){Console.WriteLine("BaseClass Method()");}
   }
   ​
   public class DerivedClass : BaseClass
   {public override void Method(){Console.WriteLine("DerivedClass Method()");}
   }

5. 密封方法（Sealed Method）：与重写相对，密封方法使用 sealed 关键字声明，它防止进一步的派生类重写该方法。这通常用于确保方法的特定实现不会被改变。

   ​
   public class BaseClass
   {public virtual void Method(){Console.WriteLine("BaseClass Method()");}
   }
   ​
   public class IntermediateClass : BaseClass
   {public sealed override void Method(){Console.WriteLine("IntermediateClass Method()");}
   }
   ​
   // 下面的代码将导致编译错误，因为 IntermediateClass 中的 Method 已被密封
   // public class DerivedClass : IntermediateClass
   // {
   //     public override void Method()
   //     {
   //         Console.WriteLine("DerivedClass Method()");
   //     }
   // }

virtual和abstract方法的区别？即虚方法和抽象方法的区别？

virtual 关键字和 abstract 关键字在C#中都用于实现运行时多态，但它们之间有一些关键的区别：

1. 定义方式：

   • 虚方法（Virtual Method）：使用 virtual 关键字在基类中定义，可以提供一个默认实现。
   • 抽象方法（Abstract Method）：使用 abstract 关键字在抽象类中定义，没有实现体，必须在派生类中提供实现。

2. 实现：

   • 虚方法：可以在基类中提供实现，派生类可以选择重写（Override）该方法。
   • 抽象方法：在声明时没有实现，派生类必须提供实现。

3. 使用场景：

   • 虚方法：当基类知道如何实现方法，但允许派生类提供特定行为时使用。
   • 抽象方法：当基类不知道如何实现方法，需要派生类根据具体情况提供实现时使用。

4. 非抽象类中的使用：

   • 虚方法：可以在任何类中声明，无论该类是否被声明为 abstract。
   • 抽象方法：只能在抽象类中声明。

5. 调用：

   • 虚方法：可以通过基类引用或派生类引用调用，如果派生类重写了该方法，将调用派生类的实现。
   • 抽象方法：只能通过派生类的引用调用，因为抽象方法本身没有实现。

6. 重写：

   • 虚方法：派生类可以使用 override 关键字重写基类中的虚方法。
   • 抽象方法：派生类必须实现抽象方法，这不是重写，因为抽象方法没有实现。

7. 新方法的添加：

   • 虚方法：可以在任何时候向基类中添加新的虚方法，这不会影响现有的派生类。
   • 抽象方法：向现有抽象类添加新的抽象方法可能需要修改所有现有的派生类，以实现新的方法。

8. 密封方法：

   • 虚方法：可以被密封（使用 sealed 关键字），这意味着派生类不能重写该方法。
   • 抽象方法：不能被密封，因为它们没有实现。

new和override区别？即隐藏方法和重写方法的区别？

区别：

• 目的：new 用于隐藏基类成员，override 用于重写基类成员。
• 调用：使用 new 的成员不能通过基类引用以多态方式调用，而 override 的成员可以。
• 基类成员：new 可以隐藏基类中的任何成员，而 override 只能用于基类中声明为 virtual 或 abstract 的成员。
• 访问修饰符：new 隐藏的成员可以有不同的访问修饰符，而 override 的成员访问修饰符不能比基类成员更严格。
• 多态性：override 支持多态性，new 不支持。

主要区别：

• 作用范围：
  • 重载：发生在同一个类中。
  • 重写：发生在继承体系中，基类和派生类之间。
• 调用机制：
  • 重载：编译时多态，编译器根据方法的参数类型和数量决定调用哪个方法。
  • 重写：运行时多态，运行时根据对象的实际类型决定调用哪个方法。
• 方法签名：
  • 重载：方法名称相同，参数列表不同。
  • 重写：方法名称、参数列表和返回类型必须与基类中的虚方法完全一致。
• 关键字：
  • 重载：不需要使用任何关键字。
  • 重写：基类方法需要使用 virtual 或 abstract 关键字，派生类方法使用 override 关键字。
• 访问级别：
  • 重载：可以有不同的访问修饰符。
  • 重写：派生类中重写的方法访问级别不能比基类方法更严格。