Object与封装、继承和多态性

Object与封装、继承和多态性

　　在面向对象编程思想中，无论是C++，Java还是C#等，封装、继承与多态性都有着无与伦比的地位，深入理解并掌握它们是必不可少的。而我将使用C#来浅谈继承与多态性。

1.封装：

　　封装就是把里面实现的细节包起来，这样很复杂的逻辑经过包装之后给别人使用就很方便，别人不需要了解里面是如何实现的，只要传入所需要的参数就可以得到想要的结果。封装很好理解，像我们常见的函数，就是一种封装。还有
类将一些函数一数据封装。类是比函数更高级的一种封装方法。

2.继承：

　　新类（即派生类）通过继承将获取基类的所有非私有数据和行为以及新类为自己定义的所有其他数据或行为。因此，新类具有两个有效类型：新类的类型和它继承的类的类型。

public class A

{

    public A() { }

}

public class B : A　　// B 直接继承自 A

{

    public B() { }

}

　　aaarticlea/png;base64,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" alt="" />

　　从上面的代码与图形可与看出B直接继承自A，那么B就拥有了A的除了私有数据与行为外的所有部分，但在为B分配内存时，却包涵了A的部分，那么在B的内存中也包含A的私有数据和行为的部分，那么又为什么说B没有这部分呢？要解决

这个问题就要先理解类的结构：类自己的所有成员对自己都是可见（可访问）的，但类的实例只可以访问它的公有（public）成员，如下：

public class A

{

    private int temp;

    protected int temp2;

    public int temp3;

}

public class B : A

{

    public int temp4;

}

此时，B的可见成员有 temp2,temp3,temp4 ,由于 temp 是 A 的私有成员，所以在继承时不包含它。但在 B 的内存里确实有一块是用来存放A的，而在存放 A 的部分里又有一部分存储 temp ，所以在B的存储空间里也存放着 temp 这个量。

只不过类 B无法直接访问temp，如果说B继承了A的temp，那么B就应该可以直接访问temp，但实际上并不能直接访问，所以说我们说：在继承时，子类确实包含了父类的所有部分，但子类自己所能访问的只有父类的非私有部分和自己新定义

的部分，即实际继承时，只从父类继承了其非私有部分。

3.多态性：

　　多态按字面的意思就是“多种状态”。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4 编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指针（或引用）赋值给父类类型的指针（或引用）。

aaarticlea/png;base64,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" alt="" />

　　从上图看出，“汽车”，“小轿车”，“马车”等都继承自“车”,但他们除了公有的“车”这个属性外，都不相同。一组类，它们都继承自同一个类，但各自拥有的新的不同的属性，使得它们都不相同，呈现出多种状态的现象，就是所谓的多态。

4.object类：

　　在C#（与Java）中，所有的类都直接或间接的继承自 object 类，即 object 是所有类的基类。在我们定义类是，如果不显示指明基类，在编译时，编译器都会默认为继承自 object 类。为什么要这样做呢？当然是为了充分的体现

和利用面向对象思想的优点--即多态性的利用。

　　在学习C#时你也许会忽略一个重要的知识点： 向上转型和向下转型

class A

{

    pubic void A_Text()

    {

        Console.WriteLine("I'm A!");

    }

}

class B

{

    public void B_Text()

    {

        Console.WriteLine("I'm B!");

    }

}

void Sample(object obj)

{

    if(obj is A)

    {

        A a=(A)obj;    //向下转型

        a.A_Text();

    }

    else if(obj is B)

    {

        B b=(B)obj;    //向下转型

        b.B_Text();

    }

}

A a=new A();

B b=new B();

Sample(a)     //向上转型

Sample(b)     //向上转型

　　可以看出，通过向上与向下转型使得我们在遇到类似于上面（通过另一个函数来调用一个对象的成员）的情况时，不需要根据参数类型写多个重载函数，实现了代码的简化，可读性更强。还有接口的实现也是通过多态来实现的，可见，使用多态的好处有很多，

只不过要真正体会其好处和掌握多态，需要大量的实践！！！

　　object 类充分用到了前面讲的封装、继承与多态，并将它们的作用发挥到了极致，学会使用 object 是我们学习和使用C#不可或缺的部分。在这里只是简单提了一下 object ,如果真正的深入讲 object 类可能将是长篇大论，如果以后有时

间可能会专门研究一下 object 的成员与使用。

巴特西

Object与封装、继承和多态性

最新文章

热门文章