首页 > 其他分享 >值类型和引用类型、装箱和拆箱、静态类和普通类、方法的重载、继承和多态、访问修饰符

值类型和引用类型、装箱和拆箱、静态类和普通类、方法的重载、继承和多态、访问修饰符

时间：2024-08-18 18:51:53浏览次数：14  
标签：拆箱 示例 int void 修饰符 多态 public 类型 class

目录

一、值类型和引用类型的区别?

在C#中，数据类型主要分为两类：值类型（value types）和引用类型（reference types）。这两类类型在内存管理、性能表现以及使用场景上有着显著的不同。下面我将详细介绍这两类类型的特点和区别。

值类型 (Value Types)

定义：
  • 直接存储数据本身：值类型直接在内存中存储具体的值。
  • 分配在栈上：大多数情况下，值类型的实例存储在栈上，这使得它们的内存分配和释放非常高效。
特点：
  • 内存分配：值类型直接存储在栈中，如果作为结构的一部分，则存储在包含它的对象中。
  • 赋值操作：当一个值类型变量被赋值给另一个变量时，会创建一个该值类型的副本。
  • 传递方式：在函数调用中，值类型以值传递的方式进行传递，这意味着任何对参数的修改都不会影响原始变量。
  • 初始化：值类型必须被初始化才能使用，否则会引发编译错误。
示例：
  • 基本类型：如 int, float, bool, char 等。
  • 结构体 (struct)：用户定义的值类型，可以包含字段、属性和方法。
  • 枚举 (enum)：表示一组命名常量的集合。

引用类型 (Reference Types)

定义：
  • 存储引用而非数据本身：引用类型存储的是指向实际数据的内存地址（即引用），而不是数据本身。
  • 分配在堆上：引用类型的实例存储在堆上，而引用本身则存储在栈上。
特点：
  • 内存分配：引用类型只存储指向对象的引用，对象本身位于堆上。
  • 赋值操作：当一个引用类型变量被赋值给另一个变量时，实际上是复制了引用，而不是复制了对象本身。
  • 传递方式：在函数调用中，引用类型以引用传递的方式进行传递，这意味着对参数的任何修改都会影响到原始变量。
  • 初始化：引用类型默认初始化为 null，如果要使用对象，则需要先实例化。
示例：
  • 类 (class)：用户定义的类型，可以包含字段、属性、方法等。
  • 接口 (interface)：定义了一组行为规范，不包含任何实现。
  • 数组 (array)：元素的有序集合，可以是一维或多维。
  • 字符串 (string)：不可变的字符序列。
  • 动态类型 (dynamic)：运行时确定类型的类型。
  • 对象 (object)：C# 中所有类型的基类。

举例说明：

假设我们有一个简单的程序，其中包含一个值类型 int 和一个引用类型 class 的实例：

using System;

class Program
{
    struct Point
    {
        public int X;
        public int Y;
    }

    class Circle
    {
        public Point Center;
        public double Radius;
    }

    static void Main()
    {
        Point point = new Point { X = 1, Y = 2 };
        Circle circle = new Circle { Center = point, Radius = 3.5 };

        // 修改point
        point.X = 10;

        Console.WriteLine("Point X: " + point.X); // 输出 10
        Console.WriteLine("Circle Center X: " + circle.Center.X); // 输出 1

        // 修改circle.Center
        circle.Center.Y = 20;

        Console.WriteLine("Point Y: " + point.Y); // 输出 2
        Console.WriteLine("Circle Center Y: " + circle.Center.Y); // 输出 20
    }
}

在这个例子中，当你修改 point 变量时，它不会影响 circle.Center，因为 point 是值类型，修改 point 实际上是修改了一个新的副本。但是，当你修改 circle.Center 时，这会影响到 circle 对象中的 Center 字段，因为 circle.Center 是一个引用类型（结构体 Point）的引用。

总结：

  • 性能：值类型通常更快，因为它们直接存储在栈中，而引用类型涉及额外的间接寻址。
  • 内存消耗：值类型在频繁复制时可能会消耗更多内存；引用类型则可能因对象的生命周期管理不当导致内存泄漏。
  • 使用场景：值类型适合简单的数据结构，如数字和字符；引用类型适合复杂的数据结构，如对象图和引用链。

