09.静态（Static）:

10.继承：

11.继承中成员的特点：

12.构造函数：

13.this关键字:

14.super关键字:

15.final关键字：

Java基础--面向对象02

09.静态（Static）:

static关键字：

       用于修饰成员（成员变量和成员函数）

被修饰后的成员具备以下特点：

      随着类的加载而加载

      优先于对象存在

      被所有对象所共享

      可以直接被类名调用

使用注意：

      静态方法只能访问静态成员

      静态方法中不可以写this，super关键字

      主函数是静态的

静态成员与普通成员的区别:

        静态成员:包括 静态成员变量、静态成员方法

        普通成员:包括 成员变量、成员方法

        1：位置上的区别

                静态成员: 在方法区内的静态区中

                普通成员：在堆内存中

        2:什么时候存在和消失

                静态成员： 随着类class的加载而存在，随着类的消失而消失

                普通成员： 随着对象的创建而存在，随着对象的消失而消失

        3: 使用上的区别：

                静态成员： 对象名.成员    类名.成员   

                普通成员： 对象名.成员                       

静态成员与普通成员的理解上的区别:

        静态成员：是所有对象共享同一个变量。

                它是与类相关，类变量

        普通成员：变量是每个对象单独拥有的。

                它是与对象相关，实例变量、成员变量

为什么要学习静态：

                好处： 可以把多个对象中共享的数据设置成static  比如说  国家

                       可以把方法使用static 来修饰，可以通过类名调用方法，不需 要创建对象      

                用处： 一般在工具类中使用静态

                       多个对象中共享的数据

10.继承：

        概述：

             在一个已有类的基础上，进行一些更改，得到了一个新类，该新类可以访问原有类的非私有成员

        继承的特点：

                子类可以直接访问父类中的非私有的成员

                        案例： 和媳妇开心的方法，儿子必须不能继承

                Java只支持单继承，不支持多继承

                        案例： 亲爹只能有一个，不能有多个

                Java支持多层(重)继承

                        案例： 你的姓由爹继承来的， 爹的姓由爷爷继承来的

11.继承中成员的特点：

                成员变量：

                        局部变量与成员变量同名，使用this来区别

                        子父类成员同名，使用super来区别

                        变量使用原则： 就近原则

                                如果局部位置找到该变量，使用局部变量

                                如果成员位置找到该变量，使用成员变量

                                如果父类中成员位置找到该变量，使用父类中的成员变量

                                如果父类中也没有，报错了

                成员方法[函数覆盖]:

                        函数的格式：

                                修饰符 返回值类型 方法名(参数列表){...}

                        子类与父类方法的声明部分一致

                                声明部分包含( 返回值类型 与方法名  与 参数列表)

                        子类的访问修饰符 要大于等于 父类的访问修饰符

                        由小到大

                        private < 默认的 < protected < public

                        面试题：

                                方法重写[函数覆盖] 与 方法重载的区别

                                方法重写: 子父类中的方法声明一致，子类将父类中声明一致的 方法重新实现

                                方法重载: 在同一个类中，有多个同名方法，它们的参数列表不 同

                        静态只能覆盖静态

12.构造函数：

                        a: 使用子类构造函数的时候，会默认调用父类的空参数构造函数

                        b: 任何一个构造函数默认的第一行语句都是 super(), super()是 用来调用父类的空参构造函数的

                        c: 为什么说构造函数第一行是super()

                           因为，在创建完子类对象的时候，就可以使用父类的成员了，所 以父类要在子类创建之前完成

                           所以，通过super()来实现将父类中的成员初始化

                        d: 在构造函数中 可以访问其他构造函数

                                访问父类构造函数：

                                        空参数：

                                                super()

                                        有参数：

                                                super(参数列表)

                                访问本类构造函数:

                                        空参数：

                                                this()

                                        有参数：

                                                this(参数列表)

                        e: 如果父类中，没有空参构造函数，需要手动指定调用父类中其他的构造函数

                        f: super(参数列表) 与 this(参数列表) 都必须在构造函数的第一 行，二者冲突

                           有 super(参数列表)  , 无 this(参数列表)

                           有 this(参数列表)   ，无 super(参数列表)

13.this关键字:

        理解： 当前对象的引用

               当前方法调用的时候，谁调用的该方法，那么，这个this关键字就                        相当于是谁      

        使用场景：

                当局部变量与 成员变量 重名的时候

                在构造函数中使用

        使用的方式：

                this.成员变量

                this.成员方法()

14.super关键字:

        理解： 父类对象的引用

               父类方法调用的时候，谁调用的该方法，那么，这个super关键字就相当于是谁      

        使用场景：

                super(),在继承中的子类对象的构造函数中使用

        使用的方式：

                super.成员变量

                super.成员方法()  也可在子类对象的成员方法内使用

15.final关键字：

        最终的意思：

        final修饰的类： 子类不可以继承

        final修饰的方法： 子类不可以重写

        final修饰的变量： 值不能改变，相当于是一个常量

                在java中定义常量的常用修饰符为：

                        public static final

                        举例：

                        public static final double PI = 3.14;

     ------------------------------以上只是楼主认为的重点知识，后续还有其它。如有不足还请补充。

