C#面向对象之访问限制，类基础，继承

1 访问限制

1.1 简介

C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。
一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：

• public：所有对象都可以访问；
  允许一个类将其成员变量和成员函数暴露给其他的函数和对象
• private：对象本身在对象内部可以访问；
  允许一个类将其成员变量和成员函数对其他的函数和对象进行隐藏。只有同一个类中的函数可以访问它的私有成员。即使是类的实例也不能访问它的私有成员
• protected：只有该类对象及其子类对象可以访问
  允许子类访问它的基类的成员变量和成员函数。这样有助于实现继承
• internal：同一个程序集（即：一个项目内）的对象可以访问；
  允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说，带有 internal 访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问。
• protected internal：访问限于当前程序集或派生自包含类的类型。
  访问修饰符允许在本类,派生类或者包含该类的程序集中访问。这也被用于实现继承
  即：不仅限于当前程序集内的类型和成员，还包括所有继承自该类型的子类，无论子类是否在同一个程序集内
• file： C# 11 中引入了一个新的关键字 file，用于声明文件作用域的成员。这意味着被标记为 file 的成员只能在声明它们的文件中访问，主要用于限制代码的可见性，确保某些类或成员只在当前文件中使用，提高模块化和封装性
  与 private 区别：
  • private：是限制在类或结构体内，可以应用于类、结构体的成员（字段、方法、属性等）
  • file：限制在文件内，可以应用于类、结构体、接口、枚举、委托等顶级声明。

2 类基础讲解

2.1 类定义

类的定义是以关键字 class 开始，后跟类的名称。类的主体，包含在一对花括号内。下面是类定义的一般形式：

<access specifier> class  class_name
{
    // member variables
    <access specifier> <data type> variable1;
    <access specifier> <data type> variable2;
    ...
    <access specifier> <data type> variableN;
    // member methods
    <access specifier> <return type> method1(parameter_list)
    {
        // method body
    }
    <access specifier> <return type> method2(parameter_list)
    {
        // method body
    }
    ...
    <access specifier> <return type> methodN(parameter_list)
    {
        // method body
    }
}

注意：

• 访问标识符 <access specifier> 指定了对类及其成员的访问规则。如果没有指定，则使用默认的访问标识符。类的默认访问标识符是 internal，成员的默认访问标识符是 private。
• 数据类型 <data type> 指定了变量的类型，返回类型 <return type> 指定了返回的方法返回的数据类型。
• 如果要访问类的成员，要使用点（.）运算符。点运算符链接了对象的名称和成员的名称。

2.2 构造函数

2.2.1 构造函数

类的 构造函数 是类的一个特殊的成员函数，当创建类的新对象时执行。
构造函数的名称与类的名称完全相同，它没有任何返回类型。

默认的构造函数没有任何参数。但是如果需要一个带有参数的构造函数可以有参数，这种构造函数叫做参数化构造函数。可以在创建对象的同时给对象赋初始值

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      public Line(double len)  // 参数化构造函数
      {
         Console.WriteLine("对象已创建，length = {0}", len);
         length = len;
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line(10.0);
         Console.WriteLine("线条的长度： {0}", line.getLength());
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength());
         Console.ReadKey();
      }
   }
}

2.2.2 静态构造函数

在 C# 中存在一种叫做静态构造函数（static constructor）的特殊构造函数，虽然它与实例构造函数不同，但依然被称为构造函数，且可以使用 static 修饰。静态构造函数用于初始化静态成员，并在类被加载时自动执行一次。
静态构造函数和静态方法或字段类似，属于类本身，而不属于类实例
静态构造函数的特点：

• 只能被定义一次：每个类只能有一个静态构造函数。
• 无访问修饰符：静态构造函数不能有访问修饰符（如 public、private 等），因为它的访问是由系统控制的。
• 不能带参数：静态构造函数不接受参数。
• 自动调用：静态构造函数在类的静态成员首次被访问时，或类的实例被首次创建时自动调用，仅执行一次。
• 执行时机：在类的静态成员首次被访问时或类的第一个实例被创建时自动执行

