csharp:类:理解类

差别

这里会显示出您选择的修订版和当前版本之间的差别。

到此差别页面的链接

两侧同时换到之前的修订记录 前一修订版
后一修订版		 前一修订版
csharp:类:理解类 [2025/09/28 16:28] – [类的绑定理解1] 张叶安csharp:类:理解类 [2025/11/26 16:36] (当前版本) – 张叶安
行 1: 行 1:
-# 类的实例化、+====== 类的实例化 ======
  
-实例化：把类创建为对象的过程+实例化：把类创建为对象的过程。
  
-表达式1：+===== 1. 实例化表达式 =====
  
-[直接实例化创建对象]+==== 表达式1：直接实例化创建对象 ====
  
-``` +<code csharp> 
-类名称 对象名 =  new  类名称(); +// 语法 
-```+类名称 对象名 = new 类名称(); 
 +</code>
  
-表达式2：+==== 表达式2：先创建对象再实例化 ====
  
-[先创建对象再实例化]+<code csharp> 
 +// 语法 
 +类名称 变量; 
 +变量 = new 类名称(); 
 +</code>
  
-``` +===== 注意事项 =====
-类名称 变量 ; +
-变量=  new  类名称(); +
-```+
  
-注意： +<code csharp>
-```+
 Car myCar = new Car(); Car myCar = new Car();
-``` +</code>
-创建了一个名为myCar的变量，并将其初始化为一个新的Car对象。+
  
-这意味着myCar现在引用了一个实际存在的Car实例。+  * 创建了一个名为 ''myCar'' 的变量，并将其初始化为一个新的 ''Car'' 对象。 
 +  * 这意味着 ''myCar'' 现在引用了一个实际存在的 ''Car'' 实例。 
 +  * **结论**：''myCar'' 是 ''Car'' 类的实例/对象。
  
-[ myCar 是Car 类的实例/对象  ]+> **特别提醒**： 
 +> 如果只写 ''Car myCar;''，这仅仅声明了一个名为 ''myCar'' 的变量，但并没有给它分配任何值。在这种情况下，''myCar'' 是一个未初始化的变量（或 null），你不能直接使用它，**必须先实例化它**。
  
-Car myCar; 声明了一个名为myCar的变量，但并没有给它分配任何值。在这种情况下，myCar是一个未初始化的变量，你不能使用它、需要实例化它、+====== 为什么要创建类及对类的理解 ======
  
-# 为什么要创建类及对类的理解+当多个对象具有相同属性时，可以把他们归于一类，即创建一个类。 
 +  * **属性**：类中包含他们相同的特征。 
 +  * **行为**：可以看做方法（函数）。
  