理解这两种类型之间的区别对于编写高效且易于维护的代码至关重要。

二、装箱和拆箱

在C#中，装箱（boxing）和拆箱（unboxing）是值类型和引用类型之间转换的一种机制。装箱是指将值类型转换为引用类型的过程，而拆箱则是相反的过程，即将引用类型转换回值类型。

装箱 (Boxing)

装箱是将值类型转换成引用类型的过程。通常发生在将值类型放入引用类型容器（如 object 或 System.Collections.Generic.List<T>）时。

特点：
  • 转换过程：从值类型到引用类型的转换是隐式的。
  • 内存分配：装箱过程中会在堆上为值类型分配一个新的对象，并将值类型的内容复制到这个新对象中。
  • 性能开销：装箱涉及到在堆上分配内存，这可能会导致额外的性能开销。
示例：
int i = 10;
object o = i; // 装箱

拆箱 (Unboxing)

拆箱是将引用类型转换回值类型的过程。这是一个显式转换过程，通常需要使用 as 关键字或者强制类型转换。

特点：
  • 转换过程：从引用类型到值类型的转换是显式的。
  • 类型检查：拆箱时需要确保引用类型实际上包含的是值类型的实例。
  • 性能影响：拆箱过程涉及类型检查和强制类型转换，可能会影响性能。
示例：
object o = 10; // 假设这里通过装箱已经存储了一个整数值
int i = (int)o; // 拆箱

示例代码:

下面是一个简单的示例，演示了如何在C#中执行装箱和拆箱操作：

using System;

public class Program
{
    static void Main()
    {
        int intValue = 10;
        
        // 装箱
        object boxedInt = intValue; // 将值类型 int 转换为引用类型 object
        
        // 拆箱
        int unboxedInt = (int)boxedInt; // 将引用类型 object 强制转换为值类型 int
        
        Console.WriteLine($"Original value: {intValue}");
        Console.WriteLine($"Boxed value: {boxedInt}");
        Console.WriteLine($"Unboxed value: {unboxedInt}");
    }
}

输出：

Original value: 10
Boxed value: 10
Unboxed value: 10

装箱和拆箱的影响

  • 性能：频繁的装箱和拆箱可能导致性能下降，尤其是在循环和其他性能敏感的操作中。
  • 内存使用：装箱会导致在堆上分配额外的内存。
  • 类型安全性：拆箱时需要确保对象确实包含正确的值类型，否则会出现运行时错误。

最佳实践:

为了减少装箱和拆箱带来的性能开销，你可以考虑以下最佳实践：

  • 使用泛型集合，如 List<int>，而不是 List<object>，以避免不必要的装箱。
  • 在性能关键的部分尽量避免使用装箱和拆箱。
  • 使用值类型时考虑使用可空类型，如 int?，以便更好地处理可为空的情况，同时减少装箱的需要。
  • 对于频繁使用的值类型，考虑使用结构体（structs）来代替类（classes），特别是在这些类型用作集合元素时。

通过理解和合理使用装箱和拆箱，你可以编写出更加高效和安全的C#程序。

三、静态类和普通类的区别?

在C#中，静态类（static 类）和普通类（非静态类）之间存在一些重要的区别。这些区别主要体现在类的成员、实例化过程以及使用方式上。下面是两种类型的比较：

静态类 (Static Class)

  • 定义：

    • 静态类使用 static 关键字声明。
    • 静态类不能实例化，也就是说，你不能创建一个静态类的实例。

  • 成员：

    • 静态类只能包含静态成员（字段、属性、方法和嵌套类型）。
    • 所有的成员都必须是静态的，不允许包含实例成员。
    • 成员可以通过类名直接访问，无需创建类的实例。

  • 用途：

    • 静态类通常用于提供实用工具方法，如数学运算、文件操作等。
    • 静态类适合用来封装一组相关的功能，这些功能不需要实例上下文就可以工作。

  • 示例：

    using System;

