Explorerの日常

C# 学习笔记（三）：从类与对象到继承、接口与多态

Sat, 15 Aug 2026 00:00:00 GMT

这部分内容是我学习 C# 面向对象编程时的阶段性整理。与其把每个关键字拆成独立词条，我更想回答几个实际问题：对象怎样保存状态，类之间怎样复用代码，多态为什么有用，以及什么时候该用抽象类、接口、结构体或普通类。

文中的示例尽量保持短小，但都按真实 C# 语法重新校对。阅读时不必死记定义，先看对象之间的关系，再回头理解关键字会轻松很多。

一、类与对象：把数据和行为放在一起

类是对一类事物的描述，对象则是根据这份描述创建出来的具体实例。比如“玩家”可以是一种类型，而游戏里的某个玩家才是对象。

public class Player
{
    public string Name { get; set; }
    public int Level { get; private set; }

    public Player(string name)
    {
        Name = name;
        Level = 1;
    }

    public void LevelUp()
    {
        Level++;
    }
}

Player player = new Player("Mori");
player.LevelUp();

Console.WriteLine($"{player.Name} 当前是 {player.Level} 级");

Player 是类，player 是变量，new Player("Mori") 才真正创建了一个对象。对象既保存 Name、Level 这些状态，也提供 LevelUp 这样的行为。

1. 字段、属性和访问修饰符

字段直接保存数据，属性则在读取和写入之间多了一层控制。实际开发中，我会优先把字段设为 private，再通过属性或方法暴露必要的操作，避免外部代码随意破坏对象状态。

public class BankAccount
{
    private decimal _balance;

    public string Owner { get; }
    public decimal Balance => _balance;

    public BankAccount(string owner)
    {
        Owner = owner;
    }

    public void Deposit(decimal amount)
    {
        if (amount <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(amount));
        }

        _balance += amount;
    }
}

常见的访问修饰符可以这样理解：

private：只允许当前类型内部访问，是隐藏实现细节的默认选择。
protected：当前类型和派生类型可以访问，常用于为子类保留扩展点。
public：任何能访问该类型的代码都可以使用，适合稳定的对外接口。
internal：只在当前程序集内可见，适合项目内部协作而不对外公开的类型或成员。

访问范围并不是越大越方便。公开成员一旦被其他代码依赖，后续修改成本就会明显增加。

2. 构造函数与对象初始化

构造函数负责让对象从一开始就处于有效状态。它没有返回值，名称必须与类名相同，并且可以重载。

public class Character
{
    public string Name { get; }
    public int Health { get; private set; }

    public Character(string name) : this(name, 100)
    {
    }

    public Character(string name, int health)
    {
        Name = string.IsNullOrWhiteSpace(name)
            ? throw new ArgumentException("名字不能为空", nameof(name))
            : name;

        Health = health > 0
            ? health
            : throw new ArgumentOutOfRangeException(nameof(health));
    }
}

这里的 this(name, 100) 会调用同一个类里的另一个构造函数，避免重复初始化逻辑。只要自己声明了任意构造函数，编译器就不会再自动提供无参构造函数。

也可以使用对象初始化器，但它只能给允许写入的成员赋值：

public class Profile
{
    public string Nickname { get; set; } = string.Empty;
    public string City { get; set; } = string.Empty;
}

Profile profile = new Profile
{
    Nickname = "Mori",
    City = "Tokyo"
};

原稿里类似 new Person{} 的写法并非一定错误，但标准、清晰的空对象初始化器应写作 new Person { }；如果没有成员需要初始化，直接写 new Person() 更容易读懂。

3. 属性：让状态变化有边界

自动属性适合不需要额外逻辑的场景：

public string Title { get; set; } = string.Empty;

如果写入时需要校验，就使用完整属性：

private int _age;

public int Age
{
    get => _age;
    set
    {
        if (value is < 0 or > 150)
        {
            throw new ArgumentOutOfRangeException(nameof(value));
        }

        _age = value;
    }
}

public int Level { get; private set; } 则表示所有代码都能读取等级，但只有当前类能修改它。相比公开字段，这种写法更能表达对象的使用规则。

4. 索引器：让对象像集合一样访问

索引器使用 this[...] 声明，适合类型本身就代表一组元素的情况。

public class Inventory
{
    private readonly List<string> _items = new();

    public int Count => _items.Count;

    public string this[int index]
    {
        get => _items[index];
        set => _items[index] = value;
    }

    public void Add(string item)
    {
        _items.Add(item);
    }
}

Inventory inventory = new Inventory();
inventory.Add("木剑");
inventory[0] = "铁剑";
Console.WriteLine(inventory[0]);

索引器不是普通类的必选项。如果一个类型并不具有明显的“容器”含义，使用具名方法通常更清楚。

5. 垃圾回收与资源释放

.NET 的垃圾回收器会自动回收不再被引用的托管对象，但回收时机不由程序精确控制。因此，析构函数（终结器）不适合承担“用完立刻释放”的工作。

文件、数据库连接、网络流等资源需要及时释放时，应使用 IDisposable 和 using：

using FileStream stream = File.OpenRead("data.bin");

byte[] buffer = new byte[stream.Length];
int bytesRead = stream.Read(buffer, 0, buffer.Length);
Console.WriteLine($"读取了 {bytesRead} 字节");

我目前给自己的判断标准是：普通对象交给 GC；持有需要及时归还的资源时，优先寻找或实现 IDisposable，不要依赖终结器碰运气。

二、类的进阶用法

1. 静态成员与静态类

实例成员属于某个对象，静态成员属于类型本身。下面的计数器会记录一共创建过多少个对象：

public class Enemy
{
    public static int CreatedCount { get; private set; }

    public string Name { get; }

    public Enemy(string name)
    {
        Name = name;
        CreatedCount++;
    }
}

_ = new Enemy("Slime");
_ = new Enemy("Bat");

Console.WriteLine(Enemy.CreatedCount); // 2

静态方法没有具体对象，所以不能直接访问实例字段或属性。静态构造函数则用于初始化类型级别的数据，由运行时在首次使用类型前调用一次，不能手动调用，也不能带参数。

如果一个类型只负责组织无状态的工具方法，可以声明为静态类：

public static class Temperature
{
    public static double CelsiusToFahrenheit(double value)
    {
        return value * 9 / 5 + 32;
    }
}

静态类很方便，但大量共享的可变静态状态会让测试和并发控制变得困难。工具函数适合静态化，业务状态则应谨慎处理。

2. 扩展方法

扩展方法能让现有类型以实例方法的形式调用新功能，但它并没有真正修改原类型。它必须写在非泛型静态类中，并且方法本身也是静态的；第一个参数前的 this 指明要扩展的类型。

public static class StringExtensions
{
    public static int WordCount(this string? text)
    {
        if (string.IsNullOrWhiteSpace(text))
        {
            return 0;
        }

        return text.Split(
            new[] { ' ', '\t', '\r', '\n' },
            StringSplitOptions.RemoveEmptyEntries
        ).Length;
    }
}

int count = "C# is fun".WordCount();

当实例方法与扩展方法同名时，实例方法优先。扩展方法更适合补充通用、稳定的操作，不适合拿来隐藏复杂业务流程。

3. 运算符重载

当自定义类型具有明确的数学或领域含义时，运算符重载能让表达式更自然。下面用不可变结构体表示二维向量：

public readonly struct Vector2
{
    public double X { get; }
    public double Y { get; }

    public Vector2(double x, double y)
    {
        X = x;
        Y = y;
    }

    public static Vector2 operator +(Vector2 left, Vector2 right)
    {
        return new Vector2(left.X + right.X, left.Y + right.Y);
    }

    public override string ToString() => $"({X}, {Y})";
}

Vector2 result = new Vector2(1, 2) + new Vector2(3, 4);
Console.WriteLine(result); // (4, 6)

运算符的含义应当符合直觉。为了少写几行代码而重载一个语义含糊的运算符，往往会让调用者更难理解。

4. 嵌套类与分部类

嵌套类定义在另一个类内部，适合只服务于外部类的辅助类型。它不是继承关系，只是作用域上的包含关系。

public class Cache
{
    private sealed class Entry
    {
        public string Key { get; init; } = string.Empty;
        public object? Value { get; init; }
    }
}

分部类使用 partial，允许同一个类型分散在多个文件中。编译后它仍然是一个类，常见于代码生成器、WinForms 设计器以及需要分离生成代码和手写代码的场景。

// Player.Generated.cs
public partial class Player
{
    public int Id { get; set; }
}

// Player.cs
public partial class Player
{
    public void Move()
    {
        Console.WriteLine("移动");
    }
}

分部类能拆分文件，但不能代替合理的职责划分。一个类如果本身承担了太多工作，拆成多个文件也不会让设计变好。

三、继承：复用共同特征，而不是复制代码

继承表达的是“子类也是一种父类”。C# 的类只支持单继承，但继承可以继续向下传递。

public class Animal
{
    public string Name { get; }

    public Animal(string name)
    {
        Name = name;
    }

    public void Eat()
    {
        Console.WriteLine($"{Name} 正在进食");
    }
}

public class Dog : Animal
{
    public Dog(string name) : base(name)
    {
    }

    public void Bark()
    {
        Console.WriteLine($"{Name}: 汪！");
    }
}

Dog 会继承 Animal 可访问的成员。父类的私有成员依然存在于对象中，但子类不能直接访问它们。base(name) 用来选择父类构造函数，而且父类构造逻辑会先执行。

1. `this` 和 `base`

this 指向当前对象，也可以在构造函数之间转发参数。
base 指向当前对象中的父类部分，可用于调用父类构造函数或父类实现。

如果父类没有无参构造函数，子类构造函数就必须通过 base(...) 明确选择一个可用的父类构造函数。

2. 里氏替换与安全类型判断

父类变量可以引用子类对象：

Animal animal = new Dog("Coco");
animal.Eat();

这不仅是语法规则，也提醒我：如果一个子类真的符合父类约定，那么使用父类的地方换成子类后，程序的合理行为不应被破坏。继承不只是“拿到父类代码”，还意味着遵守父类承诺。

需要使用子类特有能力时，可以用模式匹配安全判断：

if (animal is Dog dog)
{
    dog.Bark();
}

as 转换失败会得到 null，只适用于引用类型和可空值类型：

Dog? dog = animal as Dog;
dog?.Bark();

相比先用 is 判断再强制转换，is Dog dog 一次完成判断和取值，通常更简洁。

3. `object`、装箱与拆箱

所有 C# 类型最终都与 object 有关。引用类型转换为 object 只是引用转换；值类型转换为 object 才会发生装箱。

int number = 42;
object boxed = number;       // 装箱
int restored = (int)boxed;  // 拆箱

拆箱时必须还原为原来的值类型。下面的代码会抛出 InvalidCastException，即使 int 可以数值转换为 long：

object boxed = 42;
long value = (long)boxed; // 运行时错误

正确做法是先拆成 int，再做数值转换：

long value = (int)boxed;

装箱会产生额外对象和复制开销。在高频路径中，优先使用泛型集合（如 List<int>），不要用 ArrayList 一类依赖 object 的旧式容器保存大量值类型。

4. 密封类

sealed 表示类不能继续被继承：

public sealed class GameConfig
{
    public int MaxPlayers { get; init; } = 4;
}

密封类仍然可以正常实例化。它适合明确不提供继承扩展、需要固定行为边界的类型，但不应该只因为“暂时没想到子类”就随手密封所有类。

四、多态：让调用者依赖共同能力

继承解决“是什么”，多态解决“同一个调用在不同对象上做不同的事”。

1. `virtual`、`override` 与 `base`

父类用 virtual 提供可替换的默认实现，子类用 override 重写。真正调用哪个版本，由对象的运行时类型决定。

public class Notification
{
    public virtual void Send(string message)
    {
        Console.WriteLine($"默认通知：{message}");
    }
}

public class EmailNotification : Notification
{
    public override void Send(string message)
    {
        Console.WriteLine($"发送邮件：{message}");
    }
}

Notification notification = new EmailNotification();
notification.Send("构建完成"); // 调用 EmailNotification.Send

子类如果想保留父类逻辑，可以调用 base.Send(message)，再补充自己的行为。重写不是定义一个碰巧同名的方法；它必须使用 override，并且父类成员必须允许重写。

2. 抽象类与抽象方法

抽象类用于表达一组具有共同状态和基础行为、但本身不够具体的对象。它不能直接实例化，可以同时包含普通成员和抽象成员。

public abstract class Shape
{
    public string Color { get; }

    protected Shape(string color)
    {
        Color = color;
    }

    public abstract double Area();

    public void Print()
    {
        Console.WriteLine($"{Color} 图形，面积为 {Area():F2}");
    }
}

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

    public Circle(string color, double radius) : base(color)
    {
        Radius = radius;
    }

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

抽象方法只有契约，没有方法体，具体子类必须实现；抽象子类则可以把实现责任继续留给下一层。

abstract 与 virtual 的区别很直接：抽象方法没有默认实现，子类必须重写；虚方法已经有默认实现，子类可以选择是否重写。

3. 接口与多实现

接口更强调“能做什么”。一个类只能继承一个直接父类，却可以实现多个接口，这使它很适合描述可以组合的能力。

public interface ISavable
{
    void Save();
}

public interface ILoadable
{
    void Load();
}

public class GameState : ISavable, ILoadable
{
    public void Save()
    {
        Console.WriteLine("保存游戏");
    }

    public void Load()
    {
        Console.WriteLine("读取游戏");
    }
}

调用者只依赖自己真正需要的接口，通常比依赖一个庞大的具体类更灵活：

public static void SaveNow(ISavable target)
{
    target.Save();
}

现代 C# 允许接口提供默认实现，但我在学习阶段仍会优先把接口看作能力契约。只有在维护公共接口兼容性等明确场景下，才考虑默认接口成员。

4. 密封重写

子类可以用 sealed override 表示“这次重写到此为止”，后续派生类不能再改变该方法。

public class BaseLogger
{
    public virtual void Write(string message)
    {
        Console.WriteLine(message);
    }
}

public class TimestampLogger : BaseLogger
{
    public sealed override void Write(string message)
    {
        Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] {message}");
    }
}

密封方法只能用于重写成员，因此 sealed 必须和 override 一起出现。它与密封类的范围不同：密封类禁止整个类型被继承；密封重写只禁止某个成员继续被改写。

五、代码组织与常用基础类型

1. 命名空间

命名空间用于组织类型并避免命名冲突。using 只是让当前文件可以用短名称引用类型，不会把任何代码“复制”进来。

namespace MyGame.Combat;

public class DamageCalculator
{
    public int Calculate(int attack, int defense)
    {
        return Math.Max(1, attack - defense);
    }
}

不同命名空间可以包含同名类型。发生冲突时，可以使用完全限定名或别名：

using GameTimer = MyGame.Core.Timer;
using SystemTimer = System.Timers.Timer;

命名空间通常按项目或功能域组织。它不是文件夹的强制映射，但保持两者大体一致，会更容易定位代码。

2. `object` 提供的常用方法

所有类型都能使用 object 的基础方法，其中最常见的是：

ToString()：返回对象的文本表示，自定义类型通常应重写它。
Equals()：判断两个对象在语义上是否相等。
ReferenceEquals()：判断两个引用是否指向同一个对象。
GetHashCode()：为哈希集合和字典提供哈希值。
GetType()：取得对象实际的运行时类型。

public sealed class User
{
    public int Id { get; }
    public string Name { get; }

    public User(int id, string name)
    {
        Id = id;
        Name = name;
    }

    public override string ToString() => $"{Name} (#{Id})";
}

如果重写 Equals，通常也要重写 GetHashCode，保证两个相等对象得到相同哈希值。对值语义明显的数据类型，使用 record 往往比手写整套相等逻辑更省心。

MemberwiseClone() 会做浅复制：值类型字段被复制，引用类型字段仍指向同一个对象。它是 protected 成员，只有类型内部或派生类型能直接调用。遇到包含列表、字典等可变引用成员的对象时，必须先想清楚究竟需要浅复制还是深复制。

3. `string` 的不可变性

字符串创建后内容不能原地修改。Replace、Remove、Substring 等方法都会返回新字符串，原变量不会自动改变。

string source = "hello world";
string changed = source.Replace("world", "C#");

Console.WriteLine(source);  // hello world
Console.WriteLine(changed); // hello C#

常见操作包括：

string text = "red,green,blue";

int length = text.Length;
char first = text[0];
string[] colors = text.Split(',');
string middle = text.Substring(4, 5);
bool contains = text.Contains("green", StringComparison.Ordinal);

索引可以读取字符，但不能写 text[0] = 'R'，原因正是字符串不可变。需要少量修改时，接收方法返回的新字符串即可；大量循环拼接时则考虑 StringBuilder。

4. `StringBuilder`

重复使用 + 拼接字符串可能不断创建中间对象。StringBuilder 维护一个可扩展缓冲区，更适合循环构造较长文本。

using System.Text;

StringBuilder builder = new StringBuilder();

for (int i = 1; i <= 3; i++)
{
    builder.Append("第 ")
           .Append(i)
           .AppendLine(" 行");
}

string result = builder.ToString();

常用成员有 Append、AppendLine、Insert、Remove、Replace 和 Clear。Length 是当前字符数，Capacity 是当前缓冲区容量；一般不需要手动管理容量，除非已经知道最终文本会很大且对分配次数敏感。

普通插值字符串清楚又直接，不必为了几次拼接就换成 StringBuilder。是否使用它，取决于拼接次数和代码可读性。

5. 结构体和类

结构体是值类型，类是引用类型。两者最关键的差异不是一句“一个在栈上、一个在堆上”，而是赋值与传参时采用值语义还是引用语义。

public struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

Point first = new Point { X = 1, Y = 2 };
Point second = first;
second.X = 10;

Console.WriteLine(first.X);  // 1
Console.WriteLine(second.X); // 10

second = first 会复制整个结构体，所以修改 second 不影响 first。类变量复制的则是引用，两个变量可能指向同一个对象。

适合结构体的情况通常包括：数据量小、含义完整、天然具有值语义，并且最好设计为不可变类型，例如坐标、颜色、时间范围。对象较大、需要继承、需要共享可变状态或具有明确身份时，类通常更合适。

结构体不能继承另一个类或结构体，但可以实现接口；类可以为 null，普通非可空结构体则始终有一个值。

6. 抽象类还是接口

这是我最容易混淆的一组概念，可以先从设计意图判断：

问题	抽象类	接口
主要表达	一组对象“是什么”	对象“会做什么”
状态	可以保存实例字段	通常不保存实例状态
构造函数	可以有	没有实例构造函数
普通实现	可以有普通和抽象成员	以契约为主，也可有默认实现
数量限制	一个类只能直接继承一个类	一个类可以实现多个接口

例如，Enemy 和 Player 都可以继承 Character，因为它们共享生命值、名字等基础状态；两者还可以分别实现 IDamageable、IMovable、ISavable 等接口，因为这些是可以组合的能力。

当我需要共享状态和基础实现时，会先考虑抽象类；当我只想约定某种能力、让不同继承体系的类型都能参与时，会先考虑接口。两者也可以一起使用，并不是二选一。

六、一个贯穿示例

下面的小例子把抽象类、接口、继承和多态放在一起。调用者只关心 Character 和 IDamageable 的约定，不需要为每种角色写一套分支。

public interface IDamageable
{
    bool IsAlive { get; }
    void TakeDamage(int amount);
}

public abstract class Character : IDamageable
{
    public string Name { get; }
    public int Health { get; private set; }
    public bool IsAlive => Health > 0;

    protected Character(string name, int health)
    {
        Name = name;
        Health = health;
    }

    public void TakeDamage(int amount)
    {
        if (amount < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(amount));
        }

        Health = Math.Max(0, Health - amount);
    }

    public abstract void Act();
}

public sealed class Warrior : Character
{
    public Warrior(string name) : base(name, 120)
    {
    }

    public override void Act()
    {
        Console.WriteLine($"{Name} 挥动长剑");
    }
}

public sealed class Mage : Character
{
    public Mage(string name) : base(name, 80)
    {
    }

    public override void Act()
    {
        Console.WriteLine($"{Name} 释放法术");
    }
}

