C#封装学习

一：封装

封装就像一个ATM机器，只需要插卡，输密码，取钱，不需要关心怎么点钞，怎么记账；

封装的本质

1.把数据和方法包在一起

2.隐藏内部实现细节

3.只暴露一些必要的细节

创建：->类库（如果在winform中引用创建带NET的类库，且最好选择低版本类似于4.8）

也可以在其他工程中通过解决资源管理器进行新建一个类库。

类的创建：

在解决资源管理器改变类的名称时，我们的代码中的名称也会跟着改变

0个引用是因为在外界winform中还未有单位引用;

逐行解析

A.private string FilePath { get; set; }

1. private → 给数据加 “私门锁”

• 这是访问修饰符，意思是：这个 FilePath 属性只有当前类（比如你的 Calculate 类）内部能访问 / 修改，类外面的代码完全看不到、碰不到。
• 比如 WinForm 里的按钮点击方法，没法直接写 calc.FilePath = "xxx";，只能通过类内部的方法 / 构造函数来操作，保护数据不被外部随意篡改。

2. string → 定义数据类型

• 表示这个属性专门存储字符串类型的数据（比如文件路径 "C:\\test.txt"、名字 "张三" 等），对应之前跟你讲的 string 用法。

3. FilePath → 属性名（帕斯卡命名）

• 这是你给这个属性起的名字，用 帕斯卡命名法（首字母大写） 是 C# 的官方规范，一眼能看出它代表 “文件路径”，比小写的 filepath 更易读。

4. { get; set; } → 自动属性的 “读写开关”

• 这是 C# 简化代码的语法（自动属性），编译器会帮你自动生成底层的存储逻辑，不用手动写私有字段。
  • get：取值器 → 当类内部想读取 FilePath 的值时，执行 get 逻辑，返回存储的文件路径。
  • set：赋值器 → 当类内部想给 FilePath 设置新值时，执行 set 逻辑，把新值存起来。

B.private double OffSetValue { get; set; }

1. private → 数据的 “私门锁”（和之前完全一样）

• 这个属性仅当前类（比如 Calculate 类）内部能访问 / 修改，类外部（比如 WinForm 按钮事件）无法直接写 calc.OffSetValue = 10.5;，只能通过类内部的构造函数、方法来操作，避免数据被随意篡改。

2. double → 定义数据类型（核心区别）

• double 是 C# 的双精度浮点型，专门用来存储带小数的数值（比如 0.5、3.14159、100.25、-8.9 等），精度比普通的 float 更高，适合需要精准计算的场景（比如你的偏移值、数学计算结果）。
• 和 string 对比：string 存文本（如文件路径），double 存小数数值（如偏移值）。

3. OffSetValue → 属性名（帕斯卡命名）

• 这是属性的名字，用帕斯卡命名法（首字母大写）符合 C# 规范，一眼能看出它代表 “偏移值”（建议统一写成 OffsetValue，去掉中间的大写 S，更符合命名习惯）。

4. { get; set; } → 自动属性的 “读写开关”（和之前完全一样）

• 编译器会自动帮你生成底层的私有存储字段，不用手动写繁琐的代码：
  • get：类内部读取 OffSetValue 时，返回存储的小数数值（比如读取偏移值 5.2）；
  • set：类内部给 OffSetValue 赋值时，把新的小数存进去（比如设置偏移值为 10.8）

C&D

构造函数是和类名完全同名的特殊方法，有两个关键特点：

1. 没有返回值（连 void 都不用写）；
2. 创建类的对象时自动执行，用来给类的属性 / 字段初始化。

而 public jisuan() {} 是无参数的构造函数（简称 “无参构造”）—— 就是创建对象时不用传任何参数，执行空的初始化逻辑。

🛠️ 逐部分拆解代码

public jisuan()
{
    // 这里是空的，说明初始化时不做任何额外操作
}

1. public：访问修饰符 → 外部代码（比如 WinForm 里）能调用这个构造函数创建对象；
2. jisuan：构造函数名 → 必须和你的类名（jisuan）完全一致，编译器才会识别为构造函数；
3. ()：无参数 → 创建对象时不用传任何值；
4. {}：空的方法体 → 创建对象时，除了给属性赋默认值（比如 FilePath 默认为 null、OffsetValue 默认为 0.0），不执行其他逻辑。

