【C#基础学习】第十一章、类-创新互联
目录
类
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#类可以有任意数目的数据成员和函数成员）
- 数据成员：存储 与类或类的实例 相关的数据。数据成员通常模拟和该类所表示的现实世界事务的特性。
- 函数成员：它执行代码。通常会模拟类所表示的现实世界的功能和操作
一个运行中的C#程序是一组相互作用的类型对象，它们中大部分都是类的实例。
2.声明类（类定义）
类的声明定义类的特征和成员。
声明一个类并不创建类的实例，而是用于创建实例的模板。
2.1 分部类和分布类型声明类的语法：
class 大象（类的名称） //声明类
{
string sex； //数据成员声明（类的成员）
...
void swim（）{...} //函数成员声明（类的成员）
...
}
声明类必须包含：
- 类的名称
- 类的成员
- 类的特征（封装、继承、多态，第十四章会讲）
类声明可以分割为几个分布类的声明
- 每个分布类的声明都含有一些类成员的声明。
- 类的分布类声明可以在同一个文件中、也可以在不同文件中。
分布类的使用要求：
- 类声明必须加类型修饰符 partical
- 类名称相同
- 组成类的所有分布类声明必须在一起编译
//示例：
partical class A //类名称相同
{
int a;
}
partical class A
{
int b;
}3.类成员
（注意：本章主讲实例成员，静态成员放在十三章讲）
在类声明中定义的类成员有9种成员类型。
其中字段和方法是最重要的类成员类型。（本章不会介绍事件）
类声明相当于蓝图，通过蓝图可以创建多个类的实例。
通过类创建的实例，其中的类成员分为两种：实例成员和类成员。
- 实例成员：每个类的实例都是不同的个体，它们有自己独有的一组类成员。且因为这些数据成员都和类的实例相关，所以称为实例成员。
- 静态成员：实例成员是默认类型，但也可以声明与类而不是实例相关的成员，也就是静态成员。
字段是在类或结构中直接声明的任意类型的变量。
3.1.1 字段的语法3.1.2 显示字段和隐式字段的初始化声明字段的语法：
数据类型 字段名；
例如：
int a；
隐式字段初始化：若字段被声明且没有被赋值，则为隐式初始化。
不同类型隐式初始化的默认值：
- 值类型为0
- bool类型为false
- 引用类型为null
被readonly和const修饰的字段一旦赋值便不能再被修改。
readonly关键字&const的区别：
- 若使用readonly来修饰字段，则不需要在定义时初始化，可以在类的构造函数完成初始化。
- 若使用const来修饰字段，如果没有在定义时初始化，就会发生编译错误。
3.1.4 静态字段语法：
访问修饰符 const 数据类型 变量名=值；
访问修饰符 readonly 数据类型 变量名；
若使用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：
常量就是被const修饰的字段。
常量的特点：
- 类成员常量类似于局部变量。区别在于常量在类声明中，而局部变量在方法中。
- 常量在堆中没有自己的存储位置，它在编译时被编译器替换。（类似C、C++中的#define）
- 常量可以用类名直接访问。
- 常量本质上就是静态的。
属性是对字段的扩展。
根据面向对象语言的封装思想（见第十章），字段最好设置为private。这样能防止客户端直接对字段进行篡改，从而保证了内部成员的完整性的同时，也可以更好的为程序员提供编写的便利。而属性的作用就是为了访问类中的私有字段。
3.3.1 属性的组成属性的语法：
访问修饰符 数据类型 字段名{get{return 字段名；}set{字段名=value；}}
属性由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这种。
静态属性与静态字段类似。 若用static来修饰属性，则属性为静态属性。
静态属性有以下特点：
- 静态属性属于类级别，无法通过实例对象访问。
- 也不能访问类的实例成员，但能被实例成员访问。
- 在类的内部，可以仅使用名称来引用静态属性
- 在类的外部，可以通过类名或者using static结构来引用静态属性
实例：
public class People
{
//静态字段
public static string Name;
//静态属性
public static string Name
{
get
{
return Name;
}
set
{
Name = value;
}
}
}构造函数主要用于初始化类的实例状态。当我们用构造函数创建一个对象时，构造函数会为对象分配空间，并初始化类的成员。
使用构造函数的要求：
- 如果希望从类的外部创建类的实例，需要将构造函数声明为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);
}
}静态构造函数用于初始化类中的静态成员。
在创建第一个实例或引用任何静态成员之前，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);
}
}结果如下：
从上述代码我们可知静态构造函数有以下特点：
- 静态构造函数只会执行一次
- 静态构造函数不能使用任何访问修饰符，也不能带任何参数
- 不能直接调用静态构造函数
- 在程序中，我们无法控制执行静态构造函数的时机
析构函数用于类销毁之前释放类实例所使用的托管和非托管资源。
析构函数的作用：
对于C#应用程序所创建的大多数对象，都可以使用.NET框架的垃圾回收器（GC）来隐式地执行内存管理任务，但如创建了一个封装非托管资源的对象，在应用程序使用完这些非托管资源之后，垃圾回收器就需要运行对象的析构函数（即Finalize方法）来释放这些资源。
使用析构函数的要求：
- 只能在类中使用析构函数。
- 一个类只能有一个析构函数。
- 无法继承或重载析构函数。
- 无法显示地调用析构函数，由垃圾回收器自动调用。
- 析构函数没有参数和修饰符。
代码示例：
class People
{
//析构函数
~People()
{
Console.WriteLine("析构函数被调用");
}
}
//该析构函数隐式调用了基类Object的Finalize方法，上面代码中的析构函数将被隐式转化为以下代码
//
//override
protectd override void Finalize()
{
try
{
Console.WriteLine("析构函数被调用");
}
finally
{
//调用基类方法
base.Finalize();
}
}当一个类包含数组成员时，使用索引器可以大大地简化类中数组的访问。
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;
}
}索引器的定义类似属性，也具有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运算符为任意指定类型的实例分配并初始化内存。它依据类成员类型的不同从栈和堆里分配内存。
4.1.2 对象初始化语句类的实例语法： 类类型 变量 = new 类类型（）；
//类类型 变量 是创建变量
//new 类类型（）； 是对象创建表达式
对象初始化语句扩展了创建语法，在表达式尾部放置一组成员初始化语句。
利用对象初始化语句，可以创建新的对象实例，设置字段和属性的值。
两种语法：
new TypeName {变量名=初始值，变量名=初始值，...}
new TypeName(参数){变量名=初始值，变量名=初始值，...}
注意：
- 初始化发生在构造方法执行之后，因此要注意构造方法中初始化的值可能会在之后对象初始化中重置。
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
网页名称：【C#基础学习】第十一章、类-创新互联
网站URL：http://myzitong.com/article/dsgpig.html