以上，我们可以看出来，类与对象的区别，类是具有相同或相似结构、操作和约束规则的对象组成的集合，而对象是某一类的具体实例，每一个类都是具有某些共同特征的对象的抽象。类的面向对象具有封装、继承、多态的特性，接下来我们对这三种特性进行详细阐述，首先-封装。
封装其实就是信息隐藏，隐藏一个对象的本质，让用户不再注意那些细节．提供一些向外的接口供别人使用。就像电脑的内部已经被封起来，我们不需要知道它的内部是由哪些零件组成、如何工作。我们只需要知道用键盘，鼠标等设备来进行相应操作可以了。那么封装有哪些优点？她的实现方法以及目的又是怎样的呢？
接下来，举个例子，自定义一个MyClass类，该类用来封装加数和被加数属性，然后自定义一个Add方法，该方法用来返回该类中两个int属性的和，Program主程序类中，实例化自定义类的对象，并分别为MyClass类中的两个属性赋值，最后调用MyClass类中的自定义方法Add返回两个属性的和，相关代码如下：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication1
{
class myclass //自定义类，封装加数和被加数属性
{
private int x = 0; //定义int型变量，作为加数
private int y = 0; //定义int型变量，作为被加数
///<summary>
///加数
///</summary>
public int X
{
get
{
return x;
}
set
{
x = value;
}
}
public int Y //被加数
{
get
{
return y;
}
set
{
y = value;
}
}
public int add ()//求和
{
return X + Y;
}
}
class Program
{
static void Main(string[] args)
{
myclass myclass = new myclass(); //实例化myclass的对象
myclass.X = 3; //为myclass类中的属性赋值
myclass.Y = 5; //为myclass类中的属性赋值
Console.WriteLine(myclass.add()); //调用myclass类中的add方法求和
Console.ReadLine();
}
}
}
运行效果如下：
再者，继承-指一个对象直接使用另一个对象的属性和方法，任何类都可以从另一个类继承，这就是说，这个类拥有她继承的类的所有成员，在面对想编程中，被继承的类称为父类或基类，C#中提供了类的继承机制，但只支持但继承，而不支持多重继承，即在C#中一次只允许继承一个类，不能同时继承多个类。下面我们来举一个例子，来看一下继承是如何在代码中得到实现的。
创建一个控制台应用程序，其中自定义一个MyClass1类，然后自定义一个MyClass2类，该类继承于MyClass1类，这是MyClass2类就拥有MyClass1类中的所有公有成员，并且可以扩展其成员。Program主程序中，可以通过MyClass类的对象调用MyClass。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication1
{
class myclass1 //自定义类
{
private int x = 0; //定义int型变量，作为加数
private int y = 0; //定义int型变量，作为被加数
public int X
{
get
{
return x;
}
set
{
x = value;
}
}
public int Y //被加数
{
get
{
return y;
}
set
{
y = value;
}
}
public int add1()//求和
{
return X + Y;
}
}
class myclass2:myclass1 //自定义类，该类继承自myclass1
{
private int z=0; //定义int型变量，作为第二个被加数
public int Z //被加数
{
get
{
return z;
}
set
{
z=value ;
}
}
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=5; //使用myclass2类对象调用基类中的属性并赋值
myclass2 .Z =7; //为myclass2类中的属性赋值
Console.WriteLine (myclass1.add1()); //调用myclass1类中的add1方法求和
Console.WriteLine (myclass2.add1()); //使用myclass类对象调用基类中的方法
Console.WriteLine (myclass2.Add2 ()); //调用myclass类中的add2方法求和
}
}
}
运行效果如下：
最后，我们来看一下多态，多态是指类可以有多种形态，通过修改可以形成多个实现方法，当子类从父类继承时，她会获得父类的所有方法、字段、属性和事件。若要更改父类的数据和行为，通常有两种选择，可以创建新的成员替换父级成员，或者可以重写虚拟的父级成员。
在派生于同一个类的不同对象上执行任务时，多态是一种极为有效的技巧，使用的代码最少，可以把一组对象放到一个数组中然后调用她们的方法，在这种情况下多态的作用就体现出来了，这些对象不必是相同类型的对象，当然如果他们都继承自某个类，可以把这些子类（派生类）都放到一个数组中，如果这些对象都有同名方法，就可以调用每个对象的同名方法，在C#中，类的多态性是通过在子类（派生类）中重载基类的虚方法或函数成员来实现。
现在，我们来举个例子，看看多态是如何在代码中体现她的作用，首先创建一个控制台应用程序，其中自定义一个MyClass1类，该类中定义了一个虚方法Add，用来计算两个整数的和，然后自定义一个MyClass2类，该类继承与MyClass1类，在MyClass2类中重写MyClass1类中的虚方法。Program主程序类中，首先实例化子类MyClass2的一个对象，然后使用该对象实例化基类MyClass1的一个对象，这时，使用实例化的这两个对象都可以调用子类MyClass2中的重写方法，程序代码如下：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication1
{
class MyClass1 //自定义类
{
private int x = 0;//定义int型变量，作为加数
private int y = 0;//定义int型变量，作为被加数
public int X //加数
{
get
{ return x; }
set
{ x = value; }
}
public int Y //被加数
{
get
{
return y;
}
set
{
y = value;
}
}
public virtual int Add()//定义一个virtual类型的方法，以便在子类（派生类）中重写该方法，求和
{
return X + Y;
}
}
class MyClass2: MyClass1 //自定义类，该类继承自myclass1
{
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的对象
//使用子类（派生类）myclass2的对象实例化基类myclass1的对象
MyClass1 myclass1 = (MyClass1)myclass2;
myclass1.X = 3;//为myclass1类中的属性赋值
myclass2.Y = 5;//为myclass1类中的属性赋值
Console.WriteLine(myclass2.Add ());//调用子类（派生类）中的方法
Console.WriteLine(myclass1.Add());//同样调用子类（派生类）中的方法
}
}
}
运行效果如下：
通过上述，我们知道封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性的正确调用，C#之旅，未完待续......