public static class Utility
{
    public static int Add(int a, int b)
    {
        return a + b;
    }
}

class Program
{
    static void Main()
    {
        int result = Utility.Add(5, 3);
        Console.WriteLine(result); // 输出 8
    }
}

普通类 (Non-Static Class)

  • 定义：

    • 普通类没有 static 关键字。
    • 普通类可以实例化，也就是说，你可以创建一个或多个该类的实例。

  • 成员：

    • 普通类可以包含静态成员和实例成员。
    • 实例成员需要通过类的实例来访问。
    • 静态成员可以直接通过类名访问。

  • 用途：

    • 普通类用于定义对象模型，这些对象可以具有状态和行为。
    • 普通类适合用来表示具体的事物，比如用户、订单、产品等。

  • 示例：

    using System;

public class User
{
    public string Name { get; set; }
    public int Age { get; set; }

    public User(string name, int age)
    {
        this.Name = name;
        this.Age = age;
    }

    public void PrintInfo()
    {
        Console.WriteLine($"Name: {this.Name}, Age: {this.Age}");
    }
}

class Program
{
    static void Main()
    {
        User user = new User("Alice", 30);
        user.PrintInfo(); // 输出 "Name: Alice, Age: 30"
    }
}

比较总结

  • 实例化：

    • 静态类：不能创建实例。
    • 普通类：可以创建一个或多个实例。

  • 成员：

    • 静态类：只能包含静态成员。
    • 普通类：可以包含静态成员和实例成员。

  • 访问：

    • 静态类：成员直接通过类名访问。
    • 普通类：实例成员通过实例访问，静态成员直接通过类名访问。

  • 生命周期：

    • 静态类：静态类的生命周期与应用程序的生命周期相同，只要应用程序运行，静态类就会存在。
    • 普通类：普通类的实例有自己的生命周期，可以通过垃圾回收机制自动清理不再使用的实例。

  • 设计模式：

    • 静态类：通常用于工具类或单例模式。
    • 普通类：适用于多种设计模式，如工厂模式、策略模式等。

选择使用哪种类型的类取决于你的具体需求。如果你想要封装一组不需要实例化的工具方法，那么静态类是一个好选择。如果你需要创建具有状态的对象，那么应该使用普通类。

四、方法的重载

在C#中，方法重载（overloading）是指在同一类中定义多个同名的方法，但要求这些方法具有不同的参数列表。通过这种方法，你可以为同一个方法名称提供多个实现，从而简化代码并提高可读性。下面我将详细介绍方法重载的概念、特点以及如何使用它。

方法重载的特点

  • 方法名称相同：所有重载的方法必须拥有相同的名称。
  • 参数列表不同：重载的方法必须有不同的参数列表。参数列表的不同可以是参数的数量、类型或者顺序不同。
  • 返回类型无关：重载的方法可以有不同的返回类型，但这不是区分方法的关键因素。
  • 访问修饰符无关：重载的方法可以有不同的访问修饰符，例如 public、private 或 protected。
  • 异常抛出无关：重载的方法可以抛出不同的异常。

方法重载的作用

  • 代码复用：可以使用相同的方法名称来执行类似的操作，减少代码重复。
  • 提高代码可读性：使用有意义的方法名称可以提高代码的可读性和可维护性。
  • 灵活性：可以根据传入的不同参数执行不同的逻辑。

方法重载示例

下面是一个简单的方法重载示例，展示如何定义一个名为 Add 的方法，它可以接受不同类型和数量的参数，并返回相应的结果。

using System;

class MathOperations
{
    // 两个整数相加
    public static int Add(int a, int b)
    {
        return a + b;
    }

    // 三个整数相加
    public static int Add(int a, int b, int c)
    {
        return a + b + c;
    }

    // 两个浮点数相加
    public static double Add(double a, double b)
    {
        return a + b;
    }

    // 一个整数和一个浮点数相加
    public static double Add(int a, double b)
    {
        return a + b;
    }

