C# 的类定义，构造函数和析构函数（学习心得 18）

最新推荐文章于 2023-09-11 14:40:33 发布
最新推荐文章于 2023-09-11 14:40:33 发布
阅读量1.3k 收藏 4
点赞数
分类专栏： C# 文章标签： 类 编程语言 c# .net 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42067550/article/details/106955037
版权

类，相当于一个数据类型的蓝图。

超级小白友好，讲解C#基础，每集5分钟轻松学习，拒绝从入门到放弃！

一、类的定义

关键字 class 开始，形式如下：

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

参数：

  • 访问标识符 指定了对类及其成员的访问规则。类的默认访问标识符为 internal：同一个程序集的对象可以访问；成员的默认为 private：对象本身在对象内部可以访问。
  • 数据类型 指定了变量的类型。
  • 返回类型 指定了返回的方法返回的数据类型。
  • 运用 “点” 运算符访问成员。

例：

using System;
namespace BoxApplication
{
    class Box
    {
       public double length;   // 长度
       public double breadth;  // 宽度
       public double height;   // 高度
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();        // 声明 Box2，类型为 Box
            double volume = 0.0;         // 体积

            // Box1 详述
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;

            // Box2 详述
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;
           
            // Box1 的体积
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Box1 的体积： {0}",  volume);

            // Box2 的体积
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Box2 的体积： {0}", volume);
            Console.ReadKey();
        }
    }
}

运行结果：

Box1 的体积： 210
Box2 的体积： 1560

二、成员函数和封装

类的成员可以访问该类所有成员。

所以有 private 的变量，只要通过该类的 public 的方法，也是可以访问的。

例：

using System;
namespace BoxApplication
{
    class Box
    {
       private double length;   // 长度
       private double breadth;  // 宽度
       private double height;   // 高度
       public void setLength( double len )
       {
            length = len;
       }

       public void setBreadth( double bre )
       {
            breadth = bre;
       }

       public void setHeight( double hei )
       {
            height = hei;
       }
       public double getVolume()
       {
           return length * breadth * height;
       }
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();                // 声明 Box2，类型为 Box
            double volume;                               // 体积


            // Box1 详述
            Box1.setLength(6.0);
            Box1.setBreadth(7.0);
            Box1.setHeight(5.0);

            // Box2 详述
            Box2.setLength(12.0);
            Box2.setBreadth(13.0);
            Box2.setHeight(10.0);
       
            // Box1 的体积
            volume = Box1.getVolume();
            Console.WriteLine("Box1 的体积： {0}" ,volume);

            // Box2 的体积
            volume = Box2.getVolume();
            Console.WriteLine("Box2 的体积： {0}", volume);
           
            Console.ReadKey();
        }
    }
}

运行结果：

Box1 的体积： 210
Box2 的体积： 1560

三、C# 中的构造函数

类的 构造函数 是类的一个特殊的成员函数，当创建类的新对象时执行。

构造函数的名称与类的名称完全相同，它没有任何返回类型。

例：设定一个构造函数

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      
      // 这里手动设定一个构造函数，函数名与类名相同，实例化的时候自动调用
      public Line()
      {
         Console.WriteLine("对象已创建");
      }

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

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

运行结果：

对象已创建
线条的长度： 6

默认的构造函数没有任何参数。

但是如果需要一个带有参数的构造函数可以有参数，这种构造函数叫做参数化构造函数。

这种技术可以在创建对象的同时给对象赋初始值。

例：参数化构造函数

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

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

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

运行结果：

对象已创建，length = 10
线条的长度： 10
线条的长度： 6

四、C# 中的析构函数

类的 析构函数 的名称是在类的名称前加上一个波浪形（~）作为前缀，它不返回值，也不带任何参数。

析构函数用于在结束程序（比如关闭文件、释放内存等）之前释放资源。

析构函数不能继承或重载。

例：

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

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

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

运行结果：

对象已创建
线条的长度： 6

这里我们会发现，在 idle 中不会显示“对象已删除”，这是因为程序员无法控制解构器何时被执行，这是由垃圾搜集器决定的。程序退出时虽然解构器被调用了，但由于程序已经退出，所以也无法在终端进行显示。

五、C# 类的静态成员

使用 static 关键字把类成员定义为静态的。

