面向对象中的基本概念

面向对象中的基本概念

       

        近期在学习c#编程程序设计语言，对面向对象技术有了一点点的体会，下面我就自己的所掌握的面向对象的基本概念进行一下总结。

 

一、面向对象和面向过程二者之间的关系

       在学习面向对象之前，我们要先了解一下面对对象和面向过程二者的关系 。

    面向对象不是取代面向过程．面向对象和面向过程是一种互补关系，不要把它们割裂开来，面向对象是为了简化（面向过程）程序的开发。面向对象是弥补了面向过程中的不足而已。

 

二、 面向对象中的几个概念：

        1.类：类是具有相同特征的事物的抽象

               类就是具有相同的属性和功能的对象的集合（大话设计模式的定义）。（怎样定义一个类：类的名称和类的方法）

        

        类的成员（Merber）包括：字段，方法，属性

        1-1.字段（Field）：和某个对象相关的变量，是类的状态。(注意：所有类的字段都不要写成public的方式，都要写成private.)

        1-2.方法（Method）：方法就是类能够执行的动作。

        1-3.属性

        属性是一个方法或一对方法，但在调用它的代码看来，它是一个字段，即属性适合于以字段的方式使用方法调用的场合。

        属性有两下方法get（表示“取值”）和set（表示“设值”）。

        get访问器返回与声明的属性相同的数据类型，表示的意思是调用时可以得到的内部字段的值或引用；

        set访问器没有显示设置参数，但它有一个隐式参数，用关键字value表示，它的作用是调用属性时可以给内部字段或引用赋值。

 

        注意：字段和属性的区别？

        通常字段都是private,即私有的变量，而属性都是public，即公有的变量。

        属性开头字母要大写，字段开头字母小写。

        属性看似字段，不是字段，属性可以进行非法值的控制，而字段不可以。

          

        2.对象：具体的某一个东西，对象也可以叫做类的一个实例（instance）。（传智博客的定义）

 

         类和对象的区别：一个抽象的，一个是具体的某个东西。

 

        注意：方法和函数的区别？

        在c#中方法和函数可以看做一个东西，在写纯面向过程的程序时它就叫做函数，在写面向对象的代码中叫方法。其实都是指一个东西，都是名字，返回值，参数这么一个东西。它就叫做方法。

                  

            3.修饰符

          修饰符可以修饰类的成员变量（字段，属性，方法）

 

          C# 中有三类修饰符，分别是访问修饰符、类修饰符和成员修饰符。

          （1）访问修饰符（4个）

                              public定义公共类型------任何地方都可以访问；

                              private定义私有类型------默认级别，只能由本类中的成员访问；

                              protected定义保护类型------表示继承时子类可以对基类有完全访问权；

                              internal定义内部类型。

          （2）类修饰符（2个）

                              abstract用于修饰抽象类；

                                 sealed用于修饰最终类。

          （3）成员修饰符（8个）

                              abstract定义抽象函数；

                              const定义常量;

                              event定义事件

                              extern告诉编译器在外部实现

                              override定义重载；

                              readonly定义只读属性；

                              static用来声明静态成员；

                               virtual定义虚函数（虚方法）。

 

       

         封装体现在成员的访问级别上。

         字段、方法、属性都可以叫做类的成员（Member）,它们都需要定义访问级别。访问级别的用处在于控件成员在哪些地方可以被访问，这样达到面向对象中“封装”的目的。

       

        4.封装

         每个对象都包含它能进行操作所需要的所有信息，这个特性称为封装，因此对象不必依赖其他对象来完成自己的操作。

         封装的好处，第一、良好的封装能够减少耦合。第二、类内部的实现可以自由地修改。第三、类具有清晰的对外接口。

 

        5.继承

        继承定义了类如何相互关联，共享特性。继承的工作方式是，定义父类和子类，或叫做基类和派生类，其中子类继承父类的所有特性。子类不但继承了父类的所有特性，还可以定义新的特性。

 

       电脑类可以从电器类继承，电脑类是电器类的子类（派生类），电器类是电脑类的父类（基类）。

        5-1.父类（Parent）：电器类——电压，功率

        5-2.子类(ChildClass)：电脑类——（定义自己特有的属性，如内存大小，CPU型号等）

 

        5-3.基类（Base）：电脑类从电器类继承 , 电器类也可以从其他类继承，如“电器”类可以从“家用物品”类继承,

                               那么"家用物品类"就是"电脑类"的基类.

 

         怎样定义和使用一个类？

       （1）定义类的规则：

         定义一个类的定义一个枚举是一样的，一般和class Program这个类平行（不平行也可以）.

         类名称首字母要大写，多个单词则各个首字母大写。对外公开的方法需要用“public”修饰符。

       （2）定义类的步骤：

                     （1）构架

                                     class 类名

                                     {

                                     }

 

                     （2）定义类的字段：

                                      比如我们定义了“人”类

                                      “人”类的字段：身高，名字，年龄（每个人都不一样）。

                                      类的字段，每个对象都不一样

                      （3）定义类的方法：就是定义函数，定义自己的行为和动作

 

        （3）怎样使用一个类？

                 将类实例化就可以使用了。实例化就是创建对象的过程，使用new关键字来创建。→构造方法。

       

          下面的例1演示了子类是如何继承父类的属性和方法的。

 