List<Character> team = new()
{
    new Warrior("Aki"),
    new Mage("Yuki")
};

foreach (Character member in team)
{
    member.Act();
    member.TakeDamage(20);
    Console.WriteLine($"剩余生命值：{member.Health}");
}

这个例子里有几条值得记住的线索：

Character 保存所有角色共有的状态和受伤逻辑。
Act 没有统一实现，所以声明为抽象方法，交给具体角色完成。
IDamageable 只描述“可以受到伤害”这项能力，其他不属于角色体系的对象也能实现它。
List<Character> 同时保存不同子类，循环中的 member.Act() 会根据实际对象调用不同实现。
Warrior 和 Mage 已经足够具体，不准备继续派生，因此声明为 sealed。

结语：目前最需要记牢的几件事

学完这一段后，我不再把面向对象理解成一串关键字，而是把它看成对变化边界的安排：

用私有字段和受控属性保护对象状态，不让无效数据随意进入。
用构造函数保证对象创建完成时就能正常工作。
只有确实存在“是一个”的关系时才使用继承。
用多态消除针对具体类型的重复判断，让调用者依赖共同约定。
抽象类负责共享状态和骨架，接口负责组合能力。
字符串少量拼接优先可读性，大量循环拼接再用 StringBuilder。
选择结构体或类时先判断值语义和引用语义，不要只背“栈和堆”。

这些规则还不足以覆盖所有设计场景，但已经能帮助我写出边界更清楚、也更容易继续维护的 C# 代码。

C# 基础教程：枚举、数组、函数、结构体与排序完整梳理

Sun, 09 Aug 2026 00:00:00 GMT

整理框架

本文整体框架如下：

枚举
→ 一维数组
→ 二维数组
→ 交错数组
→ 值类型和引用类型
→ string
→ 函数
→ ref 和 out
→ params 与参数默认值
→ 函数重载
→ 递归
→ 结构体
→ 冒泡排序
→ 选择排序

Lesson 1：枚举

什么是枚举？

枚举是一个被命名的整型常量集合。

当某个变量只能在几个固定选项中取值时，可以使用枚举表示，例如：

玩家状态
怪物状态
角色职业
游戏难度
QQ 在线状态

如果直接用整数表示玩家状态：

int playerState = 1;

只看到数字 1，很难知道它代表待机、行走还是攻击。

使用枚举可以让代码含义更加清晰：

enum PlayerState
{
    Idle,
    Walk,
    Run,
    Jump
}

PlayerState state = PlayerState.Walk;

这里需要区分三个概念：

PlayerState       枚举类型
state             枚举变量
PlayerState.Walk  枚举值

枚举可以声明在 namespace、class 或 struct 中，但不能声明在函数内部。

枚举的整数值

枚举成员默认从 0 开始，后面的成员依次加 1：

enum PlayerState
{
    Idle,   // 0
    Walk,   // 1
    Run,    // 2
    Jump    // 3
}

也可以主动指定数值：

enum PlayerState
{
    Idle = 0,
    Walk = 10,
    Run = 20,
    Jump = 30
}

虽然枚举在底层与整数有关，但实际编程时应优先使用枚举成员名称，避免在程序中到处使用含义不明确的数字。

枚举与 switch

枚举非常适合配合 switch 表现状态逻辑：

PlayerState state = PlayerState.Run;

switch (state)
{
    case PlayerState.Idle:
        Console.WriteLine("玩家正在待机");
        break;

    case PlayerState.Walk:
        Console.WriteLine("玩家正在行走");
        break;

    case PlayerState.Run:
        Console.WriteLine("玩家正在奔跑");
        break;

    case PlayerState.Jump:
        Console.WriteLine("玩家正在跳跃");
        break;
}

同样的方式也可以用于处理 QQ 在线状态、咖啡规格、角色职业等固定选项。

枚举类型转换

枚举可以和 int 相互转换：

PlayerState state = PlayerState.Run;

int number = (int)state;
PlayerState newState = (PlayerState)number;

枚举也可以转换成字符串：

string stateName = state.ToString();

将字符串转换成枚举时，可以使用 Enum.Parse：

string input = "Walk";

PlayerState state =
    (PlayerState)Enum.Parse(typeof(PlayerState), input);

如果字符串无法匹配对应的枚举成员，程序会产生错误，因此使用时要保证字符串内容正确。

Lesson 2：一维数组

什么是数组

数组用于存储一组相同类型的数据。

例如，使用一个数组存储多名学生的成绩：

int[] scores = { 80, 90, 75, 88, 96 };

数组中的所有元素必须是同一种类型。

C# 中常见的数组包括：

一维数组
二维数组
交错数组

一维数组的声明

一维数组有多种声明方式：

int[] arr1;
arr1 = new int[5];

int[] arr2 = new int[5];

int[] arr3 = new int[] { 1, 2, 3, 4, 5 };

int[] arr4 = { 1, 2, 3, 4, 5 };

使用 new int[5] 创建数组时，数组中会有 5 个整数元素，每个元素的初始值都是 0。

数组长度和索引

使用 Length 获取数组长度：

int[] arr = { 10, 20, 30, 40 };

Console.WriteLine(arr.Length);

数组索引从 0 开始：

索引	元素
0	10
1	20
2	30
3	40

数组的最大索引为：

arr.Length - 1

访问数组元素时使用中括号：

Console.WriteLine(arr[0]);

arr[1] = 100;

如果访问不存在的索引，会产生数组越界错误。

遍历数组

数组通常使用 for 循环遍历：

for (int i = 0; i < arr.Length; i++)
{
    Console.WriteLine(arr[i]);
}

这里的 i 既表示循环次数，也表示当前元素的索引。

例如，创建一个长度为 100 的数组，并让元素值与索引相同：

int[] numbers = new int[100];

for (int i = 0; i < numbers.Length; i++)
{
    numbers[i] = i;
}

这段代码把数组声明、数组长度、索引和遍历结合到了一起。

数组数据统计

数组经常配合循环完成最大值、最小值、总和与平均值计算：

int[] scores = { 78, 92, 65, 88, 96 };

int max = scores[0];
int min = scores[0];
int sum = 0;

for (int i = 0; i < scores.Length; i++)
{
    if (scores[i] > max)
    {
        max = scores[i];
    }

    if (scores[i] < min)
    {
        min = scores[i];
    }

    sum += scores[i];
}

float average = (float)sum / scores.Length;

Console.WriteLine("最高分：" + max);
Console.WriteLine("最低分：" + min);
Console.WriteLine("总分：" + sum);
Console.WriteLine("平均分：" + average);

最大值和最小值通常使用数组第一个元素作为初始值：

int max = scores[0];
int min = scores[0];

计算平均值时，将 sum 转换成 float，可以避免整数除法丢失小数部分。

手动反转数组

反转数组时，可以交换数组前后对应位置：

int[] arr = { 1, 2, 3, 4, 5 };

for (int i = 0; i < arr.Length / 2; i++)
{
    int temp = arr[i];

    arr[i] = arr[arr.Length - 1 - i];
    arr[arr.Length - 1 - i] = temp;
}

数组反转后变成：

5 4 3 2 1

因为每次会同时处理前后两个元素，所以循环到数组长度的一半即可。

数组增加元素

数组创建以后，长度不能直接改变。

如果需要增加元素，就要创建一个更大的数组，再把旧数据复制过去：

int[] oldArr = { 10, 20, 30 };
int[] newArr = new int[oldArr.Length + 1];

for (int i = 0; i < oldArr.Length; i++)
{
    newArr[i] = oldArr[i];
}

newArr[newArr.Length - 1] = 40;
oldArr = newArr;

课程把这种处理方式称为数组“搬家”。

数组删除元素

删除元素时，也需要创建一个长度更小的新数组：

int[] oldArr = { 10, 20, 30, 40 };
int deleteIndex = 1;

int[] newArr = new int[oldArr.Length - 1];

for (int i = 0, j = 0; i < oldArr.Length; i++)
{
    if (i == deleteIndex)
    {
        continue;
    }

    newArr[j] = oldArr[i];
    j++;
}

oldArr = newArr;

最终数组内容为：

10 30 40

查找数组元素

可以通过遍历查找指定元素：

int[] arr = { 15, 28, 36, 42 };
int target = 36;
int targetIndex = -1;

for (int i = 0; i < arr.Length; i++)
{
    if (arr[i] == target)
    {
        targetIndex = i;
        break;
    }
}

if (targetIndex == -1)
{
    Console.WriteLine("没有找到");
}
else
{
    Console.WriteLine("元素索引：" + targetIndex);
}

这里使用 -1 表示没有找到目标元素。

在游戏开发中，一维数组可以用于批量存储怪物、玩家、道具或者其他同类型数据。

Lesson 3：二维数组

二维数组的基本概念

二维数组可以理解为由行和列组成的数据表格。

int[,] map = new int[3, 4];

这表示创建了一个 3 行 4 列的二维数组。

二维数组也可以在声明时直接赋值：

int[,] arr =
{
    { 1, 2, 3 },
    { 4, 5, 6 }
};

这个数组有 2 行、3 列。

获取行数和列数

二维数组使用 GetLength() 获取指定维度的长度：

int rowCount = arr.GetLength(0);
int columnCount = arr.GetLength(1);

其中：

GetLength(0)  获取行数
GetLength(1)  获取列数

获取、修改和遍历元素

访问二维数组元素时，需要同时提供行索引和列索引：

Console.WriteLine(arr[0, 1]);

arr[1, 2] = 100;

二维数组通常使用双层循环遍历：

for (int i = 0; i < arr.GetLength(0); i++)
{
    for (int j = 0; j < arr.GetLength(1); j++)
    {
        Console.Write(arr[i, j] + " ");
    }

    Console.WriteLine();
}

其中：

外层循环控制行
内层循环控制列

例如，将 1～10000 依次填入一个 100 × 100 的二维数组：

int[,] numbers = new int[100, 100];
int value = 1;

for (int i = 0; i < numbers.GetLength(0); i++)
{
    for (int j = 0; j < numbers.GetLength(1); j++)
    {
        numbers[i, j] = value;
        value++;
    }
}

二维数组中的位置关系

二维数组练习的重点之一，是通过行列索引判断元素位置。

例如，将主对角线右上方的元素置为 0：

int[,] arr =
{
    { 1,  2,  3,  4 },
    { 5,  6,  7,  8 },
    { 9, 10, 11, 12 },
    { 13, 14, 15, 16 }
};

for (int i = 0; i < arr.GetLength(0); i++)
{
    for (int j = i + 1; j < arr.GetLength(1); j++)
    {
        arr[i, j] = 0;
    }
}

处理后的结果为：

1  0  0  0
5  6  0  0
9 10 11  0
13 14 15 16

主对角线元素的特点是行索引与列索引相同：

int sum = 0;

for (int i = 0; i < arr.GetLength(0); i++)
{
    sum += arr[i, i];
}

在二维数组中查找最大值时，可以同时记录元素的行列位置：

int max = arr[0, 0];
int maxRow = 0;
int maxColumn = 0;

for (int i = 0; i < arr.GetLength(0); i++)
{
    for (int j = 0; j < arr.GetLength(1); j++)
    {
        if (arr[i, j] > max)
        {
            max = arr[i, j];
            maxRow = i;
            maxColumn = j;
        }
    }
}

二维数组常用于表示：

矩阵
棋盘
控制台游戏地图
固定行列的表格数据

Lesson 4：交错数组

交错数组与二维数组的区别

交错数组是“数组的数组”。

二维数组的每一行长度相同，而交错数组的每一行可以拥有不同长度：

int[][] arr = new int[3][];

arr[0] = new int[2];
arr[1] = new int[4];
arr[2] = new int[3];

也可以直接初始化：

int[][] arr =
{
    new int[] { 1, 2 },
    new int[] { 3, 4, 5, 6 },
    new int[] { 7, 8, 9 }
};

获取交错数组的行数：

Console.WriteLine(arr.Length);

获取某一行的长度：

Console.WriteLine(arr[1].Length);

访问元素时使用两个中括号：

Console.WriteLine(arr[1][2]);

arr[1][2] = 100;

遍历时，每一行都要使用自己的长度：

for (int i = 0; i < arr.Length; i++)
{
    for (int j = 0; j < arr[i].Length; j++)
    {
        Console.Write(arr[i][j] + " ");
    }

    Console.WriteLine();
}

交错数组在这套课程中属于非重点知识，理解它与二维数组的区别，并掌握基本访问方式即可。

Lesson 5：值类型和引用类型

值类型的赋值特点

课程使用整数变量演示值类型：

int a = 10;
int b = a;

b = 20;

Console.WriteLine(a);
Console.WriteLine(b);

输出：

10
20

执行：

int b = a;

相当于把 a 中的值复制一份交给 b。

之后修改 b，不会影响 a，可以总结为：

它变，我不变。

引用类型的赋值特点

课程使用数组演示引用类型：

int[] arr1 = { 1, 2, 3 };
int[] arr2 = arr1;

arr2[0] = 100;

Console.WriteLine(arr1[0]);
Console.WriteLine(arr2[0]);

输出：

100
100

这里并没有复制一份完整数组，而是让 arr1 和 arr2 指向同一份数组数据。

因此，通过其中一个变量修改数组，另一个变量也能观察到变化：

它变，我也变。

重新创建引用类型数据

如果重新使用 new 创建数组，变量就会指向一份新数据：

int[] arr1 = { 1, 2, 3 };
int[] arr2 = arr1;

arr2 = new int[] { 10, 20, 30 };
arr2[0] = 100;

Console.WriteLine(arr1[0]);
Console.WriteLine(arr2[0]);

输出：

1
100

重新创建数组以后，arr1 和 arr2 不再指向同一份数据。

本阶段需要掌握的核心结论是：

类型	赋值特点
值类型	复制一份数据
引用类型	可能指向同一份数据
重新 `new`	创建新数据并改变引用

课程还提到了栈空间、堆空间和 new。现阶段重点是理解赋值和修改的结果，不需要过度深入内存实现细节。

Lesson 6：特殊引用类型 string

string 的特殊表现

string 属于引用类型，但它的赋值表现比较特殊：

string str1 = "123";
string str2 = str1;

str2 = "321";

Console.WriteLine(str1);
Console.WriteLine(str2);

输出：

123
321

看起来很像值类型的“它变，我不变”。

字符串不可变

字符串具有不可变的特点。

执行：

str2 = "321";

并不是把原来的 "123" 修改成 "321"，而是让 str2 对应一个新的字符串。

因此：

str1 仍然对应 "123"
str2 重新对应 "321"

下面的代码看起来是在不断修改字符串：

string result = "";

for (int i = 0; i < 10; i++)
{
    result += i;
}

实际上，每次拼接通常都会产生新的字符串结果。

现阶段只需要掌握：

string 是引用类型
字符串具有不可变特点
对字符串重新赋值时，原字符串本身不会被直接修改
频繁拼接字符串可能产生较多新数据

字符串优化方案属于后续课程内容，本阶段不展开。

Lesson 7：函数

函数的基本概念

函数本质上是一块具有名称的代码块。

它的主要作用包括：

封装代码
提高代码复用率
抽象程序行为

例如：

static void Welcome()
{
    Console.WriteLine("欢迎学习 C#");
}

调用函数：

Welcome();

本阶段介绍的函数写在 class 或 struct 中。由于还没有正式学习类，当前程序中的函数暂时配合 static 使用。

函数基本结构

static 返回类型 函数名(参数)
{
    // 函数逻辑

    return 返回值;
}

例如：

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

调用函数并接收返回值：

int result = Add(10, 20);
Console.WriteLine(result);

四种基本函数形式

根据是否有参数和返回值，函数可以分为四种形式：

// 无参数、无返回值
static void SayHello()
{
    Console.WriteLine("Hello");
}

// 有参数、无返回值
static void PrintNumber(int number)
{
    Console.WriteLine(number);
}

// 无参数、有返回值
static int GetNumber()
{
    return 100;
}

// 有参数、有返回值
static int GetMax(int a, int b)
{
    return a > b ? a : b;
}

void 表示函数不返回数据。

return 的作用

return 不仅可以返回函数结果，还可以提前结束函数：

static void CheckAge(int age)
{
    if (age < 0)
    {
        Console.WriteLine("年龄不能小于 0");
        return;
    }

    Console.WriteLine("年龄：" + age);
}

当年龄小于 0 时，函数执行到 return 就会立即结束。

使用函数封装数组统计

此前在数组中编写的统计逻辑，可以进一步封装成函数：

static float[] GetArrayInfo(int[] arr)
{
    int sum = 0;
    int max = arr[0];
    int min = arr[0];

    for (int i = 0; i < arr.Length; i++)
    {
        sum += arr[i];

        if (arr[i] > max)
        {
            max = arr[i];
        }

        if (arr[i] < min)
        {
            min = arr[i];
        }
    }

    float average = (float)sum / arr.Length;

    return new float[] { sum, max, min, average };
}

通过数组，可以暂时让一个函数返回多个同类型结果：

int[] numbers = { 12, 35, 18, 46 };

float[] result = GetArrayInfo(numbers);

Console.WriteLine("总和：" + result[0]);
Console.WriteLine("最大值：" + result[1]);
Console.WriteLine("最小值：" + result[2]);
Console.WriteLine("平均值：" + result[3]);

使用函数判断质数和闰年

函数适合封装能够重复使用的判断逻辑。

判断质数：

static bool IsPrime(int number)
{
    if (number < 2)
    {
        return false;
    }

    for (int i = 2; i < number; i++)
    {
        if (number % i == 0)
        {
            return false;
        }
    }

    return true;
}

判断闰年：

static bool IsLeapYear(int year)
{
    return year % 400 == 0 ||
           year % 4 == 0 && year % 100 != 0;
}

函数把判断过程封装起来，调用者只需要关心返回结果。

Lesson 8：ref 和 out

普通参数为什么不能直接修改外部变量

普通值类型参数传入函数时，函数得到的是数据副本：

static void ChangeNumber(int number)
{
    number = 100;
}

int value = 10;
ChangeNumber(value);

Console.WriteLine(value);

输出仍然是：

如果希望函数内部的修改影响外部变量，可以使用 ref 或 out。

ref 参数

static void ChangeNumber(ref int number)
{
    number = 100;
}

int value = 10;
ChangeNumber(ref value);

Console.WriteLine(value);

使用 ref 时：

定义参数时需要写 ref
调用函数时也需要写 ref
传入函数前必须初始化
函数内部可以修改，也可以不修改

out 参数

static void GetNumber(out int number)
{
    number = 100;
}

int value;
GetNumber(out value);

Console.WriteLine(value);

使用 out 时：

定义参数时需要写 out
调用函数时也需要写 out
传入前可以不初始化
函数内部必须赋值

两者的核心区别如下：

对比项目	ref	out
调用前是否必须初始化	必须	不需要
函数内部是否必须赋值	不强制	必须
是否能修改外部变量	可以	可以
常见用途	修改已有数据	返回额外结果

可以简单理解为：

ref：带着已有数据进入函数
out：从函数中领取一份结果

使用 out 返回额外信息

登录函数可以直接返回登录是否成功，再通过 out 返回提示信息：

static bool Login(
    string inputName,
    string inputPassword,
    out string message)
{
    string correctName = "admin";
    string correctPassword = "123456";

    if (inputName != correctName)
    {
        message = "用户名错误";
        return false;
    }

    if (inputPassword != correctPassword)
    {
        message = "密码错误";
        return false;
    }

    message = "登录成功";
    return true;
}

调用：

string message;

bool result = Login(
    "admin",
    "123456",
    out message);

Console.WriteLine(result);
Console.WriteLine(message);

Lesson 9：变长参数与参数默认值

params 变长参数

如果函数需要接收数量不确定的同类型参数，可以使用 params：

static int Sum(params int[] numbers)
{
    int sum = 0;

    for (int i = 0; i < numbers.Length; i++)
    {
        sum += numbers[i];
    }

    return sum;
}

调用时可以传入不同数量的整数：

Console.WriteLine(Sum());
Console.WriteLine(Sum(10));
Console.WriteLine(Sum(10, 20, 30));
Console.WriteLine(Sum(1, 2, 3, 4, 5));

params 的使用规则包括：

params 后面必须是数组
数组可以是任意数据类型
一个函数最多只能有一个 params
params 必须放在参数列表最后
参数数量可以为 0

