代码块：
        概述：由{}括起来的内容。
        分类：
                局部代码块：
                        定义在局部位置，作用是让变量尽可能早的从内存中消失，节约内存，提高效率。

                构造代码块：
                        定义在成员位置。
                        作用：
                                里边存储的是所有构造方法的共性内容，因为它是优先于构造方法执行的，从而来提高代码的复用性和编写效率。
                静态代码块：
                        被static修饰的代码块。
                        作用：一般是用来加载驱动的，因为它是随着类的加载而执行。
                        特点：静态代码块只执行一次（类文件只加载一次的情况下）。

                同步代码块：（多线程的时候讲）
                        被synchronized修饰的代码块。


继承：
        概述：就是通过extends关键字让类与类之间产生 子父类关系，这种现象就叫继承。
        格式：
                class 类A extends 类B {        //子承父业
                }
        叫法：
                类A：子类，派生类
                类B：父类，基类，超类。

        好处：
                A：复用性。
                B：维护性。
                C: 让类与类之间产生关系，是多态的前提。

        弊端：
                耦合性太强了。
                开发原则：高内聚，低耦合。
                        耦合：类与类之间的关系。
                        内聚：类自己独立处理问题的能力。

        继承的特点：
                类与类之间的继承：
                        A：只支持单继承，不支持多继承。
                        B：Java支持多层继承。

                总结：看顶层，用底层。

                接口与接口之间的继承：
               
        继承的注意事项：
                A：子类只能继承父类的所有非私有成员（成员变量和成员方法）。
                B：子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法。
                C：不用为了使用部分功能而去使用继承。

        什么时候使用继承？
                只有当类与类之间满足"is a"的关系的时候，就可以考虑使用继承。
                A is a B :        A是子类，B是父类
                B is a A :        A是父类，B是子类

        继承中的成员特点：
                成员变量：
                        使用变量遵循一个“就近原则”。局部位置有就使用，没有就去本类的成员位置找，有就使用；没有就去父类的成员位置找，有就使用，没有就报错.

                        this和super的区别：
                                this：代表本类当前对象的引用。
                                super：当前对象父类的引用。

                                区别：
                                        A：调用成员变量：
                                                this.成员变量： 即可以调用本类成员变量，也可以调用父类成员变量（本类没有）
                                                super.成员变量：只能调用父类的成员变量

                                        B：调用构造方法：
                                                this( 参数 )        ： 调用本类的其他构造
                                                super( 参数 )        ： 调用的父类的其他构造

                                        C：调用成员方法：
                                                this.成员方法： 即可以调用本类成员方法，也可以调用父类成员方法（本类没有）
                                                super.成员方法：只能调用父类的成员方法

                构造方法：
                        子类所有的构造方法默认都去访问了父类的 无参构造。
                        为什么？
                                用于子类对象访问父类数据前，对父类数据进行初始化。
                        掌握：
                                所有的类都直接或间接继承自Object类，Object类是所有类的父类。
                                Object类中只有一个无参构造。

                        如果父类没有无参构造怎么办？
                                第一种方式：
                                        通过 this(参数) 的形式调用本类的其他构造。

                                第二种方式：
                                        通过 super(参数) 的形式调用父类的带参构造。

                        注意事项：
                                super()语句和this()语句必须放在构造方法的第一行。并且这两个语句不能共存。
                                问：super关键字和this关键字，在同一个构造方法中，能不能共存？
                                        可以。
                                       
                        如果子父类都有 静态代码块，构造代码块，构造方法，那么他们六者之间的执行顺序是什么？
                                第一次：
                                        父静，子静，父类的构造代码块，父类的构造方法，子类的构造代码块，子类的构造方法。
                                第二次：
                                        父类的构造代码块，父类的构造方法，子类的构造代码块，子类的构造方法。
                                       

                成员方法：
                        方法重写：子类出现和父类一模一样的方法时，称为方法重写。
                                          注意：返回值类型也必须完全一样（或者有子父类关系）。

                        什么时候使用方法重写？
                                当子类需要使用父类的功能，并且功能主体又有自己特有功能的时候，就可以考虑使用方法重写。
                                （大白话：想使用父类的内容，并且还想加入自己的内容，就考虑使用方法重写）

                        注意事项：
                                1、父类的私有方法不能被子类重写。
                                2、子类重写的时候，方法的访问权限不能低于父类方法的访问权限。
                                        权限修饰符：
                                                （从小到大） private --> 默认 --> protected        --> public

                                3、父类的静态方法不能被子类的非静态重写。
                                   静态只能覆盖静态（严格来讲，算不上重写）。

                        面试题：
                                方法重写Override和方法重载Overload有什么区别？
                                        方法重写Override：
                                                子类出现和父类一模一样的方法时，称为方法重写，返回值类型也必须完全一样（或者有子父类关系

                                        方法重载Overload：
                                                同一个类中，出现方法名相同，参数列表不同（个数，对应的类型）的两个或两个以上的方法时称为方法重载，方法重载与返回值的数据类型无关。

final关键字：
        概述：最终的意思，是一个关键字，可以修饰类，变量，方法。
                修饰类：不能被继承，但是可以继承其他类。
                修饰变量：其实是一个常量。
                        一般和public static共用。
                        问：public static final 他们三者之间有无顺序关系？
                                没有顺序关系，但是一般写成：public static final
                修饰方法：不能被子类重写。


        修饰局部变量：
                基本类型：值不能改变。
                引用类型：地址值不能改变，但是对象的属性值可以改变。


        修饰变量的初始化时机：
                1、显示初始化。
                2、通过构造方法进行初始化。
                        （在对象构造完毕前进行初始化即可）
       






               

厉害，学习了

敲满10G代码，我给你推荐工作