C#之面向对象的特性

  1. 云栖社区>
  2. 博客>
  3. 正文

C#之面向对象的特性

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

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

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

        

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

       

网友评论

登录后评论
0/500
评论
丁国华
+ 关注