💡 实际用法：怎么用这个无参构造创建对象？

📌 关键补充：无参构造的 “隐藏规则”

1. 默认生成：如果你的类里没写任何构造函数，C# 编译器会自动给你生成一个空的无参构造（和你手动写的 public jisuan() {} 效果一样）；
2. 手动写的意义：如果你的类里已经写了有参构造（比如 public jisuan(string path) {}），编译器就不会自动生成无参构造了 —— 此时如果你想允许 “无参创建对象”，就必须手动写这个 public jisuan() {}；
3. 初始化逻辑：空的无参构造只会给属性赋 “默认值”（string 默认为 null，double 默认为 0.0，int 默认为 0），如果想自定义默认值，可在 {} 里加代码（比如上面注释里的默认文件路径）。

对比：无参构造 vs 有参构造（更易理解）

总结

1. public jisuan() {} 是 jisuan 类的无参构造函数，创建对象时自动执行；
2. 空的无参构造会给类的属性赋默认值，也可在 {} 里自定义初始化逻辑；
3. 如果类里写了有参构造，想无参创建对象就必须手动写这个无参构造。

接下来就是我们熟悉的内容，函数编译，只不过前面加了public以及是否决定其带不带偏移量;

写完之后点击生成解决方案->在对应文件中的debug文件夹会发现一个jisuan,dll,这就是把一个类给封装起来了.

以下是详细代码：

namespace caulate_class//namespace是 C# 的关键字，意思是「命名空间」，一个逻辑容器，
                       //用来把相关的类、接口、结构体等代码 “打包” 在一起，避免不同模块的代码重名冲突。
{
    public class jisuan    //public表示这是公用的，可以被外部引用。class表示这是我们的类
    //构造函数的作用：主要是给类里面的参数赋值
    
    {
        private string FilePath { get; set; }
        private double OffSetValue { get; set; }
                       
        public jisuan()
        {

        }//无参构造函数;
        public jisuan(string path,double os)
        {
                 FilePath=path;
                OffSetValue=os;

        }//带参构造函数;
        public double sum(double a,double b)
        {
            return a + b;
        }//加法＋偏移量。之后加减乘除随便你，想咋玩咋玩。🤭
        public double dec(double a, double b)
        {
            return a -b;
        }
        public double mul(double a, double b)
        {
            return a * b ;
        }
        public double div(double a, double b)
        {
            return a/b;
        }
    }

}

学会封装之后，调用当然也必不可少，接下来是在winform中的调用。

winform:比较古老的产物
学习目的：1.巩固C#产物2.入门快速简单
缺点:1.默认皮肤丑  2.DPI
简单介绍一些计算机如何创造出来图像的：
 图像 小部件
 计算机扩展：窗口界面由显示器来提供，二进制0101；

   显示器扩展显示能力；
喇叭扩展了喇叭的播放能力;
 图像 小部件

通过RGB进行显示孔的显示，比如000就是纯白，255 255 255，不断地切换灯珠的能力;
一：创建项目

要选 「Windows 窗体应用 (.NET Framework)」（C# 版本） ✅

🔍 为什么选它？

1. 兼容性最好你之前写的 jisuan 类库是基于 .NET Framework 的，这个模板和类库的技术栈完全匹配，引用和调用不会有兼容性问题。
2. 最适合初学者这是最经典的 WinForm 模板，网上绝大多数教程、示例都是基于它的，遇到问题更容易找到解决方案。
3. 排除其他选项
   • 第一个 “Windows 窗体应用”（C#）是基于 .NET 6+ 的新模板，虽然也能用，但和旧的 .NET Framework 类库可能存在引用问题。
   • 第二个 “Windows 窗体应用”（Visual Basic）是 VB.NET 语言的，和你用的 C# 不兼容，直接排除。

添加引用

🛠️ 步骤 1：找到 “引用” 节点

在你的 解决方案资源管理器 中（就是左侧的项目结构树），展开你的 WinForm 项目 WindowsForms计算类的调用，找到下面的 「引用」 文件夹（在 Properties 下面，App.config 上面）。

🛠️ 步骤 2：打开添加引用窗口

右键点击 「引用」，在弹出的菜单中选择 「添加引用...」。

