使用 C# 学习面向对象编程：第 4 部分

最新推荐文章于 2024-09-10 23:15:55 发布
最新推荐文章于 2024-09-10 23:15:55 发布
阅读量791 收藏 21
点赞数 22
分类专栏： 面向对象 文章标签： c# 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiefeng240601/article/details/139584134
版权

C# 构造函数

第 1 部分仅介绍了类构造函数的基础知识。 在本课中，我们将详细讨论各种类型的构造函数。

属性类型

  • 默认构造函数
  • 构造函数重载
  • 私有构造函数
  • 构造函数链
  • 静态构造函数
  • 析构函数

请注意构造函数的一些基本概念，并确保你的理解非常清楚，否则你无法理解 OOP（构造函数）。

  1. 构造函数的名称与类名相同。
  2. 构造函数的目的是为了初始化成员变量。
  3. 创建对象时会自动调用构造函数。
  4. 构造函数没有任何返回类型，甚至没有 void。
  5. 如果我们希望自动执行某些代码，那么我们想要执行的代码必须放在构造函数中。
  6. 我们不能明确调用构造函数。

C# 构造函数的一般形式如下。

modifier constructor_name(parameters)
{
    // constructor body
}

修饰符可以是 private、public、protected 或 internal。构造函数的名称必须是其定义所属类的名称。构造函数可以接受零个或多个参数。零个参数（即无参数）的构造函数称为默认构造函数。请记住，构造函数没有返回类型。

默认构造函数

无参数的构造函数称为默认构造函数。请记住，构造函数没有返回类型。默认构造函数只是调用直接基类的无参数构造函数。

例子

using System;

namespace DefaultConstructors
{
    class Program
    {
        static void Main(string[] args)
        {
            // 创建 car 类的一个实例 sportscar，调用默认构造函数
            car sportscar = new car();

            // 打印 sportscar 的 model_Id 属性值
            Console.WriteLine("Car Model is :{0} ", sportscar.model_Id);

            // 打印 sportscar 的 Maker_Name 属性值
            Console.WriteLine("Car Name is :{0}", sportscar.Maker_Name);

            // 等待用户按下任意键继续执行程序
            Console.ReadKey();
        }

        // 定义 car 类
        class car
        {
            // 私有字段 model，表示车型
            private int model = -1;

            // 私有字段 maker，表示制造商
            private string maker = string.Empty;

            // 默认构造函数
            public car()
            {
                // 默认构造函数的主体是空的，可以添加初始化逻辑
            }

            // 公共只读属性 model_Id，用于获取 model 字段的值
            public int model_Id
            {
                get 
                {
                    return model;
                }
            }

            // 公共只读属性 Maker_Name，用于获取 maker 字段的值
            public string Maker_Name
            {
                get
                {
                    return maker;
                }
            }
        }
    }
}

输出


在这个简单的例子中，我们有一个无参数或零参数的构造函数，它是类的默认构造函数。上述示例的输出是空成员变量。

请注意另外一点；如果我们从示例 1 中删除以下代码，则输出是相同的。

public car()
{
   //Default Constructor
}

这意味着如果我们没有定义类的构造函数，系统将调用默认构造函数。

构造函数重载

首先，我们来讨论一下构造函数重载的目的；对前面的主题有清晰的理解非常重要。在设计 OOP 模型时存在许多复杂的情况，我们需要为类的不同目的初始化一组不同的成员变量。所以我们需要使用构造函数重载。构造函数重载的定义是。

和成员函数一样，构造函数也可以在类中重载。重载的构造函数必须在参数数量和/或参数类型和/或参数顺序上有所不同。

例子

using System;