09.静态（Static）:

10.继承：

11.继承中成员的特点：

12.构造函数：

13.this关键字:

14.super关键字:

15.final关键字：

Java基础--面向对象02

09.静态（Static）:

static关键字：

       用于修饰成员（成员变量和成员函数）

被修饰后的成员具备以下特点：

      随着类的加载而加载

      优先于对象存在

      被所有对象所共享

      可以直接被类名调用

使用注意：

      静态方法只能访问静态成员

      静态方法中不可以写this，super关键字

      主函数是静态的

静态成员与普通成员的区别:

        静态成员:包括 静态成员变量、静态成员方法

        普通成员:包括 成员变量、成员方法

        1：位置上的区别

                静态成员: 在方法区内的静态区中

                普通成员：在堆内存中

        2:什么时候存在和消失

                静态成员： 随着类class的加载而存在，随着类的消失而消失

                普通成员： 随着对象的创建而存在，随着对象的消失而消失

        3: 使用上的区别：

                静态成员： 对象名.成员    类名.成员   

                普通成员： 对象名.成员                       

静态成员与普通成员的理解上的区别:

        静态成员：是所有对象共享同一个变量。

                它是与类相关，类变量

        普通成员：变量是每个对象单独拥有的。

                它是与对象相关，实例变量、成员变量

为什么要学习静态：

                好处： 可以把多个对象中共享的数据设置成static  比如说  国家

                       可以把方法使用static 来修饰，可以通过类名调用方法，不需 要创建对象      

                用处： 一般在工具类中使用静态

                       多个对象中共享的数据

10.继承：

        概述：

             在一个已有类的基础上，进行一些更改，得到了一个新类，该新类可以访问原有类的非私有成员

        继承的特点：

                子类可以直接访问父类中的非私有的成员

                        案例： 和媳妇开心的方法，儿子必须不能继承

                Java只支持单继承，不支持多继承

                        案例： 亲爹只能有一个，不能有多个

                Java支持多层(重)继承

                        案例： 你的姓由爹继承来的， 爹的姓由爷爷继承来的

11.继承中成员的特点：

                成员变量：

                        局部变量与成员变量同名，使用this来区别

                        子父类成员同名，使用super来区别

                        变量使用原则： 就近原则

                                如果局部位置找到该变量，使用局部变量

                                如果成员位置找到该变量，使用成员变量

                                如果父类中成员位置找到该变量，使用父类中的成员变量

                                如果父类中也没有，报错了

                成员方法[函数覆盖]:

                        函数的格式：

                                修饰符 返回值类型 方法名(参数列表){...}

                        子类与父类方法的声明部分一致

                                声明部分包含( 返回值类型 与方法名  与 参数列表)

                        子类的访问修饰符 要大于等于 父类的访问修饰符

                        由小到大

                        private < 默认的 < protected < public

                        面试题：

                                方法重写[函数覆盖] 与 方法重载的区别

                                方法重写: 子父类中的方法声明一致，子类将父类中声明一致的 方法重新实现

                                方法重载: 在同一个类中，有多个同名方法，它们的参数列表不 同

                        静态只能覆盖静态

12.构造函数：

                        a: 使用子类构造函数的时候，会默认调用父类的空参数构造函数

                        b: 任何一个构造函数默认的第一行语句都是 super(), super()是 用来调用父类的空参构造函数的

                        c: 为什么说构造函数第一行是super()

                           因为，在创建完子类对象的时候，就可以使用父类的成员了，所 以父类要在子类创建之前完成

                           所以，通过super()来实现将父类中的成员初始化

                        d: 在构造函数中 可以访问其他构造函数

                                访问父类构造函数：

                                        空参数：

                                                super()

                                        有参数：

                                                super(参数列表)

                                访问本类构造函数:

                                        空参数：

                                                this()

                                        有参数：

                                                this(参数列表)

                        e: 如果父类中，没有空参构造函数，需要手动指定调用父类中其他的构造函数

                        f: super(参数列表) 与 this(参数列表) 都必须在构造函数的第一 行，二者冲突

                           有 super(参数列表)  , 无 this(参数列表)

                           有 this(参数列表)   ，无 super(参数列表)

13.this关键字:

        理解： 当前对象的引用

               当前方法调用的时候，谁调用的该方法，那么，这个this关键字就                        相当于是谁      

        使用场景：

                当局部变量与 成员变量 重名的时候

                在构造函数中使用

        使用的方式：

                this.成员变量

                this.成员方法()

14.super关键字:

        理解： 父类对象的引用

               父类方法调用的时候，谁调用的该方法，那么，这个super关键字就相当于是谁      

        使用场景：

                super(),在继承中的子类对象的构造函数中使用

        使用的方式：

                super.成员变量

                super.成员方法()  也可在子类对象的成员方法内使用

15.final关键字：

        最终的意思：

        final修饰的类： 子类不可以继承

        final修饰的方法： 子类不可以重写

        final修饰的变量： 值不能改变，相当于是一个常量

                在java中定义常量的常用修饰符为：

                        public static final

                        举例：

                        public static final double PI = 3.14;

     ------------------------------以上只是楼主认为的重点知识，后续还有其它。如有不足还请补充。