第六章：面向对象

6.1 面向过程与面向对象

什么是面向过程，面向对象？它们都是解决问题的思路 大致的方向。

面向过程其实是最基本的思路 而面向对象是基于面向过程的思路。

6.2 对象与类

什么是对象？但凡是真实存在的且具体的事物 都称之为对象。就是由某一个类所描述出来的具体的事物。

什么是类？具有相同行为和特征的一些具体事物的总称。类相当于大楼设计图纸，对象就是由该图纸所建成的具体的大楼。

类就是用于描述事物的。类主要描述事物的那些方面呢？

                                        属性-数据-成员变量
                                        行为-函数-成员函数

描述一个事物的行为 可以用函数来表示。

也就意味着当我们在创建一个类的时候 其实就是在自定义一个数据类型。
对象就是由一个类所描述的内容从而产生的一个具体的事物。

目前而言 但凡创建对象 用new关键字
    格式：类名/数据类型 变量名=new 类名();
    如何访问对象中的成员呢 变量名.成员

6.3 对象的内存图解I

1.在堆内存中开辟一个空间并分配地址
2.按照类的描述，在该空间中定义成员变量 并且有默认初始化值 

3.加载成员函数进入方法区(只加载一次)
4.对象创建完毕 将空间地址赋值给相应的变量
5.变量(p1/p2)调用成员变量
    先通过该变量所存储的地址去堆空间中找
    然后在该空间中找相应的成员变量
6.变量(p1/p2)调用成员函数
    直接去方法区中找该成员函数
    将该函数加载进栈内存开始运行
    为了方便区分哪个对象调用的该成员函数
    由this这个关键字段 来区分 this主要存的是当前对象的地址
    注意：当成员函数在操作变量的时候 
        先在当前函数的空间里找 局部变量
        如果没有找到，再去this所指向的堆内存中对象所属空间里去找。

6.4 封装与private关键字

private关键字 就是一个权限关键字 public protected 默认不写。

private关键字 表示私有权限 该成员变量或成员函数只能够在类中被访问 外界不可访问。

目前发现的两个问题
1.我们可以通过对象直接修改对象中的成员变量
    弊端：如果赋予了一个错误的值 那么势必回导致程序后期的运行结果

就是说我们对象的成员变量并不是完全需要向外界可访问的，如果能够被外界访问 那么势必也能被外界修改。

为了防范外界直接修改对象的成员变量？使用private私有化关键字，成员变量加了private的话 修改不行了 获取也不行了。

本质上而言 我们应该防范的是什么？无条件强制的给成员变量修改
就是说 修改是可以修改的 但是你不能忽略对象的感受 万一给一个错误的值怎么办？
不能直接修改的意思就是间接修改(是不是应该加上相应的对值的判断 语句if-else)

setter 是一个Java当中的规范 修改器 主要负责修改成员变量
本身就是一个成员函数 命名方式一般为 setXxx:setAge setName

getter 访问器 主要负责访问成员变量(返回成员变量) getter看需求

建议：今后的代码中 成员变量一律私有 然后再去设置访问器和修改器
注意：如果成员变量和局部变量重名了 如何区分呢？只需要在成员变量之前加this.即可

面向对象三大特征：封装 继承 多态
封装：从字面意义上来看 封装就是将一些杂七杂八的东西进行统一的管理
    收纳盒 衣柜 冰箱 书柜
    最大的好处就是节约代码 方便管理 降低耦合性
在代码中有什么体现：
    循环：主要解决有规律且重复性执行的代码
    函数：主要解决具有独立功能的一段代码 后期进行复用即可
    数组：主要解决多种同类型数据的操作 统一操作 方便类管理
    类：主要将数据和行为进行统一方便操作 仿真现实中的事物

6.5 成员变量与局部变量的区别

1.存储位置
        局部变量存储在栈内存中函数的所属空间里
        成员变量存储在堆内存中对象的所属空间里
    2.生命周期
        局部变量随着函数的进栈而存在，随着函数的弹栈而消失
        成员变量随着对象的创建而存在，随着对象的销毁而消失
    3.访问范围
        局部变量的访问范围仅仅在函数当中
        成员变量的访问范围在当前类中
    4.初始化值
        局部变量必须先进行初始化 之后再能被调用
        成员变量在创建时有默认初始化 

6.6 构造函数

