面向对象的三大特征

面向对象的三大特征

封装

隐藏内部实现，稳定外部接口->系统安全性进行提升

继承

子类继承父类成员，实现代码的复用->开发和维护效率提高

继承的使用

1. 继承的特点

   1. 继承的顺序不可逆：继承从上往下依次继承，而不能逆序继承

   2. 继承的延续性：在继承的顺序中，下一级完整的具备上一级的属性和特征

为什么要使用继承

继承使用的必要性

1. 提高代码的复用，减少代码的冗余

2. 一处更新，处处更新

如何实现继承

继承的步骤

1. 抽象公共部分，放到一个特定的类中(父类、基类)

2. 其他类(子类、派生类)只需要继承父类，即可拥有父类的特征(属性、方法)

3. 根据子类的需求添加属于自己的特征和方法

具体实现

    在子类后面使用继承符号":"继承父类

继承中的关键字

继承关系

Animal(父类)<<<<-----[Cat,Frog] (派生类)

概念

1. 子类继承父类，父类派生子类

2. 子类又叫派生类，父类又叫基类(超类)

3. 子类继承父类成员，也可以有自己的独立程序

4. 继承具有传递性：A->B;B->C C就具有A的特性

5. 继承的单根性：一个类只能有一个父类，一个父类可以有任意多个子类

继承的必要条件

继承必须要符合关系：is-a的关系 【Cat is an Animal】

关键字

this关键字：

    1.可以访问自身也可以访问父类

base关键字：

    1.调用父类的构造函数

    2.调用父类的属性和方法

和继承有关的访问修饰符

问题：如果父类中的某个成员只允许其子类访问应该如何实现

父类成员：

1. 使用public修饰：所有的类都可以访问

2. 使用private修饰：只有自己可以访问

3. 使用protected修饰：仅允许子类访问，而不允许其他非子类访问

修饰符	类内部	子类	其他类
public	可以	可以	可以
private	可以	不可以	不可以
protected	可以	可以	不可以

多态

不同子类对同一消息，做出不同反应->系统扩展性增强

概念：

1. 不同对象，接收相同消息，产生不同行为，称为多态

2. 多态是由“聪明的”虚拟机自行决定的

实现：

使用继承实现多态

1. 父类中必须有抽象方法或虚拟方法

2. 子类必须重写父类中的抽象方法或选择重写父类中的虚拟方法

3. 子类对象必须转成父类类型去使用

方法

1. 方法的重载

2. 构造重载

3. 方法的重写：重写不能改变方法签名

里式替换原则

1. 子类的对象能够替换其父类、

2. 父类对象不能够替换子类

3. 父类的方法都要在子类中实现或重写

is与as操作符

1. is主要用作检查对象是否是指定类型兼容，如果转换失败程序中断

2. as主要用作在兼容的引用类型之间执行转换，转换失败返回null

抽象

父类和子类相互转换

Cat cat = new Cat()
            {
                Name = "小黄",
                Type = AnimalType.Mammal
            };

            Frog frog = new Frog()
            {
                Name = "小青",
                Type = AnimalType.Amphibious
            };

            List<Animal> list = new List<Animal>();
            //子类隐式转换为父类
            list.Add(cat);
            list.Add(frog);
            foreach (Animal item in list)
            {
                //将父类强转成对应的子类
                if (item is Cat)
                {
                    ((Cat)item).Work();
                }
                if (item is Frog)
                {
                    ((Frog)item).Work();
                }
            }

1. 父类类型可以添加子类对象，子类自动转换成父类类型

2. 将父类类型转成子类对象时，父类类型的对象必须强制转换成对应的子类对象，才能调用子类的独立成员

抽象类的使用

1. 使用关键字abstract修饰的类称为抽象类

2. 抽象类只是用来列举一个类所具有的行为，不能单独通过创建对象来使用

3. 抽象类中可以有抽象成员，也可以没有任何抽象成员

4. 抽象类不能是静态的或密封的

抽象方法的使用

1. 抽象方法必须放在抽象类中

2. 抽象方法使用关键字abstract修饰

3. 抽象方法只是一个方法的声明，没有方法体

4. 抽象方法仅表示一个应该具备的行为，具体的实现由子类完成

5. 抽象方法在子类中必须被实现，使用关键字override重写

6. 子类必须重写父类的所有抽象方法，除非子类本身也是抽象类

虚拟

问题：如果需要在父类中提供一个方法，该方法有自己的方法体，子类根据自身的需要再去决定是否重写该方法，这个方法重写不重写取决于子类自身的需求。

虚拟方法	抽象方法
使用virtual	使用abstract
必须提供方法体和正常方法一致	不允许有方法体，只能有方法签名
子类可以选择重写也可不重写	子类必须重写抽象方法
除了密封类中都可以写	只能在抽象类中

 

访问修饰符

public   完全公开的

private  私有的，在类的内部才可以访问

protected  保护成员，继承类和该类内部可访问

internal  在同一命名空间下即可访问

protected internal/protected internal

密封类

使用关键字：sealed

1. 当一个类使用sealed修饰后，该类不能被继承

2. sealed对于保护知识产权起到一定作用，一定程度上限制别人二次开发