面向对象的封装性和多态性

Posted 2020-06-17

面向对象之封装性：

1、继承要符合is-a的关系。即"子类is a 父类"——子类是父类。如：卡车是汽车，卡车is a 汽车。

2、父类中如果用Protected修饰符，表示只允许其子类访问，而不允许其他非子类访问：

    父类中如果用private修饰符,子类是不能访问的。

3、除了构造方法不能被子类继承外，其他都可以直接被继承。可以用base关键字调用父类的构造函数：语法如下

     ：base(参数变量名)

     使用base还可以调用父类的属性和方法。

     注意：子类构造函数中已经定义了这些参数，在base()中只需指定变量名即可，

              这个变量名必须与父类中的构造函数中的一致

4、继承的特征：

     A 继承的传递性

     B 继承的单根性 表示一个子类只能继承一个父类。

     C 密封类 它修饰的类是不能被继承的。用关键字sealed

---------------------------------------------------------------------------------------------------------------------------------------------------

面向对象之多态性：

多态是指两个或多个属于不同类的对象，对于同一个消息（方法调用）作出不同响应的方式。实现多态的方式：

一、抽象类和抽象方法

    1、 抽象类的语法:

                         访问修饰符 abstract class 类名

    2、 父类中的方法：

                         访问修饰符 abstract 返回类型 方法（）；

注意：含有抽象方法的类必然是抽象类。抽象类中的方法并不一定都是抽象方法。

         抽象类是不能被实例化的。只能通过它的子类来实现该类的方法，除非它的子类也是一个抽象类。

         抽象类不能是密封或者静态的，抽象类被子类继承并实现它的抽象方法。

    3、重写抽象方法：

                          访问修饰符 override 返回类型 方法（）

     4、使用场合：

                       A 父类提供了一个功能或者规定，约束子类的行为。

 示例：

abstract public class Person
    {
        abstract public void SayHi();
    }

//子类
   public class Student:Person
    {
      public override void SayHi()
        { 
             //代码省略
        }
     }

    public class Teacher:Person
    {
      public override void SayHi()
        { 
             //代码省略
         }
     }

里氏替换原则

     "is"操作符用于检查对象是否与给定的类型相同。如： if（obj is string）{}

     "as"用于两个对象之间的类型转换。如:string as obj;

注意：as运算符当转换失败时，运算符将产生null，而不是引发异常。

     "is"检查一个对象是否兼容于指定的类型，并返回一个Boolean值：true或者fasle。注意，is操作符永远不会抛出异常，请看以下示例：

ClassA

{

.... 

}

Object o=new Object();

Boolean b1=(o is Object); //b1为true. 

Boolean b2=(o is ClassA) ; b2为false.

如果对象引用是null,is操作符总是返回false,因为没有可检查的其类型的对象。

 

二、虚方法：

                访问修饰符 virtual 返回类型 方法（）

               {

                     //方法体

               }

 1、每个对象Object都有一个Equals（）方法，用于确定两个实例对象是否相等，它是一个虚方法，可以重写这个方法。

      public virtual bool Equals(Object obj)

      默认情况下，Equals（）方法只支持引用相等，也就是相比较的两个对象是否引用同一个对象。

      重写Equals()虚方法如：

        public override bool Equals(object obj)
        {
            //将要比较的对象转换为当前类型
            Student target = obj as Student;

            //如果为空、类型不同
            if (target == null)
                return false;

            if (target.name == this.name &&
                target.gender == this.gender &&
                target.age == this.age &&
                target.hobby == this.hobby &&
                target.popularity == this.popularity)
            {
                return true;
            }
            return false;
        }

2、虚方法和抽象方法的区别：

  A、修饰的关键字不同

  B、父类中方法体的区别

  C、重写的区别（抽象方法必须override）

  D、抽象方法只能在抽象类中，而虚方法除了密封类外都可以写

3、方法重写的条件：

     A、方法签名必须一样

     B、访问修饰符允许被放大

     C、返回类型必须一样   

总结：面向对象的三大特征:

        封装：保证对象自身数据的完整性、安全性

        继承：建立类之间的关系，实现代码复用、方便系统的扩展

        多态：相同的方法调用可实现不同的实现方式

三、方法重载

      1、与重写方法的区别

           A、应用场合不同：如果父类中有abstract/virtual，才能被重写，重写方法要求类与类之间是继承关系。

                                    而重载没有过多的要求。

四、方法隐藏：父类和子类的方法都存在。

五、静态（satice）类/密封（sealed）类/抽象（abstract）类它们各自的特点

注：本文转载于http://www.cnblogs.com/028fly/archive/2009/06/06/1497079.html