例如，通过 params 计算平均值：

static float GetAverage(params int[] numbers)
{
    if (numbers.Length == 0)
    {
        return 0;
    }

    int sum = 0;

    for (int i = 0; i < numbers.Length; i++)
    {
        sum += numbers[i];
    }

    return (float)sum / numbers.Length;
}

参数默认值

参数默认值也叫可选参数：

static void PrintPlayer(
    string name,
    int level = 1,
    int health = 100)
{
    Console.WriteLine("姓名：" + name);
    Console.WriteLine("等级：" + level);
    Console.WriteLine("生命值：" + health);
}

调用时可以省略可选参数：

PrintPlayer("勇者");
PrintPlayer("勇者", 10);
PrintPlayer("勇者", 10, 500);

没有传入数据时，函数使用默认值；传入数据时，则使用调用者提供的值。

普通参数必须放在可选参数前面：

static void Test(int a, int b = 10, int c = 20)
{
}

Lesson 10：函数重载

函数重载的基本概念

在同一个语句块中，可以声明多个同名函数。

只要参数列表不同，就可以构成函数重载。

参数列表不同包括：

参数数量不同
参数类型不同
参数顺序不同

例如，根据参数类型重载比较函数：

static int GetMax(int a, int b)
{
    return a > b ? a : b;
}

static float GetMax(float a, float b)
{
    return a > b ? a : b;
}

static double GetMax(double a, double b)
{
    return a > b ? a : b;
}

调用时，程序会根据传入的数据类型选择对应函数：

Console.WriteLine(GetMax(10, 20));
Console.WriteLine(GetMax(3.5f, 8.2f));
Console.WriteLine(GetMax(7.8, 9.6));

重载的作用是让一组相似功能使用同一个函数名，减少函数名称数量，提高代码可读性。

重载与返回值无关

下面两个函数不能构成重载：

static int Test(int number)
{
    return number;
}

static float Test(int number)
{
    return number;
}

它们只有返回值类型不同，参数列表完全相同，因此会产生冲突。

函数重载判断的是参数列表，而不是返回值类型。

另外，ref 和 out 不能作为唯一的重载区别，不能只依靠一个函数使用 ref、另一个函数使用 out 来构成重载。

Lesson 11：递归函数

什么是递归

递归就是函数自己调用自己。

如果函数无条件调用自己：

static void Test()
{
    Test();
}

程序将无法停止，最终产生错误。

正确的递归必须具备三个条件：

存在结束条件
控制结束条件的数据不断变化
最终能够达到结束条件

递归调用过程

下面的函数会递归打印 0～10：

static void PrintNumber(int number)
{
    if (number > 10)
    {
        return;
    }

    Console.WriteLine(number);

    PrintNumber(number + 1);
}

调用：

PrintNumber(0);

每次调用时，number 都会加 1，最终达到结束条件。

递归求阶乘

阶乘具有明显的递归关系：

1! = 1
2! = 2 × 1!
3! = 3 × 2!
n! = n × (n - 1)!

代码如下：

static int Factorial(int number)
{
    if (number == 1)
    {
        return 1;
    }

    return number * Factorial(number - 1);
}

调用：

Console.WriteLine(Factorial(5));

结果为：

这里：

number == 1 是结束条件
number - 1 让控制数据发生变化
数据最终会减少到 1

递归的重点不是记住某一道题，而是学会识别结束条件和数据变化规律。

Lesson 12：结构体

什么是结构体

结构体是一种自定义变量类型，是数据和函数的集合。

它可以用于描述：

学生
玩家
怪物
矩形
其他具有一组相关信息的数据

基本语法如下：

struct 自定义结构体名
{
    // 成员变量
    // 构造函数
    // 成员函数
}

例如，使用结构体描述学生：

enum Gender
{
    Male,
    Female
}

struct Student
{
    public string name;
    public Gender gender;
    public int age;
    public string className;
    public string major;
}

结构体可以把原本分散的相关数据组织在一起。

public 与 private

课程介绍了两个访问修饰符：

修饰符	作用
`public`	外部可以访问
`private`	只能在结构体内部访问

如果没有写访问修饰符，结构体成员默认为 private。

struct Player
{
    public string name;
    private int health;
}

外部可以访问 name，但不能直接访问 health。

结构体构造函数与 this

构造函数用于方便地创建和初始化结构体数据：

struct Rectangle
{
    public float width;
    public float height;

    public Rectangle(float width, float height)
    {
        this.width = width;
        this.height = height;
    }
}

结构体构造函数具有以下特点：

没有返回值
名称与结构体名称相同
当前课程使用带参数的构造函数
需要初始化结构体中的成员数据
构造函数可以重载

this 表示当前这个结构体自己：

this.width  结构体自己的成员变量
width       构造函数传入的参数

结构体中的成员函数

结构体中的成员函数可以直接访问结构体自己的数据：

struct Rectangle
{
    public float width;
    public float height;

    public Rectangle(float width, float height)
    {
        this.width = width;
        this.height = height;
    }

    public float GetArea()
    {
        return width * height;
    }

    public float GetPerimeter()
    {
        return (width + height) * 2;
    }

    public void ShowInfo()
    {
        Console.WriteLine("面积：" + GetArea());
        Console.WriteLine("周长：" + GetPerimeter());
    }
}

使用：

Rectangle rectangle = new Rectangle(10, 5);
rectangle.ShowInfo();

当前阶段，结构体中的普通成员函数不需要写 static。

结构体与数组结合

结构体可以描述一只怪物，数组可以批量存储多只怪物：

struct Monster
{
    public string name;
    public int health;
    public int attack;

    public Monster(string name, int health, int attack)
    {
        this.name = name;
        this.health = health;
        this.attack = attack;
    }
}

创建怪物数组：

Monster[] monsters = new Monster[10];

for (int i = 0; i < monsters.Length; i++)
{
    monsters[i] = new Monster(
        "小怪兽" + (i + 1),
        100,
        10);
}

这里综合使用了：

结构体
构造函数
数组
循环
字符串拼接

结构体与 ref 结合

结构体属于值类型。将结构体传入函数时，如果希望函数直接修改外部结构体数据，可以使用 ref：

struct Fighter
{
    public string name;
    public int health;
    public int attack;

    public Fighter(string name, int health, int attack)
    {
        this.name = name;
        this.health = health;
        this.attack = attack;
    }
}

攻击函数：

static bool Attack(
    ref Fighter attacker,
    ref Fighter target,
    out string message)
{
    target.health -= attacker.attack;

    if (target.health <= 0)
    {
        target.health = 0;
        message = attacker.name + "击败了" + target.name;
        return true;
    }

    message =
        attacker.name + "攻击了" + target.name +
        "，目标剩余生命值：" + target.health;

    return false;
}

调用：

Fighter hero = new Fighter("奥特曼", 500, 80);
Fighter monster = new Fighter("小怪兽", 300, 30);

string message;
bool isOver = Attack(
    ref hero,
    ref monster,
    out message);

Console.WriteLine(message);

这段代码把结构体、函数、ref 和 out 联系了起来。

Lesson 13：冒泡排序

冒泡排序的基本思路

排序是把无序数据调整为指定顺序：

原数组：5 2 8 1 4
升序：  1 2 4 5 8
降序：  8 5 4 2 1

冒泡排序的核心过程是：

比较两个相邻元素
如果顺序不符合要求，就交换
一轮比较后，让一个元素到达正确位置
重复多轮，直到数组有序

升序冒泡排序：

int[] arr = { 5, 2, 8, 1, 4 };

