C#基础之类的详解

类

        类是自定义数据类型的蓝图,对现实生活中一类具有共同特征的事物的抽象。它是面向对象中的概念，是面向对象编程的基础。

        类是一种数据结构，包含了数据成员（字段、常量）和函数成员（方法、属性、索引器、事件、运算符、构造函数、析构函数和静态构造函数）。类的类型是支持继承。

1、类的声明

        class是声明类的关键字，其格式为[访问修饰符] class 类名称 [: 父类名] { [访问修饰符] 数据成员或函数成员 }。关于访问修饰符可以阅读前面文章[访问修饰符]。下面通过一段代码了解其定义：

public class PrintImage
{
#region  数据成员
  /// <summary>
  /// 打印机名称
  /// </summary>
  private string _Printername= string.Empty;;
  /// <summary>
  /// 图片
  /// </summary>
  public Image ImageDocument { get; set; }
#endregion

#region  函数成员
  /// <summary>
  /// 构造函数
  /// </summary>
  public PrintImage()
  {
    // 方法体内容
  }
  /// <summary>
  /// 析构函数
  /// </summary>
  ~ PrintImage() 
  { 
    // 方法体内容    
  }        
  /// <summary
  /// 打印方法
  /// </summary> 
  public Print(string printername,Image image)
  {
    // 方法体内容
  }
  /// <summary
  /// 预览方法
  /// </summary> 
  public Preview(Image image)
  {
    // 方法体内容
  }
  /// <summary>
  /// 泛型方法
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="parameter"></param>
  public static void Show<T>(T parameter)
  {
    // 方法体内容
  }
#endregion
}

2、构造函数

构造函数是一个与类共享相同名称的方法，每个类只有一个。通常设置在类中定义的变量的初始值。

构造函数类型有默认构造函数、参数化构造函数、复制构造函数、静态构造函数和私有构造函数。默认构造函数没有任何参数。

using System;

namespace Fountain.Net.Base.Sample
{
    public class Cars
    {
        /// <summary>
        /// 品牌
        /// </summary>
        private  string brand =string.Empty;
        /// <summary>
        /// 
        /// </summary>
        public string Brand
        {
            get { return brand; }
            set { brand = value; }
        }
        /// <summary>
        /// 构造函数
        /// </summary>
        public Cars()
        {
            Console.WriteLine("已声明创建对象");
        }
        /// <summary>
        /// 析构函数
        /// </summary>
        ~ Cars()
        {
            Console.WriteLine("对象已被删除");
        }
    }
}
//== 引用
using System;

namespace Fountain.Net.Base.Sample
{
    class Program
    {
        static void Main(string[] args)
        {
            Cars cars=new Cars();
            // 设置
            cars.Brand="dotNet开发技术分享";
            // 获取后输出
            Console.WriteLine(string.Format("汽车品牌：{0}",cars.Brand));
            //
            Console.ReadLine();
        }
    }
}

//== 结果
已声明创建对象
汽车品牌：dotNet开发技术分享

对象已被删除

3、析构函数

        析构函数是一种特殊的成员函数,用于在对象被销毁时执行必要的释放资源。

        析构函数特性：一个类只能有一个、无法继承或重载、无法调用、既没有修饰符，也没有参数。

//== 引用
using System;

namespace Fountain.Net.Base.Sample
{
    class Program
    {
        static void Main(string[] args)
        {
            Cars cars=new Cars();
            // 设置
            cars.Brand="dotNet开发技术分享";
            // 获取后输出
            Console.WriteLine(string.Format("汽车品牌：{0}",cars.Brand));
        }
    }
}

//== 结果
已声明创建对象
汽车品牌：dotNet开发技术分享
对象已被删除

4、抽象类

        以abstract 关键字修饰符用于定义抽象类，不完整，并且它仅用作基类。抽象类有几个特性，包括不能直接实例化、不能被密封、允许但非必须包含抽象成员。

using System;

namespace Fountain.Net.Base.Sample
{
    /// <summary>
    /// 定义动物抽象类
    /// </summary>
    public abstract class Animal
    {
        public abstract void Run(); 
    }
    /// <summary>
    /// 定义由动物类派生猫
    /// </summary>
    public class Cat : Animal
    {
        public override void Eat()
        {
            // 输出
            Console.WriteLine("小猫吃鱼");
        }
    }
}
//== 引用
using System;

