JavaSE进阶-面向对象高级（一）

    继承                               【重点】
    修饰符                             【重点】
        权限修饰符
        静态修饰符
        最终修饰符
   

继承                               【重点】
    继承的概述
        什么是继承
            继承是面向对象的三大特征（封装、继承和多态）之一
            继承使类与类之间产生了关系(子父类)，子类可以拥有父类中的成员，除此之外子类还可以拥有自己特有的成员

            注：
                私有的成员不能被继承
                构造方法不能被继承

        继承的格式
            public class 类名 extends 类名{}

            子类：也可以称为派生类
            父类：也可以称为基类或者超类

    继承的好处和弊端
        好处
            1、可以提高代码的复用性
            2、提高的代码的可维护性
            3、是多态的前提之一
        弊端
            让类与类之间的关系变得更加紧密（耦合性变强），子类受到了一些约束

    继承的注意事项
        1、Java中类的继承，支持单继承，不支持多继承
            public A {}
            public B {}
            public C extends A{}// 单继承，支持
            // public C extends A,B{}// 多继承，不支持

        2、Java中类的继承，支持多层继承
            public A {}
            public B extends A{}
            public C extends B{}

        3、Java中的子父类是相对的概念，一个类不可能永远是子类，也不可能永远是父类

        4、Java中的继承描述的是"is a"的关系
            "is a"的关系：...是...的一种
            学生是人的一种
            苹果是水果的一种

            "like a"的关系：...像...的一种

    继承中成员访问的特点
        成员变量
            就近原则：谁离我近我就使用谁
            找方法中的局部变量，如果没有局部变量
            找子类的成员变量，如果子类没有成员变量
            找父类的成员变量，如果父类没有成员变量
            则编译报错

            如果都有，就近找局部变量，但是如果偏要找子类的成员变量或者父类的成员变量，此时就可以
            使用this和super关键字

        构造方法
                一定会先执行父类的构造，再执行子类的构造方法

                因为每一个构造方法中，第一行默认有"super()"这样的语句
                但是如果我们显式在构造方法中使用"super(实参)或者this(实参)"这样的语句，那么默认的"super()"
                语句就不再有了

                为什么要先执行父类的构造方法，再执行子类的构造方法？
                    要先给父类中的成员变量进行初始化，因为子类可能会使用到父类中的成员变量，
                    一定要先保证父类中的成员变量被初始化

        成员方法
            类似于就近原则
                创建子类对象调用的时候先找子类的成员方法，如果没有，则找父类的，如果也没有则编译报错

    this和super关键字
        this:表示本类的对象(的引用),
              在一个方法中的this，谁来调用该方法，那么该方法中的this就表示谁

             作用：
                1、通过this.成员变量，调用本类的成员变量
                2、通过this.成员方法，调用本类的成员方法
                3、通过this(实参)，调用本类其他构造方法

        super:表示父类的那片空间（为了方便理解，可以表示父类的对象的地址）
            作用：
                1、通过super.成员变量，调用父类的成员变量
                2、通过super.成员方法，调用父类的成员方法
                3、通过super(实参)，调用父类的构造方法

                按住alt，可以竖选

            构造方法调用方式：
                1、使用new关键字调用
                    Student s = new Student();

                2、使用this()或者super()
                    this(实参);
                    super(实参);

            this()或者super()这种语句使用的注意事项：
                1、this()或者super()这样的语句只能使用在构造方法
                2、this()或者super()这样的语句必须位于构造方法的第一行有效代码
                3、this()或者super()这样的语句不能同时出现

    方法重写
        什么是方法重写
            可以称为方法复写、方法覆盖
            在有继承关系的两个类中，子类中出现了父类相同的方法的情况，就是方法重写
            我们可以使用一个@Override注解，检查一个方法是否是重写的方法

        为什么要进行方法重写（方法重写的使用场景）
            父类中的方法子类是可以继承的，为什么要让子类中出现和父类相同的方法？
            因为父类继承的方法有时候无法满足子类的需求：
                1、无法完全满足，可以重写，将方法体内容重写的时候，与父类方法相同的内容可以直接调用
                2、完全无法满足，可以重写，将方法体内容完全重写
                3、完全满足，不需要重写，直接继承下来使用即可

        方法重写的规则
            方法在重写的时候，一般肯定会修改方法体内容，而不修改方法声明。
            但是如果方法声明要改也是可以的，必须遵循以下原则：
            一大两同两小
            一大：子类重写的方法的权限必须大于等于父类被重写方法的权限
                权限修饰符： private < 默认 < protected < public
                注意：private修饰的方法不能被继承，也不能被重写
            两同：
                方法名和参数列表必须相同
            两小
                子类重写的方法的返回值类型可以小于和等于父类被重写的方法的返回值类型（针对引用类型有效，针对基本类型无效）
                子类重写的方法所抛异常可以小于等于/少于等于父类被重写的方法的返回值类型

        面试题：方法重写（override）和方法重载（overload）的区别
            方法重载（overload）
                在同一个类中
                方法名相同
                参数列表不同
                和其他的（修饰符、返回值类型等）无关

            方法重写（override）
                在有继承关系的子父类中（至少是两个类）
                方法名相同
                参数列表相同
                和其他的（修饰符、返回值类型等）有关