namespace ConstructorsOverloading
{
    class Program
    {
        static void Main(string[] args)
        {
            // 使用无参数构造函数创建 car 类的一个实例
            car sportscar1 = new car();

            // 使用包含两个参数（model 和 maker）的构造函数创建 car 类的一个实例
            car sportscar2 = new car(2013, "mercedes");

            // 使用包含两个参数（maker 和 Enginetype）的构造函数创建 car 类的一个实例
            car sportscar3 = new car("mercedes", 7.8);

            // 输出使用无参数构造函数创建的 sportscar1 的属性值
            Console.WriteLine("Constructor without arguments");
            Console.WriteLine("Car Model is :{0} ", sportscar1.model_Id);
            Console.WriteLine("Car Name is :{0}", sportscar1.Maker_Name);
            Console.WriteLine("Car Engine Power is :{0}", sportscar1.Engine);

            // 输出使用包含两个参数的构造函数创建的 sportscar2 的属性值
            Console.WriteLine("\nConstructor with two arguments");
            Console.WriteLine("Car Model is :{0} ", sportscar2.model_Id);
            Console.WriteLine("Car Name is :{0}", sportscar2.Maker_Name);
            Console.WriteLine("Car Engine Power is :{0}", sportscar2.Engine);

            // 输出使用包含两个参数的构造函数创建的 sportscar3 的属性值
            Console.WriteLine("\nConstructor with two arguments");
            Console.WriteLine("Car Model is :{0} ", sportscar3.model_Id);
            Console.WriteLine("Car Name is :{0} ", sportscar3.Maker_Name);
            Console.WriteLine("Car Engine Power is :{0}", sportscar3.Engine);

            // 等待用户按下任意键继续执行程序
            Console.ReadKey();
        }

        // 定义 car 类
        class car
        {
            // 私有字段，表示车型
            private int model = -1;

            // 私有字段，表示制造商
            private string maker = string.Empty;

            // 私有字段，表示发动机类型
            private double Enginetype = 0.0;

            // 无参数的默认构造函数
            public car()
            {
                // 默认构造函数的主体是空的，可以添加初始化逻辑
            }

            // 包含两个参数（model 和 maker）的构造函数
            public car(int _model, string _maker)
            {
                model = _model;
                maker = _maker;
            }

            // 包含两个参数（maker 和 Enginetype）的构造函数
            public car(string _maker, double _power)
            {
                maker = _maker;
                Enginetype = _power;
            }

            // 公共属性，用于获取和设置 model 字段的值
            public int model_Id
            {
                get
                {
                    return model;
                }
                set
                {
                    model = value;
                }
            }

            // 公共属性，用于获取和设置 maker 字段的值
            public string Maker_Name
            {
                get
                {
                    return maker;
                }
                set
                {
                    maker = value;
                }
            }

            // 公共属性，用于获取和设置 Enginetype 字段的值
            public double Engine
            {
                get
                {
                    return Enginetype;
                }
                set
                {
                    Enginetype = value;
                }
            }
        }
    }
}

输出


亲爱的读者，请注意，在这个例子中，我们使用三个不同的对象重载了构造函数，它们是sportscar1、sportscar2 和 sportscar3。

我们注意到

  • sportscar1 没有参数（默认构造函数超出了主题范围）。因此该成员变量具有在初始化时分配的默认值。
  • sportscar2 有两个参数，分别用值 2013 和 Mercedes 初始化成员变量 model 和 name，但没有初始化 Enginetype 变量，因此它具有默认值零。
  • sportscar3 有两个参数，分别用值 Mercedes 和 7.8 初始化成员变量 name 和 Enginetype，但不初始化 model 变量，因此它具有默认值 -1。

私有构造函数

亲爱的读者，我们知道，私有访问修饰符有点特殊。我们既不能创建类的对象，也不能仅使用私有构造函数来继承类。但是，是的，我们可以在类中拥有一组公共构造函数以及私有构造函数，并且公共构造函数可以通过构造函数链从类内部访问私有构造函数。私有构造函数通常用于仅包含静态成员的类中。

using System;

namespace PrivateConstructors
{
    class Program
    {
        static void Main(string[] args)
        {
            // 使用包含 model 参数的构造函数创建 car 类的一个实例
            car sportscar = new car(2013);
            Console.Read();
        }

        class car
        {
            // 公共字段，表示汽车名称
            public string carname;

            // 私有的默认构造函数
            private car()
            {
                // 初始化 carname 字段
                carname = "lamborghini";
            }

            // 公共的构造函数，包含一个 int 型的 model 参数
            // 该构造函数通过 :this() 调用私有的默认构造函数
            public car(int model) : this()
            {
                // 打印车型年份
                Console.WriteLine("Model Year:{0}", model);

                // 打印制造商名称
                Console.WriteLine("Maker Name:{0}", carname);
            }
        }
    }
}

这是一个非常简单的私有构造函数的例子，其中我们使用公共构造函数来调用私有构造函数。

构造函数链

亲爱的读者，当一个构造函数调用同一个类或该类的基类中的另一个构造函数时，这被称为构造函数链。这是避免代码重复的非常有用的技术。

using System;

namespace Constructorchaining
{
    class Program
    {
        static void Main(string[] args)
        {
            // 使用包含 engine 参数的构造函数创建 car 类的一个实例
            car sportscar = new car(7.8);
            Console.Read();
        }