namespace Fountain.Net.Base.Sample
{
    class Program
    {
        static void Main(string[] args)
        {
            Cat cat=new Cat();
            // 调用方法
            cat.Eat();
            Console.ReadLine();
        }
    }
}

5、密封类

        以sealed关健字修饰符定义的类，密封类特性有不能被继承。如果是密封成员，则派生类中不能对其重写该成员。密封成员属性可提高反射在检索属性时的性能。

using System;
using System.Collections.Generic;

namespace Fountain.Net.Base.Sample
{
    /// <summary>
    /// 密封类
    /// </summary>
    public sealed class Users
    {
        /// <summary>
        /// 用户ID
        /// </summary>
        public string UserId { get; set; }
        /// <summary>
        /// 用户名称
        /// </summary>
        public string UserName { get; set; }
        /// <summary>
        /// 密封并重写基类中的ShowInfo方法/// 
        /// </summary>
        public bool Login()
        {
            try
            {
                return true;
            }
            catch(Exception exception)
            {
                throw new Exception(exception.Message);
            }
        }
        /// <summary>
        /// 获取用户列表
        /// </summary>
        /// <returns></returns>
        public Dictionary<string,string> Getuser()
        {
            try
            {
                Dictionary<string, string> userList = new Dictionary<string, string>();

                userList.Add("ID20240001", "A用户");
                userList.Add("ID20240002", "B用户");
                userList.Add("ID20240003", "C用户");
                userList.Add("ID20240004", "D用户");

                return userList;

            }
            catch (Exception exception)
            {
                throw new Exception(exception.Message);
            }
        }
    }
}

using System;

namespace Fountain.Net.Base.Sample
{
    class Program
    {
        static void Main(string[] args)
        {
            Users users = new Users();
            users.UserId="ID20240001";
            users.UserName="A用户";
            Console.WriteLine(string.Format("用户:{0}-{1} 登录状态:{2}",users.UserId,users.UserName,users.Login()));
       
            Dictionary<string, string> userList = users.Getuser();
            foreach (string item in userList.Keys)
            {
                Console.WriteLine(string.Format("在线用户:{0}-{1}", item, userList[item]));
            }
            Console.ReadLine();
        }
    }
}

// 输出结果
用户:ID20240001-A用户 登录状态:True
在线用户:ID20240001-A用户
在线用户:ID20240002-B用户
在线用户:ID20240003-C用户
在线用户:ID20240004-D用户

6、静态类

        以static关健字修饰符定义的类，静态类主要特性有不能实例化、仅包含静态成员、密封的、不能包含实例构造函数。

using System;
using System.IO;

namespace Fountain.Net.Base.Sample
{
    /// <summary>
    /// 静态类
    /// </summary>
    public static class Logs
    {
        // 静态字段 当前程序的执行路径
        private static string path=System.AppDomain.CurrentDomain.BaseDirectory;
        /// <summary>
        /// 写日志内容的静态方法
        /// </summary>
        /// <param name="content">内容</param>
        public static void Writting(string content) 
        {
            try
            {
                // 根据日期定义文件名称
                string filename = string.Format("{0}.log",DateTime.Now.ToString("yyyyMMddHH"));
                // 将内写转成字节
                byte[] contentArray = System.Text.Encoding.UTF8.GetBytes(content);
                // 创建文件流
                using (FileStream fileStream = new FileStream(path + Path.DirectorySeparatorChar + filename, FileMode.Append, FileAccess.Write, FileShare.ReadWrite))
                {
                    fileStream.Seek(0, System.IO.SeekOrigin.End);
                    // 写入流
                    fileStream.Write(contentArray, 0, contentArray.Length);
                }
            }
            catch(Exception exception)
            {
                throw new Exception(exception.Message);
            }
        }
    }
}

// 应用
// 静态类 不用创建实列直接调用
Logs.Writting("测试静态类的调用");

小结

        以上是C#中面向对象基础的类的全部内容，希望对大家理解类一定的参考借鉴价值， 敬请关注后续内容。