C#之面向对象的特性

            类是一种抽象的数据类型，但是其抽象的程度有可能会不同，而对象就是一个类的实例，例如，将花设计为一个类，天堂鸟和矢车菊就可以各为一个对象，从这里我们可以看出来，天堂鸟和矢车菊有很多共同点，她们都在某个地方生存，都会开花结果，对于这样相似的对象就可以将其抽象出一个数据类型，此处抽象为花，这样，只要将花这个数据类型编写好，程序中就可以方便地创建天堂鸟和矢车菊这样的对象，在代码需要更改时，只需要对花的类型进行修改即可。

以上，我们可以看出来，类与对象的区别，类是具有相同或相似结构、操作和约束规则的对象组成的集合，而对象是某一类的具体实例，每一个类都是具有某些共同特征的对象的抽象。类的面向对象具有封装、继承、多态的特性，接下来我们对这三种特性进行详细阐述，首先-封装。

封装其实就是信息隐藏，隐藏一个对象的本质，让用户不再注意那些细节．提供一些向外的接口供别人使用。就像电脑的内部已经被封起来，我们不需要知道它的内部是由哪些零件组成、如何工作。我们只需要知道用键盘，鼠标等设备来进行相应操作可以了。那么封装有哪些优点？她的实现方法以及目的又是怎样的呢？

接下来，举个例子，自定义一个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#之旅，未完待续......