- +<code csharp>
-当多个对象具有相同属性时、可以把他们归于一类、即创建一个类、[行为可以看做方法] +
- +
-类中包含他们相同的属性、 +
- +
-```+
 namespace 创建类及对类的理解 namespace 创建类及对类的理解
 { {
行 46: 行 46:
         static void Main(string[] args)         static void Main(string[] args)
         {         {
-         //当多个对象具有相同属性时、行为、可以把他们归于一类、即创建一个类、[行为可以看做方法] +            // 当多个对象具有相同属性、行为时，可以把他们归于一类 
-         //类中包含他们相同的属性、 +             
- +            // 利用同种类型创建英雄 
-            //利用同种类型创建英雄 +            MAX_pipou LeiShen = new MAX_pipou(); // 创建一个英雄叫雷神 
-            MAX_pipou LeiShen = new MAX_pipou(); //创建一个英雄叫雷神 +            MAX_pipou gaiya = new MAX_pipou();   // 创建一个英雄叫盖亚 
-            MAX_pipou gaiya = new MAX_pipou(); //创建一个英雄叫盖亚 +            MAX_pipou wunu = new MAX_pipou();    // 创建一个英雄叫舞女
-            MAX_pipou wunu = new MAX_pipou(); //创建一个英雄叫舞女+
  
-            //英雄属性赋予+            // 英雄属性赋予
             LeiShen.name = "雷神"; LeiShen.agg = 22; LeiShen.shengao = 175;             LeiShen.name = "雷神"; LeiShen.agg = 22; LeiShen.shengao = 175;
             gaiya.name = "盖亚"; gaiya.agg = 25; gaiya.shengao = 182;             gaiya.name = "盖亚"; gaiya.agg = 25; gaiya.shengao = 182;
             wunu.name = "舞女"; wunu.agg = 18; wunu.shengao = 163;             wunu.name = "舞女"; wunu.agg = 18; wunu.shengao = 163;
-            //英雄展示 + 
-            LeiShen.show_MAX_pipou(); gaiya.show_MAX_pipou(); wunu.show_MAX_pipou();+            // 英雄展示 
 +            LeiShen.show_MAX_pipou();  
 +            gaiya.show_MAX_pipou();  
 +            wunu.show_MAX_pipou();
         }         }
     }     }
-    class MAX_pipou  //创建英雄的类+ 
 +    class MAX_pipou  // 创建英雄的类
     {     {
-        //字段变量  等待外部赋值   变量不加static必须要实例化类才能使用 +        // 字段变量 等待外部赋值 
-        public String name;//名  +        // 变量不加 static 必须要实例化类才能使用 
-        public int agg;//年龄 +        public String name; // 名  
-        public int shengao;//身高 +        public int agg;     // 年龄 
-        public void  show_MAX_pipou() //方法+        public int shengao; // 身高 
 + 
 +        public void show_MAX_pipou() // 方法
         {         {
             Console.WriteLine(name);             Console.WriteLine(name);
行 76: 行 81:
     }     }
 } }
 +</code>
  
 +====== 成员变量与成员函数 ======
  
-```+  * **成员变量**：一个类里面的变量。 
 +  * **成员函数**：一个类里面的方法。
  
-# 成员变量与成员函数+====== 创建类添加 static ======
  
 +类里面的变量如果添加了 ''static'' 关键字，相当于直接创建了变量。
 +**特点**：无需实例化即可直接访问。
  
-一个类里面的变量叫：成员变量 +<code csharp>
- +
- +
-一个类里面的方法叫：成员函数 +
- +
-# 创建类添加static +
- +
-类里面的变量添加的 static、相当于直接创建了变量、 +
- +
-无需实例化访问、 +
- +
-```+
 namespace 创建类及对类的理解加入static namespace 创建类及对类的理解加入static
 { {
行 101: 行 100:
         static void Main(string[] args)         static void Main(string[] args)
         {         {
-            //当多个对象具有相同属性时、行为、可以把他们归于一类、即创建一个类、[行为可以看做方法] +            // 直接通过 类名.属性 访问，不需要 new 对象
-            //类中包含他们相同的属性、+
             MAX_pipou.name = "英雄";             MAX_pipou.name = "英雄";
             MAX_pipou.agg = 24;             MAX_pipou.agg = 24;
         }         }
     }     }
-    class MAX_pipou  //创建英雄的类加static+ 
 +    class MAX_pipou  // 创建英雄的类加 static
     {     {
-        //字段变量 +        // 静态字段变量 
-        public static String name;//名  +        public static String name;   // 名  
-        public static int agg;//年龄 +        public static int agg;       // 年龄 
-        public static short xbie;//性别 +        public static short xbie;    // 性别 
-        public static int shengao;//身高 +        public static int shengao;   // 身高 
-        public static short jineng;//技能 +        public static short jineng;  // 技能 
-        public static short wuqi;//武器 +        public static short wuqi;    // 武器 
-        public static int gongjili;//攻击力 +        public static int gongjili;  // 攻击力 
-        public void  show_MAX_pipou()+ 
 +        public void show_MAX_pipou()
         {         {
             Console.WriteLine(name);             Console.WriteLine(name);
行 125: 行 125:
     }     }
 } }
 +</code>
  
-```+====== 主类与次类之间变量需要传递数据 ======
  
-# 主类与次类之间变量需要传递数据+在主类中实例化次类的对象，可以通过以下方式传递数据： 
 +  - 1. 通过 **对象点 (Object.Property)** 的方式赋值。 
 +  - 2. 调用其中方法，**传入参数**。 
 +  - 3. 把一个**对象**当做参数传入。 
 +  - 4. 建议使用**委托**（Delegate）。
  