        class car
        {
            // 公共字段，表示汽车名称
            public string carname;

            // 公共字段，表示车型年份
            public int model;

            // 公共字段，表示发动机类型
            public double engine;

            // 包含一个 carname 参数的构造函数
            public car(string _carname)
            {
                carname = _carname;
            }

            // 包含一个 model 参数的构造函数，并调用包含 carname 参数的构造函数
            public car(int _model) : this("lamborghini")
            {
                model = _model;
            }

            // 包含一个 engine 参数的构造函数，并调用包含 model 参数的构造函数
            public car(double _engine) : this(2013)
            {
                engine = _engine;
                
                // 打印车型年份
                Console.WriteLine("Model Year:{0}", model);
                
                // 打印制造商名称
                Console.WriteLine("Maker Name:{0}", carname);
                
                // 打印发动机类型
                Console.WriteLine("Engine Type:{0}", engine);
            }
        }
    }
}

在前面的例子中，我们创建了三个不同的类，它们都具有相同的名称 car 和不同的参数类型，每个类都链接前一个类来调用另一个构造函数。

静态构造函数

静态构造函数是一种特殊类型，不采用访问修饰符，也不具有参数。在创建第一个实例或引用任何静态成员之前，会自动调用它以初始化类。静态构造函数不会被直接调用。用户无法控制静态构造函数的执行。

using System;

namespace staticconstructors
{
    class Program
    {
        // 定义 car 类
        public class car
        {
            // 静态构造函数
            static car()
            {
                // 打印静态信息，静态构造函数在类第一次被使用前自动调用，并且只调用一次
                System.Console.WriteLine(@"Lamborghini is the best sports car owned by Audi AG 1998 (its static info)");
            }

            // 静态方法 Drive
            public static void Drive()
            {
                // 打印稳定公司信息
                System.Console.WriteLine("Audi is the stable company");
            }
        }

        // 主程序入口点
        static void Main()
        {
            // 调用 car 类的静态方法 Drive
            car.Drive();

            // 再次调用 car 类的静态方法 Drive
            car.Drive();

            // 等待用户按下任意键继续执行程序
            Console.ReadKey();
        }
    }
}

输出


注意，静态构造函数在第一次加载类时被调用。当我们再次调用“car.Drive”时，它不会调用静态构造函数。

析构函数

亲爱的读者，当我们使用 OOP 并在系统内存中创建对象时，需要从系统内存中清除不需要的对象。.NET 框架内置了垃圾收集功能，用于释放未使用对象占用的内存。析构函数是一个与类名同名但以字符 ~ 开头的函数。析构函数不能有任何修饰符 private、public 等。

例子

class car
{
    // 公共构造函数
    public car()
    {
        // 构造函数，在创建对象实例时调用
        // 可以在这里进行对象的初始化操作
        // 比如分配资源，设置初始状态等
    }