namespace 继承
{
    class Program
    {
        //演示：子类是如何继承父类的属性和方法的。
        static void Main(string[] args)
        {
            Child a = new Child();
            a.Say();              //继承父类的方法
            Console.Read();
        }
    }

    public class Parent           //定义父类
    {
        public Parent()           //父类的构造函数
        {
            Console.WriteLine("构造父类\n");
        }

        public void Say()         //父类的方法
        {
            Console.WriteLine("调用父类的函数\n");
        }
    }

    public class Child : Parent    //定义子类
    {
        public Child()            //子类的构造函数
        {
            Console.WriteLine("构造子类\n");
        }   
    }
}

       

程序编译运行的结果如下：

                    构造父类

                    构造子类

                    调用父类的函数

 

        6.构造方法，又叫构造函数，其实就是对类进行初始化。构造方法与类名，无返回值，也不需要void，在new时候调用。

          7.方法重载，C#中允许在在同名的函数。在对象被创建后，这个对象调用的是这些同名函数的哪一个，要看调用加载的函数参数的个数和类型而定。这就是我们常说的重载。

 

        8.多态

        多态性是指派生类可以重载基类定义的虚函数（也叫做虚方法）。虚函数就是有virtual修饰的、在基类中没有具体实现的函数，可以被子类重写。

        当基类使用虚函数时，派生类有多种实现该函数的方法。

        下面看一下例2，

 

namespace 多态
{
    class Program    
    { 
        static void Main(string[] args)
        {
            Child1 child1 = new Child1();  //调用父类的虚函数
            child1.Say();

            Console.Read();
        }
    }

    public class Parent             //父类
    {
        public Parent()             //父类的构造函数
        {
            Console.WriteLine("构造父类\n");
        }

        public virtual void Say()   //使用关键字virtual定义虚函数
        {
            
        }
    }

    public class Child1 : Parent   //子类Child1
    {
        public Child1()            //子类Child1的构造函数
        {
            Console.WriteLine("构造子类\n");
        }

        public override void Say()   
        {
            Console.WriteLine("这是子类1重载的虚函数\n");  //使用关键字override来实现虚函数的重载
        }
    }
}

 

        程序编译运行的结果如下：

                   构造父类

 

                   构造子类

 

                    这是子类1重载的虚函数。

  

 

三、面向对象编程的特点：

      （1）代码的模块化

              程序代码的模块化使得程序结构清淅，层次分明

      （2） 代码的可重用性（亦称作复用性）方便了代码的横向（项目之间）和纵向（不同时期）移植，减少了开发人员的工作量， 提高了开发效率。

      （3）继承

              面向对象编程过程中，子类（派生类）可以继承父类（基类）的所有属性和方法。