🛠️ 步骤 3：选择要引用的类库

在弹出的 “引用管理器” 窗口中：

1. 点击左侧的 「项目」 选项卡（如果你的 caulate_class 类库和当前 WinForm 项目在同一个解决方案里，就用这个选项）；
2. 在右侧列表中找到你的类库项目（比如 caulate_class），勾选它前面的复选框；
3. 点击右下角的 「确定」 按钮，完成引用添加。

如果你的类库不在同一个解决方案里：

• 切换到 「浏览」 选项卡；
• 找到类库编译生成的 .dll 文件（一般在类库项目的 bin\Debug 文件夹里）；
• 选中 .dll 并点击 “确定”。

🛠️ 步骤 4：验证引用是否成功

回到解决方案资源管理器，展开 「引用」 文件夹，你会看到 caulate_class 已经出现在列表里，说明引用成功了。

💡 最后一步：在代码里导入命名空间

打开你的 Form1.cs 文件，在代码最顶部添加：

using caulate_class; // 导入类库的命名空间

这样你就能在 WinForm 代码里直接调用 jisuan 类了。

之后整理一下验证所需要加的东西：

打开视图，工具箱，自己装个页面，很完美。

之后往里面填东西：短期一些代码示例；

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using caulate_class;

namespace WindowsForms计算类的调用
{
    public partial class Form1 : Form//这行代码定义了一个：
                                      //公开的、可拆分的窗体类 Form1，它继承自系统的 Form 类，
                                     //拥有窗口的所有基础功能，同时代码被拆分为 “你写的逻辑” 
                                     //和 “自动生成的界面” 两部分，方便管理。
    {
        


        public Form1()
        {
            InitializeComponent();//这个方法是 Visual Studio 在你拖放控件、设置界面属性（比如调整 TextBox 大小、设置 Label 文字）后，自动在 Form1.Designer.cs 文件里生成的代码。
            //它的唯一作用就是：根据你在设计视图里的操作，自动创建所有控件、设置它们的位置 / 大小 / 属性，并把它们添加到窗体上，让你的界面完整显示出来。
        }
        /*不要手动修改：这个方法是自动生成的，手动修改 Form1.Designer.cs 里的代码会导致界面错乱，所有界面调整都要在设计视图里操作。
必须调用：如果删除构造函数里的 InitializeComponent();，你的窗体将是空的，不会显示任何控件。
简单来说，InitializeComponent(); 就是 Visual Studio 帮你写的 “界面装修工人”，负责把你设计的界面完整搭建出来，你只需要专注写业务逻辑就行。*/
        jisuan calculate = new jisuan();//此处声明后整个全局都可以使用.




        private void Form1_Load(object sender, EventArgs e)
            //是 WinForm 里的窗体加载事件处理方法，简单说就是 “窗体第一次打开时，自动执行这个方法里的代码”。
        {
            
        }

        private void label1_Click(object sender, EventArgs e)//是 WinForm 里针对 label1 标签控件的点击事件处理方法，简单说就是：当你用鼠标点击界面上的 label1 标签时，会自动执行这个方法里的代码。
        {
            int a = 0, b = 0;
            bool res = false;//利用布尔类型，表示判断.
            res = int.TryParse(textBox1.Text, out a);
            res = res && int.TryParse(textBox2.Text, out b); // 两个都解析成功，res才是true.
            if (res)
            {

                textBox3.Text = calculate.sum(a, b).ToString();//把 calculate 对象计算出的 a+b 结果，显示到界面的 textBox3 输入框里（也就是你的加法结果框）。
            }
        }

        private void richTextBox1_TextChanged(object sender, EventArgs e)
        {

        }

        private void textBox3_TextChanged(object sender, EventArgs e)
        {

        }

        private void richTextBox11_TextChanged(object sender, EventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)
        {

        }

        private void richTextBox3_TextChanged(object sender, EventArgs e)
        {

        }
    }
}


