Java从零开始（day10）

方法重写和多态

1.static关键字

static关键字可以修饰属性、方法、代码块

1.1 修饰属性

static修饰属性，称之为静态属性/变量 可以通过类名加点来访问，不需要new对象

回顾实例属性，必须通过对象名.访问

static修饰的属性在内存中只存在一份(方法区—>静态区) 属于整个类 不属于任何对象 可以被所有的对象所共享

package com.atguigu.test4;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/18 11:31
 *
 *  static修饰属性，称之为静态属性/变量  可以通过类名加点来访问，不需要new对象
 *  回顾实例属性，必须通过对象名.访问
 *  static修饰的属性在内存中只存在一份(方法区--->静态区) 属于整个类  不属于任何对象 可以被所有的对象所共享
 */
public class DrinkWater {
    static int capacity = 100; // 单位L  升
    String name;





    public void getWater(){
        if(capacity > 0){
            capacity--;
            System.out.println(name + "接水一升，还剩余" + capacity + "升");
        }else{
            System.out.println("没水了");
        }
    }

    public static void main(String[] args) {
        DrinkWater zhaosi = new DrinkWater();
        zhaosi.name = "赵四";
        zhaosi.getWater();

        zhaosi = null;





        DrinkWater guangkun = new DrinkWater();
        guangkun.name = "广坤";
        guangkun.getWater();


        DrinkWater dana = new DrinkWater();
        dana.name = "大拿";
        dana.getWater();
    }
}

1.2 修饰方法

静态方法：本类中直接书写方法名访问 其他类同过类名访问

package com.atguigu.test6;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/18 15:33
 *  静态方法：本类中直接书写方法名访问  其他类同过类名访问
 */
public class Test1 {
    public static void m1(){
        System.out.println("Test1类中的静态方法m1");
    }


    public static void main(String[] args) {
        m1();
        Test1 test1 = new Test1();
        test1.m1();
    }

}

package com.atguigu.test6;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/18 15:35
 */
public class Test2 {
    public static void main(String[] args) {
        Test1.m1();
    }
}

1.3 修饰代码块

静态代码块：静态代码块随着类的加载而执行 因为类只加载一次 所以静态代码块也只执行一次

多个静态代码块按照书写顺序执行

什么时候会加载类？

1.new对象

2.访问此类的信息 静态属性 静态方法

静态代码块用在哪里：用于数据的初始化 以及 一些必要的前置操作

package com.atguigu.test6;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/18 15:36
 *  静态代码块：静态代码块随着类的加载而执行 因为类只加载一次 所以静态代码块也只执行一次
 *  多个静态代码块按照书写顺序执行
 *
 * 什么时候会加载类？
 *  1.new对象
 *  2.访问此类的信息  静态属性  静态方法
 *
 *  静态代码块用在哪里：用于数据的初始化   以及 一些必要的前置操作
 */
public class Test3 {
    static int num = 10;

    static{
        System.out.println("Test3中静态代码块1");
    }

    static{
        System.out.println("Test3中静态代码块2");
    }

    static{
        System.out.println("Test3中静态代码块3");
    }

    public Test3(){
        System.out.println("Test3无参构造执行了");
    }

    public static void m1(){
        System.out.println("Test3中的静态方法m1");
    }

    {
        System.out.println("普通代码块1");
    }

    {
        System.out.println("普通代码块2");
    }


    {
        System.out.println("普通代码块3");
    }



    public static void main(String[] args) {
        Test3 test1 = new Test3();

        Test3 test2 = new Test3();

        Test3 test3 = new Test3();
//        System.out.println(Test3.num);

//        m1();
    }


}

1.4 访问规则

静态访问静态，直接访问

实例访问实例，直接访问

同级别直接访问

静态访问实例，先new对象

实例访问静态，直接访问

2. 方法重写

方法重写：

1.存在于父子类之间

2.方法名相同

3.参数列表相同

4.返回值相同 或者是其子类

5.访问权限不能严于父类 （不能窄化父类的访问权限）

6.不能抛出比父类更多的异常

7.静态方法可以被继承，但不能被重写

@Override 注解 此注解只能用于声明在方法上 被此注释修饰的方法 必须是重写父类的方法 必须符合以上重写的要求 否则编译报错

package com.atguigu.test7;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/16 16:16
 *  宠物类父类：父类中书写子类共有的属性和方法
 *
 */
public class Pet {
    protected String name;
    protected int health;
    protected int love;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }

    void print(){
        System.out.println("宠物的名字是：" + name + ",健康值是：" + health);
        System.out.println("亲密值是：" + love );
    }

    public Pet(){
    }



}

package com.atguigu.test7;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/16 16:12
 *  狗类
 */
public class Dog extends Pet {
    private String strain;
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
    public Dog(){
    }


    /**
     *  方法重写：
     *      1.存在于父子类之间
     *      2.方法名相同
     *      3.参数列表相同
     *      4.返回值相同   或者是其子类
     *      5.访问权限不能严于父类 （不能窄化父类的访问权限）
     *
     *      6.不能抛出比父类更多的异常
     *      7.静态方法可以被继承，但不能被重写
     */
    public void print(){
        super.print();
        System.out.println("狗狗的品种是：" + strain);
    }

}

package com.atguigu.test7;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/16 16:14
 *  企鹅类
 */
public class Penguin extends Pet {
    private String sex;

    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }

    public Penguin(){}




    public void print(){
        super.print();
        System.out.println("企鹅的性别是：" + sex);
    }


}

package com.atguigu.test7;

import com.atguigu.test2.Cat;

/**
 * @author WHD
 * @description TODO
 * @date 2022/7/16 16:19
 *
 *  方法重写：
 *      前提：必须是父子类，在子类中对父类的方法进行重写  override(覆盖)
 *
 */
public class TestPet {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.print();

        Penguin p1 = new Penguin();
        p1.print();

    }
}

3. 方法重写override和方法重载overload的区别？