using System;
public class MyClass
{
    // 静态字段
    public static int StaticValue;
    // 静态构造函数
    static MyClass()
    {
        Console.WriteLine("静态构造函数被调用");
        StaticValue = 42; // 初始化静态字段
    }
    // 实例构造函数
    public MyClass()
    {
        Console.WriteLine("实例构造函数被调用");
    }
}
public class Program
{
    public static void Main()
    {
        Console.WriteLine("第一次创建对象");
        MyClass obj1 = new MyClass();
        Console.WriteLine("第二次创建对象");
        MyClass obj2 = new MyClass();   
        Console.WriteLine($"StaticValue = {MyClass.StaticValue}");
    }
}
结果：
第一次创建对象
静态构造函数被调用
实例构造函数被调用
第二次创建对象
实例构造函数被调用
StaticValue = 42

2.2.3 初始化顺序

在 C# 中，静态初始化和继承的初始化遵循一定的顺序。对于有继承关系的类，在初始化时遵循以下规则：

• 静态构造函数与实例构造函数的执行顺序
  在一个继承层次结构中：
  • 静态构造函数优先于实例构造函数执行。
  • 静态构造函数只会在该类的任何成员首次被访问时执行一次。
  • 父类的静态构造函数会先于子类的静态构造函数执行。
• 执行顺序概述
  • 基类的静态构造函数 (只执行一次，且在第一次访问时)。
  • 子类的静态构造函数 (只执行一次，且在第一次访问时)。
  • 基类的实例构造函数 (每次实例化时都执行)。
  • 子类的实例构造函数 (每次实例化时都执行)。

注意：

• 静态构造函数无访问修饰符：静态构造函数没有访问修饰符，且不能带参数。
• 控制静态构造的执行时机：静态构造函数在类的任何静态成员或实例成员首次被调用时执行。
• 子类静态成员不会触发父类的实例构造函数：只有当实例化类时才会触发实例构造函数

using System;

public class BaseClass
{
    // 静态构造函数
    static BaseClass()
    {
        Console.WriteLine("BaseClass: 静态构造函数");
    }

    // 实例构造函数
    public BaseClass()
    {
        Console.WriteLine("BaseClass: 实例构造函数");
    }
}

public class DerivedClass : BaseClass
{
    // 静态构造函数
    static DerivedClass()
    {
        Console.WriteLine("DerivedClass: 静态构造函数");
    }

    // 实例构造函数
    public DerivedClass()
    {
        Console.WriteLine("DerivedClass: 实例构造函数");
    }
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine("第一次创建 DerivedClass 对象");
        DerivedClass obj1 = new DerivedClass();

        Console.WriteLine("\n第二次创建 DerivedClass 对象");
        DerivedClass obj2 = new DerivedClass();
    }
}
结果：
第一次创建 DerivedClass 对象
BaseClass: 静态构造函数
DerivedClass: 静态构造函数
BaseClass: 实例构造函数
DerivedClass: 实例构造函数

第二次创建 DerivedClass 对象
BaseClass: 实例构造函数
DerivedClass: 实例构造函数

2.2.4 对象初始化器

在 new 关键字后使用大括号 {} 进行对象初始化。这种方式称为对象初始化器（object initializer），允许在创建对象时直接初始化其属性或字段。使用对象初始化器的语法简洁、方便，特别适合在构造函数之外进行属性的直接赋值。

对象初始化器的特点：

• 无需构造函数：对象初始化器不要求类提供特定的构造函数，且允许在对象实例化时直接为公开的属性或字段赋值。
• 与默认构造函数兼容：它只会调用类的默认构造函数，但依然允许在构造函数完成后进一步初始化属性。
• 集合初始化器：C# 还支持集合初始化器，这是一种对象初始化器的扩展，用于初始化集合类型的元素。

适用场景：

• 简单赋值：适合在对象创建时进行基本的属性赋值。
• 更清晰的代码：将对象创建与属性初始化合并到一起，使代码更加简洁明了。
• 避免重复代码：尤其适合在不需要复杂初始化逻辑的场景下，省去了显式调用设置方法或构造函数的代码。

对象示例：

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

public class Program
{
    public static void Main()
    {
        // 使用对象初始化器创建并初始化对象
        Person person = new Person
        {
            Name = "Alice",
            Age = 30
        };

        Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
    }
}

集合示例：

using System;
using System.Collections.Generic;

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