    // 一个字符串和一个整数相加（拼接）
    public static string Add(string text, int number)
    {
        return text + number.ToString();
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(MathOperations.Add(5, 3)); // 输出 8
        Console.WriteLine(MathOperations.Add(5, 3, 7)); // 输出 15
        Console.WriteLine(MathOperations.Add(5.5, 3.2)); // 输出 8.7
        Console.WriteLine(MathOperations.Add(5, 3.2)); // 输出 8.2
        Console.WriteLine(MathOperations.Add("Hello ", 5)); // 输出 "Hello 5"
    }
}

注意事项

  • 参数类型转换：C# 中的方法重载会根据参数的类型进行最合适的匹配。如果参数可以通过隐式类型转换来匹配某个方法签名，那么这个方法将被选中。
  • 重载解析：当多个方法签名都符合调用时，编译器会根据最精确的匹配原则来选择合适的方法。如果有多个方法都同样匹配，则会出现编译错误。

使用方法重载的最佳实践

  • 避免过量重载：过多的方法重载可能会导致代码难以理解和维护。
  • 明确的方法签名：确保每个重载的方法签名清晰明了，避免不必要的混淆。
  • 考虑可扩展性：设计方法时考虑未来可能需要添加的新重载版本，以保持代码的一致性和可维护性。

通过合理地使用方法重载，你可以使代码更加简洁、易于理解和维护。

五、继承和多态

在C#中，继承（Inheritance）和多态（Polymorphism）是面向对象编程的两个核心概念。它们允许你构建可复用的代码，并使程序设计更为灵活和模块化。

继承 (Inheritance)

继承是一种机制，允许一个类（子类或派生类）继承另一个类（父类或基类）的特性和行为。子类可以重用、扩展或修改父类的行为。

特点：
  • 继承层次：通过继承，可以形成类的层次结构，基类可以有多个派生类。
  • 访问修饰符：继承时需要注意成员的访问级别，子类只能访问父类中的公共（public）、受保护（protected）或内部（internal）成员。
  • 构造函数：子类构造函数必须调用基类的构造函数。
  • 虚方法：基类可以声明虚方法（virtual method），派生类可以选择覆盖这些方法。
示例代码：
public class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("The animal makes a sound");
    }
}

public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("The dog barks");
    }
}

public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("The cat meows");
    }
}

class Program
{
    static void Main()
    {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myAnimal.MakeSound(); // 输出 "The animal makes a sound"
        myDog.MakeSound();    // 输出 "The dog barks"
        myCat.MakeSound();    // 输出 "The cat meows"
    }
}

多态 (Polymorphism)

多态允许你使用基类类型的指针或引用调用派生类的方法。这使得你可以编写更通用的代码，这些代码可以处理多种类型的对象。

特点：
  • 方法覆盖：通过在派生类中覆盖基类的虚方法来实现多态。
  • 接口实现：实现接口也是一种形式的多态，允许不同类实现相同的接口方法。
  • 抽象类：抽象类可以定义抽象方法，强制派生类实现这些方法。
  • 动态绑定：多态通常涉及到动态绑定，即在运行时确定调用哪个方法版本。
示例代码：
public abstract class Shape
{
    public abstract double GetArea();
}

public class Circle : Shape
{
    public double Radius { get; set; }

    public Circle(double radius)
    {
        Radius = radius;
    }

    public override double GetArea()
    {
        return Math.PI * Radius * Radius;
    }
}

public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }

    public Rectangle(double width, double height)
    {
        Width = width;
        Height = height;
    }

    public override double GetArea()
    {
        return Width * Height;
    }
}

class Program
{
    static void PrintArea(Shape shape)
    {
        Console.WriteLine($"Area: {shape.GetArea()}");
    }

    static void Main()
    {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);

        PrintArea(circle); // 输出 "Area: 78.53981633974483"
        PrintArea(rectangle); // 输出 "Area: 24"
    }
}

总结

  • 继承：提供了一种定义类层次结构的方式，子类可以从基类继承成员，并可以覆盖或扩展这些成员。
  • 多态：允许你通过基类类型的引用或指针来处理派生类对象，从而编写更加灵活和可扩展的代码。

