C#中的new以及类

使用。

就是有点傻

1661人浏览 · 2024-07-23 20:03:14

就是有点傻 · 2024-07-23 20:03:14 发布

new关键字的用法

实例化对象：使用 new 关键字可以创建一个类的实例。例如：
```
MyClass obj = new MyClass();
```
指定构造函数：如果类有多个构造函数，可以使用 new 关键字指定使用哪一个构造函数来创建对象。例如：
```
MyClass obj = new MyClass(10, "Hello");
```

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

public class BaseClass
{
    public int Number { get; set; }
}

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

隐藏基类的构造函数：使用 new 关键字可以隐藏基类的构造函数，使得派生类不能直接调用基类的构造函数。例如：
```
public class BaseClass
{
    public BaseClass() { }
}

public class DerivedClass : BaseClass
{
    new public DerivedClass() { }
}
```
创建数组：new 关键字也用于创建数组。例如：
```
int[] numbers = new int[10];
```
创建委托实例：new 关键字可以用来创建委托实例。例如：
```
Action action = new Action(Console.WriteLine);
```
创建匿名类型实例：在查询表达式或对象初始化器中，可以使用 new 关键字创建匿名类型的实例。例如：
```
var anonymousType = new { Name = "Kimi", Age = 25 };
```

静态类

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

定义静态类：使用 static 关键字定义一个静态类。例如：
```
public static class MathUtils
{
    // 类成员
}
```
静态成员：静态类只能包含静态成员，如静态字段、静态方法、静态属性、静态事件和嵌套的静态类。
不能实例化：由于静态类没有实例状态，因此不能创建其实例。尝试实例化静态类将导致编译错误。
访问静态成员：静态类的成员可以通过类名直接访问，而不需要创建类的实例。例如：
```
int result = MathUtils.Add(3, 5);
```
静态构造函数：静态类可以有一个静态构造函数，它不带任何参数，并且仅在类第一次被访问时调用一次。例如：
```
public static class MathUtils
{
    static MathUtils()
    {
        // 初始化代码
    }
}
```
使用场景：静态类通常用于工具类，提供一组静态方法，如数学计算、字符串处理、日期时间操作等。
继承：静态类不能被继承，也不能继承其他类或接口。

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

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

密封类

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

定义密封类：使用 sealed 关键字定义一个密封类。例如：
```
public sealed class FinalClass
{
    // 类成员
}
```
不能被继承：密封类不能被其他类继承。如果尝试从密封类派生，将导致编译错误。
继承的成员：密封类可以继承其他类，但这些继承的成员可以被密封，使得派生类不能重写这些成员。
重写方法：密封类可以重写基类的方法，但这些重写的方法不能被进一步重写。
访问修饰符：密封类可以是 public 或 internal，但不能是 private。
使用场景：密封类通常用于以下场景：
- 当你不希望某个类被继承时。
- 当你希望确保某个类的行为不被改变时。

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

public sealed class FinalClass
{
    public void Display()
    {
        Console.WriteLine("This class cannot be inherited.");
    }
}

// 以下代码将导致编译错误，因为 FinalClass 是密封的
// public class DerivedClass : FinalClass
// {
// }

与静态类的区别：
- 静态类不能被实例化，而密封类可以。
- 静态类只能包含静态成员，而密封类可以包含非静态成员。

抽象类

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

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

定义抽象类：使用 abstract 关键字定义一个抽象类。例如：
```
public abstract class Animal
{
    // 抽象类成员
}
```
抽象成员：抽象类可以包含抽象方法、抽象属性、抽象索引器或抽象事件。这些成员在抽象类中没有实现，必须在派生类中提供具体实现。
不能实例化：由于抽象类不包含完整的实现，因此不能直接创建其实例。尝试实例化抽象类将导致编译错误。
派生类实现：从抽象类派生的类必须实现所有抽象成员，否则该派生类也必须被声明为抽象类。
非抽象成员：抽象类也可以包含非抽象成员，这些成员在类中已经提供了具体的实现。
构造函数：抽象类可以有构造函数，但这些构造函数只能在派生类中被调用。
使用场景：抽象类通常用于以下场景：
- 定义一个接口或一组接口，派生类必须实现这些接口。
- 提供一些共通的实现代码，减少派生类的代码重复。

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

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();

与接口的区别：
- 抽象类可以包含抽象方法和非抽象方法，而接口只能包含抽象方法。
- 接口可以被多个类实现，而抽象类只能被单个类继承。

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

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

多态（Polymorphism）：多态是指允许不同类的对象对同一消息做出响应的能力，即同一个接口可以被不同的实例以不同的方式实现。多态有两种主要形式：编译时多态（方法重载）和运行时多态（方法重写）。
重载（Overloading）：重载发生在同一个类中，当有两个或多个方法在类中具有相同的名称但参数列表不同（参数类型、数量或顺序不同）时。编译器根据方法调用时提供的参数来确定应该调用哪个方法。
```
public class Example
{
    public void Display(int a)
    {
        Console.WriteLine(a);
    }

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

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

public class BaseClass
{
    public virtual void Show()
    {
        Console.WriteLine("BaseClass Show()");
    }
}

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

虚方法（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()");
    }
}

密封方法（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#中都用于实现运行时多态，但它们之间有一些关键的区别：

定义方式：
- 虚方法（Virtual Method）：使用 virtual 关键字在基类中定义，可以提供一个默认实现。
- 抽象方法（Abstract Method）：使用 abstract 关键字在抽象类中定义，没有实现体，必须在派生类中提供实现。
实现：
- 虚方法：可以在基类中提供实现，派生类可以选择重写（Override）该方法。
- 抽象方法：在声明时没有实现，派生类必须提供实现。
使用场景：
- 虚方法：当基类知道如何实现方法，但允许派生类提供特定行为时使用。
- 抽象方法：当基类不知道如何实现方法，需要派生类根据具体情况提供实现时使用。
非抽象类中的使用：
- 虚方法：可以在任何类中声明，无论该类是否被声明为 abstract。
- 抽象方法：只能在抽象类中声明。
调用：
- 虚方法：可以通过基类引用或派生类引用调用，如果派生类重写了该方法，将调用派生类的实现。
- 抽象方法：只能通过派生类的引用调用，因为抽象方法本身没有实现。
重写：
- 虚方法：派生类可以使用 override 关键字重写基类中的虚方法。
- 抽象方法：派生类必须实现抽象方法，这不是重写，因为抽象方法没有实现。
新方法的添加：
- 虚方法：可以在任何时候向基类中添加新的虚方法，这不会影响现有的派生类。
- 抽象方法：向现有抽象类添加新的抽象方法可能需要修改所有现有的派生类，以实现新的方法。
密封方法：
- 虚方法：可以被密封（使用 sealed 关键字），这意味着派生类不能重写该方法。
- 抽象方法：不能被密封，因为它们没有实现。

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

区别：

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

主要区别：

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