修饰符                             【重点】
    权限修饰符                       【重点】
        什么是权限修饰符
            是用于控制所修饰内容（类、成员变量、成员方法和构造方法等）的访问权限（使用范围）的修饰符
            使用范围最小都是本类

        权限修饰符有哪些（只有4种）
            权限范围从大到小依次如下：
            public   protected   默认(default)           private
            公共的   受保护的      缺省（不写）              私有的

        权限修饰的使用范围
                            本类          本包              不同包的子类       不同包的无关类
            public          √               √               √                   √
            protected       √               √               √                   ×
            默认             √               √               ×                   ×
            private         √               ×               ×                   ×

            public：是最大的权限，在整个模块中的不同包不同类之间都可以使用
            protected:本包+不同包的子类，在不同包的子类中使用的时候不能通过创建父类对象调用
            默认：只能在本包中使用
            private:是最小的权限，只能在本类中使用

        权限修饰符修饰类：只能使用public和默认，不能使用protected和private修饰类，但是一般以后我们都使用public修饰类
        权限修饰符修饰成员变量：四种权限修饰符都可以使用，但是一般以后我们都使用private修饰成员变量
        权限修饰符修饰成员方法：四种权限修饰符都可以使用，但是一般以后我们都使用public，其次private修饰成员方法
        权限修饰符修饰构造方法：四种权限修饰符都可以使用，但是一般以后我们都使用public，其次private修饰构造方法

        注：类使用的权限修饰符会影响类中的成员的访问权限

最终修饰符
    final
    什么是最终修饰符
        final修饰符，它也是一个关键字
        final可以修饰类、成员方法和变量（成员变量和局部变量）

    作用（特点）：
        final修饰类，该类不能被继承（太监类）,JDK中也提供了一些final修饰的类，比如：String类、System类

        final修饰成员方法，该方法不能被重写，但是可以被继承
                哪些方法不能被继承
                    private修饰的方法
                    构造方法
                哪些方法不能被重写
                    private修饰的方法
                    构造方法

                    final修饰
                    static修饰

                    不能被继承肯定不能被重写

        final修饰变量，该变量就变成了常量，不能再次赋值
            final修饰成员变量
                基本类型的
                    值不能改变
                引用类型的
                    地址值不能改变，但是成员变量（内容）可以改

                final修饰的成员变量赋值时机
                    1、显式赋值
                    2、通过构造方法赋值

                常量的命名规范
                    所有的字母都是大写
                    如果由多个单词组成，则中间使用下划线(_)进行分隔
                    大小写切换的快捷键：ctrl+shift+u

                    NUM
                    MAX_NUM

            final修饰局部变量

            常量分类：
                字面值常量（6种）
                    整数常量
                    小数常量
                    字符常量
                    布尔常量
                    字符串常量
                    空常量
                自定义常量(final)

    静态修饰符(static)
        static是一个关键字，也是一个修饰符，是静态修饰符
        可以修饰成员变量和成员方法等

        修饰成员变量
            可以称为类变量

            什么时候是static修饰成员变量？
                1、当同一个类中的一个或者多个成员变量的值，对于所有的对象来说都相同，都可以使用static修饰
                2、如果要在一个静态的内容中直接使用成员变量，此时也可以使用static修饰

                满足以上条件之一，就可以使用static修饰成员变量，否则都不要使用

            类变量和实例（对象）变量
                类变量：static修饰的成员变量
                实例（对象）变量：非static修饰的成员变量

        修饰成员方法
            什么时候是static修饰成员方法？
                1、当一个类是工具类的时候，那么所有的方法使用static修饰，方便调用
                2、如果要在一个静态的内容中直接使用成员方法，此时也可以使用static修饰

                满足以上条件之一，就可以使用static修饰成员方法，否则都不要使用

        静态修饰的特点
            1、静态修饰之后属于类的，本不是属于某一个对象，而是该类所有对象所共享的内容
            2、多了一种调用方式，可以直接通过类名.进行调用
            3、静态只能调用静态，不能直接调用非静态
                非静态既可以调用静态，也可以调用非静态

    main方法的详解
        public :权限修饰符，使用的是最大的权限
        static :方法是静态的，方法在内存中出现的很早
        void ：该方法没有返回值，不需要给JVM返回结果
        main：方法的名称，JVM只认这个名称，才会认为这是一个入口方法
        (String[] args)：参数列表，参数类型是String数组，参数名是args
                        arguments