最佳实践

  • 合理设计继承层次：确保继承关系有意义，避免过度使用继承。
  • 谨慎使用抽象类和接口：抽象类和接口可以帮助定义清晰的接口，但也要注意不要过度设计。
  • 避免紧耦合：通过依赖注入等技术减少类之间的紧密耦合，使代码更易于维护和扩展。

通过理解和运用继承和多态的概念，你可以编写出更加健壮、可维护和可扩展的C#程序。

六、访问修饰符

在C#中，访问修饰符（access modifiers）是用来控制类、方法、属性等成员的可见性的关键字。C#提供了五种不同的访问修饰符，每一种都有其特定的作用范围。以下是这些访问修饰符的概述及其使用场景：

1. public (公共)

  • 描述：公共成员对任何其他代码都是可见的，无论这些代码是否在同一个命名空间中。
  • 示例：
    public class MyClass
{
    public void MyMethod() { /* ... */ }
}

2. private (私有)

  • 描述：私有成员仅在其声明所在的类中可见。
  • 示例：
    public class MyClass
{
    private void MyMethod() { /* ... */ }
}

3. protected (受保护)

  • 描述：受保护成员对其所在的类和从该类派生的所有类可见。
  • 示例：
    public class MyBaseClass
{
    protected void MyProtectedMethod() { /* ... */ }
}

public class MyDerivedClass : MyBaseClass
{
    public void DerivedMethod()
    {
        MyProtectedMethod(); // 可以访问
    }
}

4. internal (内部)

  • 描述：内部成员仅在同一程序集（assembly）内的代码中可见。
  • 示例：
    internal class MyClass
{
    internal void MyMethod() { /* ... */ }
}

5. protected internal (受保护内部)

  • 描述：受保护内部成员对同一程序集中的代码以及从该类派生的所有类可见。
  • 示例：
    public class MyBaseClass
{
    protected internal void MyProtectedInternalMethod() { /* ... */ }
}

public class MyDerivedClass : MyBaseClass
{
    public void DerivedMethod()
    {
        MyProtectedInternalMethod(); // 可以访问
    }
}

6. private protected (私有受保护)

  • 描述：私有受保护成员仅在声明它的类和从该类派生的类中可见，但这些类必须位于同一个程序集中。
  • 示例：
    public class MyBaseClass
{
    private protected void MyPrivateProtectedMethod() { /* ... */ }
}

public class MyDerivedClass : MyBaseClass
{
    public void DerivedMethod()
    {
        MyPrivateProtectedMethod(); // 可以访问
    }
}

示例代码

下面是一个简单的示例，展示了不同访问修饰符的使用：

using System;

public class BaseClass
{
    public void PublicMethod() { Console.WriteLine("Public Method"); }
    private void PrivateMethod() { Console.WriteLine("Private Method"); }
    protected void ProtectedMethod() { Console.WriteLine("Protected Method"); }
    internal void InternalMethod() { Console.WriteLine("Internal Method"); }
    protected internal void ProtectedInternalMethod() { Console.WriteLine("Protected Internal Method"); }
    private protected void PrivateProtectedMethod() { Console.WriteLine("Private Protected Method"); }
}

public class DerivedClass : BaseClass
{
    public void CallMethods()
    {
        PublicMethod(); // 可以访问
        ProtectedMethod(); // 可以访问
        ProtectedInternalMethod(); // 可以访问
        PrivateProtectedMethod(); // 可以访问
        // PrivateMethod() 和 InternalMethod() 无法访问
    }
}

class Program
{
    static void Main()
    {
        BaseClass baseObj = new BaseClass();
        baseObj.PublicMethod(); // 可以访问
        // baseObj.PrivateMethod(); // 无法访问
        // baseObj.ProtectedMethod(); // 无法访问
        // baseObj.InternalMethod(); // 无法访问
        // baseObj.ProtectedInternalMethod(); // 无法访问
        // baseObj.PrivateProtectedMethod(); // 无法访问

        DerivedClass derivedObj = new DerivedClass();
        derivedObj.CallMethods();
    }
}

