Java笔记Day_09

static关键字

static关键字: 静态的 adj.[形容词: 修饰符]

        static关键字可以用来修饰: 成员变量 和 成员方法 //被修饰的成员变量和成员方法就被称作为 静态的成员变量和静态的成员方法

        static关键字的特点

                1.被静态static修饰的成员被所有对象 所共享 --> 一变则都变

                2.被静态static修饰的成员不属于对象了, 而是属于类 --> 属于类

                3.被静态static修饰的成员可以直接使用类名调用 --> 类名调

                4.被static修饰的成员[类属性]随着类的加载而加载优先于对象 -->随着类

静态成员的内存图

静态成员的访问问题

	非静态成员变量	非静态成员方法	静态成员变量	静态成员方法
非静态      成员方法	√	√	√	√
静态成员        方法	×	×	√	√

总结: 静态成员方法只能访问静态成员变量或者静态成员方法 --> 不可以访问非静态的成员变量和成员方法

1.为什么静态成员方法不可以访问非静态的成员变量和成员方法?

        因为静态成员方法加载的早[随着类], 而非静态成员加载的晚[随着对象], 所以当静态成员方法加载时, 非静态成员还没有加载 --> 不能访问[为什么再main方法所在的类中定义方法要求大家加static]

2.为什么在描述事物的时候[定义事物描述类的时候]要求大家定义方法时不加static?

        因为希望事物描述类中的方法就是由具体对象去启动

3.非要在静态方法内访问非静态成员, 怎么办? 创建对象, 使用对象调用非静态成员

4.static和this是矛盾的[不能在静态方法内使用this关键字]: static方法可以使用类名调用而this关键字必须指向一个具体的对象, 当静态方法用类名调用时, 对象没有产生, 方法内的this就没有具体的指向! 逻辑矛盾!!

        总结: 静态虽好[好在调用方式简单], 但是只能访问静态!

静态的使用场景

Arrays类: 数组操作的工具类

        方法:

                Arrays.toString(数组): 漂亮打印数组

                Arrays.sort(数组): 数组排序[升序]

静态的使用场景在定义工具类的时候, 把工具类中所有的成员变量和成员方法全部用static修饰 -->目的是为了更方便使用工具类的方法 --> 可以不创建工具类的对象, 直接使用工具类的类名调用类中的方法!

工具类的定义步骤:

        1.定义类 --> 类名: XxxxUtils

        2.把类中无参构造用private修饰, 并不提供任何其他构造方法 --> 目的: 不让使用工具类的程序员创建工具类的对象, 因为工具类中所有的成员变量和成员方法都用静态修饰, 可以使用类名调用

        3.把工具类中所有的 成员变量和成员方法都用static修饰

Math工具类的使用

Math工具类: 关于简单数学运算的工具类型; 指数, 对数, 三角函数...

Math类中的static常量

       

Math类中的static方法:

继承性

继承性: Java中类和类之间的关系! [1.没关系 2.继承关系(子父关系)]

继承关系的特点

        1.子类继承父类, 一个子类只能有一个父亲 //单一继承

        2.父类也可以有自己的父类 //多层继承

        3.Java中所有的类都直接或间接的继承于 Object, 如果一个类没有编写继承关系,就默认继承Object[根类, 基类, 超类] //Object: 炎黄 --> 数组也是继承Object的

        4.一个父类可以有多个子类

        5.子类继承父类, 子类可以使用父类中所有非私有的成员 //子类继承父类, 子类对象可以调用父类中的功能 //父爱如山

        6.子类继承父类, 父类是不能使用子类的成员的 //父类对象无法调用子类中的功能 //私生子,父亲根本不知道孩子存在

        7.子类要加载, 优先加载父类 //先有爹,后有仔

继承的格式

继承的关键字: extends

继承关系:

        //父类

        public class Fu{  //extends Object

        }                

        //继承格式在子类上

        public class Zi extends Fu{

        }

        //一个父类可以有多个子类
        public class Son extends Fu{
        
        }
        //Zi 和 Son 类之间没有关系

继承关系下成员变量访问问题

总结: 就近原则

继承关系下 , 成员变量的访问特点 :
        1. 在子类中访问父类成员:
            a. 私有的 -> 访问不了
            b. 不同名的 -> 直接访问
            c. 同名的 -> 就近原则
                this.num : 访问本类成员位置
                super.num : 访问本类父类成员位置

        2. 在父类中访问子类成员:
            a. 直接访问 : 访问不了 -> 父类不知道自己有哪些子类
            b. 创建子类对象 : 通过子类对象调用子类自己的成员变量

        3. 在第三方类中,创建子类对象访问父类成员
            a. 私有的 : 访问不了
            b. 不同名 : 子类对象直接访问
            c. 同名的 : 子类对象只能访问自己类中的同名变量,访问不了父类的同名变量 -> 就近原则

        4. 在第三方类中,创建父类对象访问子类成员 : 不可以

继承关系下成员方法访问问题

