【C#基础学习】第十一章、类-创新互联

目录

10余年的卢氏网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。全网整合营销推广的优势是能够根据用户设备显示端的尺寸不同，自动调整卢氏建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联公司从事“卢氏网站设计”,“卢氏网站推广”以来，每个客户项目都认真落实执行。

类

1.类的概述

1.1 类的定义

1.2 程序和类

2.声明类（类定义）

2.1 分部类和分布类型 

3.类成员

3.1 字段

3.1.1 字段的语法

3.1.2 显示字段和隐式字段的初始化

3.1.3 字段的修饰符：readonly关键字&const关键字

3.1.4 静态字段

3.2 常量

3.2.1 使用readonly关键字&const关键字来修饰字段的区别

3.3 属性

3.3.1 属性的组成

3.3.2 静态属性

3.4 构造函数

3.4.1 实例构造函数

3.4.2 静态构造函数

3.5 析构函数

3.6 索引器

3.6.1 this关键字

3.6.2 索引器的语法

4.类的实例

4.1实例化

4.1.1 实例对象

4.1.2 对象初始化语句

---

类

  C#是一种面向对象的语言，这点与C语言不同，C语言是一种面向过程的语言。除此之外，面向对象的语言还有C++、Java等。而面向对象语言的一个基本特征是它们都有类，类是C#中比较复杂的数据类型。

 本章将先讲明 什么是类，并说明类由什么组成，组成类的函数成员和数据成员怎么用，接着讲如何实例一个类。

---

1.类的概述

 就像第五章数据类型里对类型的解释一样。

带到现实中来看，大象这个物种就是一个类。大象这个物种的共同的特性（比如 年龄、分布区域、归属群落、性别，体型等）和行为（吃草、繁衍、行走、潜水等）就是类的公共属性和行为。类的实例就是大象这个物种中的一头大象。

1.1 类的定义

  类是一个能存储数据并执行代码的数据结构。

类包含数据成员和函数成员。（一个C#类可以有任意数目的数据成员和函数成员）

• 数据成员：存储 与类或类的实例 相关的数据。数据成员通常模拟和该类所表示的现实世界事务的特性。
• 函数成员：它执行代码。通常会模拟类所表示的现实世界的功能和操作

1.2 程序和类

一个运行中的C#程序是一组相互作用的类型对象，它们中大部分都是类的实例。

---

2.声明类（类定义）

类的声明定义类的特征和成员。

声明一个类并不创建类的实例，而是用于创建实例的模板。

声明类的语法：

class 大象（类的名称）     //声明类

{

  string sex；                //数据成员声明（类的成员）

  ...

  void swim（）{...}      //函数成员声明（类的成员）

  ...

} 

声明类必须包含：

• 类的名称
• 类的成员
• 类的特征（封装、继承、多态，第十四章会讲）

2.1 分部类和分布类型 

类声明可以分割为几个分布类的声明

• 每个分布类的声明都含有一些类成员的声明。
• 类的分布类声明可以在同一个文件中、也可以在不同文件中。

分布类的使用要求： 

• 类声明必须加类型修饰符 partical
• 类名称相同
• 组成类的所有分布类声明必须在一起编译

//示例：
partical class A //类名称相同
{
    int a;
}

partical class A 
{
    int b;
}

---

3.类成员

（注意：本章主讲实例成员，静态成员放在十三章讲）

在类声明中定义的类成员有9种成员类型。

其中字段和方法是最重要的类成员类型。（本章不会介绍事件）

 

类声明相当于蓝图，通过蓝图可以创建多个类的实例。

  通过类创建的实例，其中的类成员分为两种：实例成员和类成员。

• 实例成员：每个类的实例都是不同的个体，它们有自己独有的一组类成员。且因为这些数据成员都和类的实例相关，所以称为实例成员。
• 静态成员：实例成员是默认类型，但也可以声明与类而不是实例相关的成员，也就是静态成员。

3.1 字段

字段是在类或结构中直接声明的任意类型的变量。

3.1.1 字段的语法

声明字段的语法：

                     数据类型  字段名；

例如：

                     int a；

3.1.2 显示字段和隐式字段的初始化

隐式字段初始化：若字段被声明且没有被赋值，则为隐式初始化。

不同类型隐式初始化的默认值： 

