面向对象的装封、继承、多态的概念理解

时间：2013-7-25类别：软件设计

面向对象的装封、继承、多态的概念理解

面向对象的装封、继承、多态的概念理解

一、封装的概念

1、可以把程序按某种规则分成很多“块“，块与块之间可能会有联系，每个块都有一个可变部分和一个稳定的部

分。我们需要把可变的部分和稳定的部分分离出来，将稳定的部分暴露给其他块，而将可变的部分隐藏起来，以

便于随时可以让它修改。这项工作就是封装.

2、例如：在用类实现某个逻辑的时候，类就是以上所说的块，实现功能的具体代码就是可变的部分，而public的

方法或者属性则是稳定的部分。

二、封装的意义

1、封装的意义在于保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的原素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改。

2、封装提供了一个有效的途径来保护数据不被意外的破坏。相比我们将数据（用域来实现）在程序中定义为公用的（public）我们将它们(fields)定义为私有的（privat）在很多方面会更好。

3、封装的目标是在使用数据的同时不能使它受到任何的破坏和改变。有如下好处

其一、使用者只需要了解如何通过类的接口使用类，而不用关心类的内部数据结构和数据组织方法。

其二、高内聚，低耦合一直是我们所追求的，用好封装恰恰可以减少耦合

其三、只要对外接口不改变，可以任意修改内部实现，这个可以很好的应对变化

其四、类具有了简洁清晰的对外接口，降低了使用者的学习过程

三、继承

1、面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

2、通过继承创建的新类称为“子类”或“派生类”。

3、被继承的类称为“基类”、“父类”或“超类”。

4、继承的过程，就是从一般到特殊的过程。

5、要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

6、在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

7、继承概念的实现方式有三类：实现继承、接口继承和可视继承：

(1)、实现继承是指使用基类的属性和方法而无需额外编码的能力；

(2)、接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

(3)、可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

8、在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

9、抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。

10、OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

四、多态

1、多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

2、实现多态，有二种方式，覆盖，重载。

(1)、覆盖，是指子类重新定义父类的虚函数的做法。

(2)、重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

3、那么，多态的作用是什么呢？

封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

4、override实现多态

(1)、真正的多态使用override来实现的。需要注意的是，要对一个类中一个方法用override修饰，该类必须从父类中继承了一个对应的用virtual修饰的虚拟方法，否则编译器将报错。

(2)、多层继承中又是怎样实现多态的？比如类A是基类，有一个虚拟方法method()（virtual修饰），类B继承自类A，并对method()进行重写（override修饰），现在类C又继承自类B，是不是可以继续对method()进行重写，并实现多态呢？看下面的例子。

C# 代码复制


public class Animal
    ...{
        public virtual void Eat()
        ...{
            Console.WriteLine("Animal eat");
        }
    }

    public class Dog : Animal
    ...{
        public override void Eat()
        ...{
            Console.WriteLine("Dog eat");
        }
    }

    public class WolfDog : Dog
    ...{
        public override void Eat()
        ...{
            Console.WriteLine("WolfDog eat");
        }
    }

    class Tester
    ...{
        static void Main(string[] args)
        ...{
            Animal[] animals = new Animal[3];

            animals[0] = new Animal();
            animals[1] = new Dog();
            animals[2] = new WolfDog();

            for (int i = 0; i < 3; i++)
            ...{
                animals[i].Eat();
            }
        }
}

//运行结果为： 

//Animal eat...
//Dog eat..
//WolfDog eat... 

//类Dog继承自类Animal，对方法Eat()进行了重写，类WolfDog又继承自Dog，再一次对Eat()方法进行了重写，并很好地实现了多态。不管继承了多少层，都可以在子类中对父类中已经重写的方法继续进行重写，即如果父类方法用override修饰，如果子类继承了该方法，也可以用override修饰，多层继承中的多态就是这样实现的。要想终止这种重写，只需重写方法时用sealed关键字进行修饰即可。