我们只能将对象创建完毕之后，再进行对成员变量的赋值
        对于一个人而言 是出生后才有的性别 还是出生前就有性别
        有些人 出生前就有姓名了 有些人出生后才有的姓名
        隐喻的对象 
                有些对象创建之前成员变量就有值（不含默认初始化）
                有些对象创建之后成员变量才有值
        所以就有一个问题了 如何在创建对象之前之中对我们的成员变量进行赋值呢？
    
    构造函数的主要作用：在创建对象之时对成员变量进行赋值操作
    构造函数的格式：
    权限修饰符 函数名(参数列表){
        函数体;
    }
    对比和之前学过的函数来说 
    构造函数
        没有函数类型关键字 
        没有返回值类型（并不意味着没有return）
        函数名必须是类名
    但凡创建一个对象 构造函数就执行一次
    问题：我们之前并没有写构造函数
            如果类中没有定义任何构造函数的情况下，则会有一个默认无参的构造函数
            public ClassName(){}
            如果类中有明显定义的构造函数 则默认无参的构造函数不存在了
        所以 一般而言 我们最好将那个无参的构造函数写出来！！！！！！！
    成员变量的赋值其实经历了三个阶段
        默认初始化-    显式初始化  -      针对性初始化
                  类中成员变量被赋值        构造函数

    构造函数和成员函数有什么样的区别
        构造函数只在创建对象的时候调用 而且仅仅调用一次
        成员函数在创建对象之后调动 可以调用任意次数

        成员函数能否调用成员函数 可以
        成员函数能否调用构造函数 不可以的
        构造函数能否调用成员函数 可以 只不过此时的成员函数不应该当做对象的特有行为而向外界提供的
                                仅仅是构造函数中的代码略多 从而分出来的函数 本质上这个函数还是构造函数的内容
                                那么该函数一般被定义为private
        构造函数能否调用构造函数 可以 适当减少代码的冗余 提高构造函数的利用率
                                原则上一般是参数较少的构造函数调用参数较多的构造函数
                                具体的调用方式并不像成员函数一样 写个方法名
                                注意：成员函数劲量和构造函数别重名
                                this(...) 对this的调用必须是构造器中的第一个语句
                                在注意一点：构造函数可以调用构造函数 但是不能产生回调
                                ERROR:递归构造器调用
    
    那么有了构造函数 是否还需要Setter和Getter吗？
        不一定 看需求 如果确定数据后期要被修改 则添加。

6.7 对象的内存图解II

1.在堆内存中开辟一个空间并分配地址
2.对成员变量进行【默认初始化】
3.相应的构造函数进栈 刚开始就对成员变量进行【显式初始化】
4.接着再去执行构造函数中的内容【针对性初始化】
5.构造函数执行完毕 弹栈 将对象的地址赋值给相应变量即可
Stack
MyString

面向对象最大的好处：就是可模拟现实生活中的事物。

6.8 static关键字

成员变量+static=静态变量
当我们在设计类的时候 发现多个对象中有共享数据的时候 我们就可以把这个共享的数据 定义为静态的
name age虽然每个对象都有 但是值不一定一样 对象的特有数据->成员变量
country虽然每个对象也都有 但是值一样 对象的共有数据-> 静态变量
静态的东西从堆中对象的空间里抽取出来了 放到哪里了呢？静态方法区

共有的数据 要 活的比 对象 长

成员函数+static=静态函数
静态函数意味着就是对象的共有行为吗？不行的
我们当前的成员函数如果不访问任何成员变量的情况下 这个函数就可以定义为静态的
这就意味着 静态函数不能直接调用当前类中的成员变量 无法从静态上下文中引用非静态
为啥？静态的生命周期要长于对象

所以 静态是优先于对象存在的

静态也称之为是类的成员，我们可以直接通过类去调用
类.静态成员

主函数是程序的入口，优于其它运行
假设主函数是非静态的 那么必须先创建对象 才能调用主函数

静态变量有没有默认初始化值？有  （运行时常量 永久代 JVM）

类的分类：
        实体类：
            就是为了描述一个事物 Person Point
            类中内容基本上都是成员函数/成员变量
            也会而存在一个静态成员
        工具类
            提供一些已经被实现好的功能 向外部供应
            所以工具类中基本上全都是静态函数
            类.Xxx 类.Xxx() Math Arrays
            为啥工具类中都是静态？
            1.共有的
            2.长时间存在
            3.加载一次 后期随便使用
            一个道理：
                当我们钉一个钉子的时候 找榔头
                你是造一个榔头 还是用已存在的榔头？
            如果工具类可以被创建对象 是不是就想用的时候去创建
                效率较低
        主类/测试类
            主要用于运行/测试代码
            这个类中会有主函数的存在
            实体类是可以存在主函数的 但是不推荐
            工具类一般不会存在主函数

        建议 一个类一个文.java件
    查漏补缺：
    1.静态函数中，是否存在this这个关键字？不可能
    2.静态变量，我们在定义的时候，一般而言这个变量是不可修改的 加上final修饰

6.9 对象的内存图解III