• 值类型为0
• bool类型为false
• 引用类型为null

3.1.3 字段的修饰符：readonly关键字&const关键字

被readonly和const修饰的字段一旦赋值便不能再被修改。

readonly关键字&const的区别：

• 若使用readonly来修饰字段，则不需要在定义时初始化，可以在类的构造函数完成初始化。
• 若使用const来修饰字段，如果没有在定义时初始化，就会发生编译错误。

语法：

  访问修饰符 const 数据类型 变量名=值；

  访问修饰符 readonly 数据类型 变量名；

3.1.4 静态字段

若使用static关键字修饰字段，则字段为静态字段。

  静态字段被类的所有实例所共享，所有实例都访问同一内存位置。

静态字段必须通过类来访问，不能像实例字段一样通过类的对象的实例来访问字段。

语法：

  访问修饰符 static 数据类型 变量名；        //静态字段定义

  访问修饰符 数据类型 变量名；                 //实例字段定义

实例1：

class People
{
    //声明静态字段
    public static string Name; 
    //声明实例字段
    public int Age;
}

class Program
{
    static void Main(string[] args)
    {
        //实例字段通过实例对象访问
        People one=new People();
        one.Age=18;
        //静态字段只能通过类名访问
        People.Name="人类";
    }
}

实例2：

3.2 常量

  常量就是被const修饰的字段。

常量的特点：

• 类成员常量类似于局部变量。区别在于常量在类声明中，而局部变量在方法中。
• 常量在堆中没有自己的存储位置，它在编译时被编译器替换。（类似C、C++中的#define）
• 常量可以用类名直接访问。
• 常量本质上就是静态的。

3.3 属性

属性是对字段的扩展。

根据面向对象语言的封装思想（见第十章），字段最好设置为private。这样能防止客户端直接对字段进行篡改，从而保证了内部成员的完整性的同时，也可以更好的为程序员提供编写的便利。而属性的作用就是为了访问类中的私有字段。

属性的语法：

  访问修饰符  数据类型  字段名{get{return 字段名；}set{字段名=value；}}

3.3.1 属性的组成

属性由set访问器和get访问器组成。

属性可以只包含set或get，当只包含一个访问器时，另一个可以省略、或者在前面加访问修饰符private。

属性除了开头的语法，还有三种写法：

• 只包含get访问器，为只读属性。
• 只包含set访问器，为只写属性。
• 只声明属性（自动实现属性）

属性的示例：设置一个人的年龄字段，将赋值范围设置在0-150之间
public class People

{
    //私有字段声明
    private int age；
    private string name;
    private string sex;
    private string high;

    //公有属性：属性类型必须和字段属性一致
    public  string  Age
    {
        //get访问器：负责对字段值进行读取（返回字段）
        get
        {
            return age；
        }
        //set访问器：负责对字段值进行赋值（把用户传入的值赋给字段）
        //set访问器里有隐式参数value
        set
        {
            //设置年龄范围在0-150之间
            if(value<0 || value>150)
            {
                //抛出异常代码
                throw(new ArgumentOutOfRangeException("AgeIntProPery"),value,"年龄必须在0-150之间"）)；
            }
            //value是隐式参数：表示用户传入的值
            age=value；
        }
    }

    //只读属性
    public string Sex
    {
        get
        {
            return sex；
        }
    }
    //只写属性
    public string Name
    {
        private get
        {
            return name；
        }
        set
        {
            name=value；
        }
    }
    //自动实现属性
    public string High
    {
        get;set;
    }
}

属性字段命名规范：

• 对于私有字段，为Camle写法，即age、name这种。
• 对于属性名，为Pascal写法，即Age、Name这种。

3.3.2 静态属性

  静态属性与静态字段类似。 若用static来修饰属性，则属性为静态属性。

静态属性有以下特点：

• 静态属性属于类级别，无法通过实例对象访问。
• 也不能访问类的实例成员，但能被实例成员访问。
• 在类的内部，可以仅使用名称来引用静态属性
• 在类的外部，可以通过类名或者using static结构来引用静态属性

实例：

public class People
{
    //静态字段
    public static string Name;
    
    //静态属性
    public static string Name
    {
        get
        {
            return Name;
        }
        set
        {
            Name = value;
        }
    }
}