public class Program
{
    public static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };

        foreach (var person in people)
        {
            Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
        }
    }
}

2.3 析构函数

类的 析构函数 是类的一个特殊的成员函数，当类的对象超出范围时执行。
析构函数的名称是在类的名称前加上一个波浪形（~）作为前缀，它不返回值，也不带任何参数。
析构函数用于在结束程序（比如关闭文件、释放内存等）之前释放资源。析构函数不能继承或重载。

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      public Line()  // 构造函数
      {
         Console.WriteLine("对象已创建");
      }
      ~Line() //析构函数
      {
         Console.WriteLine("对象已删除");
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line();
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength());          
      }
   }
}

2.4 类的静态成员

我们可以使用 static 关键字把类成员定义为静态的。当我们声明一个类成员为静态时，意味着无论有多少个类的对象被创建，只会有一个该静态成员的副本。

关键字 static 意味着类中只有一个该成员的实例。静态变量用于定义常量，因为它们的值可以通过直接调用类而不需要创建类的实例来获取。静态变量可在成员函数或类的定义外部进行初始化。也可以在类的定义内部初始化静态变量。
也可以把一个成员函数声明为 static。这样的函数只能访问静态变量。静态函数在对象被创建之前就已经存在。

using System;
namespace StaticVarApplication
{
    class StaticVar
    {
       public static int num;
        public void count()
        {
            num++;
        }
        public static int getNum()
        {
            return num;
        }
    }
    class StaticTester
    {
        static void Main(string[] args)
        {
            StaticVar s = new StaticVar();
            s.count();
            s.count();
            s.count();                  
            Console.WriteLine("变量 num： {0}", StaticVar.getNum());
            Console.ReadKey();
        }
    }
}

2.5 匿名对象

2.5.1 定义

在 C# 中，匿名对象（anonymous type）是一种没有明确定义类名称的对象，通常在不需要为对象创建完整的类定义时使用。匿名对象的典型场景是临时存储数据，特别是在查询结果和临时数据封装时使用。

匿名对象的特点：

• 只读属性：匿名对象的所有属性都是只读的，一旦创建，属性值就不能更改。
• 类型安全：虽然是匿名对象，但它具有静态类型安全，编译器会自动生成类型。
• 自动推断属性类型：编译器根据初始化的值自动推断属性类型。
• 仅在本地作用域使用：匿名对象通常用于临时场景，例如查询结果、局部范围的数据传递等，不适合作为类成员或方法返回类型。
• 不可变性：匿名对象的每个属性在初始化后不能更改，匿名对象本身也是不可变的。

使用场景：

• LINQ 查询：在 LINQ 查询中，匿名对象常用于封装查询结果。
• 数据转换：可以将不同数据源的数据转换为简单结构的匿名对象，便于局部范围的数据传递。

注意：

• 只读特性：匿名对象的属性是只读的，适合用于不需要修改的临时数据。
• 作用范围：匿名对象最好仅在方法或局部范围中使用，因为其类型名称是由编译器生成的，无法在类或接口中返回匿名类型。

2.5.2 匿名对象的创建

匿名对象使用 new 关键字创建，属性名和属性值直接在大括号 {} 中指定。因为匿名对象没有类名，所以只能通过属性名访问其数据成员。

示例

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

在上面的代码中，person 是一个匿名对象，包含两个属性 Name 和 Age。使用 var 关键字声明匿名对象的变量类型，因为匿名类型没有显式的类型名称。

LINQ 查询示例

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };

        // 使用 LINQ 查询生成匿名对象列表
        var selectedPeople = from p in people
                             where p.Age > 28
                             select new { p.Name, p.Age };

        foreach (var person in selectedPeople)
        {
            Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
        }
    }
}

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

3 继承

继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。
继承的思想实现了 属于（IS-A） 关系

3.1 基类和派生类

一个类可以继承自另一个类，被称为基类（父类）和派生类（子类）。
C# 不支持类的多重继承，但支持接口的多重继承，一个类可以实现多个接口。
概括来说：一个类可以继承多个接口，但只能继承自一个类。

派生类会继承基类的成员（字段、方法、属性等），除非它们被明确地标记为私有（private）。
派生类可以通过关键字base来调用基类的构造函数和方法。