多少个类的对象被创建，只会有一个该静态成员的副本。

即所有实例化对象共用该成员的值。

静态变量用于定义常量，因为它们的值可以通过直接调用类而不需要创建类的实例来获取。

静态变量可在成员函数或类的定义外部进行初始化，也可以在类的定义内部初始化。

例：

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

运行结果：

s1 的变量 num： 6
s2 的变量 num： 6

可以把一个成员函数声明为 static。

静态函数 只能访问 静态变量。

静态函数 在对象被创建之前就已经存在。

例：

using System;
namespace StaticVarApplication
{
    class StaticVar
    {
       public static int num;
        public void count()
        {
            num++;
        }
        public static int getNum()
        {
            return num;
        }
    }
    class StaticTester
    {
        static void Main(string[] args)
        {
            StaticVar s = new StaticVar();
            s.count();
            s.count();
            s.count();                  
            Console.WriteLine("变量 num： {0}", StaticVar.getNum()); // 不需要实例化，直接通过类名访问该静态函数
            Console.ReadKey();
        }
    }
}

运行结果：

变量 num： 3
AItrust
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 析构
xutao_ustc的专栏
04-24 565
对象不用的时候，可能会有它占用的资源需要释放（文件句柄，网络连接，数据库连接），为了释放非托管资源，一般有两种方式：1,申明一个析构函数2,在类中执行IDisposable接口public class MyClass { ~MyClass() { Console.WriteLine("xuxu"); } }第一种方式，编译器会把析构函数编译成Finalize()，看来是一种好的地方放置释放资源的地方。但是析构函数具有不确定性，它是在垃圾
c# 构造函数和析构函数
m0_59076427的博客
09-01 102
默认的构造函数是没有任何参数的，可以重新设置无参数的构造函数，也可以为构造函数设置参数，构造函数的名称必须跟类名一样。析构函数也理解为一种特殊的函数，及类开始要构造，结束要析构。构造函数理解为一种特殊的函数，起构造作用。类的构造函数是类的一个特殊的成员函数，class类都需要构造函数和析构函数。
C# 类的构造函数以及析构函数
Crookiebird的博客
09-11 280
C#的构造函数，C#析构函数，C#基础知识
C#定义类（构造函数）
duanworld的博客
03-30 2483
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; /*  * C#定义类  * 类是抽象的概念，比如猫、狗可以归为动物一类  * 类和对象的区别：  * 对象是具体的物体，比如猫和狗属于动物类，但他们
C# 方法的定义，调用，和参数传递（学习心得 12）
AItrust的博客
06-18 1253
用来执行一个任务的语句块。 每个 C# 程序至少有一个 Main 方法。 使用方法需要： 定义方法。 调用方法。 文章目录一、定义方法二、调用方法三、递归方法调用四、参数传递4.1 按值传递参数4.2 按引用传递参数4.3 按输出传递参数 一、定义方法 语法： <Access Specifier> <Return Type> <Method Name>(Parameter List) { Method Body } 参数： Access Specifier：
一起学C#：构造函数和析构函数.rar
03-27
在C#编程语言中，构造函数和析构函数是两个非常关键的概念，它们在对象生命周期管理中起到至关重要的作用。让我们深入探讨一下这两个概念及其在实际编程中的应用。 首先，构造函数是C#中用于初始化新创建对象的方法...
C#中构造函数和析构函数的用法
04-28
构造函数与析构函数是一个类中看似较为简单的两类函数，但在实际运用过程中总会出现一些意想不到的运行错误。本文将较系统的介绍构造函数与析构函数的原理及在C#中的运用，以及在使用过程中需要注意的若干事项。
C#中构造函数和析构函数用法实例详解
09-02
在C#编程语言中，构造函数和析构函数是两种非常关键的特殊方法，它们分别负责对象的初始化和清理工作。下面将详细讲解这两种方法的原理、定义、使用方法及注意事项。 **一、构造函数** 构造函数是创建类实例时自动...
从小白开始学C++ 类与对象一（创建、定义类、构造函数、析构函数）
Enternalwiser的博客
08-09 1070
C++ 对象和类 创建和定义类 构造函数 析构函数
C# 类、对象、属性、方法
向死而生
03-05 4566
前言：      C#视频看完有些日子了，总结一下收获吧！学习是一个不断思考总结的的过程，从总结中也能查漏补缺。今天小编就来聊聊自己对C#中的类、对象、属性和方法的理解。 正文： 一 相关概念         先来说一说类、对象、属性和方法的字面理解。         类：具有相似属性和方法的集合。         对象：客观真实存在的物体或者事物，看得见摸得着。         属
C#访问修饰符
juandaidai的博客
08-18 349
类定义的具体语法形式如下。 1 类的访问修饰符 修饰符 类名2 { 3 类的成员 4 } 类的访问修饰符：用于设定对类的访问限制，包括 public、internal 或者不写，用 internal 或者不写时代表只能在当前项目中访问类；public 则代表可以在任何项目中访问 类。 修饰符：修饰符是对类本身特点的描述，包括 abstract、sealed 和 static。abstract 是象的意思，使用它修饰符的类不能被实例化；sealed 修饰的类是密封类，不能 被继.
C#类的定义
solar_lcx的博客
05-26 954
如何定义一个类 定义一个类应该要有属性和方法(所属的属性及方法一定是该类事物所共有的)关键字 class用于修饰一个类。 这个类包含了 public、 private、class、int几个关键字。 public ： 即公共的的意思，代表这个类是对外公开的。 class：即类的意思，用于修饰一个类。 private：即私有的意思，代表这个类是私有化的。类是私有化的。 Person：在此代表类名。 height、age：字段名，在此被称为成员变量。 int：基本数据类型之一，..
定义C#的类
weixin_34268310的博客
04-19 172
《叩开C#之门》系列之四 四、定义C#的类 既然类类型是C#中最重要、最常见的类型，因此它是我要介绍的重点，实际上，C#中的许多特性都可以通过类类型来体现。 前面已经介绍，一个类对象中，主要包括字段、属性和方法。不过除此之外，在类类型中还可以定义嵌套类，也可以定义一个常量。 对于一个没有任何编程知识的初学者而言，也许还应介绍一下常量与变量。不过从它们的名字就可以非常清晰地辨明二者的区别，常...
【c#】定义类成员（字段、方法、属性）
热门推荐
学习ing.........
07-16 1万+
成员定义 public----成员可以由任何代码访问private----成员只能由类中的代码访问（如果没有使用任何关键字，默认使用这个关键字）internal----成员定只能由义他的程序集（命名空间）内部的代码访问protected----成员只能由类或派生类的代码访问protect和internal也可以结合使用   protected internal ，表示它们只能由项目中
类的析构函数-C#
kooalle_cln的专栏
08-05 531
在类的实例超出范围时，要确保其所占的存储能被回收，于是出现了析构函数，析构函数在C++中用于释放内存并且执行清除操作。C#中使用垃圾回收器来自动完成大部分的类似工作。 下面举个例子，来看看析构函数： using System; using System.Collections.Generic; using System.Linq; using System.Text;   names
C#构造函数、操作符重载以及自定义类型转换
weixin_30868855的博客
09-11 121
构造器 　　构造器（构造函数）是将类型的实例初始化的特殊方法。构造器可分为实例构造器和类型构造器，本节将详细介绍有关内容。 实例构造器 　　顾名思义，实例构造器的作用就是对类型的实例进行初始化。如果类没有显示定义任何构造器，C#编译器会定义一个默认的无参构造器。相反，如果类中已经显示地定义了一个构造器，那么就不会再生成默认构造器了。定义实例构造器的语法这里就不再多做阐述了（该懂得要懂呀），下面通...
C#构造函数详解
ChinarCSDN的博客
06-03 1万+
构造函数 本文提供全流程，中文翻译。 Chinar 坚持将简单的生活方式，带给世人！（拥有更好的阅读体验 —— 高分辨率用户请根据需求调整网页缩放比例） Chinar —— 心分享、心创新！助力快速理解 构造函数的用法、详解为新手节省宝贵的时间，避免采坑！ 1 Constructor —— 构造函数 2 Initialize object —— 初...
c#构造函数和析构函数
最新发布
09-21
构造函数分为实例构造函数、私有构造函数和静态构造函数： 1. 实例构造函数是实现对类中实例进行初始化的方法成员。 示例： ```csharp public class Cat { int i = 4; public Cat() { Console.WriteLine("The ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值