3.4 构造函数

构造函数主要用于初始化类的实例状态。当我们用构造函数创建一个对象时，构造函数会为对象分配空间，并初始化类的成员。

使用构造函数的要求：

• 如果希望从类的外部创建类的实例，需要将构造函数声明为public
• 构造函数名和类名相同
• 构造函数不能有返回值

构造函数分为两种：实例构造函数、静态构造函数。

3.4.1 实例构造函数

实例构造函数用于创建和初始化类的实例。

其中使用new运算符创建对象的过程，其实是在调用实例构造函数来初始化类中所有实例成员。

实例构造函数的特点：

• 构造函数可以有参数。
• 构造函数可以进行方法重载。
• 如果没有为类显示地定义一个构造函数，则C#编译器会自动生成一个函数体为空的默认无参的实例构造函数。如果有至少一个显示构造函数，则C#编译器不会自动生成多的构造函数。
• 可以为构造函数添加访问修饰符。

使用实例构造函数的条件：

• 构造函数必须和类同名。
• 构造函数不允许有返回类型。

//实例构造函数示例：
class People
{
    private string name;

    //只读属性
    public string Name
    {
        get
        {
            return name;
        }
    }
    
    //实例构造函数
    //被public关键字修饰的构造函数,称为公共构造函数
    //被private关键字修饰的构造函数，称为私有构造函数
    public People()
    {
        name="憨憨一号";
    }

    public people(string name)
    {
        //this关键字指代当前类的实例，可以理解为当前实例对象的引用。
        this.name=name;
    }
}

class Program
{
    static void Main(string[] args)
    {
        People one=new People();
        People two=new People("憨憨二号");
        
        Console.Writeline(one.Name)；    //打印“憨憨一号”
        Console.Writeline(two.Name)；    //打印“憨憨二号”
    }
}

注意：如果一个类只定义了一个或多个私有构造函数，而没有其他公共构造函数，则其他类就不能通过调用该类的私有构造函数来创建类的实例。

私有构造函数最典型的应用是设计模式中单例模式的实现。

单例模式是C#中的一种设计模式，他是指在设计一个类时，需要保证整个程序在运行期间只存在一个实例对象。

//设计模式中单例模式的实现：
class People
{
    //声明私有字段
    private string name;
    //声明一个公开的、静态的、类类型的变量
    public static People people;
    
    //声明属性
    public string Name
    {
        get{return name;}
    }

    //私有构造函数，只能在类的内部调用
    //也就是说用私有构造函数只能在类定义时被实例化
    private People()
    {
        Console.Writeline("私有函数被调用");
        this.name="Learning Hard";
    }
    
    //静态方法,用于返回类的实例
    public static People GetInstance()
    {
        //将实例对象的引用赋值给变量
        people=new People();
        return people;
    }
}
class Program
{
    static void Main(string[] args)
    {
        //通过调用GetInstance（）静态方法返回一个Person的实例
        //此时不能使用new运算符来创建实例，即不能使用People one=new People（）来创建实例
        People one=People.GetInstance();

        Console.Writeline("类实例的Name属性为{0}",one.Name);
    }
}

3.4.2 静态构造函数

静态构造函数用于初始化类中的静态成员。

在创建第一个实例或引用任何静态成员之前，CLR（公共语言运行时）都将自动调用静态构造函数。

class People
{
    
    private static string name;
    

    //声明属性
    public static string Name
    {
        get{return name;}
    }

    static People()
    {
        Console.WriteLine("静态函数被调用");
        name="Learning Hard";
    }
    
}
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(People.Name);
        Console.WriteLine(People.Name);
    }
}

结果如下：

从上述代码我们可知静态构造函数有以下特点：

• 静态构造函数只会执行一次
• 静态构造函数不能使用任何访问修饰符，也不能带任何参数
• 不能直接调用静态构造函数
• 在程序中，我们无法控制执行静态构造函数的时机

3.5 析构函数

析构函数用于类销毁之前释放类实例所使用的托管和非托管资源。

析构函数的作用：

对于C#应用程序所创建的大多数对象，都可以使用.NET框架的垃圾回收器（GC）来隐式地执行内存管理任务，但如创建了一个封装非托管资源的对象，在应用程序使用完这些非托管资源之后，垃圾回收器就需要运行对象的析构函数（即Finalize方法）来释放这些资源。

