任务八嵌套类

五、什么时候嵌套类？

嵌套类的核心特性

嵌套类是定义在另一个类（外部类/包含类）内部的类，它的核心特性：

可以直接访问外部类的静态成员，但访问非静态成员需要外部类的实例；
按访问修饰符（public/private/protected/internal）控制可见性，默认是private（仅外部类可访问）；
逻辑上属于外部类的“附属”，仅与外部类强关联，不适合被其他无关类使用。

场景1：为外部类服务的“辅助类”

当一个类的作用仅限于辅助外部类完成功能，且不会被其他类调用时，适合嵌套。（最常用） 👉 示例（动物叫声的辅助枚举嵌套在Animal类中）：

using System;

public class Animal
{
    // 嵌套枚举：仅Animal类使用的叫声类型，外部无需访问
    private enum SoundType
    {
        Bark,   // 狗叫
        Meow,   // 猫叫
        Moo     // 牛叫
    }

    // 移除属性的箭头语法（改用传统get/set写法，虽然原代码没箭头，但统一基础写法）
    private string _name;
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }

    // 外部类方法使用嵌套枚举（移除switch表达式的=>，改用传统switch语句）
    public void MakeSound(SoundType sound)
    {
        string soundStr;
        // 传统switch语句替代switch表达式，无任何箭头语法
        switch (sound)
        {
            case SoundType.Bark:
                soundStr = "Woof";
                break;
            case SoundType.Meow:
                soundStr = "Meow";
                break;
            case SoundType.Moo:
                soundStr = "Moo";
                break;
            default:
                soundStr = "未知叫声";
                break;
        }
        Console.WriteLine($"{Name}发出了：{soundStr}");
    }

    // 新增：对外暴露调用入口（解决原Main中无法访问私有枚举的问题，让代码可运行）
    public void MakeDogSound()
    {
        MakeSound(SoundType.Bark);
    }

    public void MakeCatSound()
    {
        MakeSound(SoundType.Meow);
    }

    public void MakeCowSound()
    {
        MakeSound(SoundType.Moo);
    }
}

public class Program
{
    public static void Main()
    {
        Animal dog = new Animal();
        // 移除对象初始化器的箭头语法（改用传统赋值）
        dog.Name = "狗";
        // 调用新增的公开方法，间接使用私有枚举
        dog.MakeDogSound();

        Animal cat = new Animal();
        cat.Name = "猫";
        cat.MakeCatSound();

        Animal cow = new Animal();
        cow.Name = "牛";
        cow.MakeCowSound();
    }
}

场景2：封装“逻辑内聚”的子功能

当某个功能是外部类的“子模块”，且类名太通用（如Node/Item），嵌套可避免和其他类重名。 👉 示例（链表的节点类嵌套在链表类中）：

public class SimpleLinkedList
{
    // 嵌套类：仅链表使用的节点，外部无需知道节点的实现
    private class Node
    {
        public int Value { get; set; }
        public Node Next { get; set; }
    }

    private Node _head; // 链表头节点

    // 外部类提供添加元素的方法，隐藏节点的操作
    public void Add(int value)
    {
        Node newNode = new Node { Value = value };
        if (_head == null)
        {
            _head = newNode;
            return;
        }
        Node current = _head;
        while (current.Next != null)
        {
            current = current.Next;
        }
        current.Next = newNode;
    }
}

场景3：实现“仅外部类可用”的接口/功能

通过private嵌套类实现接口，外部无法直接实例化该类，仅外部类能提供访问入口，保证封装性。（控制访问范围） 👉 示例（外部类暴露功能，嵌套类实现具体逻辑）：

// 定义一个简单接口
public interface ISoundMaker
{
    void PlaySound();
}

public class Animal
{
    public string Name { get; set; }

    // 嵌套类：实现ISoundMaker，仅Animal类可访问
    private class DogSound : ISoundMaker
    {
        public void PlaySound()
        {
            Console.WriteLine("Woof!");
        }
    }

    // 外部类提供统一入口，隐藏具体实现
    public void MakeDogSound()
    {
        ISoundMaker maker = new DogSound();
        maker.PlaySound();
    }
}

场景4：与外部类强关联的“数据容器”

当一个类仅用于存储外部类的临时数据/配置，且无独立存在的意义时，适合嵌套。 👉 示例（学生类中嵌套成绩容器）：

public class Student
{
    public string Name { get; set; }

    // 嵌套类：仅存储学生的单科成绩，无独立意义
    public class Score
    {
        public string Subject { get; set; }
        public int Point { get; set; }
    }

    // 学生的成绩列表，使用嵌套类作为元素类型
    public List<Score> Scores = new List<Score>();
}

public class Program
{
    public static void Main()
    {
        Student stu = new Student { Name = "张三" };
        // 嵌套类可通过“外部类.嵌套类”访问（如果是public）
        stu.Scores.Add(new Student.Score { Subject = "数学", Point = 90 });
    }
}

绝对不要用嵌套类的场景（避坑）

嵌套类需要被多个外部类使用（此时应独立定义）；
嵌套类的逻辑复杂、代码量多（会导致外部类过于臃肿）；
仅为了“代码归拢”而嵌套，无实际逻辑关联（如把无关的Teacher类嵌套在Student类中）。

总结

嵌套类的核心适用场景：仅为外部类服务、逻辑强内聚、避免命名污染、控制访问范围；
设计原则：嵌套类应“轻量、内聚、无独立存在意义”，否则优先独立定义；
访问控制：默认private（仅外部类可见），需对外暴露时设为public/internal。

五、什么时候嵌套类？​

嵌套类的核心特性​

场景1：为外部类服务的“辅助类”​

场景2：封装“逻辑内聚”的子功能​

场景3：实现“仅外部类可用”的接口/功能​

场景4：与外部类强关联的“数据容器”​

绝对不要用嵌套类的场景（避坑）​

总结​