1.javac 将Java源代码进行编译 生成字节码文件
2.java 将字节码文件加载进虚拟机中 开始运行程序
        字节码具体被加载在方法区里面
        方法区可以大致分为 非静态方法区/静态方法区
        所有非静态的代码(二进制)内容加载进非静态去
        所有静态的代码(二进制)内容加载进静态区
        JVM接下来会根据参数(java 字节码文件名(类名)) 去静态区找主函数
        将主函数代码加载进虚拟机栈 开始运行
3.后面的和之前一样

6.10 静态变量与成员变量的区别

 1.生命周期
        成员变量随着对象的创建而创建 随着对象的消亡而消亡
        静态变量随着类的加载而创建 随着程序结束而消失
2.调用方式
        成员变量必须先创建对象 在通过对象去调用
        静态变量可以被对象调用 也可以直接用类调用
3.存储位置
        成员变量存在于堆内存中对象的所属空间里
        静态变量存在于静态方法区中类的所属空间里
4.命名
        成员变量-对象的特有属性
        静态变量-对象的共有属性 类成员

6.11 代码块

代码块 { ... }
    
    局部代码块：存在于函数当中(包括函数) for(){...} if(){...}
    
    构造代码块：直接在类中出现的{...}
        当对象创建一次 构造代码块执行一次
        作用等同于构造函数

    静态代码块：直接在类中出现的static{...}
        当类被加载的时候 仅且只执行一次
        作用于 对类进行一些初始化操作 JDBC

6.12 单例模式

设计模式：就是我们的前辈们总结出来的一些编码技巧
    它并不是随着Java的诞生而诞生的
    它是由Java的广大使用者总结出来的一套编码经验
    常见26种

    单例模式：使用场景是 某一个类只能创建一个对象
    比如某一个朝代的皇帝 只能是唯一的
    1.既然只能创建一个对象的话 就得不能让外界去创建对象
        限制使用new不现实
        只能从对象的创建流程中考虑 只要有一个步骤不行 对象就创建不出来
        开辟空间分配地址 是由计算机底层决定 我们也控制不了
        构造函数执行  只需要将构造函数私有化即可
    2.既然外界不能创建对象 我们还得保证对象的创建
        所以我们只能在类内部创建对象
        Single s=new Single();
        能否写成 成员变量的形式？
        所以private static
    3.内部创建出对象 还得向外界提供
        因为private 外界不能直接访问
        所以见解 向外界提供一个函数 外界通过调用函数获取对象

6.13 继承