使用析构函数的要求：

• 只能在类中使用析构函数。
• 一个类只能有一个析构函数。
• 无法继承或重载析构函数。
• 无法显示地调用析构函数，由垃圾回收器自动调用。
• 析构函数没有参数和修饰符。

代码示例：

class People
{
    //析构函数
    ~People()
    {
        Console.WriteLine("析构函数被调用");
    }
}
//该析构函数隐式调用了基类Object的Finalize方法，上面代码中的析构函数将被隐式转化为以下代码


//
//override
protectd override void Finalize()
{
    try
    {
        Console.WriteLine("析构函数被调用");
    }
    finally
    {
        //调用基类方法
        base.Finalize();
    }
}

3.6 索引器

当一个类包含数组成员时，使用索引器可以大大地简化类中数组的访问。

3.6.1 this关键字

  this关键字在类中使用，是对当前实例的引用。

this关键字的使用要求：

• 它只能出现在以下类成员的代码块中
  • 实例构造函数
  • 实例方法
  • 属性和索引器的实例访问器
• 静态成员不是实例的一部分，所以不能在任何静态函数成员的代码中使用this关键字

this关键字的用途：

• 用于区分类的成员和局部变量或参数
• 作为调用方法的实参

//实例：创建一个方法，将一个恒定值与输入的值作比较，返回大值
class Program
{
    private int a;
    //this.a为恒定值，而a为输入的形参（形参名与变量名相同是不推荐的哦）
    public int Add(int a)
    {
        return a>this.a
                ?a
                :this.a;
    }
}

3.6.2 索引器的语法

索引器的定义类似属性，也具有get访问器和set访问器。

索引器的语法格式：

访问修饰符   数据类型  this[索引类型 index]

{

  get{//返回类中某个元素}

  set{//对类中数组元素赋值}

}

//其中数据类型指的是要存取的数组的类型

//索引类型表示该索引器使用哪一个类型的索引来存取数组元素（可以为整形或字符串型）

示例：索引器也是一种针对私有字段进行访问的方式

class People
{
    //可容纳10个整数的整数数组
    private int[] intarray = new int[10];
    
    //索引器的定义
    //this表示所操作的是类对象的数组成员（可以简单理解为索引器的名称，注意索引器不能自定义名称）
    public int this[int index]
    {
        get{return intarray[index];}
        set{intarray[index] = value;}
    }
}

class Program
{
    static void Main(string[] args)
    {
        People one=new People();
        
        one[0]=1;
        one[1]=2;
        one[2]=3;
        one[3]=4;
    }
}

---

4.类的实例

类的声明只是用于创建类的实例的蓝图。一旦类被声明，就可以创建类的实例。

4.1实例化

前面介绍了类中可以创建的类成员，但想要访问这些实例成员，必须通过类的实例对象来完成。而要得到一个类的实例对象，就必须先声明一个该类类型的变量，然后使用new运算符后跟类的实例构造函数来完成实例化。

4.1.1 实例对象

实例对象由变量和对象创建表达式组成。

• 创建变量
  • 类是引用类型，其变量为数据引用和实际数据都申请了内存。
  • 此变量所分配内存是用来保存引用的。
• 对象创建表达式
  • 对象创建表达式由关键字new后面跟一个类构造函数及其参数列表组成。
  • new运算符为任意指定类型的实例分配并初始化内存。它依据类成员类型的不同从栈和堆里分配内存。

类的实例语法： 类类型 变量 = new 类类型（）；

//类类型 变量                   是创建变量

//new 类类型（）；        是对象创建表达式

4.1.2 对象初始化语句

对象初始化语句扩展了创建语法，在表达式尾部放置一组成员初始化语句。

  利用对象初始化语句，可以创建新的对象实例，设置字段和属性的值。

两种语法：

  new TypeName         {变量名=初始值，变量名=初始值，...}

  new TypeName(参数){变量名=初始值，变量名=初始值，...}

注意：

• 初始化发生在构造方法执行之后，因此要注意构造方法中初始化的值可能会在之后对象初始化中重置。

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

网页标题：【C#基础学习】第十一章、类-创新互联
分享网址：http://mswzjz.cn/article/dsgpig.html