总结 : 看创建对象语句等号右边具体new的是什么类型

    1. 在子类中访问父类的成员方法
        a. 不同名 : 直接访问
        b. 同名 : super.方法名(实参)

    2. 在父类中访问子类的成员方法 :
        a. 不能直接访问 -> 父类只能访问父类自己和父类父类的
        b. 创建子类对象,再使用子类对象调用子类中的方法

    3. 在第三方类中,创建子类对象访问父类的成员方法
        a. 不同名 : 子类对象直接调用
        b. 同名 : 优先访问子类自己的

    4. 在第三方类中,创建父类对象访问子类的成员方法 -> 不可以

    总结 : 成员方法的调用不遵循就近原则[没有就近原则],
    具体调用的的哪个方法需要看调用方法真实对象的类型 [看对象等号右边的类型]

继承关系下构造方法访问问题

子类要加载 优先加载父类 [子类对象要加载 优先加载"父类对象"]

子类对象要加载 优先加载父类对象 !

    注意事项 :
        1. 在每一个构造方法中都存在默认第一句代码 : super();
        2. super() : 调用本类父类的无参构造方法
           super(实参) : 调用本类父类的有参构造方法
           this() : 调用本类的无参构造方法
           this(实参) : 调用本类的有参构造方法

           this.变量名 : 访问本类的成员变量
           this.方法名() : 访问本类的无参方法
           this.方法名(实参) : 访问本类的有参方法
           super.变量名 : 访问本类父类的成员变量
           super.方法名() : 访问本类父类的无参成员方法
           super.方法名(实参) : 访问本类父类的有参成员方法

       3. 调用其他构造方法的代码(super(),super(实参),this(),this(实参))必须是构造方法的第一句

       4. 如果在构造方法内 调用了其他构造方法,那么默认赠送的 super() 就不送了 !

       5. 子类构造方法中 必须有一个构造方法去 加载父类  !!

this 和 super 关键字

实操层面 :
    super() : 调用本类父类的无参构造方法
    super(实参) : 调用本类父类的有参构造方法
    this() : 调用本类的无参构造方法
    this(实参) : 调用本类的有参构造方法

    this.变量名 : 访问本类的成员变量
    this.方法名() : 访问本类的无参方法
    this.方法名(实参) : 访问本类的有参方法
    super.变量名 : 访问本类父类的成员变量
    super.方法名() : 访问本类父类的无参成员方法
    super.方法名(实参) : 访问本类父类的有参成员方法
        
    this : 打破局部位置的访问就近原则 !
    super : 打破本类成员位置的访问就近原则 !    
---------------------------------------------------------
概念层面 : 
    this : 当前对象的引用 
        哪个对象启动含有this关键字的方法,那么方法内的this关键字就指向哪个对象 ! -> 对象照镜子
        
   super : 父类的
        super 关键字不指向父类对象 , 因为当子类对象创建时并没有生成一个具体的父类对象 !

面向对象之继承性的好处和弊端

面向对象之继承性: Java种类与类之间的关系 -->子父关系

        好处: 

                1.拓展了子类对象的功能 [子类看向父类的角度] //子类对象的功能 > 父类对象的功能

                2.父类约束了子类对象的功能 [父类看向子类的角度] 

                3.编程技巧: 把多个子类的共性提取到一个父类中, 代码只需要在父类中写一次, 子类只需要继承并调用即可 --> 提高代码的复用性

        弊端: 

                1.继承提高了代码的耦合性 [高内聚, 低耦合]

                        内聚: 独立完成功能的能力

                        耦合: 依赖关系

                继承一定是利大于弊 !!能用继承 果断使用继承 ! 

方法的重写

方法的重载: Overload --> 调用的多, 定义少

        1.必须在同一个类中

        2.必须方法名相同

        3.形参列表必须不同[数量, 类型, 类型顺序]

        4.与 返回值类型, 方法体, 形参变量名 无关

方法的重写 : Override --> 调用的多, 定义的也多

        1.必须有继承关系 / 实现关系[两个方法不在同一个类中]

        2.子类重写父亲的方法 要求: 子类方法的声明和父类方法的声明 一模一样[99%情况]

        3.方法体不一样[子类覆盖父类的方法]

何时使用方法重写特性:

        当父类的行为不能满足子类的要求时, 在子类中重写父类的该行为[照抄父类方法的格式, 修改方法体]

[了解内容]方法重写时方法声明上可以不一样的地方

        1.访问权限修饰符: public > protected > 不写 > private

                子类重写方法的访问权限修饰符 >= 父类方法的访问权限修饰符

        2.方法的返回值类型:

                //父类方法的返回值类型

                1).void: 必须一样

                2).基本数据类型: 必须一样

                3).引用数据类型: 子类重写方法的返回值类型 必须是 父类方法返回值类型的 同类型或者子类型

                //假设父亲是大, 子类是小 --> 子类重写方法的返回值类型 <== 父类方法返回值类型的

JDK提供了一个注解: @Override --> 约束方法重写格式的,如果子类方法的重写格式不正确, @Override注解就会报错!!

        书写在: 子类重写方法的声明上

注意事项:

        1.私有方法不存在重写概念

        2.static修饰的方法, 不存在重写概念: 当方法被加上static关键字, 那么方法就属于类了, 而方法的重写是子类方法对父类方法的一种延续[覆盖], 两个方法时关系的! 加上static让2个方法就没有了关系, 各自属于各自的类!