for (int i = 0; i < arr.Length - 1; i++)
{
    for (int j = 0; j < arr.Length - 1 - i; j++)
    {
        if (arr[j] > arr[j + 1])
        {
            int temp = arr[j];

            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

外层循环控制比较轮数，内层循环比较相邻元素。

冒泡排序优化

每完成一轮，就有一个元素到达最终位置，因此内层循环可以缩小比较范围：

j < arr.Length - 1 - i

还可以使用一个 bool 变量记录当前轮是否发生交换。

如果一轮比较完全没有发生交换，说明数组已经有序，可以提前结束：

static void BubbleSort(int[] arr, bool ascending)
{
    for (int i = 0; i < arr.Length - 1; i++)
    {
        bool exchanged = false;

        for (int j = 0; j < arr.Length - 1 - i; j++)
        {
            bool needExchange;

            if (ascending)
            {
                needExchange = arr[j] > arr[j + 1];
            }
            else
            {
                needExchange = arr[j] < arr[j + 1];
            }

            if (needExchange)
            {
                int temp = arr[j];

                arr[j] = arr[j + 1];
                arr[j + 1] = temp;

                exchanged = true;
            }
        }

        if (!exchanged)
        {
            break;
        }
    }
}

调用时通过参数控制排序方向：

BubbleSort(arr, true);   // 升序
BubbleSort(arr, false);  // 降序

Lesson 14：选择排序

选择排序的基本思路

选择排序每一轮都会从剩余元素中找到一个极值，再把它放到当前目标位置。

升序排序时：

假设当前位置是最小值位置
向后查找真正的最小值
记录最小值索引
将最小值与当前位置交换
继续处理后面的元素

代码如下：

int[] arr = { 5, 2, 8, 1, 4 };

for (int i = 0; i < arr.Length - 1; i++)
{
    int minIndex = i;

    for (int j = i + 1; j < arr.Length; j++)
    {
        if (arr[j] < arr[minIndex])
        {
            minIndex = j;
        }
    }

    if (minIndex != i)
    {
        int temp = arr[i];

        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

课程中将 minIndex 这类记录极值位置的变量形容为“中间商”。

如果需要降序排列，就在每一轮查找最大值。

也可以通过参数统一控制排序方向：

static void SelectionSort(int[] arr, bool ascending)
{
    for (int i = 0; i < arr.Length - 1; i++)
    {
        int targetIndex = i;

        for (int j = i + 1; j < arr.Length; j++)
        {
            bool foundTarget;

            if (ascending)
            {
                foundTarget = arr[j] < arr[targetIndex];
            }
            else
            {
                foundTarget = arr[j] > arr[targetIndex];
            }

            if (foundTarget)
            {
                targetIndex = j;
            }
        }

        if (targetIndex != i)
        {
            int temp = arr[i];

            arr[i] = arr[targetIndex];
            arr[targetIndex] = temp;
        }
    }
}

冒泡排序与选择排序的区别

对比项目	冒泡排序	选择排序
比较方式	比较相邻元素	在剩余元素中寻找极值
每轮结果	一个元素逐渐移动到正确位置	直接把极值放到目标位置
交换次数	一轮可能交换多次	一轮通常最多交换一次
基本结构	两层循环	两层循环
练习重点	相邻元素交换	极值索引记录

两种算法都适合练习：

数组遍历
双层循环
条件判断
元素交换
函数封装

C# 入门教程：基础语法、核心知识与学习要点全面总结

Tue, 04 Aug 2026 00:00:00 GMT

一、变量

在入门要求下，C# 中的变量类型可大致分为 整数、小数、字符类、布尔类型四大类。

1.变量类型

1.整数类型

整数类型变量又可分为有符号整数、无符号整数两类，以下是详细区分

类型	位数	取值范围
`sbyte`	8位	-128 ～ 127
`byte`	8位	0 ～ 255
`short`	16位	-32,768 ～ 32,767
`ushort`	16位	0 ～ 65,535
`int`	32位	约 -21亿～ 21亿
`uint`	32位	0 ～约42亿
`long`	64位	很大的正负整数
`ulong`	64位	很大的非负整数

对于取值范围可以从数字位数的角度理解，比如int类型，总共有32位，最左边第一位数字代表符号位（1为负、0为正），剩下31位可用于表示数字，因此其数字范围是正负231-1。

例如：

byte age = 18;
int population = 1_400_000_000;
long distance = 9_000_000_000L;
uint count = 100U;

在实际游戏开发中，通常先使用int；数字超过int范围后再使用long类型。

2.小数类型

小数类型可分为二进制浮点数和高精度十进制数字

类型	位数	有效精度	适合场景
`float`	32位	约6～9位数字	图形、游戏等
`double`	64位	约15～17位数字	普通小数计算，默认选择
`decimal`	128位	约28～29位数字	金额、财务等高精度计算

float height = 1.75F;       // 必须加 F
double pi = 3.1415926535;   // 小数字面量默认是 double
decimal price = 99.99M;     // 必须加 M

float 和 double 可能产生小数误差：

double result = 0.1 + 0.2;  // 可能不是精确的 0.3

涉及金钱时通常使用 decimal

3.字符类型

char 表示一个 UTF-16 编码单元，使用单引号：

char grade = 'A';
char chinese = '中';
char newLine = '\n';

注意：部分 emoji 需要两个 char 才能表示，因此 char 不一定等同于用户看到的一个完整字符。

string 表示零个或多个字符组成的文本，使用双引号：

string name = "张三";
string message = "Hello, C#!";
string empty = "";

string 和 char 的区别：

char letter = 'A';       // 单引号，一个字符
string word = "Apple";   // 双引号，一串字符

4. 布尔类型

布尔类型只有 true 和 false 两个值：

bool isStudent = true;
bool isFinished = false;

其主要作用是用于条件判断

2.变量的本质

1.定义与特征

变量就是：一个有名称、有类型、能够保存数据的位置。一个变量通常具有：

类型：可以保存什么数据。
名称：如何访问这个变量。
值：当前保存的数据。
作用域：可以在哪些位置使用。

if (true)
{
    int score = 100;
    Console.WriteLine(score); // 可以使用
}

// Console.WriteLine(score);  // 错误，超出作用域

2.值类型与引用类型

变量除了通过数据类型分类外，还可以通过值类型和引用类型

整数、小数、布尔和字符通常属于值类型：

int number1 = 10;
int number2 = number1;

number2 = 20;

Console.WriteLine(number1); // 10
Console.WriteLine(number2); // 20

赋值时会复制一份值，所以修改 number2 不会影响 number1。

常见值类型包括：

int、long、float、double、decimal、bool、char、struct、enum

字符串、数组、类等属于引用类型。变量中保存的是对象的引用：

int[] numbers1 = { 1, 2, 3 };
int[] numbers2 = numbers1;

numbers2[0] = 100;

Console.WriteLine(numbers1[0]); // 100

常见引用类型包括：

string、数组、class、interface、object、delegate

string 虽然是引用类型，但它具有不可变性，不能直接修改已有字符串的内容。

string name = "张";
name = name + "三"; // 实际上产生了一个新的字符串

3.命名规则

C# 变量名必须符合以下基本规则：

可以使用字母、数字和下划线。
不能以数字开头。
不能包含空格以及 -、+、% 等符号。
不能直接使用 C# 关键字。
C# 严格区分大小写。

二、常量

常量是一个在声明后不能再被修改的固定值。C# 中主要使用 const 声明编译期常量

1.基本语法

const 数据类型常量名称 = 常量值;

例如：

const int MaximumScore = 100;
const double Pi = 3.1415926;
const string DefaultName = "游客";
const bool IsDebugMode = false;

//常量必须在声明时赋值：

const int MaximumScore = 100; // 正确

// const int MinimumScore;    // 错误：没有初始化
// MinimumScore = 0;

//赋值后不能修改

const int MaximumScore = 100;

// MaximumScore = 200; // 编译错误

2.const的主要特点

1.必须在声明时初始化。2.初始化值必须能在编译期间确定。3.声明后不能重新赋值。4.可以声明为局部常量或类成员常量。5.类中的 const 成员隐式属于类本身，相当于静态成员。6.不能同时写成 static const。

class MathSettings
{
    public const double Pi = 3.1415926;
}

double result = MathSettings.Pi * 10;

//下面写法错误：

// public static const double Pi = 3.14;

3.常用的常量类型

通常，以上变量类型都可作为常量定义，运行编译才可确定的数值，不可作为常量：

const byte Level = 10;
const int MaximumCount = 100;
const long Distance = 9_000_000_000L;

const float Rate = 0.5F;
const double Pi = 3.1415926;
const decimal TaxRate = 0.13M;

const char Separator = ',';
const string DefaultName = "游客";
const bool IsEnabled = true;

//枚举值也可以作为常量：
const ConsoleColor DefaultColor = ConsoleColor.Blue;
//常量表达式可以使用其他常量：
const int SecondsPerMinute = 60;
const int MinutesPerHour = 60;
const int SecondsPerHour = SecondsPerMinute * MinutesPerHour;

4.常量的作用域

局部常量只能在所在代码块中使用，类成员常量可以通过类名访问：

void Calculate()
{
    const double Pi = 3.1415926;
    double area = Pi * 10 * 10;
}

// 此处不能使用 Pi

class GameSettings
{
    public const int MaximumLevel = 100;
}

Console.WriteLine(GameSettings.MaximumLevel);

三、C# 转义字符

转义字符用于表示一些不能直接输入，或者具有特殊含义的字符。它们通常以反斜杠 \ 开头。

1.常用转义字符

转义字符	含义	示例
`\n`	换行	`"第一行\n第二行"`
`\r`	回车	`"内容\r"`
`\t`	水平制表符	`"姓名\t成绩"`
`\\`	反斜杠	`"C:\\Users\\Li"`
`\"`	双引号	`"他说：\"你好\""`
`\'`	单引号	`'\''`
`\0`	空字符，Unicode `U+0000`	`'\0'`
`\a`	警报、响铃	`"\a"`
`\b`	退格	`"ABC\b"`
`\f`	换页	`"\f"`
`\v`	垂直制表符	`"\v"`
`\e`	Escape 字符	`"\e"`，C# 13+

2.常见示例

换行：

string message = "姓名：张三\n年龄：18";
Console.WriteLine(message);

制表符：

Console.WriteLine("姓名\t成绩");
Console.WriteLine("张三\t100");
Console.WriteLine("李四\t90");

双引号：

string sentence = "老师说：\"请认真学习。\"";

反斜杠：

string path = "C:\\Users\\Li\\Documents";

单引号字符：

char singleQuote = '\'';

3.Unicode 转义字符

可以通过 Unicode 编码表示字符。

\u 后面必须跟四位十六进制数字：

char letter = '\u0041';       // A
char chinese = '\u4E2D';      // 中
string text = "\u4F60\u597D"; // 你好

\U 后面跟八位十六进制数字，可以表示 emoji 等较大的 Unicode 字符：

string emoji = "\U0001F600"; // 😀

\x 后面可以跟十六进制数字：

char letter = '\x41'; // A

由于 \x 使用的数字位数可能不固定，容易产生歧义，因此通常优先使用固定四位的 \u

4.逐字字符串 `@`与原始字符串

在字符串前添加 @，反斜杠会按照普通字符处理，适合表示文件路径：

string path1 = "C:\\Users\\Li\\Documents";
string path2 = @"C:\Users\Li\Documents";

这两个字符串的内容相同。

逐字字符串中的双引号需要写两次：

string text = @"老师说：""你好。""";

在逐字字符串中，\n 不会被解释为换行：

string text = @"第一行\n第二行";

Console.WriteLine(text);

输出：

第一行\n第二行

C# 11 开始支持三个双引号组成的原始字符串，适合保存 JSON、HTML 等文本：

string json = """
{
    "name": "张三",
    "path": "C:\Users\Li"
}
""";

四、数据类型的转换

类型转换主要分为两类：隐式转换和显式转换。

1.隐式转换

范围较小的类型转换为范围较大的类型，编译器自动完成，通常不会丢失数据。

int damage = 10;
float finalDamage = damage;

int 转 float：

int speed = 5;
float distance = speed * Time.deltaTime;

2. 显式转换

强制转换 (类型)

可能丢失数据，需要使用强制转换符：

float distance = 9.8f;
int value = (int)distance; // 9，直接截掉小数

Unity 中常用于坐标、时间或下标：

int x = (int)transform.position.x;
int second = (int)Time.time;

不能直接将字符串强转为整数：

// int level = (int)"10"; // 错误

Parse

用于将字符串转换成指定类型：

int level = int.Parse("10");
float speed = float.Parse("5.5");
bool enabled = bool.Parse("true");

格式错误时会抛出异常，因此不适合直接处理玩家输入。可使用TryParse替代：

if (int.TryParse(inputField.text, out int level))
{
    Debug.Log($"等级：{level}");
}
else
{
    Debug.LogWarning("请输入正确的数字");
}

// bool 是否成功 = 数据类型.TryParse(字符串, out 转换结果);

//其他类型：
float.TryParse("5.5", out float speed);
double.TryParse("3.14", out double pi);
bool.TryParse("true", out bool enabled);

Convert：

可以在字符串和常见基础类型之间转换：

int level = Convert.ToInt32("10");
float speed = Convert.ToSingle("5.5");
string text = Convert.ToString(100);

注意强转与 Convert 的区别：

int a = (int)3.8f;             // 3，截掉小数
int b = Convert.ToInt32(3.8f); // 4，四舍五入

五、C# 异常捕获

异常捕获用于处理程序运行期间出现的错误，避免程序直接中断。

基本语法

try
{
    // 可能出现异常的代码
}
catch (Exception ex)
{
    // 出现异常后的处理
}
finally
{
    // 无论是否异常，通常都会执行
}

//示例

try
{
    int number = int.Parse("abc");
}
catch (Exception ex)
{
    Debug.LogError($"转换失败：{ex.Message}");
}

六、运算

运算可分为算数运算、逻辑运算、位运算几类。

1.算数运算符

运算符	含义	示例
`+`	加法	`a + b`
`-`	减法	`a - b`
`*`	乘法	`a * b`
`/`	除法	`a / b`
`%`	取余	`a % b`
`++`	自增 1	`count++`
`--`	自减 1	`count--`

int a = 10;
int b = 3;

Debug.Log(a + b); // 13
Debug.Log(a - b); // 7
Debug.Log(a * b); // 30
Debug.Log(a / b); // 3
Debug.Log(a % b); // 1

//整数相除会舍弃小数：

float result1 = 5 / 2;    // 2
float result2 = 5f / 2f;  // 2.5

//复合赋值运算符：

hp += 10; // hp = hp + 10
hp -= 10;
hp *= 2;
hp /= 2;
hp %= 3;

//++ 前置与后置：

int a = 10;

int b = a++; // b是10，然后a变成11
int c = ++a; // a先变成12，然后赋给c

Unity 常用数学方法：

Mathf.Abs(value);             // 绝对值
Mathf.Min(a, b);              // 最小值
Mathf.Max(a, b);              // 最大值
Mathf.Clamp(hp, 0, 100);      // 限制范围
Mathf.Pow(2, 3);              // 2的3次方
Mathf.Sqrt(16);               // 平方根
Mathf.RoundToInt(3.6f);       // 四舍五入
Mathf.FloorToInt(3.6f);       // 向下取整
Mathf.CeilToInt(3.1f);        // 向上取整
Mathf.Lerp(0, 100, 0.5f);     // 插值，结果50

随机数：

int number = Random.Range(0, 10);      // 0～9
float value = Random.Range(0f, 10f);   // 浮点范围

//复杂运算建议使用括号明确顺序：
float damage = (attack + weaponDamage) * multiplier; 若无括号则是先算乘除后算加减

2. 字符串拼接与打印

使用 `+` 拼接

string playerName = "张三";
int score = 100;

string message = "玩家：" + playerName + "，分数：" + score;

字符串插值

Unity 开发中推荐使用：

string message = $"玩家：{playerName}，分数：{score}";

设置小数显示位数：

float time = 12.3456f;
Debug.Log($"时间：{time:F2}"); // 时间：12.35

其他拼接方法

string result1 = string.Concat("生命值：", hp);
string result2 = string.Join(", ", playerNames);
string result3 = string.Format("分数：{0}", score);
Console.WriteLine("分数：{0}", score); //格式化打印

打印方法

普通 C#：

Console.Write("不换行");
Console.WriteLine("打印后换行");

Unity：

Debug.Log("普通信息");
Debug.LogWarning("警告信息");
Debug.LogError("错误信息");
Debug.LogException(exception);

显示到 UI：

scoreText.text = $"分数：{score}";

字符串不可变。在 Update() 中频繁拼接和更新 UI 可能产生额外内存分配，最好只在数据改变时更新。

3. 条件运算符（比较运算符）

比较结果都是 bool 类型：

运算符	含义
`==`	等于
`!=`	不等于
`>`	大于
`<`	小于
`>=`	大于等于
`<=`	小于等于

if (hp <= 0)
{
    Debug.Log("玩家死亡");
}

判断范围：

if (hp >= 0 && hp <= maxHp)
{
    Debug.Log("生命值正常");
}

浮点数可能存在精度误差，Unity 中推荐：

if (Mathf.Approximately(a, b))
{
    Debug.Log("两个浮点数近似相等");
}

字符串内容比较：

if (playerName == "张三")
{
}

忽略大小写：

bool same = string.Equals(
    input,
    "start",
    StringComparison.OrdinalIgnoreCase
);

4. 逻辑运算符

运算符	含义
`&&`	并且，全部为真才是真
`
`!`	取反
`^`	异或，两个条件不同时为真

if (hp > 0 && hasWeapon)
{
    Debug.Log("可以攻击");
}

if (isDead || isPaused)
{
    return;
}

if (!isGrounded)
{
    Debug.Log("角色在空中");
}

&& 和 || 具有短路功能：

if (player != null && player.Health > 0)
{
}

如果 player 是 null，后面的代码不会执行，因此不会访问空对象。

& 和 | 也能用于布尔值，但不会短路，普通条件判断优先使用 && 和 ||。

5. 位运算符

位运算直接操作整数的二进制位：

运算符	含义
`&`	按位与
`	`
`^`	按位异或
`~`	按位取反
`<<`	左移
`>>`	右移

int a = 6; // 0110
int b = 3; // 0011

int andResult = a & b; // 0010，结果2
int orResult  = a | b; // 0111，结果7
int xorResult = a ^ b; // 0101，结果5

位移：

int a = 1 << 3; // 0001 左移3位，结果8
int b = 8 >> 2; // 1000 右移2位，结果2

Unity 中最常见的用途是 LayerMask：

LayerMask targetMask = LayerMask.GetMask("Enemy", "Obstacle");

bool isIncluded =
    (targetMask.value & (1 << gameObject.layer)) != 0;

添加和移除某一位：

mask |= 1 << layer;       // 添加层
mask &= ~(1 << layer);    // 移除层

位运算通常用于层级遮罩、权限和状态标记，不用于普通小数。

6. 三目运算符

语法：

条件 ? 条件成立的值 : 条件不成立的值

示例：

string state = hp > 0 ? "存活" : "死亡";

等价于：

string state;

if (hp ＞ 0)
{
    state = "存活";
}
else
{
    state = "死亡";
}

Unity 示例：

spriteRenderer.color = isHurt ? Color.red : Color.white;

三目运算符适合简单的二选一。逻辑复杂时使用 if...else。

七、三类逻辑

1. `while` 循环

只要条件成立，就不断执行：

int count = 0;

while (count < 3)
{
    Debug.Log(count);
    count++;
}

适合循环次数事先不确定的情况。

无限循环：

while (true)
{
    if (shouldStop)
    {
        break;
    }
}

Unity 主线程中不能执行无法及时结束的循环，否则游戏会卡死。跨帧等待应使用协程：

IEnumerator Countdown(float time)
{
    while (time ＞ 0f)
    {
        time -= Time.deltaTime;
        yield return null;
    }

    Debug.Log("倒计时结束");
}

2. `for` 循环

语法：

for (初始化; 循环条件; 更新变量)
{
    // 循环体
}

示例：

for (int i = 0; i < 5; i++)
{
    Debug.Log(i);
}

遍历数组和列表：

for (int i = 0; i < enemies.Count; i++)
{
    enemies[i].TakeDamage(10);
}

删除列表元素时通常倒序遍历：

for (int i = enemies.Count - 1; i ＞= 0; i--)
{
    if (enemies[i] == null)
    {
        enemies.RemoveAt(i);
    }
}

数组使用 .Length，列表使用 .Count：

array.Length;
list.Count;

3. `do...while` 循环

先执行一次，再判断条件，所以循环体至少执行一次：

int count = 0;

do
{
    Debug.Log(count);
    count++;
}
while (count < 3);

注意结尾有分号：

while (条件);

适用于必须先执行一次，再决定是否继续的逻辑。

4. `switch`

适合根据一个变量的不同值执行不同代码，Unity 中经常用于角色状态。

enum PlayerState
{
    Idle,
    Run,
    Jump
}

switch (playerState)
{
    case PlayerState.Idle:
        Debug.Log("待机");
        break;

    case PlayerState.Run:
        Debug.Log("奔跑");
        break;

    case PlayerState.Jump:
        Debug.Log("跳跃");
        break;

    default:
        Debug.LogWarning("未知状态");
        break;
}

多个情况执行相同逻辑：

switch (playerState)
{
    case PlayerState.Idle:
    case PlayerState.Run:
        Debug.Log("角色在地面");
        break;

    case PlayerState.Jump:
        Debug.Log("角色在空中");
        break;
}

较新的 C# 还可以使用 switch 表达式：

string animationName = playerState switch
{
    PlayerState.Idle => "Idle",
    PlayerState.Run  => "Run",
    PlayerState.Jump => "Jump",
    _                => "Unknown"
};

_ 相当于传统 switch 中的 default。是否支持取决于 Unity 项目使用的 C# 版本。

5. 循环控制关键字

break;    // 立即结束当前循环或switch
continue; // 跳过本次循环，进入下一次
return;   // 直接结束当前方法

示例：

for (int i = 0; i < enemies.Count; i++)
{
    if (enemies[i] == null)
    {
        continue;
    }

    if (enemies[i].IsBoss)
    {
        break;
    }

    enemies[i].TakeDamage(10);
}

补充：遍历集合还可以使用 foreach：

foreach (Enemy enemy in enemies)
{
    enemy.TakeDamage(10);
}

foreach 遍历期间通常不能增加或删除集合元素；需要删除时使用倒序 for。

小总结——游戏开发记录

Fri, 31 Oct 2025 00:00:00 GMT

一、起念 —— 梦的种子

最早有这个想法是2025年6月15日，一方面是因为见证了许多同类型的优秀游戏，也想要做一个属于自己的作品。另一方面是自己也有这个想法，想敢于尝试，总比大学四年在玩游戏、吃饭、睡觉、无用社交这类事情中虚度过去，不想混日子，更不想在三年毕业后沦入~~送外卖的境地~~（找不到体面工作）。

最早，只有一个概念那就是梦，之后又联系到预知梦这个概念，两者结合起来就是“预知梦”，游戏的名字“梦的回响”就此诞生，对于游戏大纲、剧情设计，则是后话了。

二、落幕 —— 信任的破碎

游戏立项后，在接下来的几天我进入了招兵买马阶段，拉到了几个人来合作，虽然后续的结果很凄惨，这也只是后话了。我记得当时我拉入微信制作群聊的共有8人，对于游戏早期的策划设计书、草案都是我一个人制作。

此时大约处于6月末，我的我第一次醉酒也就是这个时候，大约是因为没有人帮我，没有一个人理我，我非常愤怒但又无助，非常地憋屈。

后续一个人反应说目前正处于大学期末考试阶段，想要等到暑假正式动工。因前反应分工不够细致、不够明确，我根据目前的人员需求对其进行了分类，包括职责、产出、周期等全方位的安排，我安排地已经非常地细致了，结果得到的是什么呢？则只是一地鸡毛。在这两个月里面没有任何地产出，一个一个地都不理我。不做任何事情，没有担当这个责任，当初就不要答应，答应了却又不做任何的事情，这是极其不负责任的。

在这个暑假里面，我做了一个大致的总体系统框架，然后其他部门没有任何地实质性进展，连理我都不理一下。对Steam DB同类型游戏数据做了调研，这是其中的一部分

到了暑假快结束的几天，我联系了其中一名负责剧情的人，得到了等待开学帮我做的回复。我当时也没考虑挺多，现在才明白暑假都不帮你做一点东西，你觉得他开学会帮你？

果然到了开学，一个月后啥也没帮我做成，有时间去~~忙他那个计算机二级，都不帮我做任何的事情~~，（我并不是否认他们所做的事情不正确，因为人呀没有一个强硬的背景，最后都是要进就业市场，要把主要时间和经历投入到“正确”的事情上吧。）美名其曰其军训忙，反正是忘记了自己开学前给我的承诺，最后我说他不用帮我做了之后，过了大约2小时，给了我一份200字的设计？最后我问了之后，告诉我这200字是自己花这两小时做的，拖了一个暑假+一个月就最后临终2小时给我憋了200字？其他一些做的方面我暂时不吐槽，就单论这一点…..

三、再起 —— 自己的战场

在我赶走之前我找的团队人员之后，我就开始了对游戏主要场景UI的设计，对之前写的游戏框架进行重构，集成了一些所必须的开源框架。找了一个做配乐给主菜单做了一个还行的配音Bgm，并自己绘制一些主要的美术资源，但是现在我又面临一个同样的险境————一个人一直在找借口说自己忙，一个月左右的时间只给我产出了200字左右的剧情大纲设计，之前说过要写对话的，这样我才能录入游戏脚本，不然项目只能停滞不前了。

我在思考要不要把这个人也赶走，然后我一个人负责所有，毕竟目前所有的一切都是我一个人做的，多一样问题也不大

条目	对象
游戏UI、场景设计	我自己做的
游戏草案、剧情设计	我自己做的
游戏配乐	我自己找人代工的
游戏主菜单美术资源	我自己做的
序章（前10%）	上面那个人做的
游戏框架代码	我自己做的
游戏官网	我自己做的

只希望能够越来越好吧，我现在还不打算放弃，什么时候能找到一个志同道合的队友呢？

四、另感 —— 关于大学的质问

周围一些人的所作所为，以及一些其他上大学人的所作所为让我越来越Get不到上大学的意义在于？是在大学混四年日子，然后毕业去送外卖？希望能在以后的经历中体会到其意义。就先这样吧。

Claude Code使用技巧大全：AI编码助手上手使用攻略

Tue, 09 Sep 2025 00:00:00 GMT

前言

本篇是作者使用Claude Code两月后，逐渐摸索出的一些珍贵经验。主要涵盖了一些使用Claude Code的技巧和使用功能，更多详细使用文档请访问Claude Code官方文档。本文将带你全面了解 Claude Code 的 模型设置、项目初始化、对话管理、子代理（Agents）以及 Hooks 钩子事件。

一、安装与配置

在本地已经安装Node.js18及以上版本的执行以下命令安装并导航至项目目录：

npm install -g @anthropic-ai/claude-code
cd your-awesome-project

接着使用命令Claude启用Claude Code，此时可以通过两种方式使用Claude Code，一种是通过Claude账号登录（需要购买Pro及以上订阅服务），另一种是通过API按量使用。

Pro会员订阅支持你可以在Claude Code中与Claude 4sonnet模型对话大约10-40次，该限额是每5小时重置一次，适合中轻度使用者。我本人是通过API按量使用。

二、常用命令

Claude Code 支持多种模型，其中最常用的是 Sonnet 系列 和 Opus 系列。

推荐模型：
- sonnet4 —— 性价比最高，适合日常开发和常规任务。
- opus —— 性能更强，但价格较贵，大约是 sonnet4 的 5 倍。
费用说明：
- sonnet4：约 15 美元 / 输出百万 tokens
- opus：约 75 美元 / 输出百万 tokens

👉 如果你主要用于 代码生成、调试、文档编写，选择 sonnet4 更合适；
👉 如果需要处理更复杂的任务（如大规模代码库分析），可以考虑 opus。

设置模型的命令：

/model sonnet4

项目初始化：/init 指令

在开始使用 Claude Code 之前，可以通过 /init 指令来初始化项目。

额外提示：
你也可以在 claude.md 中添加自定义信息，帮助 Claude 记住某些规则或配置，从而避免重复询问。

功能：1.Claude 会自动扫描整个项目 2.在根目录下生成一个 claude.md 文件

文件中包含 项目基本信息 和 启用方法

对话管理：上下文优化与控制

Claude Code 的对话功能非常强大，但如果不加管理，容易出现“上下文污染”。以下是常用指令：

终端命令上下文：
在 Claude 终端使用 ?+bash 格式，可以将命令执行记录加入上下文，而不必让 Claude 后续帮你执行。

清理上下文： /clear 清除对话历史，避免旧信息干扰。

浓缩上下文： /compact 将对话内容压缩，适合在 官方模型仅支持 20k 上下文长度 时使用。

切换模型上下文： /model sonnet[1m] 使用支持 1百万上下文 的模型，适合大项目。

恢复对话： /resume 回到之前的对话场景。

4.Claude Code子代理（Agents）的高效使用

Claude Code 支持 /agents 指令，创建 独立的智能子代理，每个子代理都能专注于特定任务，且拥有独立上下文，不会污染主对话。

例如，创建一个 代码审查子代理：

---
name: code-reviewer
description: Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code.
tools: Read, Grep, Glob, Bash
---

子代理执行逻辑：

运行 git diff 获取最新代码改动
聚焦修改过的文件
按审查清单进行分析

审查清单包括：

代码是否简洁可读
命名是否规范
是否存在重复代码
是否正确处理错误
是否有敏感信息暴露（API Keys 等）
是否进行了输入验证
测试覆盖率是否足够
性能是否合理

子代理文件存放位置：

项目目录/.claude/agents —— 项目专属代理

~/.claude/agents —— 用户目录（全局可用）

Hooks钩子事件：自动化工作流

Claude Code 还支持 Hooks（钩子），允许你在特定事件发生时执行自定义命令，提升自动化能力。

支持的Hook事件

PreToolUse：工具调用之前运行（可拦截）
PostToolUse：工具调用完成后运行
UserPromptSubmit：用户输入提示时运行（Claude处理前）
Notification：Claude Code 发送通知时运行
Stop：Claude Code 完成响应时运行
SubagentStop：子代理任务完成时运行

常见的Match类型：

Task - 子代理任务
Bash - Shell 命令
Glob - 文件模式匹配
Grep - 内容搜索
Read - 文件读取
Edit、MultiEdit - 文件编辑
Write - 文件写入
WebFetch、WebSearch - Web 操作

钩子文件配置存放在：

.claude/settings.json - 项目设置
~/.claude/settings.json - 用户设置
.claude/settings.local.json - 本地项目设置（不提交）

示例：自动格式化TypeScript文件

以下 Hook 会在代码编辑后，自动调用 Prettier 格式化 .ts 文件：

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|MultiEdit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | { read file_path; if echo "$file_path" | grep -q '\.ts$'; then npx prettier --write "$file_path"; fi; }"
          }
        ]
      }
    ]
  }
}

三、Claude Code的高效使用之道

通过合理使用 模型选择、项目初始化、对话管理、子代理和Hooks，你可以将 Claude Code 打造成一个 专业的AI开发助手。

新手开发者：快速上手，提高代码产出效率
高级工程师：借助子代理与Hooks，实现代码审查与自动化工作流

Claude Code 不只是一个 AI编程工具，更是一个 可扩展的开发平台，能够显著提升你的开发体验。

云计算高可用架构部署指南：从 L1 到 L4 的完整实战与复现步骤

Fri, 15 Aug 2025 00:00:00 GMT

本文是一篇云计算高可用架构部署指南，详细记录了从单节点到 L4 全面高可用架构的构建过程。无论你是运维工程师、开发者还是学习者，都可以根据本文的步骤，使用 LNMP 技术栈完成 Web 层、数据库层和存储层的高可用部署与验证。本指南以可复现为目标，涵盖命令、配置、验证方法及常见问题解决方案，帮助你快速掌握云计算高可用架构的落地实践。

前置条件与约定

系统：CentOS Stream 9（等价 RHEL9 系）

软件栈：Nginx + PHP-FPM + WordPress、MariaDB、HAProxy、Keepalived、MaxScale、GlusterFS

角色与示例 IP（可按需替换）：

角色	主机名	示例 IP
Web01	`web01`	`59.110.162.172`
Web02	`web02`	`154.9.253.137`
LB/HAProxy + Keepalived	`lb01`	`（自定）`
VIP	-	`155.133.7.217`
DB 主	`db01`	`47.94.105.235`
DB 从	`db02`	`52.77.217.186`
MaxScale	`maxscale01`	`38.22.95.209`
NFS/Gluster 节点 A	`nfs01`	`1.94.131.251`
NFS/Gluster 节点 B	`nfs02`	`154.64.254.91`

变量化建议（每台主机都可先写入）：

# -- 根据你的环境修改 --
export WEB_ROOT=/var/www/html/wordpress
export UPLOADS=$WEB_ROOT/wp-content/uploads
export DB_NAME=wordpress
export DB_USER=wpuser
export DB_PASS='StrongPassword123'   # 生产请改强口令
export DB_HOST=47.94.105.235        # L3 后将指向 MaxScale
export VIP=155.133.7.217

通用约定

若无特别说明，命令均以 root 身份执行（或前置 sudo）。
防火墙与 SELinux：实验环境可放宽；生产必须最小化放行并保留 SELinux（见文末加固）。
分阶段验收：每个阶段完成后务必跑完“验证清单”，否则不要进入下一阶段。

阶段总览（L1→L4）

L1：搭建 LNMP + 单节点 MariaDB + NFS 共享，确保 WordPress 正常运行与媒体可写。
L2：新增一台 Web，使用 HAProxy 轮询 + Keepalived 提供 VIP，对外统一入口，保障 Web 层故障不影响访问。
L3：MariaDB 主从复制，前置 MaxScale（读写分离 + 自动故障切换），数据库层去单点。
L4：以 GlusterFS 副本卷替换单点 NFS，文件读写具备副本冗余与自愈能力。

L1 基础架构：单 Web + 单 DB + 单存储

目标

WordPress 可安装访问；
图片/附件可上传（写入共享目录）；
Web ↔ DB 连通，账号授权正确；
NFS 挂载持久化。

实施步骤

1）Web：Nginx + PHP-FPM + WordPress

# 基础工具
sudo dnf -y update && sudo dnf -y install vim wget curl net-tools firewalld
sudo systemctl enable --now firewalld
sudo firewall-cmd --add-service=http --permanent
sudo firewall-cmd --add-service=https --permanent
sudo firewall-cmd --reload

# Nginx + PHP 组件
sudo dnf -y install nginx
sudo systemctl enable --now nginx
sudo dnf -y install php php-fpm php-mysqlnd php-gd php-json php-mbstring php-xml php-zip php-curl php-opcache

# 统一 PHP-FPM 运行用户为 nginx
sudo sed -i 's/^user =.*/user = nginx/' /etc/php-fpm.d/www.conf
sudo sed -i 's/^group =.*/group = nginx/' /etc/php-fpm.d/www.conf
sudo systemctl enable --now php-fpm

# WordPress 部署
sudo mkdir -p /var/www/html
cd /var/www/html
sudo wget https://cn.wordpress.org/latest-zh_CN.tar.gz
sudo tar -xzf latest-zh_CN.tar.gz && sudo rm -f latest-zh_CN.tar.gz
sudo mv wordpress $WEB_ROOT
sudo chown -R nginx:nginx $WEB_ROOT && sudo chmod -R 755 $WEB_ROOT

# Nginx 站点（最小可用）
cat <<'CONF' | sudo tee /etc/nginx/conf.d/wordpress.conf
server {
  listen 80;
  server_name _;
  root /var/www/html/wordpress;
  index index.php index.html;
  location / { try_files $uri $uri/ /index.php?$args; }
  location ~ .php$ {
    fastcgi_pass unix:/run/php-fpm/www.sock;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    include fastcgi_params;
  }
}
CONF
sudo nginx -t && sudo systemctl reload nginx

2）DB：MariaDB 安装与初始化

sudo dnf -y install mariadb-server
sudo systemctl enable --now mariadb
sudo mysql_secure_installation   # 按需设置 root 密码、清理匿名、允许/禁止远程

# 创建库与应用用户（将 host 限定为 Web01/02 的 IP 更安全）
mysql -uroot -p <<SQL
CREATE DATABASE IF NOT EXISTS ${DB_NAME} DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
CREATE USER IF NOT EXISTS '${DB_USER}'@'59.110.162.172' IDENTIFIED BY '${DB_PASS}';
GRANT ALL PRIVILEGES ON ${DB_NAME}.* TO '${DB_USER}'@'59.110.162.172';
FLUSH PRIVILEGES;
SQL

3）存储：NFS 共享（在 nfs01）

sudo dnf -y install nfs-utils
sudo systemctl enable --now nfs-server
sudo mkdir -p /mnt/wp-shared && sudo chown -R nobody:nobody /mnt/wp-shared && sudo chmod -R 777 /mnt/wp-shared
# 导出给 Web01（先从单机开始，L2 再加 Web02）
echo "/mnt/wp-shared 59.110.162.172(rw,sync,no_root_squash,no_subtree_check)" | sudo tee -a /etc/exports
sudo exportfs -arv

4）Web 挂载 NFS（在 web01）

sudo dnf -y install nfs-utils
sudo mkdir -p $UPLOADS
sudo mount -t nfs 1.94.131.251:/mnt/wp-shared $UPLOADS
# 持久化
echo "1.94.131.251:/mnt/wp-shared $UPLOADS nfs defaults,_netdev 0 0" | sudo tee -a /etc/fstab
sudo mount -a && df -h | grep wp-content

5）运行安装向导

访问 http://<web01 公网IP>/ 完成 WordPress 安装；
如提示无法创建 wp-config.php，则在 $WEB_ROOT 手动创建并设置权限：

sudo chown nginx:nginx $WEB_ROOT/wp-config.php && sudo chmod 640 $WEB_ROOT/wp-config.php

验证清单（必须全部通过）

浏览器能打开首页与后台；
新建文章可保存；
媒体上传成功，文件落在 nfs01 的 /mnt/wp-shared；
重启 web01 后 NFS 仍自动挂载（/etc/fstab 生效）。

常见坑 & 快速修复

上传失败/没有写权限：统一 php-fpm 运行用户与目录属主为 nginx。
DB 拒绝访问：确认 GRANT 中的来源主机是 Web 的实际 IP；开放 3306。

回滚建议

站点不可用时：nginx -t 校验；回退 conf.d/wordpress.conf 的最近改动；从 NFS 切回本地目录（改 root）以应急只读访问。

L2 Web 层高可用：双 Web + 负载均衡 + VIP

目标

两台 Web 等价提供服务；
HAProxy 轮询转发并健康检查；
Keepalived 提供对外唯一入口（VIP），主备漂移无感。

实施步骤

1）准备 web02

同步 web01 的 Nginx/PHP/WordPress 版本与站点目录结构；
追加 NFS 导出（在 nfs01）：

echo "/mnt/wp-shared 154.9.253.137(rw,sync,no_root_squash,no_subtree_check)" | sudo tee -a /etc/exports
sudo exportfs -arv

web02 挂载 NFS 并持久化：

sudo mkdir -p $UPLOADS
sudo mount -t nfs 1.94.131.251:/mnt/wp-shared $UPLOADS
echo "1.94.131.251:/mnt/wp-shared $UPLOADS nfs defaults,_netdev 0 0" | sudo tee -a /etc/fstab
sudo mount -a
sudo chown -R nginx:nginx $UPLOADS

2）HAProxy（lb01）

sudo dnf -y install haproxy firewalld && sudo systemctl enable --now firewalld
sudo firewall-cmd --permanent --add-port=80/tcp && sudo firewall-cmd --reload
cat <<'HAP' | sudo tee /etc/haproxy/haproxy.cfg
global
  log /dev/log local0
  maxconn 2048
  daemon

defaults
  log global
  option httplog
  option dontlognull
  timeout connect 5s
  timeout client 30s
  timeout server 30s

# 健康检查：建议提供 /health.php 返回 200 nfrontend http_front
  bind *:80
  mode http
  default_backend web_servers

backend web_servers
  balance roundrobin
  mode http
  option httpchk GET /health.php
  server web01 59.110.162.172:80 check
  server web02 154.9.253.137:80 check
HAP
sudo haproxy -c -f /etc/haproxy/haproxy.cfg && sudo systemctl restart haproxy

在两台 Web 根目录添加 health.php：

cat <<'PHP' | sudo tee $WEB_ROOT/health.php
<?php http_response_code(200); echo "OK"; ?>
PHP
sudo chown nginx:nginx $WEB_ROOT/health.php

3）Keepalived（lb01 与备份 lb02 可选）

sudo dnf -y install keepalived
cat <<KV | sudo tee /etc/keepalived/keepalived.conf
vrrp_instance VI_1 {
  state MASTER
  interface eth0              # 按网卡名调整
  virtual_router_id 51
  priority 100
  advert_int 1
  authentication { auth_type PASS; auth_pass 1234; }
  virtual_ipaddress { ${VIP} }
}
KV
sudo systemctl enable --now keepalived

注意：域名访问：移动端浏览器常对 http + IP 做限制，建议绑定域名到 VIP，再配合 HTTPS。

验证清单

访问 VIP 可见站点；
停止 web01 的 Nginx：systemctl stop nginx，请求应自动切到 web02；恢复后回到轮询；
访问 /health.php 返回 OK；
Nginx 不再出现默认首页（如有，删除 default_server）。

常见坑 & 快速修复

只显示默认页：检查 /etc/nginx/nginx.conf 是否启用了 default_server；确保 conf.d/wordpress.conf 生效。
手机访问不了 VIP：用域名访问，或直接开启 HTTPS；排除运营商劫持。

回滚建议

临时下线某台 Web：在 HAProxy 将其 disabled 或 weight 0；
HAProxy 故障：将域名临时指回 Web01 公网 IP 做直连（降级架构）。

L3 数据库高可用：主从 + MaxScale 自动切换

目标

MariaDB GTID 主从复制；
MaxScale 自动探测主库并读写分离；
主库宕机后，从库接管写入，站点无感继续运行。

实施步骤

1）主库（db01）开启 GTID 与 binlog

cat <<'CNF' | sudo tee /etc/my.cnf.d/mariadb-server.cnf
[mysqld]
server-id=1
log-bin=mysql-bin
binlog-format=mixed
gtid_strict_mode=ON
CNF
sudo systemctl restart mariadb

创建复制与监控用户（注意来源主机限制）：

CREATE USER IF NOT EXISTS 'repl'@'%' IDENTIFIED BY 'replpass';
GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';

CREATE USER IF NOT EXISTS 'maxuser'@'38.22.95.209' IDENTIFIED BY 'maxpass';
GRANT REPLICATION CLIENT, REPLICATION SLAVE, SLAVE MONITOR, READ_ONLY ADMIN ON *.* TO 'maxuser'@'38.22.95.209';

2）从库（db02）配置复制

cat <<'CNF' | sudo tee /etc/my.cnf.d/mariadb-server.cnf
[mysqld]
server-id=2
log-bin=mysql-bin
binlog-format=mixed
gtid_strict_mode=ON
CNF
sudo systemctl restart mariadb

# 和主库对齐数据（推荐使用 --single-transaction 方式导入主库导出）
# 导入完成后：
mysql -uroot -p -e "STOP SLAVE; CHANGE MASTER TO MASTER_HOST='47.94.105.235', MASTER_USER='repl', MASTER_PASSWORD='replpass', MASTER_USE_GTID=slave_pos; START SLAVE;"
mysql -uroot -p -e "SHOW SLAVE STATUSG"   # 两项都 YES

3）MaxScale（maxscale01）读写分离与故障切换

# 安装
curl -sSL https://downloads.mariadb.com/MariaDB/mariadb_repo_setup | sudo bash
sudo dnf -y install maxscale && sudo systemctl enable --now maxscale

# 开放 3306
sudo firewall-cmd --permanent --add-port=3306/tcp && sudo firewall-cmd --reload

# 配置
cat <<'MS' | sudo tee /etc/maxscale.cnf
[maxscale]
threads=auto

[replication_monitor]
type=monitor
module=mariadbmon
servers=db1,db2
user=maxuser
password=maxpass
monitor_interval=2000ms
auto_failover=true
auto_rejoin=true
enforce_read_only_slaves=true

[Read-Write-Service]
type=service
router=readwritesplit
servers=db1,db2
user=wpuser
password=StrongPassword123
max_slave_connections=1

[Read-Write-Listener]
type=listener
service=Read-Write-Service
protocol=MariaDBClient
port=3306

[db1]
type=server
address=47.94.105.235
port=3306
protocol=MariaDBBackend

[db2]
type=server
address=52.77.217.186
port=3306
protocol=MariaDBBackend
MS

sudo systemctl restart maxscale
maxctrl list servers

4）Web 指向 MaxScale

在两台 Web 的 wp-config.php 中，将 DB_HOST 改为 maxscale01 的地址（或其 IP 38.22.95.209）。

验证清单

maxctrl list servers：主/从角色识别正确；
关闭主库 systemctl stop mariadb 后，文章发布/评论仍成功；
恢复主库后，写入自动回切（或保持从库为主视实际策略）。

常见坑 & 快速修复

MaxScale 无法监控：maxuser 权限不足（需 SLAVE MONITOR、READ_ONLY ADMIN）。
应用仍连不上：为 wpuser 针对 MaxScale 来源 IP 单独授权；必要时给予只读 mysql.* 的 SELECT 以支持认证流程。
GTID 不一致：在从库按需 SET GLOBAL sql_slave_skip_counter = 1 跳过出错事务后 START SLAVE（谨慎用，记录变更）。

回滚建议

MaxScale 故障：临时把 DB_HOST 指回主库；
复制链路异常：停止写入→备份→重新全量同步（mysqldump --single-transaction）。

L4 存储高可用：GlusterFS 副本卷

目标

以 GlusterFS 副本卷（replica 2）替代单点 NFS；
任一存储节点宕机，Web 侧文件读写不受影响；
故障恢复后自动愈合（heal）。

实施步骤

1）两节点部署 & 互信（nfs01/nfs02）

sudo dnf -y install glusterfs-server firewalld
sudo systemctl enable --now glusterd firewalld
sudo firewall-cmd --permanent --add-service=glusterfs && sudo firewall-cmd --reload

# 互信（在 nfs01 执行）
sudo gluster peer probe 154.64.254.91
sudo gluster peer status

# 创建砖与卷目录
sudo mkdir -p /gluster/wp-shared

# 创建副本卷并启动（在 nfs01）：
sudo gluster volume create wp-shared replica 2 1.94.131.251:/gluster/wp-shared 154.64.254.91:/gluster/wp-shared force
sudo gluster volume start wp-shared
sudo gluster volume info wp-shared

2）Web 节点挂载 Gluster 卷

sudo dnf -y install glusterfs-fuse
sudo umount $UPLOADS || true
sudo mount -t glusterfs 1.94.131.251:wp-shared $UPLOADS
# 持久化
sed -i '#wp-content/uploads#d' /etc/fstab
echo "1.94.131.251:wp-shared $UPLOADS glusterfs defaults,_netdev 0 0" | sudo tee -a /etc/fstab
sudo mount -a && df -h | grep wp-content
sudo chown -R nginx:nginx $UPLOADS

3）故障与自愈测试

# 模拟 nfs01 故障
sudo systemctl stop glusterd
# Web 节点继续写入
sudo sh -c "echo test-$(date +%F-%T) > $UPLOADS/ha-test.txt"
# 恢复并检查愈合
sudo systemctl start glusterd
sudo gluster volume heal wp-shared info

验证清单

单节点停机期间，上传/新增媒体仍成功；
恢复后 heal 无异常 pending 条目；
文件权限保持 nginx:nginx，无 403/写入失败。

常见坑 & 快速修复

peer 状态不一致/卷创建失败：确保两端 glusterd 已启动、端口放通，必要时 gluster peer detach 后重建；
权限问题：存储端保证砖目录可访问（nobody:nobody/755），Web 侧挂载点保留 nginx 属主。

回滚建议

临时回退到 NFS：修改 /etc/fstab 为 NFS 行并 mount -a；
卷严重异常：停止业务写入，备份数据后重建卷。

统一故障排查方法论（4 步）

日志优先：Nginx/PHP/MariaDB/HAProxy/MaxScale/Gluster 各自错误日志定位根因。
分层验证：网络连通（telnet/curl）→ 单点服务 → 组合链路。
权限一致：进程用户与目录属主一致；数据库授权匹配来源主机；
配置优先级：注意默认配置覆盖（如 default_server）。

附：实验手册

task_report

官方文档

【Unity 入门】逃离国内特供版，Unity国际版安装流程！！

Tue, 08 Jul 2025 00:00:00 GMT

一、Unity 介绍

Unity 是由 Unity Technologies 开发的一个功能强大的跨平台游戏引擎和实时内容开发平台。它不仅仅用于制作游戏，还广泛应用于建筑可视化、工业仿真、影视动画、虚拟现实（VR）和增强现实（AR）等领域。

其优秀的跨平台能力深受开发者热爱，其组件化系统使游戏逻辑的修改更加直观便捷。提供随时试玩的功能，以及优秀且丰富的商店资源。

二、Unity 的下载与安装

首先，前往Unity国际版下载站，选择长期支持版（即Unity6.0）下载。

下载完成之后，双击exe文件运行。

点击Next（下一步）即可，接着同意用户协议点击Next（下一步），继续选择Next（下一步），此处需要选择安装位置，默认是在C盘，你可以更改到其他盘以保障系统运行速度。

等待其安装完毕。桌面会多出一个Unity6的应用图标，双击打开。

其要求一个激活证明，而获取证明有要求你下载Unity Hub。下载链接：点击下载Unity Hub

双击打开所下载的exe文件，同意用户协议后，点击下一步，完成Unity Hub的安装。

打开之后，选择注册新账户，即下图的Create account

之后跳转到浏览器打开一个，选择网页上的Sign Up。

输入你的邮箱，并设置用户名、密码。如下图，点击Sign Up。因网站使用谷歌验证码，故需要挂梯子。

之后会要求验证邮箱，前往邮箱的收件箱后进行验证邮箱。之后登录你注册的账号并同意条款。

注意上面打开Unity Hub之前要把梯子（Tun）模式打开，不然后面会要求你绑定手机号。

接着回到Unity Hub点击Sign in登录你的账户，之后选择定位已存在的安装。导航到你刚刚的安装目录下的Unity.exe即可。

至此Unity 国际版的安装到此结束。

三、总结

本文首先简短地介绍了Unity，接着详细补充了Unity引擎在Windows系统下的安装，以及许可证的获取（账号的注册）教程。

【个人感悟】蓝图之上：我的第一份游戏草案，与一场自我回响

Mon, 30 Jun 2025 00:00:00 GMT

一、引言：被故事点燃的火花

一切的开始，源于一款互动电影游戏通关后绵长的余味。它用动人的剧情、鲜活的角色和深邃的哲学思辨，在我心中刻下了一道难以磨灭的印记。它让我如此真切地意识到，冰冷的代码竟能承载厚重情感与复杂人性的诗篇。正是这种对剧情深度沉浸、对选择力量痴迷的特质，让一个念头在那一刻破土而出，强烈得无法抑制——我也要创造一个属于自己的故事世界，一个可以被触摸、被感知、被他人踏入的天地。

那一次被故事点燃的火花固然是引信，但最核心的驱动引擎，始终是深植于我心底那份近乎本能的、对故事编织与创造本身的热爱。这便是我第一次踏上游戏开发之旅的全部行囊：一个被点燃的炽热梦想，满腔沸腾的热血，以及一丝新手上路时特有的、笨拙却无比真诚的莽撞。

二、起点：一份草案，两个平行的世界

翻开那份最初的游戏草案，它们早已蜕变成一张时间的切片，一枚尘封的记忆胶囊，忠实地保存着我作为“造梦主”，最初与那个虚构世界相遇时怦然的心跳。

也正是在这反复的回溯与凝视中，一个惊人的发现逐渐清晰：我们呕心沥血创造游戏的过程，与我们笔下精心构建的那个游戏世界本身，竟是两个相互映照、彼此深刻回响的平行时-空。而那份最初的草案，正是连接这两个宇宙的唯一、珍贵的蓝图。

三、设计的镜像：在创造中扮演自己设计的角色

回望这份蓝图，我惊觉：一份游戏草案所勾勒的核心体验，往往在无意间，成为了开发团队自身历程最真实的自传。

这镜像，绝非简单的形式对应，而是生命经验的深度共振。 它揭示了创作最核心也最迷人的悖论：我们既是游戏世界的“神”（创造者），也成为了被自身所造规则深刻塑造的“人”（体验者）。

四、结语：未完待续的梦

最终，我们渴望玩家在《梦》的世界里，能深切体味友情、责任与宿命的千钧之重。而对于我们这些幕后的“造梦者”而言，那份最初的、或许稚嫩却无比鲜活的草案本身，就是我们共同书写的友情、肩负的责任与共赴的宿命最坚实的物证。它记录了我们如何从一个被故事点燃的微小念头开始，以代码为砖瓦，以创意为梁柱，以无数个日夜的汗水与争论为粘合剂，一步步将虚无缥缈的“梦境”，夯筑成一个他人可踏入、可触摸、可与之共鸣的真实世界。

我想，这便是游戏开发最令人心醉神迷的魔力所在——我们既是那个在虚构谜团中孤独求索的“解梦侦探”，也是一群在现实荆棘路上携手同行的伙伴；我们呕心沥血地创造着关于“梦”的史诗，同时，也鲜活地活在自己奋力“造梦”的伟大故事里。

而这个故事，才刚刚开始…..

【KVM开源虚拟化】KVM虚拟化环境的详细配置与远程管理

Sat, 03 May 2025 00:00:00 GMT

一、环境准备

VMware Workstation Pro（官网下载）

前往VMware官网，点击右上角搜索框，输入Hypervisor，

选择Product目录下的Fusion and Workstation，点击下图中的DOWNLOAD FUSION OR WORKSTATION

后会弹出登录界面，如果没有账号就自己注册一个。之后点击Free Software Downloads available HERE

双击打开安装程序，完成安装向导即可。

二、KVM安装

前往华为镜像站点，https://mirrors.huaweicloud.com/centos/7/isos/x86_64/

选中以上镜像下载。

通过VMware Workstation 安装镜像，设置硬盘大小为80GB，勾选CPU选项中的虚拟化（第一个与第三个）去除USB和声卡。使用图形化安装向导，选择软件源安装-虚拟化安装-勾选虚拟平台安装，在网络连接中设置主机名为KVM1，设置root密码后选中开始安装。

根目录生成的anaconda-ks.cfg文件，可用于快速安装配置虚拟机。

在刚开始的安装bios菜单界面，按下tab 键，输入ks=xxx（FTP文件服务器上上传的ks文件地址。）后回车。可以使用kickstart快速安装。

目前CentOS 7官方软件源已经停止维护。可以换为华为源，使用

wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.huaweicloud.com/repository/conf/CentOS-7-anon.repo

之后通过

yum groupinstall "GNOME Desktop" -y

安装桌面环境。使用

yum install -y qemu-kvm libvirt virt-install bridge-utils virt-manager

安装核心组件。

使用 systemctl enable libvirtd --now 启动并设置libvirtd服务。

三、KVM的远程管理

通过三种方式：ssh、VNC、X-Windows
VNC：通过

yum install -y tigervnc-server

安装服务端，

vncserver

启动vnc服务端并设置密码，前往realvnc.com下载客户端。
连接之前，注意使用命令：

firewall-cmd --permanent --add-port=5901/tcp
firewall-cmd --reload

放行 5901 端口。

地址格式：IP:[第几个VNC服务器]，一般从1开始。其他选项保持默认即可，用户名不用填写，密码为你设置的密码

第二个vnc 对应服务端的端口5902…以此类推
通过X-windows方式：

X-Windows：前往https://sourceforge.net/projects/xming/下载 Xming，在PuTTY 终端连接软件选择connection->SSH->X11，在X11 forwarding里面选择 Enable X11 forwarding, X display location输入的是：localhost:0，不输入也可以。输入要启动图形界面的软件即可。

四、总结

本文首先介绍了如何下载VMware Workstation Pro，接着指出了配置CentOS 7虚拟机的具体过程。

最后又介绍了远程管理KVM的两种办法。

【学习记录】Linux用户基础课程课程笔记（一）

Tue, 22 Apr 2025 00:00:00 GMT

一、用户和组

用户概念：每个用户都有唯一的用户名和密码，包括ID。

用户权限分析：分析普通用户和超级用户（ROOT）

用户组的概念：将用户分组以简化权限管理。

Root用户的ID一般为0，普通用户的ID从500记起。用户的配置文件再在etc/passwd，密码存在于/etc/shadow，用户组的相关信息则存在于/etc/gshadow.

二、系统帮助

获取帮助的三种形式：

whatis date : 简短地介绍date的用法
--help ：输出一些常见指令的用法
man ：完全打印出该命令的用法

man指令的常见用法：

man 1 ls ：查看关于ls命令的帮助文档。1代表章节，ls表示要查看的命令。

以下为常见章节
1、  一般命令
2、  系统调用
3、  库函数，涵盖C标准函数库
4、  特殊文件（通常是/dev中的设备）和驱动程序
5、  文件格式和约定
6、  游戏和屏保
7、  杂项
8、  系统管理命令和守护进程。

我们可以通过指令whereis来查看具体我们要查询哪一章内容，如下图：

表示我们需要查询第一章节的内容

三、常用命令

常见命令如下

ls ：列出目录内容。
cd ：切换目录
pwd： 显示当前工作目录
mkdir：创建目录
rm ：删除文件或目录
cp ：复制文件或目录
mv ：移动或者重命名文件与目录
cat： 查看文件内容
touch : 创建空文件或更新文件时间戳
chmod：修改文件权限
chown ：修改文件所属者与用户

PS:rm删除指令与cp复制指令，如果要复制/删除一个目录，你需要在后边加上-r递归参数以操作文件夹。

四、文件系统

Linux文件系统层次结构

/：根目录。
/bin：存放系统二进制可执行文件。
/etc：存放系统配置文件。
/home：用户主目录。
/lib：存放库文件。
/tmp：临时文件目录。
/var：存放可变数据（如日志文件）。
/usr：存放用户程序和数据。
/boot：存放启动文件。

一些重要的目录结构：

/usr/bin /usr/sbin 存放可执行二进制文件 /var主要存放可变数据文件。

五、基本权限

1.基本权限

文件和目录的权限分为三类：主（onwer）组（group）其他用户（others）

权限类型：读（R）写 (W) 执行(X)

2.设置基本权限

使用chmod命令设置权限
- 数字模式：如 chmod 755 file
- 符号模型：如 chmod u+rwx,g+rx,o+x file
解释权限的具体含义：
属主权限：文件所有者可以进行的操作。
属组权限：同组用户可以进行的操作。
其他用户权限：非属主和非属组用户可以进行的操作。

六、文本编辑工具

Vi /Vim 编辑器

模式切换：命令模式、插入模式、末行模式

常用指令如下：

i ：进入插入模式
Esc ：退出插入模式
:wq 保存并退出
:q! ：不保存退出
dd ：删除当前行内容
yy：复制当前行内容
p： 粘贴

【经验分享】VS Code Java环境配置：详细步骤与高频问题解决方案

Fri, 21 Mar 2025 00:00:00 GMT

VS Code Java

JDK安装

一、VS Code的下载与安装

VS Code官网：https://code.visualstudio.com/
安装VS Code，建议将勾上全部的附加任务。

二、JDK开发者工具的下载

下载页面 https://www.oracle.com/java/technologies/downloads/
根据自己的实际情况选择系统、版本
这里以Windows11 64位系统 Java SE Development Kit 8u441作为演示

点击下载后，会要求登录甲骨文账号才能继续下载。如果你不想登录甲骨文，我在下方附有我使用的JDK网盘地址（稍后更新在评论区），你可以通过网盘下载

三、JDK开发者工具的安装

一直点击下一步，直到完成以上安装向导。

注意：一共需要选择两次安装路径，第一次是JDK的安装路径，第二次是JRE运行环境的安装路径。

四、VS Code中相关插件的安装

选择VS Code最左边的第五个扩展栏商店菜单，在搜索框中输入“Java”，选择安装以下拓展

五、运行代码与一些可选设置

我们以下边儿这个代码作为测试

public class test {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

可以看到已经运行成功了。

可选设置：

如果你想要在终端中运行你所编译的程序，请在launch.json（可选择第4个选项卡里的快速找到该json文件）中作出如出如下编辑
在configurations配置选项中新增一项：
" console " : " externalTerminal "
注意：json语法要求在每个配置项之间添加“,”同时不允许最后一个配置项末尾出加“,”。

六、总结

在Vs code中配置Java环境的过程难度并不是很大，但需要注意一些操作的细节。

本文出于记录目的，不保证本人的操作可在您的电脑上使用，转载请保留出处。

【经验分享】Windows与Ubuntu双系统安装教程：从零开始的完整步骤

Sun, 26 Jan 2025 00:00:00 GMT

一、事前准备与要求

至少8g内存的u盘
善用搜索引擎解决问题的你

二、安装步骤

1. 下载系统镜像

前往乌班图系统官网下载桌面版镜像，如下图

选择下载24.04.1（最新版本），等待系统下载完毕。

2. 将系统镜像写入U盘

前往Refus官网下载写盘工具，按照如下操作将系统镜像写入U盘。

Device选择你的u盘，boot section选择你刚刚下载你的乌班图系统镜像。

注意：此操作会清楚u盘内的全部数据，请您提前备份，以免丢失重要数据。

3. 磁盘分区

装新系统肯定需要单独的磁盘分区空间，以下为磁盘分区过程

右键开始按键（Windows徽标），选中磁盘管理。随机选取一个空间大磁盘，右键，如下图

选择压缩卷，请至少压缩出25g的硬盘空间。

4. 安装

进入Windows设置，选中系统-恢复选项卡，选择高级启动后面的重新启动，插入u盘，选择从u盘启动

之后按照乌班图的系统安装向导就OK了。之后每次启动都会让你选择启动哪个系统，按需选择即可

三、常见问题

Q: 如何让系统盘恢复正常呢？

A：可以参考以下视频

本文来自：https://www.jiepress.cn/

转载请附上地址，感谢配合。

【实用工具分享】RVC 变声器（AI翻唱制作工具）的使用教程

Thu, 26 Dec 2024 00:00:00 GMT

注意：请只在获得授权的声音素材、模型和作品范围内使用 RVC。不要用它冒充他人、复刻未授权声音、发布侵权翻唱或进行商业化传播；涉及真人声纹、公众人物、音乐作品和训练素材时，应优先确认版权、肖像权、人格权和平台规则。

一、前言

本次使用由GitHub大佬RVC-boss制作的开源声线检索替换技术，它是一款易于使用的AI 翻唱工具，AI变声器

GitHub 项目：RVC-Project/Retrieval-based-Voice-Conversion-WebUI

为什么选择RVC？

RVC的操作对于新手较为友好。同时官方制作的有一键整合包，可以跳过繁琐的配置环境过程。RVC的推理与训练模型界面，官方都提供了可视化操作界面，支持一键傻瓜式训练模型。

二、准备

数据集的准备与清洗

先从网络上搜集目标人物10分钟左右的音频素材，要求：情绪丰富、杂音少、声音清晰。不要闷闷的。注意将目标人物的音频素材转换为WAV格式（无损）。

准备好数据集之后就是对数据集的进一步处理，这里我推荐使用The Ultimate Vocal Remover Application（可能因网络因素导致下载过慢，当然此处也提供网盘下载地址）对素材中的杂音进行进一步处理，以下是常用的处理步骤：

网盘链接：https://pan.baidu.com/s/1Bs6W7h0IUvdMNFZfNytw0Q?pwd=e7ag 提取码：e7ag

选择你已经处理好的素材文件，首选选中“MDX-NET”模型种类，并勾选“GPU Conversion”，在“CHOOSE MDX-NET MODEL”中选择“MDX23C-InstVoc HQ”，之后点击“Start Processing”，接着选择“VR Architecture”模型种类，接着选用UVR-De-Echo-Normal UVR-De-Echo-Aggressive UVR-De-Echo-Dereverb三种模型其一去除混响。依旧点击“Strat Processing”以上操作过程中的参数保持默认即可。

UVR5程序主界面

一般情况下，数据集经过以上步骤处理之后都会变得相对较为干净。

整合包的下载

这里提供官方的一键整合包下载地址：

链接：https://pan.baidu.com/s/1Vyj_pSf5EDXpZyRYyorCVg?pwd=i72q 提取码：i72q

根据你的显卡类型下载相应版本，AMD显卡或者英伟达显卡

下载之后解压到一个你新建的文件夹内。

三、模型的训练

首先双击文件夹内的go-web.bat文件，弹出一个弹窗选择允许Python访问网络。

RVC程序主界面

弹出如上图所示的webui界面，选择第三个选项卡（训练）按照如下图配置填写。

RVC程序操作说明

在CMD窗口等待训练完成（黑框框），没有新的epoch轮次出现即可。

之后可以选择第一个选项卡，进行推理。（AI翻唱制作）

模型默认的保存文件夹在…/RVC1006Nvidiaassetsweights

四、虚拟声卡的配置（变声器适用）

先前往https://voicemeeter.com/，选择STANDARD版本下载，安装打开并留存到后台

Voice meeter程序主界面

在系统声音设置中按如下设置

进行电脑麦克风配置

关闭cmd黑框框，双击RVC1006Nvidia根目录下的go-realtime-gui.bat。出现如下gui，按照下图配置

变声器gui界面配置

至此，变声教程到此结束。

如果点击开始音频转换，提示未响应。请切换至以下版本

链接：https://pan.baidu.com/s/1N2yheyWo8i91JgRcn5mU0w?pwd=58e7 提取码：58e7

【经验分享】免费好用的CDN——jsDelivr

Mon, 23 Dec 2024 00:00:00 GMT

CDN的全称是Content Delivery Network，即内容分发网络。CDN是构建在网络之上的内容分发网络，依靠部署在各地的边缘服务器，通过中心平台的负载均衡、内容分发、调度等功能模块，使用户就近获取所需内容，降低网络拥塞，提高用户访问响应速度和命中率。CDN的关键技术主要有内容存储和分发技术。——百度百科

今天介绍一个免费公用的CDN——jsDelivr

jsDelivr

jsDelivr可以代理GitHub仓库中的资源

实际使用中的访问速度也是比较快的：

与 GitHub 整合

仅仅如此其实并不够好，jsDelivr 还能够集成 GitHub、NPM 资源，只需要通过符合 jsDelivr 规则的 URL 引用，即可直接使用 GitHub 中的资源。

例如通过jsDelivr直接引用我GitHub仓库中的图片地址（示例仓库已删除，以下地址仅演示格式，已无法访问）：

原地址为：https://raw.githubusercontent.com/lj200612/mywebsite/refs/heads/master/1729668103-433.webp

引用后：

https://cdn.jsdelivr.net/gh/lj200612/mywebsite@refs/heads/master/1729668103-433.webp

以上链接可能会跳转至raw.githubusercontent.com域名，使用以下链接即可：https://gcore.jsdelivr.net/gh/lj200612/mywebsite@master/1729668103-433.webp

可通过以下地址转换：Migrate from GitHub to jsDelivr

也可遵照以下规则自行构造地址

构造规则说明

基本格式
https://cdn.jsdelivr.net/gh/用户名/仓库名@版本号/文件路径
- 用户名：GitHub 用户名。
- 仓库名：GitHub 仓库名称。
- 版本号：指定版本（分支、标签或提交哈希），可选。

具体说明如下：

// 用户名/仓库名@版本号/文件名
https://cdn.jsdelivr.net/gh/user/repo@version/file
// load jQuery v3.2.1
https://cdn.jsdelivr.net/gh/jquery/jquery@3.2.1/dist/jquery.min.js

// 使用一个范围内的版本
https://cdn.jsdelivr.net/gh/jquery/jquery@3.2/dist/jquery.min.js
https://cdn.jsdelivr.net/gh/jquery/jquery@3/dist/jquery.min.js

// 忽略版本号则默认使用最新版
// you should NOT use this in production
https://cdn.jsdelivr.net/gh/jquery/jquery/dist/jquery.min.js

// 在任意JS/CSS文件后添加 .min 能得到一个缩小版
// 如果它本身不存在，我们将会为你生成
https://cdn.jsdelivr.net/gh/jquery/jquery@3.2.1/src/core.min.js

// 在末尾加 / 则得到目录列表
https://cdn.jsdelivr.net/gh/jquery/jquery/

【风险提示】网课助手脚本的隐私与学术诚信风险

Thu, 19 Dec 2024 00:00:00 GMT

注意：本文已从原“网课助手配置教程”调整为风险提示与技术观察，不再提供自动听课、自动答题或规避平台学习要求的操作步骤。学习平台的任务应由本人完成，任何脚本自动化都可能违反课程、学校或平台规则。

为什么不建议使用网课自动化脚本

这类脚本通常通过浏览器扩展或油猴脚本接管页面行为，实现自动播放、自动提交、自动答题等功能。它们表面上节省时间，但实际风险很高，尤其不适合作为公开推荐工具。

主要风险

学术诚信风险：自动完成课程任务可能违反课程要求、学校纪律或平台服务条款。
账号安全风险：脚本通常可以读取页面内容、课程信息、登录态，甚至与第三方接口通信。
隐私泄露风险：部分脚本会上传题目、答案、用户环境信息或接口返回数据，普通用户很难确认其边界。
稳定性风险：平台改版后脚本可能失效，误提交、漏提交、异常请求都有可能留下记录。
责任不可控：即使脚本开源，也不代表每个安装来源、更新版本和远程依赖都是可信的。

技术上可以观察什么

如果只是从技术学习角度观察，可以关注浏览器扩展的权限模型、用户脚本的运行时机、前端接口请求、跨域通信、数据最小化原则和第三方脚本供应链风险。这些内容适合作为 Web 安全与隐私保护案例，而不是作为逃避学习任务的工具教程。

更稳妥的做法

课程任务尽量自己完成，把倍速、字幕、笔记和检索工具作为辅助，而不是替代。
不要把学校账号、课程页面和隐私数据交给来源不明的脚本。
确实需要自动化时，只在自己拥有权限的测试页面或本地环境中实验。
公开写作时，应优先说明风险和边界，避免给出可直接规避规则的步骤。

这篇文章保留为一次内容修订记录：早期写工具分享时更关注“能不能用”，现在更应该关注“该不该用、风险在哪里”。

【经验分享】C语言二维数组

Fri, 13 Dec 2024 00:00:00 GMT

一、二维数组的创建

1.二维数组的创建

type arr_name[常量1][常量2];

例如：
int arr[3][5];
double data[2][8];
char ch[][];

//3表示数组有三行，5代表数组每一行有5个元素。int代表数组中的元素为整数。

2.二维数组的初始化

像一维数组一样，同样使用大括号初始化

//不完全初始化，剩余元素默认为0；
int arr1[3][5] = {1,2};
int arr2[3][5] = {0};

//按照行初始化，第2，3，4列都为0；
int arr3[3][5] = {{1,2},{3,4},{5,6}}

//完全初始化
int arr4[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};

//初始化时候可以省略行，但是不能省略列
int arr4[][5] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};

二、二维数组的使用

3.二维数组的输入与输出

C语言规定数组的索引要从0开始，包括行与列

#include<stdio.h>
int main(){
 int arr[3][5] = {0};
 int i = 0;
 for(i = 0; i < 3; i++) {
 int j = 0;
 for (j = 0; i < 5; j++) {
 scanf("%d",&a[i][j]);
}
}
 for(i = 0; i < 3; i++) {
 int j = 0;
 for (j = 0; i < 5; j++) {
 printf("%d",a[i][j]);
}
 printf("n");
}
return 0;
}

三、实操练习

字符从两端移动，到中间汇聚

前提：

strlen求的是字符串的长度，统计的是字符串中/0之前的长度。

sizeof是数组所占内存空间的大小（单位是字节），包括/0。

#include<stdio.h>
#include<string.h>

int main() {
char arr1[] = "welcome to China!!!";
char arr2[] = "###################";
int left = 0;
int right = strlen(arr1) - 1;

while(left <= right) {
 arr2[left] = arr1[left];
 arr2[right] = arr1[right];
left++;
right--;
printf("%sn", arr2);
}
return 0;
}

输出以下

w#################!
we###############!!
wel#############!!!
welc###########a!!!
welco#########na!!!
welcom#######ina!!!
welcome#####hina!!!
welcome ###China!!!
welcome t# China!!!
welcome to China!!!

关于C99中的变长数组

在C99标准中，变长数组（Variable Length Arrays, VLA）是一种允许数组的大小在运行时动态确定的特性。与传统的静态数组不同，变长数组的大小不是在编译时确定，而是在程序运行时动态指定

#include <stdio.h>

void example(int n) {
    int array[n];  // n是一个运行时确定的值
    for (int i = 0; i < n; i++) {
        array[i] = i + 1;
    }
    for (int i = 0; i < n; i++) {
        printf("%d ", array[i]);
    }
    printf("n");
}

int main() {
    int size;
    printf("Enter the size of the array: ");
    scanf("%d", &size);
    example(size);
    return 0;
}

输入5输出1 2 3 4 5；

【MC服务器】使用Linux服务器搭建Forge服流程

Sun, 08 Dec 2024 00:00:00 GMT

一、前提

熟悉Linux的基础操作指令
拥有一台2h4g的服务器（最低配置要求）
能够熟悉运用搜索引擎解决问题

二、操作流程

1.Java环境的安装

这里以1.20.1版本为例，需要安装Java17。通过ssh连接到你的服务器，在终端执行以下操作

sudo apt update
sudo apt upgrade
sudo apt install openjdk-21-jdk-headless(感谢评论区指正)
sudo apt install openjdk-17-jdk-headless

2. Forge服务端的下载

前往Forge官网下载安装程序，选择Installer.

之后会被传送至一个广告页面，在该页面停留5秒。之后点击skip即开始下载。

注意：如果此处未出现skip按钮，请关闭您的广告拦截器。

3. Forge服务端的安装

新建一个文件夹（以minecraft为例），将刚刚下载的服务端上传至服务器。在终端执行以下命令

mkdir minecraft
cd minecraft
java -jar forge-1.20.1-47.3.12-installer.jar nogui --installServer

看到

The server installed successfully
You can delete this installer file now if you wish

则证明安装完成。

4. 启动Forge服务器

使用./run.sh第一次启动服务器。

之后前往服务端根目录eula.txt文件将false改为true。

再次使用./run.sh重启服务器。

注意：添加mod后，一定要重启Forge服务器以加载mods。

之后添加的mod文件放在mods文件夹内即可。

5. 使用screen使服务器24小时运行

参考本站之前这篇文章

三、特别注意

在安装过程中，国内服务器不能正常连接到Forge服务器。可以采用本地构建后再上传至服务端。

【学习记录】Python中的类与父类

Tue, 26 Nov 2024 00:00:00 GMT

一、类

类（Class）是面向对象编程中的一种蓝图或模板，用于创建具有相似属性和行为的对象

class 类名:
    def __init__(self, 参数1, 参数2, ...):
        self.属性1 = 参数1
        self.属性2 = 参数2

    def 方法名(self, 参数):
        # 方法逻辑

类的特点
封装：将属性和方法封装在一个类中。
继承：通过继承复用父类的代码。
多态：不同的类可以实现相同的方法，表现不同的行为

类的优点

提高代码复用性。
数据和功能封装在一起，便于维护。
易于扩展和实现复杂功能

# 定义一个类
class Student:
    def __init__(self, name, student_id):
        self.name = name
        self.student_id = student_id

    def greet(self):
        print(f"您好，我叫 {self.name}，我的学号是 {self.student_id}")

# 创建对象
student1 = Student("小陈", "114514")
student2 = Student("小曾", "1919810")

# 调用对象的方法
student1.greet()
student2.greet()

输出以下

您好，我叫 小陈，我的学号是 114514
您好，我叫 小曾，我的学号是 1919810

二、父类与子类

父类是一个类的基础模板，提供了子类可以继承的属性和方法。通过继承，子类能够复用父类的代码，并在其基础上扩展功能。父类的特点如下：

1.包含公共属性和方法，这些内容通常会被多个子类复用。
2.子类通过继承，可以直接使用父类的方法，也可以重写这些方法以实现自己的逻辑。

子类（Child Class）
子类是从父类派生出来的，它继承了父类的属性和方法，但可以添加自己的属性和方法。子类的特点如下：

1.继承父类的所有非私有属性和方法。
2.子类可以添加新的属性和方法，扩展父类的功能。
3.子类可以通过重写（override）父类的方法实现多态。

# 定义父类
class ShoppingList:
    def __init__(self, shopping_list):
        self.shoppinglist = shopping_list

    def get_item(self):
        print("获取到如下商品目录：")
        for item in self.shoppinglist.keys():
            print(item)

    def get_cost(self):
        print("获取到如下价格：")
        for cost in self.shoppinglist.values():
            print(cost)

    def all_cost(self):
        sum = 0
        for cost in self.shoppinglist.values():
            sum += cost
        print(f"这次的花费为{sum}")

# 定义子类
class Shop(ShoppingList):
    def __init__(self, shopping_list, shop_name, location):
        super().__init__(shopping_list)
        self.shop_name = shop_name
        self.location = location

    def print_info(self):
        print(f"店铺名字：{self.shop_name}")
        print(f"店铺地址：{self.location}")

# 使用父类
my_shopping_list = ShoppingList({"鼠标": 0, "键盘": 50, "硬盘": 5000})

# 使用子类
my_shopping_list2 = Shop({"鼠标": 0, "键盘": 50, "电源": 100}, "百货之家", "人民路向北一百米")

# 调用子类和父类的方法
my_shopping_list2.print_info()
my_shopping_list.all_cost()
my_shopping_list.get_cost()
my_shopping_list.get_item()

输出如下：

店铺名字：百货之家
店铺地址：人民路向北一百米
这次的花费为5050
获取到如下价格：
0
50
5000
获取到如下商品目录：
鼠标
键盘
硬盘

关于 子类可以通过重写（override）父类的方法实现多态。有下例

假设我们有一个Employee类，代表员工，其中有一个work()方法。然后，我们定义了两个子类：Manager和Engineer，它们都继承自Employee。Manager重写了work()方法，而Engineer使用父类的work()方法。

# 定义父类
class Employee:
    def __init__(self, name):
        self.name = name

    def work(self):
        print(f"{self.name} 正在工作！")

# 定义子类 Manager（经理）
class Manager(Employee):
    def __init__(self, name, department):
        super().__init__(name)  # 调用父类的初始化方法
        self.department = department

    # 重写父类的 work 方法
    def work(self):
        print(f"{self.name} 作为经理，正在管理 {self.department} 部门！")

# 定义子类 Engineer（工程师）
class Engineer(Employee):
    def __init__(self, name, specialty):
        super().__init__(name)
        self.specialty = specialty

    # 使用父类的方法
    def work(self):
        # 调用父类的工作方法，附加特定的工程师行为
        super().work()  # 使用父类的 work 方法
        print(f"{self.name} 作为工程师，专注于 {self.specialty} 的开发！")

# 创建员工对象
manager = Manager("张经理", "人力资源")
engineer = Engineer("李工程师", "软件")

# 调用方法
manager.work()  # 经理重写了 work 方法
engineer.work()  # 工程师调用了父类的 work 方法并做了扩展

输出以下

张经理作为经理，正在管理人力资源部门！
李工程师正在工作！
李工程师作为工程师，专注于软件的开发！

解释：

父类Employee：
- Employee类中有一个work()方法，表示员工正在工作。
子类Manager：
- Manager类继承自Employee，并重写了work()方法。重写的方法改变了工作逻辑，打印了经理在管理部门的消息。
子类Engineer：
- Engineer类也继承自Employee，并在work()方法中调用了父类的work()方法（通过super().work()），同时增加了额外的行为，表示工程师在专注于某项开发工作。

总结：

继承父类方法：子类可以直接使用父类的方法（如Engineer类中的super().work()）。
重写父类方法：子类也可以根据自己的需求重写父类的方法（如Manager类中的work()方法）。

通过继承和重写，子类能够灵活地扩展父类的功能，同时又能保留父类的一些通用行为，从而实现代码复用和功能扩展。

【学习记录】Python中的字典数据类型

Mon, 25 Nov 2024 00:00:00 GMT

Python 字典知识点总结

Python 中的字典（dict）是一种内置的数据结构，用于存储键值对（key-value pairs）。它是无序的（Python 3.7 开始保持插入顺序），并且支持快速的查找、插入和删除操作。

1. 创建字典

方法 1： 使用大括号 {} 定义：

grades = {"语文": 90, "数学": 80, "英语": 85}

方法 2： 使用 dict() 函数：

grades = dict(语文=90, 数学=80, 英语=85)

方法 3： 从键值对列表创建：

grades = dict([("语文", 90), ("数学", 80), ("英语", 85)])

2. 字典的基本操作

访问值

使用键访问对应的值：

grades = {"语文": 90, "数学": 80}
print(grades["语文"])  # 输出: 90

如果键不存在，会抛出 KeyError。可以用 get() 方法避免：

print(grades.get("英语", "未找到该科目"))

更新或新增键值对

grades["英语"] = 85  # 更新或新增键值对
print(grades)  # 输出: {'语文': 90, '数学': 80, '英语': 85}

删除键值对

del grades["数学"]  # 删除键为 "数学" 的键值对
print(grades)  # 输出: {'语文': 90, '英语': 85}

检查键是否存在

if "语文" in grades:
    print("语文成绩存在")

3. 遍历字典

遍历键

for key in grades:
    print(key)  # 输出: 语文 数学 英语

遍历值

for value in grades.values():
    print(value)  # 输出: 90 80 85

遍历键值对

for key, value in grades.items():
    print(f"{key}: {value}")  # 输出: 语文: 90 数学: 80 英语: 85

4. 字典常用方法

获取所有键、值或键值对

keys = grades.keys()     # 获取所有键：dict_keys(['语文', '数学', '英语'])
values = grades.values() # 获取所有值：dict_values([90, 80, 85])
items = grades.items()   # 获取键值对：dict_items([('语文', 90), ('数学', 80), ('英语', 85)])

合并字典

extra_grades = {"物理": 88, "化学": 92}
grades.update(extra_grades)
print(grades)  # 输出: {'语文': 90, '数学': 80, '英语': 85, '物理': 88, '化学': 92}

清空字典

grades.clear()  # 清空所有键值对

浅拷贝字典

grades_copy = grades.copy()

5. 字典的特点

键唯一：字典的键不能重复，如果出现重复，后面的值会覆盖前面的值。
```
grades = {"语文": 90, "语文": 95}
print(grades)  # 输出: {'语文': 95}
```
键必须是不可变对象：如字符串、数字、元组等。
```
invalid_dict = {[1, 2]: "list as key"}  # 报错：TypeError
```

6. 示例：学生成绩管理系统

# 定义字典
grades = {"语文": 90, "数学": 80, "英语": 85}

# 添加一门课程
grades["物理"] = 88

# 修改成绩
grades["数学"] = 95

# 删除课程
del grades["英语"]

# 遍历输出
for course, grade in grades.items():
    print(f"{course}: {grade}")

输出结果：

语文: 90
数学: 95
物理: 88

总结

字典是非常高效且灵活的数据结构，广泛用于实际编程中，例如存储配置、实现简单数据库、计数频率等。

【经验分享】VS Code配置C语言环境

Sat, 23 Nov 2024 00:00:00 GMT

1. 安装汉化插件

打开VS Code，在插件搜索输入框输入“Chinese”，搜索插件“Chinese (Simplified) Language Pack for Visual Studio Code”。点击install安装插件。如下图

2. 下载minGW64编译器

2.1 下载工具

先通过以下链接下载

https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/8.1.0/threads-posix/seh/x86_64-8.1.0-release-posix-seh-rt_v6-rev0.7z/download

解压以上压缩包，并记好路径。

2.2 配置环境变量

如下图，在电脑搜索栏搜索“编辑系统环境变量”

之后依次点击高级-环境变量，在用户变量选中‘Path’，后点击新建，输入你刚刚解压的文件路径，例如

D:\mingw64\bin

请将以上例子中的D:\mingw64替换成你解压的路径。

注意要包含bin，之后打开VS Code，在最上边的搜索栏搜索‘>’，选中c/c++编辑配置。在编译器选项这一栏输入你的编译器路径，例如

D:\mingw64\bin\gcc.exe

请将以上例子中的D:\mingw64替换成你解压的路径。

3. 测试运行

首先选中你想要编译的C语言代码程序，接着选择‘终端’-‘运行生成任务’。如下图

此时，你会发现当前目录多出了一个exe后缀的可执行文件，接着在终端输入./exe可执行文件的名字（包括后缀名），如下图，接着会发现程序正常运行。如下图

【书籍分享】蛤蟆先生去看心理医生

Wed, 20 Nov 2024 00:00:00 GMT

1. 前言

谁都有内心忧郁的时候。笔者去年年末面对高三庞大的压力，内心陷入十分沉重的情绪中，感到十分压抑。

为了缓解这种困扰，我寻求了很多关于心理学的书籍，希望能够慰藉自己。也是从那时候我喜欢上了读书。

像《被讨厌的勇气》、《幸福的勇气》，还有这本《蛤蟆先生去看心理医生》。当然，现在回想起来，我已经不再感受到当时的痛苦了。曾经也一度怀疑过自己是不是太“做作”，不过，回忆起那段时光，我还是怀念那段用书籍慰藉自己的时光。

2. 正文

下面是当时所作的读书笔记，记录一下

一、三个自我状态

儿童自我状态(Child Ego State)

由我们童年残留的遗迹搭建而成，包括我们小时候体验过的所有情感。开始只具备几种最基本的情感：快乐和深情、愤怒、悲伤、恐惧，这些基本情感逐渐发展演变为更微妙、更复杂的行为模式，这些行为模式成为自我的核心，融为我们自身的一部分，定义了我们一生的行为。

童年体验到的最强烈的情绪，不可避免地变成我们成年后经常有的感受。

顺从行为：同意、道歉、依赖对大多数人而言，成长的本质就是要减少并最终打破这样的依赖关系，成为一个自主独立的人。顺从行为可能导致有些人把依赖当作生活方式。这些人永远都没有真正长大成人

父母自我状态(Parent Ego State)

处在这种状态的人，不是在教育别人，就是在挑剔别人。

我们从出生开始面对的最多的就是父母，我们的价值观和世界观，以及一切是非对错的评价从根本上来说，都取决于父母。这些同样成为了我们童年言行和行为的塑造，甚至对我们今后的生活都产生了影响。

我们每个人都有“父母自我状态”，只是表现方式不同。有些人表现为“我好，你不好。”而有些人表现为“我不好，你好。”前者一般都会证明别人从根本上都是无能和不可信的，接着就会以训斥和惩罚别人为己任。后者则表现为自我否定，这表现了一个人的行为态度，这类人认为自己很差劲，别人都比他好。日常生活中的一些人总是列举出一系列不幸的事件，并且借此猛烈的攻击、批判自己。没有一种批判比自我批判更强烈，也没有一个法官比我们自己更严苛。

只要我们能够真正了解自己的情绪，从“儿童自我状态”和“父母自我状态”中走出来，进而走向自立。

3. 成人自我状态(Adult Ego State)

在这个状态下，我们能够计划、考虑、决定、行动，我们能理性而合理地行事。处于这个状态的时候，我们所有的知识和技能都能为自己所用，而不再被脑子里父母过去的声音所驱使，也不会被童年的情绪所围困，相反，我们能思考当下的情况，基于事实来决定要怎么做。

这并不意味着这种状态比其他两种状态高级，相反，它们都对生存有价值。但只有在成人自我状态里，才能学到关于自我的新知识。处在童年自我状态会让一个人反复体验过去的情绪，学不到任何新的东西。处于父母自我状态的人基本上不是在挑剔就是在教育别人，都是用言行重复着从父母那里学来的观念和价值观。

没有人能够强迫别人进入成人自我状态，只能够鼓励，只有他自己能决定要怎么做。

当处于另外两种状态时，我们做事时基本上不需要思考，就好似在演戏一样。例如愤怒的人是故意愤怒的，是他们自己选择“扮演”了这个角色。没有人能让我们产生什么感觉，除非他们用蛮力胁迫你。总之，情绪并没有生命，不能主动让我们产生什么感觉，是我们自己选择了自己的感受。我们选择了愤怒，我们选择了悲伤。

【书籍分享】学会提问

Sat, 09 Nov 2024 00:00:00 GMT

分享一下之前的读书经历

★学会提问

一、两种思维模式

海绵式思维：类似于海绵放到水中的反应，充分吸收水分。

Advantage：可以吸收很多信息，为以后的展开复杂的思考奠定坚实的基础。不需要绞尽脑汁地思考，为成为一个有思想的人提供一个有效的起点。

Disadvantage：无法有效辨别所得信息和观点的真伪，造成读到什么就相信什么的情况。

淘金式思维：主动决定应该吸收什么和忽略什么，带着不断怀疑的态度读书，随时准备与作者辩论、积极参与其中的一种互动方法
联系：海绵式思维强调获取知识的结果，淘金式思维重在获取知识的过程并与之积极互动。两者互补，相互促进。

二、批判性思维

价值观：自主决断、好奇心、谦恭有礼、发自内心的尊重严密的论证。
策略：

1）使用“你是不是说？”确保完全理解对方

2）表现出体贴他人且平静随和，若讨论的火气上升，不断提醒自己：自己是为了学习，并不是要“舌战群英”。

3）寻求出共同的价值观，以此为基础找出分歧点。

4）尽量弥合分歧，融合彼此论据，看是否能够得出新结论。

5）提议双方休息、询问对方为何认为自己的证据或是看法如此薄弱。

内涵：

有效策略：控制好自己的语气，避免过度依赖专家。

三、理性思考

我们生活在嘈杂、混乱的世界，说服我们相信某件事的人往往会说出那件事情的弊端。我们习惯于、依赖于听从“大师”的“忠告”。
我们必须要理性地掌握自己的信念和结论，与之相对的是，谁是我们最后遇到的人，我们就甘愿做谁的精神奴隶。
批判性思维鼓励倾听他人，向别人学习。不能来者不拒，必须做出自己的选择。

【书籍分享】金榜题名之后：大学生出路之谜

Thu, 07 Nov 2024 00:00:00 GMT

分享一下之前读过的一本书：

一、概述

本书主要从社会学角度分析了高等教育中存在的不平等，尤其对寒门学子在大学中面临隐形文化障碍的状况作出分析，并指出这些障碍如何影响他们的毕业出路。

二、导论

该书导论部分探讨了高等教育在现代社会中的作用，特别是社会阶层流动和职业前景方面的影响。

自古以来，通过读书改变命运是中国社会普遍认知的观念，在古代，金榜题名意味着社会地位的飞升。在现代，高等教育被视为实现阶层上升的重要途经，大学文凭成为通向优质职业和体面生活的门票。随着社会发展，近20年来，中国高等教育经历的大规模扩招，为农村以及贫困地区孩子提供了向上游动的机会，人们普遍相信考上大学就能打破阶层限制，迈向更光明的未来，但是作者指出家庭背景的影响并未随着进入大学而消失，毕业后的职业前景仍然受到家庭文化资本不足的影响。

作者基于对62位毕业生的调研，作者指出低阶北京的学生缺乏组织大学生活的方式，难以利用身边存在的资源，将其转化为职业优势。她写这本书的目的就是要探讨如何打破这种隐形的文化障碍。

三、视角

从不同学科的角度探讨了高等教育中的学生分化现象，提供了本书的分析框架和研究方法。作者首先从高等教育学的角度，强调了学生的能动性，即学生在面对教育过程时并非被动接受者，而是能够通过自身努力影响学习成果与职业选择。接着，教育社会学提供了另一种视角，即社会结构的力量。作者指出，尽管学生具备一定的能动性，但他们的行动仍然受到家庭背景、社会阶层等外部结构性因素的制约。

此外，文化社会学进一步揭示了价值信念对学生行为的重要性。不同家庭背景的学生在面对大学生活时，内化了不同的文化资本，这种文化资本直接影响了他们如何组织自己的学习和生活，以及如何看待未来职业发展。因此，本书的核心理论框架是通过结合学生的能动性、社会结构的约束和文化信念，解释大学生毕业出路的分化现象。

四、家境

探讨了家庭背景对学生大学生活和未来职业选择的深刻影响。通过对调研结果的分析，作者指出，不同家庭背景的学生在大学中的实践模式存在显著差异，归纳为目标掌控模式和直觉依赖模式。

首先，作者指出，目标掌控模式的学生多来自优越家庭背景，他们在大学生活中能够设定明确的学业和职业目标，合理安排时间和资源。这类学生往往得到父母的积极支持，在重大决策上有更强的方向感。相反，来自低阶层家庭的学生则倾向于采用直觉依赖模式，他们在大学生活中缺乏明确的规划，主要依赖直觉做出选择，面对未来目标感到模糊和不确定。

此外，作者进一步分析了家庭背景在选报专业和大学初期体验中的作用。优越家庭背景的学生能够依靠父母的经验和建议做出更有利的选择，并迅速适应大学生活，充分利用大学资源。而低阶层学生则由于缺乏这种支持，在选报专业时容易迷茫，进入大学后也常常因为文化资本的不足而面临适应困难，导致他们在学业、社交和未来规划上处于劣势。

家庭背景通过文化资本的转化深刻影响了学生的大学实践方式和毕业出路。优越家庭背景的学生往往更有能力将大学提供的资源转化为职业上的优势，而低阶层家庭的学生则因缺乏有效的支持和规划，难以获得同样的机会。这种差异为他们的未来职业发展埋下了隐形的分化种子。

五、努力

主要讨论了学生在大学中的投入方式，以及不同背景学生在学业和社会性活动中的差异。作者通过对学生行为的分析，揭示了两类典型实践模式——目标掌控模式和直觉依赖模式，如何在学生投入学业与社会生活时产生不同的效果。

首先，作者指出，目标掌控模式的学生对自己的目标有着清晰的掌控，他们在大学期间能够有效管理自己的学业投入和社会性投入。他们往往秉持一种“学业成绩只是起点”的态度，不仅注重提高绩点，还积极参与各类课外活动和社交活动，为未来的职业发展积累经验和人脉资源。而这种社会性投入，虽然常常被忽视，却是职业生涯发展的关键环节。

直觉依赖模式的学生则倾向于根据当下感觉进行行动，缺乏对未来职业的长远规划。他们的学业投入虽然可能很努力，但由于缺乏对“学以致用”的清晰认知，往往无法将学业成绩与未来职业发展有效结合。同时，他们在课外活动上的参与度也相对较低，错失了通过社会性投入提升职业竞争力的机会。

最后，作者强调了学业投入与社会性投入的平衡对学生毕业出路的决定性作用。目标掌控模式的学生由于能够合理分配精力，在学业和社会活动之间找到平衡，从而获得更大的竞争优势。而直觉依赖模式的学生虽然也付出了努力，但因为缺乏长远规划，往往难以将这种努力转化为职业上的实际收益。这种不同的投入方式，进一步加剧了学生之间毕业出路的差异。

六、方向

探讨了学生生涯目标的来源及其对职业选择的影响。作者在分析的基础上，提出了一个四分类模型，揭示了内化的价值信念如何塑造学生的职业前景。首先，作者指出，学生的意义感主要源于三种观念：家本位的传统观念：此类学生通常将工作视为保障家庭地位或承担家庭责任的手段。学校的崇高理想：部分学生受到教育的影响，认为工作应为社会服务或国家理想付出努力。消费社会的新潮理念：在现代社会中，某些学生追求个体兴趣和自我表达，将工作视为实现个人价值的途径。接着，作者详细阐述了这三种观念如何影响学生的职业选择，形成不同的职业发展模式。作者指出，内化的价值信念不仅影响他们的职业目标选择，也在不同程度上影响了毕业后的职业成就和满意度。本章最后强调，清晰的职业目标和价值信念能够有效引导学生的生涯发展，帮助他们克服来自家庭背景的限制。理解和引导学生的价值观念，对于促进他们的职业成功具有重要意义。

七、余论

探讨了高等教育中存在的文化障碍及其对寒门学子毕业出路的深远影响。作者在此章中深入分析了当前教育公平理想与现实之间的巨大落差，强调了寒门学子在名校中的独特处境和所面临的挑战。

工具理性与价值信念的冲突：作者首先指出，在当今的市场经济环境中，大学生在职业选择时常常面临工具理性与价值信念之间的冲突。虽然许多学生希望追求高尚的社会理想与价值观，但在实际的职业选择中，经济利益往往占据主导地位。这种矛盾使得学生在选择职业时感到迷茫与困惑，特别是对于来自较弱势家庭背景的学生，他们可能更容易被经济压力所驱动，从而牺牲个人理想。

文化障碍的双重性：作者强调文化障碍的双重性，指出它不仅表现在寒门学子在大学生活中的困难与挑战，还反映在他们如何利用和转化所获得的高等教育资源。寒门学子由于缺乏家庭的文化资本和社会网络，往往难以有效地适应大学生活，甚至在面对丰富的资源时也显得无所适从。这种双重障碍不仅限制了他们的学业成就，也影响了他们未来的职业发展机会，导致毕业后出路的显著不平等。

寒门学子的应对策略：在总结以上问题的基础上，作者提出了针对寒门学子的几条建议，旨在帮助他们更好地跨越文化障碍，实现职业目标。这些建议包括：1. 增强对大学生活的认知：鼓励寒门学子积极探索和了解大学环境，掌握学校的规则和资源，以便更好地适应并利用这些资源。2. 提升自我认同感：建议学生通过参与社团活动、建立友谊关系等方式，提高自信心和归属感，帮助他们在大学生活中建立积极的自我形象。3. 积极参与社会性活动：强调社会性投入的重要性，鼓励学生参与课外活动，扩大人际网络，积累社会经验，从而为未来的职业发展奠定基础。

最后，作者希望通过这些反思与建议，激发更多人关注高等教育中潜在的不平等现象，进而推动社会的整体变革与进步

【书籍分享】★刻意练习

Tue, 05 Nov 2024 00:00:00 GMT

一．刻意练习的要求

具有定义明确的特定目标。（了解自己要得到什么，或是要做到什么）
练习是专注的。（完全把注意力放在任务上。）
练习要有反馈。（准确辨别在什么地方做得不足，反馈越及时越好。）
练习要走出舒适区。（不逼一逼自己，永远无法进步。但是也不要在过长时间过分逼迫自己。在距离舒适区不远的甜蜜点上挑战，改变最迅速。）

二．心理表征

大脑正在思考的某个事物、某个观点、某些信息或者其他任何事物所对应的心理结构，或者具体或者抽象。
心理表征可以帮助我们更好地理解和处理复杂的问题，提高我们的技能和效能。
刻意练习的本质就是通过有目的、有反馈、有策略、有挑战的训练，来不断改进和优化我们的心理表征。
心理表征范围广泛。（刻意练习的目的就是创建更加有效的心理表征。不止在脑力领域，创建心理表征也是进步的重要因素。）
杰出大师和普通人的差别，就在于心理表征的数量和质量。
心理表征有利于指定规划。
心理表征可以突破短时记忆的局限，可以让我们在短时间内处理大量信息，从而在短时间内做出重要抉择，得出重要想法。

三．改变大脑结构

年纪越小，训练产生的影响就越大。（折幼芽效应）
训练大脑的某些部位，另一些方面可能要付出一些代价。研究发现，那些发展了某些技能的人。在另一些行业出现了退化。
对于训练引起的认知和生理变化需要继续保持，否则会消失。

【MC服务器】服务器趣事

Sat, 02 Nov 2024 00:00:00 GMT

前言

笔者在搭建完服务器之后立马找来好朋友帮忙测试，发现玩家无法摧毁里面的方块。回到控制台，控制台提示dismatch（不匹配）什么的，于是笔者将好友设置为服务器op（管理员），此时好友可以正常lu方块了。

后来，我在网上查到相关资料，MC服务端有一个参数配置spawn-protection叫做出生点区块保护，默认为16。只需要把16设置为0，重启服务器。此时会发现好友就可以正常放置撸方块，打开箱子等操作。

于是我便找来Java服务器所有配置及其参数信息分享给大家：

注：这是Java版的服务端参数，参数介绍翻译自Mojang官方文档，地址：https://minecraft.wiki/w/Server.properties

spawn-protection=16：通过将该值进行(x*2)+1的运算来决定出生点的保护半径。设置为0将不会禁用出生点保护。设置为0将会保护位于出生点的1x1方块区域，设置为1将会保护以出生点为中心的3x3方块区域。设置为2会保护5x5的方块区域，设置为3将会保护7x7的方块区域，以此类推。这个选项只会在第一个玩家进入服务器时生成。如果服务器没有设置OP，这个选项将会自动禁用。
max-tick-time=60000：设置每个tick花费的最大毫秒数，超过该最大毫秒数看门狗将停止服务器程序并附带上一些信息。
query.port=25565：设置监听服务器的端口号。
generator-settings=：本属性用于自定义超平坦世界的生成。详见超平坦世界和自定义了解正确的设定及例子。
force-gamemode=false：是否强制玩家以默认游戏模式游玩。
allow-nether=true：是否允许玩家前往下界。
enforce-whitelist=false：在服务器上强制执行白名单。当启用后，不在白名单中的用户将在服务器重新加载白名单文件后从服务器踢出。
gamemode=survival：游戏模式，包括survival(0)生存模式、creative(1)创造模式、adventure(2)冒险模式（仅在12w22a之后，或正式版1.3之后可用）、spectator(3)旁观模式（仅在14w05a之后，或正式版1.8之后可用）。
broadcast-console-to-ops=true
enable-query=false：是否允许使用GameSpy4协议的服务器监听器。它被用于收集服务器信息。
player-idle-timeout=0：玩家n分钟无任何操作将被自动踢出，0为关闭自动踢出。
difficulty=easy：定义服务器的游戏难度（例如生物对玩家造成的伤害，饥饿与中毒对玩家的影响方式等），包括和平(peaceful)(0)、简单(easy)(1)、普通(normal)(2)、困难(hard)(3)。如果设置了旧的数字ID，则会自动转化为英文的难度名称。
broadcast-rcon-to-ops=true
op-permission-level=4：设定OP的权限等级。
- 1：OP可以无视重生点保护。
- 2：OP可以使用单人游戏作弊命令（除了/publish，因为不能在服务器上使用，/debug也是）并使用命令方块。命令方块和领域服服主/管理员有此等级权限。
- 3：OP可以使用几乎所有多人游戏限定的命令（除第4级专用命令）。
- 4：OP可以使用所有命令，包括/stop、/save-all、/save-on和/save-off。
pvp=true：是否允许玩家互相伤害。
snooper-enabled=false：自1.3正式版之后，一旦启用，将允许服务端定期发送统计数据到snoop.minecraft.net。
level-type=default：地图生成类型，包括：
- DEFAULT：标准的世界带有丘陵，河谷，海洋等。
- FLAT：一个没有特色的平坦世界，适合用于建设。
- LARGEBIOMES：如同预设世界，但所有生态系都更大（仅快照12w19a，或正式版1.3之后可用）。
- AMPLIFIED：如同预设世界，但世界生成高度提高（仅快照13w36a，或正式版1.7.2之后可用）。
- CUSTOMIZED：自快照14w21b以来，服务器也支持自定义地形。使用方法是在generator-settings贴上代码。
hardcore=：极限模式（一旦启用，玩家在死后会自动被服务器封禁，进入spectator模式），会覆写设定的游戏难度。
enable-command-block=false：是否启用命令方块。
max-players=20：服务器同时能容纳的最大玩家数量，可输入0~2147483647。服务器的OP具有在人满的情况下强行进入服务器的权力：找到在服务器根目录下叫ops.json的文件并打开，设置你要突破人数限制的OP下的bypassesPlayerLimit选项为true即可（默认值为false），这意味着OP将不需要在服务器人满时等待玩家离开再加入。过大的数值会使客户端显示的玩家列表崩坏。
network-compression-threshold=256：默认会允许n-1字节的数据包正常发送，如果数据包为n字节或更大时会进行压缩。
resource-pack-sha1=：资源包的SHA-1值，必须为小写十六进制，建议填写它。这还没有用于验证资源包的完整性，但是它提高了资源包缓存的有效性和可靠性。
max-world-size=29999984：最大世界范围（半径），比如，1000即为2000x2000方形地图。
function-permission-level=2：设置命令的权限等级（1-4），权限等级2可以使用/reload和/forceload，可以参考op-permission-level。
rcon.port=25575：设置远程访问的端口号。
server-port=25565：服务器端口。
server-ip=：服务器地址，默认留空即可。
allow-flight=false：
- false：不允许飞行。悬空超过5秒的玩家会被踢出服务器。也会包括使用三叉戟的激流附魔、时间很长的自由落体或是网络卡顿导致的误判。
- true：允许飞行。玩家得以使用飞行MOD飞行。
level-name=world：世界的名字（同时也是存放世界文件夹的名字），更改名字会让服务器尝试加载不同文件夹中的地图。
view-distance=10：它决定了服务端的可视距离，设置服务端传送给客户端的数据量，也就是设置玩家各个方向上的区块数量（是以玩家为中心的半径，不是直径）。
resource-pack=：可输入指向一个资源包的URI。玩家可选择是否使用该资源包。注：下载到的服务器资源包将保存在.minecraft/server-resource-packs下。
spawn-animals=true：是否生成动物。
spawn-monsters=true：决定攻击型生物（怪兽）是否可以生成。
spawn-npcs=true：是否生成npc。
white-list=false：服务器的白名单，当启用时，只有白名单上的用户才能连接服务器。白名单主要用于私人服务器，例如相识的朋友等。注：OP会自动被视为在白名单上，所以无需再将OP加入白名单。
- false：不使用白名单。
- true：从whitelist.json文件加载白名单。
rcon.password=：设置远程访问的密码。
generate-structures=true：是否生成建筑（包括村庄等）。注：即使设为false，地牢和下界要塞仍然会生成。
max-build-height=256：玩家能够建造的最大高度。地形生成算法并不会受这个值的影响。
online-mode=true：服务器是否开启在线验证（仅允许正版玩家连接），谨慎切换，可能导致玩家数据丢失。
level-seed=：自定义世界种子。
use-native-transport=true：是否使用针对Linux平台的数据包收发优化。
prevent-proxy-connections=false：如果服务器发送的和Mojang的验证服务器的ISP/AS不一样，玩家将会被踢出。
- true：服务器将会禁止玩家使用虚拟专用网络或代理。
- false：服务器将不会禁止玩家使用虚拟专用网络或代理。
enable-rcon=false：是否允许远程访问服务器控制台。
motd=A Minecraft Server：玩家在多人游戏服务器列表中看到的服务器信息，显示于名称下方，那些花里胡哨的东西请参考官方的样式代码。
announce-player-achievements=false：玩家获得成就时是否在服务器中进行显示。在1.12之后的版本中，announce-player-achievements属性被移除。如果已经在服务器配置文件中设置了此条属性，则游戏规则announceAdvancements将自动更新，随后从文件中删除此条属性。

【MC服务器】使用Linux服务器搭建我的世界Java版本服务器流程

Tue, 29 Oct 2024 00:00:00 GMT

起因

因国内服务器搭建网站需要备案，但是我并不喜欢备案繁琐的流程，而且国内服务器的延迟还不错。因此就用这台服务器搭建了我的世界Java服务器，服务器配置2h2g，带宽10m，这个配置够5个人同时在服务器玩耍了，下面是我搭建的过程

1.服务器配置相关依赖

1.1首先通过ssh连接到终端，更新系统并且安装所需软件包

sudo apt update
sudo apt upgrade
sudo apt install wget screen openjdk-21-jdk-headless

说明：wget 主要用于下载文件使用，screen可以确保服务器在后端运行，后面的则是Java环境，运行Minecraft服务器所必须的。

2. 搭建流程

2.1 准备目录

mkdir ~/server
cd ~/server

2.2 下载服务端文件

wget https://piston-data.mojang.com/v1/objects/45810d238246d90e811d896f87b14695b7fb6839/server.jar

说明：以上为1.21.3版本的服务端，请在 https://www.minecraft.net/zh-hans/download/server 获取最新服务端

以下链接https://launchermeta.mojang.com/mc/game/version_manifest.json可找到历史版本

完整的版本清单 JSON 体积较大，本文不再内嵌备份。请使用上方 Mojang 官方链接获取最新内容。

2.3首次尝试运行服务端

java -Xmx1024M -Xms1024M -jar minecraft_server.1.21.3.jar nogui

不出意外，会运行错误，这时候你会发现目录下生成一个eula.txt文件，你需要同意它之后才能启动服务器。

2.4接受EULA协议并再次运行

echo "eula=true" > eula.txt

java -Xmx1024M -Xms1024M -jar minecraft_server.1.21.3.jar nogui

这时候服务器就会启动成功，在该目录下可以看到一个server.properties的文件，里面包含了服务器的所有配置，在网络上可以查询到那些参数的用途，文件内也有来自官方的英文注释。

2.5 创建screen会话保证服务器后台运行

当你断开ssh后服务器就会关闭，我们可以通过使用screen（它就相当于我们手机切换窗口时候的任务）解决

screen -S Mine //创建一个名叫Mine的窗口
java -Xmx1024M -Xms1024M -jar minecraft_server.1.21.3.jar nogui //开启服务器

这时候断开ssh链接也不会影响服务器的正常运转了，如何关闭服务器呢？我们可以通过screen关闭

screen -r Mine //回到Mine窗口

这时候按下ctrl+c就可以关闭服务器了

3.进入服务器

输入你的linux服务器ip，端口号默认为25565，即可进入你的服务器玩耍了。

可以在服务器的后台（即上面ssh中Mine窗口）对服务器进行各种操作，官方也给出了各种解释。

Explorerの日常

C# 学习笔记（三）：从类与对象到继承、接口与多态

一、类与对象：把数据和行为放在一起

1. 字段、属性和访问修饰符

2. 构造函数与对象初始化

3. 属性：让状态变化有边界

4. 索引器：让对象像集合一样访问

5. 垃圾回收与资源释放

二、类的进阶用法

1. 静态成员与静态类

2. 扩展方法

3. 运算符重载

4. 嵌套类与分部类

三、继承：复用共同特征，而不是复制代码

1. this 和 base

2. 里氏替换与安全类型判断

3. object、装箱与拆箱

4. 密封类

四、多态：让调用者依赖共同能力

1. virtual、override 与 base

2. 抽象类与抽象方法

3. 接口与多实现

4. 密封重写

五、代码组织与常用基础类型

1. 命名空间

2. object 提供的常用方法

3. string 的不可变性

4. StringBuilder

5. 结构体和类

6. 抽象类还是接口

六、一个贯穿示例

结语：目前最需要记牢的几件事

C# 基础教程：枚举、数组、函数、结构体与排序完整梳理

整理框架

Lesson 1：枚举

什么是枚举？

枚举的整数值

枚举与 switch

枚举类型转换

Lesson 2：一维数组

什么是数组

一维数组的声明

数组长度和索引

遍历数组

数组数据统计

手动反转数组

数组增加元素

数组删除元素

查找数组元素

Lesson 3：二维数组

二维数组的基本概念

获取行数和列数

获取、修改和遍历元素

二维数组中的位置关系

Lesson 4：交错数组

交错数组与二维数组的区别

Lesson 5：值类型和引用类型

值类型的赋值特点

引用类型的赋值特点

重新创建引用类型数据

Lesson 6：特殊引用类型 string

string 的特殊表现

字符串不可变

Lesson 7：函数

函数的基本概念

函数基本结构

四种基本函数形式

return 的作用

使用函数封装数组统计

使用函数判断质数和闰年

Lesson 8：ref 和 out

普通参数为什么不能直接修改外部变量

ref 参数

out 参数

使用 out 返回额外信息

Lesson 9：变长参数与参数默认值

params 变长参数

参数默认值

Lesson 10：函数重载

函数重载的基本概念

1. `this` 和 `base`

3. `object`、装箱与拆箱

1. `virtual`、`override` 与 `base`

2. `object` 提供的常用方法

3. `string` 的不可变性

4. `StringBuilder`

4.逐字字符串 `@`与原始字符串

使用 `+` 拼接

1. `while` 循环

2. `for` 循环

3. `do...while` 循环

4. `switch`