Java学习day10-方法重写

方法重写

1.Static关键字

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

1.1 修饰属性

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

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

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

package com.atguigu.demo.demo2;

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

    public DrinkWater(String name) {
        this.name = name;
    }

    public void drinkWater(){
        if(capacity>0){
            System.out.println(name+"接了一什水，还剩："+capacity+"升");
            capacity--;
        }else {
            System.out.println("包租婆，怎么没水了");
        }
    }


}

class TestDrinkWater{
    public static void main(String[] args) {
        System.out.println(DrinkWater.capacity);

        DrinkWater dana = new DrinkWater("大拿");
        dana.drinkWater();

        DrinkWater zhaosi = new DrinkWater("赵四");
        zhaosi.drinkWater();
    }
}

1.2 修饰方法

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

1.3 修饰代码块

静态代码块：

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

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

什么时候会加载类？

​ 1.new对象

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

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

package com.atguigu.demo.demo3;

/**
 *      静态代码块：静态代码块随着类的加载而执行 因为类只加载一次 所以静态代码块也只执行一次
 *                多个静态代码块按照书写顺序执行
 *
 *    什么时候会加载类？
 *        1.new对象
 *        2.访问此类的信息  静态属性  静态方法
 *
 *    静态代码块用在哪里：用于数据的初始化   以及 一些必要的前置操作
 *
 *
 *     静态访问静态，直接访问
 *     实例访问实例，直接访问
 *     静态访问实例，先new对象
 *     实例访问静态，直接访问
 */
public class StaticCodeBlock {
    static String  name= "linx";
    int age;

    /**
     * 静态代码块
     */
    static{
        System.out.println("静态代码块执行");
    }
    /*
     *    普通代码块
     */
    {
        System.out.println("普通代码块执行");
    }

    public StaticCodeBlock(){
        System.out.println("无参构造执行");
    }
    public StaticCodeBlock(int age) {
        this.age = age;
    }

    public static void m1(){
        System.out.println("静态调用静态");
    }

    public static void staticMethod(){
        System.out.println("-----------静态方法------------");
        System.out.println(StaticCodeBlock.name);  //静态方法直接访问静态属性
        StaticCodeBlock.m1();             //静态方法直接访问静态方法
        StaticCodeBlock s1=new StaticCodeBlock(25);
        System.out.println(s1.age);               //静态方法访问非静态属性需要new对象

        s1.m2();                     //静态方法访问非静态方法需要new对象


    }

    public void m2(){
        System.out.println("非静态方法执行");
    }

    public void notStaticMethod(){
        System.out.println("------------实例方法-----------");
        System.out.println(StaticCodeBlock.name);//实力方法直接调用静态方法
        StaticCodeBlock.m1();         //实力方法直接调用静态属性


        System.out.println(age);             //实力方法直接调用实例方法
        m2();                               //实力方法直接调用实例方法


    }
}
class TestStaticCodeBlock{
    public static void main(String[] args) {
        StaticCodeBlock s1 = new StaticCodeBlock();
        StaticCodeBlock.staticMethod();
        s1.notStaticMethod();
    }
}

1.4 访问规则

静态访问静态，直接访问

实例访问实例，直接访问

同级别直接访问

静态访问实例，先new对象

实例访问静态，直接访问

2. 方法重写

方法重写：

1.存在于父子类之间

2.方法名相同

3.参数列表相同

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

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

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

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

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

package com.atguigu.demo.demo4;

public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void print(){
        System.out.println("This animal name's :"+ name );
        System.out.println("This animal age is :"+ age );
    }
}


package com.atguigu.demo.demo4;



public class Dog extends Animal{
    private String dogType;

    public Dog() {
    }

    public Dog(String name, int age, String dogType) {
        super(name, age);
        this.dogType = dogType;
    }

    public String getDogType() {
        return dogType;
    }

    public void setDogType(String dogType) {
        this.dogType = dogType;
    }

    @Override
    public void print() {
        super.print();
        System.out.println("狗狗的种类是："+dogType);
    }
}


class TestDogOverride{
    public static void main(String[] args) {
        Dog d1 =new Dog("大哥",3,"阿拉斯加");
        d1.print();

    }
}

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