java面向对象之封装、继承、多态

一、封装
    概念
        封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。
        面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，
        这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private实现封装。
        什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装
        实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。
    作用
        ① 对象的数据封装特性彻底消除了传统结构方法中数据与操作分离所带来的种种问题，提高了
        程序的可复用性和可维护性，降低了程序员保持数据与操作内容的负担。
        ②对象的数据封装特性还可以把对象的私有数据和公共数据分离开，保护了私有数据，减少了
        可能的模块间干扰，达到降低程序复杂性、提高可控性的目的

二、继承
        1、概述&格式
    (1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，
       这多个类就具备了这些内容。这个关系叫继承。
    (2)Java中如何表示继承呢?格式是什么呢?
        A:用关键字extends表示
        B:格式：
            class 子类名 extends 父类名 {}
        2、继承的好处 
            A:提高了代码的复用性
            B:提高了代码的维护性
            C:让类与类产生了一个关系，是多态的前提
        3、继承的弊端
                A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
                    原则：低耦合，高内聚。
                    耦合：类与类的关系
                    内聚：自己完成某件事情的能力
                B:打破了封装性
        4、继承的特点
                    Java中继承的特点
                A:Java中类只支持单继承
                B:Java中可以多层(重)继承(继承体系)
                后期接口的出现，可以实现多继承
        5、继承的注意事项
                A:子类不能继承父类的私有成员
                B:子类不能继承父类的构造方法，但是可以通过super去访问
                C:不要为了部分功能而去继承
        6、继承中的成员关系
            Java继承中的成员关系
        A:成员变量
            a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单
            b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?
                子类的方法访问变量的查找顺序：
                    在子类方法的局部范围找，有就使用。
                    在子类的成员范围找，有就使用。
                    在父类的成员范围找，有就使用。
                    找不到，就报错。
        B:构造方法
            a:子类的构造方法默认会去访问父类的无参构造方法
                是为了子类访问父类数据的初始化
            b:父类中如果没有无参构造方法，怎么办?
                子类通过super去明确调用带参构造
                子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造
                让父类提供无参构造
        C:成员方法
            a:子类的成员方法和父类中的成员方法名称不一样，这个太简单
            b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢?
                通过子类对象访问一个方法的查找顺序：
                    在子类中找，有就使用
                    在父类中找，有就使用
                    找不到，就报错

三、多态
        1、多态的前提

            A:有继承或者实现关系。
            B:有方法重写,也叫覆盖操作。
            C:有父类或者父接口引用指向子类对象。

            多态的分类：
                a:具体类多态
                    class Fu {}
                    class Zi extends Fu {}

                    Fu f = new Zi();
                b:抽象类多态
                    abstract class Fu {}
                    class Zi extends Fu {}

                    Fu f = new Zi();
                c:接口多态
                    interface Fu {}
                    class Zi implements Fu {}

                    Fu f = new Zi();

    2、子父类成员访问特点

                多态中的子父类成员访问特点
            A:成员变量
                编译看左边，运行看左边  （无论编译和运行，成员变量参考的都是引用变量所属的
                父类中的成员变量。）
            B:构造方法
                子类的构造都会默认访问父类构造
            C:成员方法
                编译看左边，运行看右边(成员方法，编译看引用型变量父类所属的类，运行看对象子类
                所属的类的方法)
            D:静态方法
                编译看左边，运行看左边 （因为静态方法，其实不所属于对象，而是所属于该方法所在的类）

            为什么?
                因为成员方法有重写。

    3、多态的好处
                A:提高代码的维护性(继承体现)
                B:提高代码的扩展性(多态体现)

    4、多态的弊端
            父不能使用子的特有功能。

            现象：
                子可以当作父使用，父不能当作子使用。

            当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以
            访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)

5、多态中的转型

            A:向上转型
                从子到父
            B:向下转型
                从父到子
多态中的成员访问特点及转型的理解：

class 孔子爹 {
            public int age = 40;

            public void teach() {
                System.out.println("讲解JavaSE");
            }
        }

        class 孔子 extends 孔子爹 {
            public int age = 20;

            public void teach() {
                System.out.println("讲解论语");
            }

            public void playGame() {
                System.out.println("英雄联盟");
            }
        }
    //Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
        //但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?
        //然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹
        //向上转型
        孔子爹 k爹 = new 孔子();
        //到人家那里去了
        System.out.println(k爹.age); //40
        k爹.teach(); //讲解论语
        //k爹.playGame(); //这是儿子才能做的


        //讲完了，下班回家了
        //脱下爹的装备，换上自己的装备
        //向下转型
        孔子 k = (孔子) k爹; 
        System.out.println(k.age); //20
        k.teach(); //讲解论语
        k.playGame(); //英雄联盟