class BaseClass
{
    public void SomeMethod()
    {
        // Method implementation
    }
}

class DerivedClass : BaseClass
{
    public void AnotherMethod()
    {
        // Accessing base class method
        base.SomeMethod();       
        // Method implementation
    }
}

3.2 基类初始化

派生类继承了基类的成员变量和成员方法。因此父类对象应在子类对象创建之前被创建。可以在成员初始化列表中进行父类的初始化。
含有父类的初始化语法：public SonClass(string str) : base(s)

using System;
namespace RectangleApplication
{
   class Rectangle
   {
      // 成员变量
      protected double length;
      protected double width;
      public Rectangle(double l, double w)
      {
         length = l;
         width = w;
      }
      public double GetArea()
      {
         return length * width;
      }
      public void Display()
      {
         Console.WriteLine("长度： {0}", length);
         Console.WriteLine("宽度： {0}", width);
         Console.WriteLine("面积： {0}", GetArea());
      }
   }//end class Rectangle  
   class Tabletop : Rectangle
   {
      private double cost;
      public Tabletop(double l, double w) : base(l, w)
      { }
      public double GetCost()
      {
         double cost;
         cost = GetArea() * 70;
         return cost;
      }
      public void Display()
      {
         base.Display();
         Console.WriteLine("成本： {0}", GetCost());
      }
   }
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Tabletop t = new Tabletop(4.5, 7.5);
         t.Display();
         Console.ReadLine();
      }
   }
}

3.3 Partial类

3.3.1 定义

partial 关键字用于将一个类、结构或方法的定义拆分到多个文件中。通过这种方式，多个开发者可以同时在不同文件中对同一个类进行扩展，而不需要合并代码到一个文件中。partial 提供了灵活性和可维护性，尤其适合复杂项目和自动生成代码的场景，可以减少派生类

partial的用途：

• 分离类定义：允许一个类的代码分布在多个文件中。
• 自动生成代码的支持：通常用于工具或框架自动生成部分代码，而开发者可以在另一个文件中扩展该类。
• 逻辑分离：将不同功能的实现分布到多个文件，便于代码组织。
• 分工协作：多个开发者可以同时对同一个类进行开发，而不需要合并代码。

使用规则：

• 类、结构或方法可以被标记为 partial
• 必须在相同的命名空间中定义。
• 必须具有相同的访问修饰符（如 public、private 等）。
• 所有部分必须组合为一个完整的类型，最终编译为一个类、结构或方法。
• partial 方法不能有访问修饰符（默认为 private）。
• 不能声明为 static、virtual、abstract、override。
• 不能定义为 extern 方法。
• 只能出现在 partial 类型中。

3.3.2 partial 类

假设你有一个类 Person，可以将其定义拆分到两个文件中。

文件 1: Person.Part1.cs

namespace MyApplication
{
    public partial class Person
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }
}

文件 2: Person.Part2.cs

namespace MyApplication
{
    public partial class Person
    {
        public string GetFullName()
        {
            return $"{FirstName} {LastName}";
        }
    }
}

使用代码：

using MyApplication;

class Program
{
    static void Main()
    {
        Person person = new Person
        {
            FirstName = "John",
            LastName = "Doe"
        };
        Console.WriteLine(person.GetFullName());
    }
}
输出：
John Doe

3.3.3 partial 方法

除了类和结构，C# 还支持 partial 方法，允许方法声明和实现分开。

文件 1: PartialMethodExample.Part1.cs

public partial class PartialMethodExample
{
    partial void OnAction(); // 声明部分方法

    public void TriggerAction()
    {
        OnAction(); // 调用部分方法
    }
}

文件 2: PartialMethodExample.Part2.cs

public partial class PartialMethodExample
{
    partial void OnAction() // 实现部分方法
    {
        Console.WriteLine("Partial method executed.");
    }
}

使用代码：

class Program
{
    static void Main()
    {
        PartialMethodExample example = new PartialMethodExample();
        example.TriggerAction();
    }
}
输出：

Partial method executed.

注意：

• 如果没有提供 partial 方法的实现，调用该方法时会被编译器优化掉，不会产生任何影响。
• partial 方法必须是 void 类型，不能有返回值。