继承由来是什么：当我们在定义若干个类的时候，发现某一些类中具有相同的属性和行为
        那么，我们就可以将这些相同的部分进行抽取，独立生成另外一个类，那么这个生成出来
        的类我们称之为是父类，其他的被抽取内容的类称之为子类
        子类与父类之间就是所谓的继承关系 用 extends来表示
    那么在现实生活中，父与子之间的一对多 还是多对多的关系？
    所以 在Java当中 继承是单继承(一个子类只能有一个父类，但是一个父类可以有若干个子类)
    当然，在C++中，继承是多继承的，不太符合实际的社会问题，所以Java更加符合现实编程
    (不代表Java当中就没有多继承的时候！如果是类与类之间 必须是单继承；如果是接口与接口之间，可以是多继承)
    既然有了继承，那么在Java当中就有了继承体系
    (既然有了父子关系，是不是就产生出了族谱这个东西)
    先说一点：我们常用的继承体系 异常体系 集合体系 IO体系 网络体系 多线程体系
    C->B->A->?->?->龙的传人/炎黄子孙
    C就是B的儿子，那么A就是C的爷爷

    在Java继承体系当中，所有类的最终父类都是Object!Object就不存在爸爸了
    如果我们在定义一个类的时候，没有显著声明父类的时候 那么该类的父类默认是Object

    注意一点：在分析设计继承的时候 一定要符合社会常识问题 
            子类 和 父类 之间 必须是 is a 关系 子类必须父类的一种 同一系列的
            she is a Girl  ; he is a boy ; he is a ladyboy ; 旺财 is a Dog 
        所以，千万不要为了获取某一个类的功能而把这个类叫爸爸！

    子父类中成员变量/静态变量的特点：
        如果只有子类有且非私有 那么就调用子类的
        如果只有父类有且非私有 那么就调用父类的
        如果子父类都有且非私有 那么就调用子类的
        (成员变量之间 是不存在重写关系的!!!)
        子类.属性 顺序：子类对象成员->子类静态->父类成员->父类静态
        子类成员函数在内部调用变量时 局部变量->子类对象成员->子类静态->父类成员->父类静态

    子父类中构造函数的特点：
        现象：子类的构造函数在调用运行的时候 先执行父类的构造函数
        在子类的构造函数当中，有一句默认的super(...)隐藏了，而且这句代码必须是在第一行
        对super的调用必须是构造器中的第一个
        为什么？道理很简单 儿子向老爸要钱，那么老爸是不是得先准备一下钱
        既然子类继承自父类 那么必然会继承到父类当中的一些数据
        所以，在子类构造函数之中，必须先让父类把这些数据进行一些初始化才能继承给子类
        注意：父类的构造函数被调用，但不代表父类就被创建对象了！
              所以this是当前对象的引用，而super不是父类对象的引用，而是父类空间的引用
        并且注意super(...) 如果父类没有默认无参构造函数 那么子类构造函数中super()失效了
        所以在调用父类构造函数时，一定要注意父类构造函数的参数情况！适时修改super(...)

        this(...)是当前类中 本类构造函数调用本类构造函数的方式
        super(...)是本类构造函数调用父类构造函数的方式
        都必须在第一行 那么这两冲突不？
        如果本类构造函数当中不存在调用关系 那么每一个本类构造函数第一句都是super(...)
        如果本类构造函数当中存在调用关系，那么最后被调用的那个构造函数第一句绝对是super(...)
        this(...)的调用是单向的还是递归的？是单向的，那么最后被调用的第一句绝对就是super(...)

    子父类中成员函数的特点：
        如果只有子类有且非私有 那么就调用子类的
        如果只有父类有且非私有 那么就调用父类的
        如果子父类都有且非私有 那么就调用子类的（函数重写）
    函数重写：在子父类中，同名函数
    函数有什么组成：函数声明(权限 类型 返回值类型 函数名 参数列表)+函数体({}里面的内容)
    重写的意义在于哪？在于子类继承了父类的函数声明(功能)，但是子类可以将该函数的具体实现进行优化或更改
                    郭德纲会说相声 郭麒麟也会说相声
                    子承父业！
        1.保留父类的功能声明 子类可以进一步优化
        2.保留父类的功能声明 子类可以重新定义
    重写当中应该注意到的一些细节：
    1.函数重名 但是参数列表不同 不构成重写关系
    2.函数重名 参数列表相同 构成重写关系 返回值类型也必须是一样的
    3.子类重写父类函数时，权限>=父类权限
    4.当然 如果父类函数权限为private 子类压根就继承不到 何谈重写

6.14 抽象类

抽象类：模糊不清的类 不具体的类
    当我们在抽取一个父类的时候，发现子类当中的一些共同方法在父类中无法进行具体的实现
    并且这些方法只能在子类中具体实现时，父类当中的这些函数就只保留函数声明即可，不必写函数体
    那么此时这个函数就是 抽象函数！ 有抽象函数的类 就是抽象类！
    特点：
    1.抽象类能否创建对象？不能 对象本身是一个具体的东西 而抽象类中含有不具体的内容
    2.抽象类必须作为父类存在吗？必须 抽象类就等着被继承呢！
    3.抽象类和一般类有什么区别？就是一般类的特殊情况 
        唯一的区别只在于抽象类中有抽象函数！
    4.抽象类中必须有抽象函数吗？不一定 AWT界面开发
    5.abstract这个关键字不能和那些关键字共存？
        private 抽象函数就等着被子类重写实现呢！
        static  静态是优先于对象存在的，在加载静态数据的时候 肯定是具体的数据
                类名.抽象函数 很尴尬！ 
                如果抽象函数可以被静态 那么我们还需要对象干什么？

 

6.17 多态

    多种状态：就是指一个对象可以有多种状态(他在继承体系中的位置变化)
    D->C->B->A->Animal
    位置的变化只能是向上变 但不能低于自身
    对于C而言 可以当做B来看 也可以当做A来看 也可以当成Animal
        小明        男人             人     动物
    小明的学校开家长会 小明不想让他爸爸去 他让大明去 大明就是小明他哥
    大明冒充Dad去参加家长会的话，那么所表现出来的行为 是不是应该符合他爸行为
    不同的视角 不同的角色
    无论是在哪个视角场合 对象本身变了没有？只不过我们需要对象在不同的场合表现出相对应的行为
    在Java当中 多态代码表现 就是 父类引用指向子类的对象
    多态的前提：继承 重写
    多态的好处：对代码的功能进行了可扩展性
        子类对象可以当做父类对象去使用 但是有限制 只能调用父类函数或重写的函数
        不能使用子类特有的行为
    
    多态当中 成员变量的特点：只能访问父类中的成员变量
    多态当中 成员函数的特点：
        如果子类没有重写 且父类中有 调用父类的
        如果子类有重写 调用子类重写的
        如果不存在重写 父类没有 那就报错了！