C#（十六）之C#类中的成员属性 构造函数 析构函数

C#中类的成员属性、构造函数、析构函数。

代码是基于昨天类的代码进行测试的。

基本代码：

/*声明对象*/
cat Tom = new cat();
Tom.age = -1;  //设置年龄
Tom.TalkAge();  //输出：我今年-1岁了

类中的方法：

/*我今年几岁了*/
public void TalkAge()
{
     Console.WriteLine("我今年{0}岁了",age);
}

这个代码是没有问题的，但是逻辑有问题，没有人可能是-1岁。

那么可以定义一个访问器进行数据合法性的检查。

这样做的好处就是即检查了数据的合法性，又加强了类的封装

上代码：

类中的代码：

private int age;
private int miceCount = 0;// 私有的
        /*访问器 start*/
        public void TellAge(int getAge)
        {
            if (getAge < 0)
            {
                age = 0;
            }
            else {
                age = getAge;
            }
        }
        public int PutAge()
        {
            return age;
        }
        /*访问器 end*/

调用：

Tom.TellAge(3);
int age = Tom.PutAge();
Console.WriteLine("我今年{0}岁了", age);  //输出我今年3岁了
// 输出负数是什么效果，可以自己尝试下。

C#中这样写是没有问题的，但是C#提供了一个更好的解决方法：属性

定义属性：

private int age;       
        // 定义一个属性
        public int Age
        {
            get{ // 返回值
                return age;
            }
            set{ //赋值
                if(value > 0){
                    age = value;
                }else{
                    age = 0;
                }
            }
        }
// value 关键字就是赋给变量的值
  
// 调用属性
            Tom.Age = -1;
            Console.WriteLine("我今年{0}岁了",Tom.Age);  //输出：我今年0岁了
 

接下来看下C#类中的构造函数：

1：默认构造函数：

就是我们在使用类的时候实例化的函数：

/*声明对象*/
cat Tom = new cat();

然后再对类中声明的共有属性进行赋值。

2：带参数的构造函数：

如果类型声明的变量都是私有的，我们可以通过构造函数给其赋值。

构造函数名称必须与类名称相同

类：

/*声明构造函数*/
        public cat(string putname,int putage)
        {
            age = putage;
            name = putname;
            Console.WriteLine("我叫{0}，今年{1}岁了",name,age);
            // 输出：我叫gc，今年23岁了
        }

调用：

/*声明对象*/
cat Tom = new cat("gc",23);

3：无参构造函数

说白了就是把有参构造函数里边的参数给去了就行了。

/*声明构造函数*/
        public cat()
        {
            age = 0;
            name =’’;
            Console.WriteLine("我叫{0}，今年{1}岁了",name,age);
            // 输出：我叫gc，今年23岁了
        }

调用：

/*声明对象*/
cat Tom = new cat();

析构函数：

作用：删除或者释放掉不使用的对象来释放内存空间。

析构函数的定义：

/*析构函数*/
~cat() {
      Console.WriteLine("我走了");
}

C#程序中在创建类的时候默认定义了一个构造函数与析构函数，所以，没有特殊需要，不需要二次定义。

析构函数让我定义在了构造函数下边，那我在析构函数下边定义一个类，看其是否可以访问到。

//在类中添加了析构函数
            cat Tom = new cat();
            //输出：
            /*
             我来了
             我走了
             */
            // 析构函数让我定义在了构造函数下边，那我在析构函数下边定义一个类，看其是否可以访问到。
            for (int i = 0; i < 5; i++)
            {
                Tom.CatchMouse();
                /*
                输出：
                我来了
                我抓了1只老鼠
                我抓了2只老鼠
                我抓了3只老鼠
                我抓了4只老鼠
                我抓了5只老鼠
                我走了
                 */
            }
            // 析构函数是在函数调用之后再执行的，与其放置的位置没有关系。

析构函数用处不大，知道就好。

测试所用代码：

类文件：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace gc
{
    class cat
    {
        public string name;       // 共有的
        private int age;
        private int miceCount = 0;// 私有的
        
        /*声明无参构造函数*/
        public cat()
        {
            age = 0;
            name = "";
            Console.WriteLine("我来了");
        }
        /*析构函数*/
        ~cat() {
            Console.WriteLine("我走了");
        }
        /*声明有参构造函数*/
        /*public cat(string putname,int putage)
        {
            age = putage;
            name = putname;
            Console.WriteLine("我叫{0}，今年{1}岁了",name,age);
            // 输出：我叫gc，今年23岁了
        }//*/
        // 定义一个属性
        public int Age
        {
            get{ // 返回值
                return age;
            }
            set{ //赋值
                if(value > 0){
                    age = value;
                }else{
                    age = 0;
                }
            }
        }
        /*访问器 start*/
        public void TellAge(int getAge)
        {
            if (getAge < 0)
            {
                age = 0;
            }
            else {
                age = getAge;
            }
        }
        public int PutAge()
        {
            return age;
        }
        /*访问器 end*/
        /*我今年几岁了*/
        public void TalkAge()
        {
            Console.WriteLine("我今年{0}岁了", age);
        }
        /*私有行为*/
        private void Hello()
        {
            Console.WriteLine("只有我自己能用");
        }
        /*公共行为*/
        public void Method()
        {
            Hello();
            Console.WriteLine("别人可以调用我");
        }
        /*捉老鼠*/
        public void CatchMouse()
        {
            miceCount++;
            //Hello();
            Console.WriteLine("我抓了{0}只老鼠", miceCount);
        }
        
    }
}

主文件：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using gc; //使用自己定义类的命名空间
namespace gc
{
    class Program
    {
        /* C#主要的运行函数，就是main函数 */
        static void Main(string[] args)
        {
            /*声明对象*/
            /*cat Tom = new cat();
            //Tom.name = "Tom"; // 设置姓名
            //Tom.age = -1;  //设置年龄
            //Tom.TalkAge();  //输出：我今年-1岁了
            Tom.TellAge(3);
            int age = Tom.PutAge();
            //Console.WriteLine("我今年{0}岁了", age);  //输出我今年3岁了
            // 输出负数是什么效果，可以自己尝试下。
            // 调用属性
            Tom.Age = -1;
            //Console.WriteLine("我今年{0}岁了",Tom.Age);  //输出：我今年0岁了//*/
            //在类中添加了析构函数
            cat Tom = new cat();
            //输出：
            /*
             我来了
             我走了
             */
            // 析构函数让我定义在了构造函数下边，那我在析构函数下边定义一个类，看其是否可以访问到。
            for (int i = 0; i < 5; i++)
            {
                Tom.CatchMouse();
                /*
                输出：
                我来了
                我抓了1只老鼠
                我抓了2只老鼠
                我抓了3只老鼠
                我抓了4只老鼠
                我抓了5只老鼠
                我走了
                 */
            }
            // 析构函数是在函数调用之后再执行的，与其放置的位置没有关系。
        }
        
    }
}

有好的建议，请在下方输入你的评论。

欢迎访问个人博客
https://guanchao.site

欢迎访问小程序：