-在主类中实例化次类的对象、通过对象点的方式赋值+====== 类的绑定理解 (引用类型) ======
  
-也可以调用其中方法、传入参数、 也可以把一个对象当做参数传入+===== 理解 1：引用传递 =====
  
-建议使用委托 +使用 ''fuka'' 对象就等于使用 ''zhuka'' 对象成员。
-# 类的绑定理解1+
  
-使用fuka对象就等于使用zhuka对象成员+<code csharp> 
 +class casrd // 卡类 
 +{ 
 +    public String Money; // 卡的金额 
 +}
  
-``` +class syong 
-    class casrd //卡类 +{ 
-    { +    public void syong_jilu() 
-        public String Money;//{ get; set; }//卡的金额+    {    
 +        Console.WriteLine("信用卡消费记录"); 
 +         
 +        // 创建卡对象、赋予8千额度 
 +        casrd zhuka = new casrd() { Money = "8000" }; 
 +        Console.WriteLine("信用卡总额度：" + zhuka.Money); // 输出主卡的总额度值 
 + 
 +        // 关键点：引用赋值 
 +        casrd fuka = zhuka; // 怎么理解这里? 
 +         
 +        fuka.Money = "2000"; // 副卡消费2千块（实际上修改的是同一个内存地址） 
 +         
 +        Console.WriteLine("消费记录：" + zhuka.Money); // 输出主卡的总额度值
     }     }
-    class syong 
-    { 
-        public void syong_jilu() 
-        {    
-            Console.WriteLine("信用卡消费记录"); 
-            casrd zhuka = new casrd() { Money = "8000" };//创建卡对象、赋予8千额度 
-            Console.WriteLine("信用卡总额度：" + zhuka.Money); //输出主卡的总额度值 
- 
-            casrd fuka = zhuka;// 怎么理解这里? 
-            fuka.Money = "2000"; //副卡消费2千块 
-            Console.WriteLine("消费记录：" + zhuka.Money); //输出主卡的总额度值 
-        } 
- 
 } }
-``` +</code>
- +
-在这段代码中，casrd fuka = zhuka; 是将 zhuka对象的引用赋值给 fuka 。这意味着 zhuka和 fuka 都指向同一个 Card 对象[创建的虚拟堆]。 +
- +
-当你修改 fuka  的属性值时，实际上是修改了zhuka的属性值，因为它们都指向同一个对象。 +
- +
-总结：使用值类型时对一个变量的修改不会影响其他的值、 +
- +
-而使用引用类型时、你对一个引用类型变量的值进行修改、会影响到与它相同引用的其他变量的值、 +
- +
- +
-# 类的绑定理解2 +
- +
- +
- +
-总结：使用值类型时对一个变量的修改不会影响其他的值、而使用引用类型时、你对一个引用类型变量的值进行修改、会影响到与它相同引用的其他变量的值、 +
- +
- +
- +
- +
  
 +**解析**：
 +在这段代码中，''casrd fuka = zhuka;'' 是将 ''zhuka'' 对象的**引用**（内存地址）赋值给 ''fuka''。这意味着 ''zhuka'' 和 ''fuka'' 都指向同一个 ''Card'' 对象（创建在堆内存中）。
  
 +当你修改 ''fuka'' 的属性值时，实际上是修改了 ''zhuka'' 的属性值，因为它们本质上是同一个对象。
  
 +===== 理解 2：总结 =====
  
 +{{.:pasted:20250928-162934.png?400|示意图}}
  
 +^ 类型 ^ 行为特征 ^
 +| **值类型** | 对一个变量的修改**不会**影响其他变量的值（复制副本）。 |
 +| **引用类型** | 对一个引用类型变量的值进行修改，**会影响**到与它相同引用的其他变量的值（操作同一地址）。 |
Detach Close

该主题尚不存在

您访问的页面并不存在。如果允许，您可以使用创建该页面按钮来创建它。

  • csharp/类/理解类.1759048129.txt.gz
  • 最后更改: 2025/09/28 16:28
  • 由 张叶安