温故而知新：封装、继承、多态

一、封装

封装就是将数据或函数等集合在一个个的单元中（我们称之为类）。被封装的对象通常被称为抽象数据类型。

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

我们用访问修饰符来控制数据的访问（封装的体现）：

Public:访问没有任何限制

Private:只有类本身能访问
Protected:类和派生类可以访问
Internal:只有同一个项目中的类可以访问
Protected Internal:是Protected和Internal的结合

二、继承

继承是OOP最重要的特性之一。任何类都可以从另外一个类继承，即这个类拥有它所继承类的所有成员。在OOP中，被继承的类称为父类或基类。C# 提供了类的继承机制，但C# 只支持单继承，不支持多重继承，即在C# 中一次只允许继承一个类，不能同时继承多个类。（接口允许多继承）

三、多态

关于多态的解释说法不一，但是表达的意思基本上相同的，以下就是对多态的几种不同的定义和解释的：

就是某一类事物的多种存在形态。

使用多态的前提是：类与类之间有关系，要么是继承关系，要么是实现。

多态体现在：父类的引用指向了子类的对象，而且也可以接收自己的子类对象。

多态：多态和继承是一组相反的调用过程，多态是父类调子类的方法，继承是子类调父类的过程

1.用override实现多态

多态的一般通过使用override来体现的。下面的例子中，在基类Animal中将方法Eat()用virtual标记为虚拟方法，再在派生类Cat和Dog中用override对Eat()修饰，进行重写，很简单就实现了多态。需要注意的是，要对一个类中一个方法用override修饰，该类必须从父类中继承了一个对应的用virtual修饰的虚拟方法，否则编译器将报错。

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

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

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

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

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

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

输出如下：

Animal eat...

Cat eat...

Dog eat...

在上面的例子中，通过继承，使得Animal对象数组中的不同的对象，在调用Eat()方法时，表现出了不同的行为。

其中 animals[1] = new Cat(); animals[2] = new Dog();是将父类（animals）的引用指向了子类(Cat,Dog)的对象,因此animals[1]，animals[2] 执行Eat() 是执行的子类中的方法。一个动物[aimals]因所指向的对象不多，它的同一行为表现出不同的结果。现在基本上已经清楚了吧，那多层继承是怎样实现多态的呢？

多层继承中实现多态：

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

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关键字进行修饰即可。

注意：多层继承和多继承的概念

多层继承是指dog 继承Animal，WolfDog 又继承自Dog,是逐层继承的。

多继承是指一个类同时继承多个类的。

C#中类是不能实现多继承的，但是接口可以实现多继承的。

2. abstract-override实现多态

先在我们在来讨论一下用abstract修饰的抽象方法。抽象方法只是对方法进行了定义，而没有实现，如果一个类包含了抽象方法，那么该类也必须用abstract声明为抽象类，一个抽象类是不能被实例化的。对于类中的抽象方法，可以再其派生类中用override进行重写，如果不重写，其派生类也要被声明为抽象类。（如果一个类包含了抽象方法，那么该类也必须用abstract声明为抽象类）

看下面的例子：

public abstract class Animal
    {
 
　　　   public abstract void Eat();
    }

    public class Cat : Animal
    {
        public override void Eat()
        {
            Console.WriteLine("Cat 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 Cat();
            animals[1] = new Dog();
            animals[2] = new WolfDog();

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

运行结果为：

Cat eat...

Dog eat...

Wolfdog eat...

从上面可以看出，通过使用abstract-override可以和virtual-override一样地实现多态，包括多层继承也是一样的。不同之处在于，包含虚拟方法的类可以被实例化，而包含抽象方法的类不能被实例化。

posted @ 2012-11-02 09:48 Snow*Cao 阅读(266) 评论(0) 编辑收藏举报

刷新页面返回顶部

温故而知新：封装、继承、多态

公告