注意事项

  • 选择合适的访问级别：选择最严格的访问级别，这有助于限制类的暴露，增加代码的安全性和可维护性。
  • 默认访问级别：如果省略访问修饰符，默认为 private。
  • 命名空间和程序集：internal 和 protected internal 修饰符与命名空间和程序集相关联。

通过合理使用这些访问修饰符，你可以更好地控制类和成员的可见性，从而使你的代码更加健壮和安全。

标签：拆箱,示例,int,void,修饰符,多态,public,类型,class
From： https://blog.csdn.net/2302_82029124/article/details/141160136

相关文章

  • java:关于多态，继承，接口的好处。
    目录比喻1. 交通工具（Driver）2. 汽车（Car）和自行车（Bicycle）代码示例：思考：为什么不直接CarV=newCar()；？1. 多态性2. 代码的灵活性3. 易于扩展4. 减少耦合总结比喻想象一下，你有一个 “交通工具” 的抽象概念（可以是一个接口或类），然后你有不同的具体交通工具，比如......
  • c#优化装箱拆箱
    1、通过泛型//obj是一个int类型的值类型，在newTest的时候传进去的obj是就会装箱成引用类型，以为Test类是引用类型intobj=2;Testtest=newTest(obj);//通过泛型这里obj传进去的就是值类型，就不需要装箱了Test<int>test=newTest<int>(obj);第一段代码中会发生装箱，因......
  • 22. 面向对象之多态
    1.多态1.1概念多态指的是一类事物有多种形态比如动物有多种形态：人、猴、鸭1.2代码示例fromabcimportABC,abstractmethod#对于程序来说，定义一个基类可以有多个子类classAnimal(ABC):@abstractmethoddefrun(self):pass@abstractmethod......
  • 小白的学习笔记1：接口和多态，以及例子
    2024.8.21.接口接口即为一个抽象的方法，此方法定义了很多种行为，可供类们去实现，而避免了使用多种重复的else……if，while等即时运算。抽象，即为更上层的概念。比如“男人”的抽象为“人”，“人”的抽象为动物，这就是一个统领的节点。以下为示例publicclassDemo1{publicinterfa......
  • 多态的含义
    目录1、多态的定义2、多态存在的三个必要条件3、多态在Java中的表现形式1、多态的定义Java多态（Polymorphism）是面向对象编程的一项核心概念，它允许对象以多种形式出现。多态其实和继承息息相关，多态通常是指声明一个父类可以指向很多个不同的子类对象，而且每个子类表现出......
  • vue按键修饰符
    事件的类型有以下四类：js事件分为四类：鼠标事件：click、mouseover、dbclick、mousedown、mouseout...键盘事件：keydown、keypress、keyup..窗体事件:load、reseize、scroll...表单事件:blur、focus、input、change、select传统方式的弊端：需要了解每个数值的键码为了在必要的......
  • vue事件修饰符
    我们用vue中的事件修饰符来做上一篇中event.preventDefault() 阻止事件的默认行为和event.stopPropagation() 阻止事件冒泡、传播事件。<divid="app"><div@click="outer"id="outer"><div@click="middle"id="middle"&......
  • 访问修饰符
    7.2访问修饰符目录7.2访问修饰符7.2.1访问修饰符时什么7.2.2private关键字7.2.3public关键字7.2.1访问修饰符时什么Java中的访问修饰符用于控制类、接口、构造函数、方法和数据成员（字段）的可见性和访问级别。Java提供了四种访问修饰符：访问修饰符同一类内同一包内......
  • 多态
    多态的概念定义：它允许不同的对象对同一操作或方法调用做出响应，但具体的行为会根据对象的实际类型而有所不同。多态性提供了一种方式，使得代码能够以统一的接口与不同的数据类型交互，而不需要关心这些数据类型背后的具体实现细节。多态的好处：提高代码的可读性和可维护性。降低......
  • 多态的机制原理
    多态的机制原理本质上多态分两种1、编译时多态（又称静态多态）2、运行时多态（又称动态多态）多态通常有两种实现方法1、子类继承父类（extends）2、类实现接口（implements）要使用多态，在声明对象时就应该遵循一条法则：声明的总是父类类型或接口类型，创建的是实际类型。例来说，假设我们......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99