C#类
今天来简单介绍一下C#中最基础，最常用的一种数据结构：类。
类是一种数据结构，它可以包含数据成员，函数成员和嵌套类型，类支持继承。
面向对象概述
了解类之前先来了解下面向对象的特点吧！
·封装。类的属性和方法的集合，为了实现某项功能而定义类后，开发人员并不需要了解类体内每句代码的含义，只需通过对象来调用类内某个属性或方法即可实现某项功能，这就是类的封装性。
·继承。通过继承可以创建子类和父类之间的层次关系，子类可以从其父类中继承属性和方法，通过这种关系模型可以简化类的操作。
·多态性。类的多态性指不同的类进行同一操作可以有不同的行为。
大家可以看出上面介绍面向对象的概述基本上都是以类做描述对象，说明了类在面向对象中举足轻重的地位哦，下面就来介绍下类吧！
类的概念
类是对象概念在面向对象编程语言中的反映，是相同对象的集合，类描述了一系列在概念上有相同的含义的对象，并为这些对象同一定义了编程语言上的属性和方法。例如：车是一个类，自行车、汽车、火车也是类。但是他们的具体的属性和方法可能不完全相同。
类的面向对象特性
·类的封装
面向对象编程中，大多数都是以类作为数据封装的基本单位。类将数据和操作数据的方法结合成一个单位。设计类时，不希望直接存取类中的数据，而希望通过方法来存取数据，这样就可以达到封装数据的目的，方便以后的升级和维护，也可以在操作数据时多一层判断。
下面就通过一个实例来简单的使用下类的封装
using System;
using System.Collections.Generic;
using System.Text;
namespace _
{
/// <summary>
/// 自定义类，封装加数和被加数属性
/// </summary>
class MyClass1
{
private int x = 0; //定义int型变量，作为加数
private int y = 0; //定义int型变量，作为被加数
/// <summary>
/// 加数
/// </summary>
public int X
{
get
{
return x;
}
set
{
x = value;
}
}
/// <summary>
/// 被加数
/// </summary>
public int Y
{
get
{
return y;
}
set
{
y = value;
}
}
}
/// <summary>
/// 自定义类，封装求和方法
/// </summary>
class MyClass2
{
MyClass1 myclass1 = new MyClass1(); //实例化MyClass1的对象
/// <summary>
/// 求和
/// </summary>
/// <returns>加法运算和</returns>
public int Add()
{
return myclass1.X + myclass1.Y;
}
}
class Program
{
static void Main(string[] args)
{
MyClass1 myclass1 = new MyClass1(); //实例化MyClass1的对象
MyClass2 myclass2 = new MyClass2(); //实例化MyClass2的对象
myclass1.X = 3; //为MyClass1类中的属性赋值
myclass1.Y = 5;
int a = myclass2.Add();
//为MyClass1类中的属性赋值
Console.WriteLine(a); //调用MyClass2类中的Add方法求和
Console.ReadLine();
}
}
}
此程序的运行结果为0
·类的继承
利用类的继承机制，用户可以通过增加、修改或替换类中的方法对这个类进行扩充，以适应不同的应用要求。利用继承，程序开发人员可以在已有类的基础上构造新类，这一性质使得类支持分类的概念。
下面通过小例子讲解下类的继承。
using System;
using System.Collections.Generic;
using System.Text;
namespace _
{
/// <summary>
/// 自定义类
/// </summary>
class MyClass1
{
private int x = 0; //定义int型变量，作为加数
private int y = 0; //定义int型变量，作为被加数
/// <summary>
/// 加数
/// </summary>
public int X
{
get
{
return x;
}
set
{
x = value;
}
}
/// <summary>
/// 被加数
/// </summary>
public int Y
{
get
{
return y;
}
set
{
y = value;
}
}
/// <summary>
/// 求和
/// </summary>
/// <returns>加法运算和</returns>
public int Add1()
{
return X + Y;
}
}
/// <summary>
/// 自定义类，该类继承自MyClass1
/// </summary>
class MyClass2:MyClass1
{
private int z = 0; //定义int型变量，作为第2个被加数
/// <summary>
/// 被加数
/// </summary>
public int Z
{
get
{
return z;
}
set
{
z = value;
}
}
/// <summary>
/// 求和
/// </summary>
/// <returns>加法运算和</returns>
public int Add2()
{
return X + Y + Z;
}
}
class Program
{
static void Main(string[] args)
{
MyClass1 myclass1 = new MyClass1(); //实例化MyClass1的对象
MyClass2 myclass2 = new MyClass2(); //实例化MyClass2的对象
myclass1.X = 3; //为MyClass1类中的属性赋值
myclass1.Y = 5; //为MyClass1类中的属性赋值
myclass2.X = 3; //使用MyClass2类对象调用基类中的属性并赋值
myclass2.Y = 6; //使用MyClass2类对象调用基类中的属性并赋值
myclass2.Z = 7; //为MyClass2类中的属性赋值
Console.WriteLine(myclass1.Add1()); //调用MyClass1类中的Add1方法求和
Console.WriteLine(myclass2.Add1()); //使用MyClass2类对象调用基类中的方法
Console.WriteLine(myclass2.Add2()); //调用MyClass2类中的Add2方法求和
Console.ReadLine();
}
}
}
运行结果为：8，9，16
·类的多态
多态使得子类的实例可以直接赋予基类的变量（这里不需要进行强制类型转换），然后直接就可以通过这个变量调用子类的方法。
举个例子：
using System;
using System.Collections.Generic;
using System.Text;
namespace _
{
/// <summary>
/// 自定义类
/// </summary>
class MyClass1
{
private int x = 0; //定义int型变量，作为加数
private int y = 0; //定义int型变量，作为被加数
/// <summary>
/// 加数
/// </summary>
public int X
{
get
{
return x;
}
set
{
x = value;
}
}
/// <summary>
/// 被加数
/// </summary>
public int Y
{
get
{
return y;
}
set
{
y = value;
}
}
/// <summary>
/// 定义一个virtual类型的方法，以便在派生类中重写该方法
/// </summary>
/// <returns>加法运算的和</returns>
public virtual int Add()
{
return X + Y;
}
}
/// <summary>
/// 自定义类，该类继承自MyClass1
/// </summary>
class MyClass2 : MyClass1
{
/// <summary>
/// 重写基类中的虚方法
/// </summary>
/// <returns>返回两个int型变量相加的和</returns>
public override int Add()
{
int x=5;
int y=7;
return x + y;
}
}
class Program
{
static void Main(string[] args)
{
MyClass2 myclass2 = new MyClass2(); //实例化MyClass2的对象
MyClass1 myclass1 = (MyClass1)myclass2;//使用派生类MyClass2的对象实例化基类MyClass1的对象
//MyClass1 myclass1 = new MyClass1();
myclass1.X = 3; //为MyClass1类中的属性赋值
myclass1.Y = 5; //为MyClass1类中的属性赋值
Console.WriteLine(myclass2.Add()); //调用派生类中的方法
Console.WriteLine(myclass1.Add()); //同样调用派生类中的方法
Console.ReadLine();
}
}
}
运行结果为12，12
红色部分表示多态特性的体现。
PS：当子类从基类继承时，它会获得基类的所有方法、字段、属性和事件。若要更改基类的数据和行为，有两种选择：可以使用新的派生成员替换基成员，或者可以重写虚拟的基成员。上面的基类重写了基类中的虚方法，另外，开发人员还可以使用新的派生成员替换基类的成员，这时需要使用new关键字。如果基类定义了一个方法、字段或属性，则new关键字用于在子类中创建该方法、字段或属性的新定义。new关键字放置在要替换的类成员的返回类型之前。
如果上面的例子中将override换成new关键字的话 那么输出结果将会不同，请读者自己验证下哦！
