07-面向对象特征

面向对象的特征:

    A: 封装:

    B: 继承:

        1. 概述:

            实际开发中,我们发现好多类中的内容是相似的,于是我们就把这些相似的内容抽取出来放到一个类中, 然后让那多个类和这个类产生一个关系,这个关系就是继承. 继承用 extends 关键字表示.

        2. 格式:

            class 类A  extends 类B {  //子承父业

            }

            /*

                class Student extends Person {

                }

            */

        3. 叫法:

            类A: 子类, 派生类

            类B: 父类, 基类, 超类

        4. 特点：(类与类之间的继承特点)

            A: Java只支持单继承，不支出多继承。    (先这么记忆，不严谨)

            B: Java支持多层继承。

        5. 注意事项:

            A: 子类只能继承父类的非私有成员。（成员变量和成员方法）

            B: 子类不能继承父类的构造方法，但是可以通过super来使用。

            C: 不要为了部分功能而去使用继承。

                什么时候使用继承呢?

                    当类与类之间满足"is a"的关系时,就可以考虑使用继承.

                    //类A is a 类B:   类A是子类, 类B是父类

        6. 好处

            A: 提高代码的复用性.

            B: 让类与类之间产生关系, 是多态的前提.

        7. 弊端

            耦合性增强了.

            开发原则: 高内聚, 低耦合.

                内聚: 指的是类自己独立处理问题的能力.

                耦合: 指的是类与类之间的关系.

        8. 继承中的成员特点:

            成员变量:

            构造方法:

            成员方法:

        继承涉及到的其他知识点:

            方法重写: // 方法覆盖, 方法复写

                概述:

                    子父类间,子类出现和父类一模一样的方法时,称为方法重写.

                什么时候使用方法重写?

                    当子类需要继续沿袭父类的功能，但是功能主体又有自己特有需求的时候，就可以考虑使用方法重写。

                注意事项：

                    1、父类的私有方法子类不能重写.

                    2、重写时，子类方法的访问权限不能低于父类方法的访问权限。

                        访问权限修饰符的范围从小到大分别是:

                            private, 默认, protected, public

                    3、静态只能覆盖静态。

                        //其实严格意义上来讲, 这个算不上方法重写的注意事项.

            final:

                是一个关键字, 表示最终的意思, 可以修饰类, 修饰变量, 修饰方法.

                修饰的类: 不能被继承, 但是可以继承别的类.

                修饰的变量: 是一个常量, 只能赋值一次.

                    如果是基本类型, 是值不能改变.

                    如果是引用类型, 是地址值不能改变, 属性值可以改变.

                修饰的方法: 不能被子类重写.

        抽象类:

            概述:

                有抽象方法的类一定是抽象类(或者接口),抽象用 abstract 修饰.

            特点:

                A: 有抽象方法的类一定是抽象类(或者接口),抽象用 abstract 修饰.

                B: 抽象类不能实例化.(抽象类不能new)

                    那么,抽象类如何实例化呢?

                        可以通过创建其子类对象来完成初始化.

                C: 抽象类的子类:

                    要么也是抽象类, 这样不用重写所有的抽象方法.

                    要么是普通类,必须重写所有的抽象方法.

                D: 抽象类有构造方法.

                    既然抽象类都不能创建对象, 那么要构造方法有什么用?

                        用于子类对象访问父类数据前, 对父类数据进行初始化.

            抽象类中,能有非抽象方法吗?

                可以.

            抽象类中, 抽象方法和非抽象方法的作用分别是什么?

                非抽象方法: 作用是让子类来继承的, 提高代码的复用性.

                抽象方法: 作用是强制要求子类必须完成某些事情.

            不能和 abstract 共存的关键字有哪些?

                private: 私有方法不能重写, 而抽象方法必须重写, 它们属于设计冲突.

                final: 被final修饰的方法不能被子类重写,而抽象方法必须重写, 它们属于设计冲突.

                static: 静态方法可以被类名点的形式调用,但是抽象方法是没有方法体的, 这样做没有意义.

        接口:

            特点:

                A: 接口用关键字 interface 修饰.

                B: 类与接口之间是实现关系, 用 implements 关键字表示.

                C: 接口不能实例化.

                    那么,接口如何实例化呢?

                        通过创建其子类对象,完成初始化.

                D: 接口的子类:

                    要么也是抽象类, 这样不用重写所有的抽象方法.

                    要么是普通类,必须重写所有的抽象方法.

            类与接口之间的关系:

                类与类: 继承关系. 只能单继承,不能多继承, 但是可以多层继承.

                类与接口: 实现关系. 可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口.

                接口与接口: 继承关系. 可以单继承,也可以多继承.

            成员特点:

                接口中有且只能有常量或者抽象方法.

                常量的默认修饰符: public static final

                抽象方法的默认修饰符: public abstract

                JDK1.8以后, 接口中可以定义有方法体的方法了, 如果是静态方法可以直接写,如果是非静态方法要加 default.

    C: 多态:

        概述: 同一事物在不同时刻表现出来的不同形态(状态).

        前提条件:

            A: 要有继承(实现)关系.

            B: 要有父类(父接口)引用指向子类对象.

            C: 要有方法重写.

        成员访问特点:

            成员变量: 编译看左边, 运行看左边.

                //      看左边有没有  具体用的左边的

            成员方法:

                非静态方法: 编译看左边, 运行看右边.

                静态方法: 编译看左边, 运行看左边.

            结论:  //记忆

                只有非静态方法是编译看左,运行看右. 其他都是编译和运行都看左边.

                原因是因为: 方法有重写.

        好处:

            A: 提高代码的维护性.

            B: 提高代码的扩展性.

            /*

                多态在实际开发中的应用:

                    父类型可以作为方法的形参的数据类型进行传递, 这样可以接受其任意的子类对象.

            */

        弊端:

            父类引用没有办法使用子类的特有成员(成员变量和成员方法).

            如何解决这个弊端?

                可以通过向下转型解决.

                    Animal a = new Cat();    //向上转型

                    Cat c = (Cat)a;            //向下转型

作业:

    案例一:

        已知有猫类和狗类, 他们都有姓名和年龄.

        也都有吃饭的方法, 不同的是猫吃鱼, 狗吃肉.

        也都会跑步, 而且仅仅是跑步.

        请用继承的思想,设计出类, 并测试.

    案例二:

        如果有时间的话, 可以用继承的思想, 优化下咱们讲的: 黑马RPG游戏(通过玩家和NPC抽取一个父类出来)

    案例三:

        员工类案例:

            已知某公司有项目经理和程序员两个职位,

                项目经理:

                    属性:

                        姓名

                        工号

                        工资

                        奖金

                    行为:

                        工作

                        喝茶

                程序员:

                    属性:

                        姓名

                        工号

                        工资

                    行为:

                        工作

        请用继承的思想完成该案例.