C#图解教程(第四章)

4.1类的概述

类是一种获得数据结构。是一个能存储数据并执行代码的数据结构。是逻辑相关的数据和函数的封装，通常代表真实世界中的或概念上的事物。

类：程序的数据和功能被组织为逻辑上相关的数据项和函数的封装集合

类包含以下内容：

• 数据成员 它存储与类或类的实例相关的数据。数据成员通过模拟该类所表示的现实世界事物的特性

• 函数成员 它执行代码，函数成员通常模拟类所表示的现实世界事物的功能和操作

  一个C#类可以由任意数目的数据成员和函数成员。成员类型如下

  

4.2 程序和类：一个快速的示例

一个运行中的Ｃ＃程序是一组相互作用的类型对象，它们中的大部分是类的实例。下面图片中Derler、Player都是针对真事世界或概念上的事物抽象后的类型对象。Playe1和player2是类型对象的实例化。

4.3 声明类

类的声明定义新类的特征和成员，它并不创建类的实例，但创建了用于创建实例的模板。类的声明包含：类的名称、类的成员、类的特征

using System
namespace ClassDemo
{
	calss People   //类的名称为People
	{
        //类的字段
		public string name;  //姓名
		public int age;      // 年龄
		public char sex;     // 性别
		
        //类的方法
		public void SayHi()
		{
			Console.WriteLine("hello world");
		}
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.4 类成员

字段和方法是最重要的类成员类型，字段是数据成员，方法是函数成员

4.4.1 字段

字段隶属于类的变量。具有以下特征：

• 可以是任何类型，无论是预定义类型还是用户定义类型。
• 和所有变量一样，字段用来保存数据，可以被读取和写入

class People
{
	public string name;//声明People类的一个字段
}
1
2
3
4

C#在类型的外部不能声明全局变量(也就是变量或字段)。所有的字段都属于类型。而且必须在类型声明内部声明。

4.4.2 显式和隐式字段初始化

因为字段是一种变量，所以字段的初始化和变量初始化相同。

• 字段初始化是字段声明的一部分，由一个等于号后面跟着一个求值表达式组成

• 初始化值必须是编译器可决定的

• 如果没有初始化语句，字段的值会被编译器设为默认值，默认值由字段的类型决定，比如每种类型的默认值都是0，bool型是false，引用类型默认为null。

  class Myclass
  {
  	int F1 = 17;  //初始化为17
  	string F2 = "hello world";//初始化为hello world
  	
  	int F3;   //初始化为0，  值类型
  	string F4  //初始化为null，  引用类型
  }
  1
  2
  3
  4
  5
  6
  7
  8

  4.4.3 声明多个字段

可以通过用逗号分隔名称的方式，在同一条语句中声明多个相同类型的字段，但不能在一个声明中混合不同的类型。

class Mycalss
{
	int var1,var2=2;
	string var3,var4 = "hello world";
}
1
2
3
4
5

4.4.4 方法

方法是具有名称的可执行代码块，可以在程序的其他地方调用执行。当方法被调用时，它执行自己所含的代码，然后返回调用它的代码，有些方法返回一个值到它们被调用的位置。

声明方法的语法包括：

• 返回类型 它声明了方法返回值的类型，如果一个方法不返回值，那么返回类型被指定为void。

• 名称 这是方法的名称

• 参数列表 它有至少一对空的圆括号组成，如果有参数，它们被列在圆括号中间

• 方法体 它由一对大括号组成，大括号包含执行代码

using System
namespace ClassDemo
{
	calss People   //类的名称为People
	{
        //类的字段
		public string name;  //姓名
		public int age;      // 年龄
		public char sex;     // 性别
		
        //类的方法
		public void SayHi()
		{
			Console.WriteLine("hello world");
		}
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.5 创建变量和类的实例

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

• 类是引用类型，即类要为数据引用和实际数据两者都申请内存

• 数据的引用保存在一个类类型的变量中，所以在创建类的实例，需要从声明一个类类型的变量开始，如果变量没有被初始化，它的值是未定义的

  

4.6 为数据分配内存

声明类类型的变量所分配的内存是用来保存引用的，而不是用来保存类对象实际数据的，要为实际数据分配内存，需要使用new运算符

• new运算符为任意指定类型的实例分配并初始化内存，会根据类型的不同从栈或堆里分配内存

• 如果内存分配给一个引用类型， 则对象创建表达式返回一个引用，指向在堆中被分配并初始化的对象实例

  //创建方法 new TypeName();
  class People
  {
      ...
  }
  People Jack = new People();
  
  //分配和初始化用于保存类实例数据的内存
  Dealer theDealer;  //声明引用变量
  theDealer = new Dealer();  //为类对象分配内存
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

  

4.7 实例成员

类声明相当于蓝图，可根据这个蓝图创建任意个类的实例。

实例成员：类的每个实例都是不同的实体，它们有自己的一组数据成员，不同于同一类的其他实例，因为这些数据成员都和类的实例相关，所以被称为实例成员。

静态成员：实例成员是默认类型，但也可以声明与类而不是实例相关的成员，它们被称为静态成员。

对于实例成员和静态成员，泛义上可通过static修饰符区别定义，

静态成员需要通过static关键字来修饰，而实例成员不用static关键字修饰。

另外对于访问方式，静态成员属于类，可直接通过：<类名.静态成员>的方式访问.

实例成员属于对象，需要通过"实例化的对象名.实例成员"。

class People
{
	public string name;
	public int age;
	public char sex;
	
	public static void SayHi()   //静态成员
	{
		Console.WriteLine(Hi wolrd");
	}
	public void SayHello()     //实例成员
	{
		Console.WriteLine(Hello wolrd");
	}
}

static void Main(string[] args)
{
	People p1 = new People();
	People.SayHi();
	p1.SayHello();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4.8 访问修饰符

从类的内部，任何函数成员都可以使用成员的名称访问类中任意的其他成员

访问修饰符是成员声明的可选部分，指明程序的其他部分如何访问成员，访问修饰符放在简单声明形式之前。

/*
字段
	访问修饰符  类型 标识符
	
	public int Age；
	
方法
	访问修饰符  返回类型 方法名()
	{
		...
	}
	
	public void SayHi()
	{
		....
	}

*/
	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5种成员访问控制：

• private 私有的
• public 共有的
• protected 受保护的
• internal 内部的
• protected internal 受保护内部的

私有访问和公有访问

私有访问只能从声明它的类的内部访问，其他的类不能看见或访问它们。方法和字段在访问性上等同

• 私有访问是默认的访问级别，如果一个成员在声明时不带访问修饰符，那该成员就是私有成员

• 还可以使用private访问修饰符显式地声明一个成员为私有

• 隐式地声明私有成员和显式地声明没有语义上的不同，两者等价

  int var1;        //隐式声明为私有
  private int var2;//显式声明为私有
  1
  2

  公有成员可以被程序中的其他对象访问，必须使用public访问修饰符

  

4.9 从类的内部访问成员

使用Private修饰符对成员进行修饰，然后在类的内部访问方法和字段

class DayTemp
{
	//字段
	private int high = 75;
	private int low = 45;
	
	//方法 
	private int GetHigh()    //访问私有字段
	{
		return High;
	}
	
	private int GetLow()    //访问私有字段
	{
		return Low;
	}
	
	public float Average()    //访问私有方法
	{
		return (GetHigh() + GetLow())//2;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4.10 从类的外部访问成员

从类的外部访问实例成员，必须包括变量名称和成员名称。中间用句点(.)分隔，这称为点运算符。

class DayTemp
{
	public int High = 75;
	public int Low = 45;
}
class Program
{
	static void Main()
	{
		DayTemp temp = new DaysTemp();//创建对象，即对象实例化
		
		//变量名称和字段 
		temp.High = 85;    //字段赋值
		temp.Low = 60;     //字段赋值
		
		Console.WriteLine("High:{0}",temp.High);//读取字段
		Console.WriteLine("Low:{0}",temp.Low);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4.11 综合应用

以下是类的demo展示。使用类的3种行为：声明一个类、创建类的实例、访问类的成员(写入和读取字段)

class DayTemp
{
	public int High,Low;//声明类
	public int Average()  //声明实例方法
	{
		return (High + Low) /2;
	}
}
class Program
{
	static void Main()
	{	
		//创建两个DaysTemp实例
        DayTemp t1 = new DaysTemp();
        DayTemp t2 = new DaysTemp();
        
        //给字段赋值
        t1.High = 76; t1.Low = 43;
        t2.High = 70; t2.Low = 53;
        
        //读取字段值
        //调用实例的方法
        Console.WriteLine("t1:{0}, {1}, {2}",t1.High,t1.Low,t1.AVerage());
        Console.WriteLine("t2:{0}, {1}, {2}",t2.High,t2.Low,t2.AVerage());
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26