    // 析构函数
    ~car()
    {
        // 析构函数，在对象被垃圾回收时调用
        // 可以在这里进行对象的清理操作
        // 比如释放资源，关闭文件，断开网络连接等
    }
}
谢.锋
关注
  • 22
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C#编程篇 第03部分 C#核心——面向对象
weixin_52566131的博客
05-05 550
第03部分 C#核心——面向对象 前言 0.1 面向过程（POP） “面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。这些都是以什么正在发生为主要目标进行编程，不同于面向对象的是谁在受影响。与面向对象明显的不同就是封装、继承、类。简写为POP。 C语言：面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。 0.2 面向数据（DOP） 面向数据主要是指面向数据解析（DOP，Data-oriented
学习C#之面向对象
骆驼祥子
12-28 346
面向对象三大特性：继承、封装、多态 一、封装 要求字段尽量不要对无关的类型开放权限，函数若外部需要访问则开为可访问权限，否则也设为封闭权限。一个类型相关的操作，尽可能的封装在类型内部。 二、继承 一个类可以派生（继承）自另一个类，也可以派生出任意多个子类（派生类）。 子类可以继承（直接访问）基类（父类）中除私有访问权限之外的任何成员。
深入理解C#面向对象编程:：概念、原则、特性及应用
qq_35320456的博客
02-06 1347
深入理解C#面向对象编程:：概念、原则、特性及应用
C#面向对象编程：类概述
2302_77319699的博客
05-18 1451
class：类声明使用的关键字。语法：[修饰符] class 类的名称 [类的基类或接口] { //方法属性 }[修饰符] [类的基类或接口] 是可选项。
【C#基础】C# 面向对象编程
好学若饥，谦卑若愚。
02-24 2994
编程语言 C# 面向对象编程知识点介绍。
c#面向对象编程的小案例 c#经典案例.pdf
05-07
"C#面向对象编程小案例：模拟彩票选号器" 本资源详细介绍了C#面向对象编程的小案例，模拟彩票选号器的实现。该案例主要使用C#语言，通过面向对象编程的思想，实现了一个彩票选号器的模拟。 知识点1：System.Random...
C#面向对象编程期末参考题
12-22
【描述】提到“期末开卷参考题”，暗示我们将探讨一些学生在学习过程中可能遇到的实际问题或考试题目，这些题目可能会涵盖C#面向对象编程的基本原理、类与对象、继承、封装、多态等关键概念。 在C#中，面向对象编程...
面向对象编程语言：C#.zip
08-19
史上最全编程语言全套教程，共99门编程语言，包括： 函数式编程语言 壳编程语言 常见编程语言 并行编程语言 数据分析编程语言 数据库查询语言 系统编程语言 ...面向对象编程语言 等所有常见的变成语言系列教程
C#面向对象编程-多态习题[整理].pdf
10-11
C#面向对象编程-多态习题[整理].pdf
原始输入解析XBOX手柄
FlameCyclone的博客
09-10 92
原始输入解析XBOx手柄输入
浅谈C#之线程锁
a876106354的博客
09-10 434
锁是一种同步机制，用于控制多个线程对共享资源的访问。当一个线程获得了锁时，其他线程将被阻塞，直到该线程释放了锁。在并发编程中，多个线程同时访问共享资源可能导致数据竞争和不确定的行为。锁可以确保在任意时刻只有一个线程可以访问共享资源，从而避免竞态条件和数据不一致性问题。
java实现文本相似度计算
fallwind_of_july的博客
09-10 156
有多个文本字符串，如何设计一个简单的统计方法（从词频的角度设计），来计算出多个文本字符串两两之间的相似度，并输出大于指定相似度阈值的文本
Unity报错：error CS8805: Program using top-level statements must be an executable.
大话程序员
09-10 102
大概意思网上查了一下，就是说C# 的第一（top)行有错误，或者类（类的头部）就没写全这什么意思呢？又定位不到具体是哪个类但肯定是刚修改了一点点代码，就导致出错（一般都是写两行代码调试一次，除非你写半天代码才进行调试一次）其实很简单，就是：多写了一个分号把分号去掉即可。
C# List定义和常用方法
語衣的个人博客
09-10 875
列表（List）是一种常用的集合类型，它属于System.Collections.Generic命名空间。列表是一个有序集合，可以包含重复的元素，并且可以根据索引访问元素。
NLP基础及其代码-tokenizer
靓仔沾点健忘症，写给时间下游的自己
09-10 492
寻找损失增加最少的分词，这些分词对语料库的整体损失影响较小,因此从某种意义上说,它们“不太需要”并且是移除的最佳候选者。选择让似然概率最大的值，具体的计算使用合并后的概率值，除以合并前的概率值，举个例子, 在考虑将"e"和"s"合并的时候除了会考虑"es"的概率值，还会考虑"e"和"s"的概率值。给定分词的概率是它在原始语料库中的频率(我们找到它的次数),除以词汇表中所有分词的所有频率的总和(以确保概率总和为 1)。其中num(x)为当前单词在语料中出现的次数，p(x)为当前单词按某种分词方式分词的概率。
浅谈C#之485通讯
a876106354的博客
09-05 642
C#中实现485通讯，通常指的是使用RS-485串行通信接口。RS-485是一种半双工通信标准，常用于工业环境中的设备之间的通信。
[C#学习笔记]接口的特性与用法
09-05 723
在接口可不实现，实现此接口的类必须要实现此方法。
Python(一)-快速入门
最新发布
weixin_58305115的博客
09-10 446
python的注释,关键字,标识符,变量,数据类型,输入函数,输出函数
C#面向对象编程：第二章关键语法详解
本教程是关于C#面向对象程序设计的基础课程，主要聚焦于第二章的内容，包括C#的语法基础。这一章节详细讲解了以下几个核心知识点： ...通过实例练习和实际项目应用，学员可以加深对C#面向对象编程的理解和技能提升。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

谢.锋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值