/*textBox3.Text = calculate.sum(a, b).ToString();
 1. 最核心：calculate.sum(a, b)
calculate：你之前创建的 jisuan 类对象（jisuan calculate = new jisuan();），是调用计算方法的 “入口”；
.sum(a, b)：通过对象调用 jisuan 类里的 sum 方法，传入两个整数 a 和 b，方法内部执行 a + b 并返回计算结果（比如 a=10、b=20，返回 30）；
关键前提：你的 jisuan 类里必须有 sum 方法，且方法逻辑是加法（比如 public int sum(int num1, int num2) { return num1 + num2; }）。
2. 中间层：.ToString()
作用：把 sum 方法返回的整数结果（比如 30）转换成字符串类型；
为什么必须加？
textBox3.Text 是 “文本属性”，只能接收字符串（比如 "30"），不能直接接收数字（比如 30）。如果不加 .ToString()，C# 会报错 “无法将 int 类型赋值给 string 类型”。
扩展：如果想保留小数（比如计算结果是 30.5），可以写 .ToString("0.00")，显示为 "30.00"。
3. 最外层：textBox3.Text =
textBox3：你界面上用来显示加法结果的输入框（控件名）；
.Text：输入框的 “文本属性”，控制输入框显示的内容；
=：赋值运算符，把右边转换好的字符串结果，赋值给 textBox3 的文本属性，最终显示到界面上。*/

Form.cs*源码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using caulate_class;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;
namespace newnew
{
    public partial class 测试 : Form
    {
        public 测试()
        {
            InitializeComponent();
        }
        jisuan cal = new jisuan();
        private void richTextBox1_TextChanged(object sender, EventArgs e)
        {

        }

        private void richTextBox3_TextChanged(object sender, EventArgs e)
        {

        }

        private void richTextBox2_TextChanged(object sender, EventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)
        {
            int a = 0, b = 0;
            bool res = false;//利用布尔类型，表示判断.
            res = int.TryParse(richTextBox1.Text, out a);
            res = res && int.TryParse(richTextBox3.Text, out b); // 两个都解析成功，res才是true.
            if (res)
            {

                richTextBox2.Text = cal.sum(a, b).ToString();//把 calculate 对象计算出的 a+b 结果，显示到界面的 textBox3 输入框里（也就是你的加法结果框）。


            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void richTextBox8_TextChanged(object sender, EventArgs e)
        {

        }

        private void richTextBox6_TextChanged(object sender, EventArgs e)
        {

        }

        private void richTextBox7_TextChanged(object sender, EventArgs e)
        {

        }

        private void button2_Click(object sender, EventArgs e)
        {
            int a=0, b=0;
            bool res= false;
            res = int.TryParse(richTextBox8.Text, out a);
            res = res && int.TryParse(richTextBox6.Text, out b);

        
        if (res) 

                richTextBox7.Text = cal.dec(a, b).ToString();//把 calculate 对象计算出的 a+b 结果，显示到界面的 textBox3 输入框里（也就是你的加法结果框）。
    }

        private void richTextBox12_TextChanged(object sender, EventArgs e)
        {

        }

        private void richTextBox10_TextChanged(object sender, EventArgs e)
        {

        }

        private void richTextBox11_TextChanged(object sender, EventArgs e)
        {

        }

        private void button3_Click(object sender, EventArgs e)
        {
            int a=0, b=0;
            bool res= false;
            res = int.TryParse(richTextBox12.Text, out a);
            res= res && int.TryParse(richTextBox10.Text, out b);
            if (res)

                richTextBox11.Text = cal.mul(a, b).ToString();//把 calculate 对象计算出的 a+b 结果，显示到界面的 textBox3 输入框里（也就是你的加法结果框）。
        }

        private void richTextBox16_TextChanged(object sender, EventArgs e)
        {

        }

        private void richTextBox14_TextChanged(object sender, EventArgs e)
        {

        }

        private void richTextBox15_TextChanged(object sender, EventArgs e)
        {

        }

        private void button4_Click(object sender, EventArgs e)
        {
            int a=0, b=0;
            bool res= false;
            res = int.TryParse(richTextBox16.Text, out a);
            res = res && int.TryParse(richTextBox14.Text, out b);
            if (res)

                richTextBox15.Text = cal.div(a, b).ToString();//把 calculate 对象计算出的 a+b 结果，显示到界面的 textBox3 输入框里（也就是你的加法结果框）。
        }

        private void richTextBox5_TextChanged(object sender, EventArgs e)
        {

        }
    }
    

    }
    

以上及为封测及其在WINFORM中运用；