覆盖都是子类与父类之间 & 接口与实现类之间 才会产生:覆盖 有很多名称,覆盖,复写,重写 都是一个意思;

注意:重载都是方法之间  方法同名 不同参数,就属于重载;

 

普通类-覆盖:

描述Animal动物对象:

 

package android.java.oop18;

public class Animal {

    public void cry() {
        System.out.println("cry");
    }

}

 

 

描述Dog狗对象:

package android.java.oop18;

public class Dog extends Animal {
}

 

描述Cat猫对象:

package android.java.oop18;

public class Cat extends Animal {

    @Override
    public void cry() {
        // super.cry();

        System.out.println("猫🐱 喵喵喵...");
    }
}

 

main测试方法:

package android.java.oop18;

public class Test {

    public static void main(String[] args) {

        new Dog().cry();

        new Cat().cry();

    }

}

 

执行结果:

 

 

以上普通类-覆盖:如果子类覆盖了父类的方法,new 子类().cry(); 就是执行子类的方法,如果子类忘记覆盖父类的方法,new 子类().cry(); 就是执行父类的方法;

覆盖:返回值 方法名 参数类型与数量 必须一致,并且,子类的修饰权限要大于等于父类(父类public 子类public 👌,父类protected 子类public 👌,父类public 子类protected ❌)

 




 

 

抽象类-覆盖:

定义Animal抽象类:

package android.java.oop18;

/**
 * 定义一个抽象类,此类 可以有抽象方法,也可以有普通方法,静态方法 等等;
 */
public abstract class Animal {

    /**
     * 举例:快看快听 那个动物在叫呢,
     * 由于这个动物 具体是什么动物在叫 这个是不知道的,是抽象的模糊的
     * 注意:我这里只是抽象这个事物,我不执行事物,子类继承重写后 在去执行这个事物
     */
    protected abstract void cry();

}

 

描述Cat对象:

package android.java.oop18;

/**
 * Cat属于动物类,具备动物的行为;
 * Cat是 Animal 的一种 所以需要继承 Animal
 */
public class Cat extends Animal {

    /**
     * Cat 🐱 具体的叫 行为
     */
    @Override
    public void cry() {
        System.out.println("猫🐱 喵喵喵....");
    }
}

 

描述Dog对象:

package android.java.oop18;


/**
 * Dog属于动物类,具备动物的行为;
 * Dog是 Animal 的一种 所以需要继承 Animal
 */
public class Dog extends Animal {

    /**
     * Dog 🐶 具体的叫 行为
     */
    @Override
    protected void cry() {
        System.out.println("狗🐶汪汪汪....");
    }
}

 

main测试方法:

package android.java.oop18;

public class Test {

    public static void main(String[] args) {

        // 让具体的狗对象 去叫
        new Dog().cry();

        // 让具体的猫对象 去叫
        new Cat().cry();

    }

}

 

执行结果:

 

以上抽象类-覆盖:如果子类覆盖了父类的方法,new 子类().cry(); 就是执行子类的方法,如果子类忘记覆盖父类的方法,编译失败 报错,所以必须要覆盖父类的抽象方法;

覆盖:返回值 方法名 参数类型与数量 必须一致,并且,子类的修饰权限要大于等于父类(父类public 子类public 👌,父类protected 子类public 👌,父类public 子类protected ❌)

 

  




 

 

方法重载:

重载案例:

 

package android.java.oop18;

class MyDemo {

    public void showValue() {
        System.out.println("my is showValue()");
    }

    public void showValue(String value1) {
        System.out.println("my is showValue(value1)");
    }

    public void showValue(String value1, int value2) {
       System.out.println("my is showValue(value1, value2)");
    }

    public int showValue(String value1, int value2, boolean isAndroidStudy) {
        System.out.println("my is showValue(String value1, int value2, boolean isAndroidStudy) return");
        return 0;
    }

    public String showValue(String value1, int value2, boolean isAndroidStudy, double money) {
        System.out.println("my is showValue(String value1, int value2, boolean isAndroidStudy, double money) return");
        return "返回值";
    }

    public static void showValue(String value1, int value2, boolean isAndroidStudy, double money, boolean isOK){
        System.out.println("my is showValue(String value1, int value2, boolean isAndroidStudy, double money) 静态方法");
    }
}

public class MethodDemo {

    public static void main(String[] s) {

        MyDemo myDemo = new MyDemo();

        myDemo.showValue();
        
        myDemo.showValue("值");
        
        myDemo.showValue("值", 9);
        
        myDemo.showValue("值", 8, true);
        
        myDemo.showValue("值", 5, true, 10009987.00);
        
        MyDemo.showValue("值", 88, true, 9999945.00, true);
    }

}

 

 执行结果:

 

在main测试方法中 myDemo.showValue 时, 开发工具只能提示 showValue重载的方法

 

 

覆盖,复写,重写,重载 很容易搞混乱,所以进行对比一下;

 

覆盖,复写,重写的规则:

 返回值 方法名 参数类型与数量 必须一致,并且,子类的修饰权限要大于等于父类(父类public 子类public 👌,父类protected 子类public 👌,父类public 子类protected ❌)

 

方法重载规则:

  方法名相同,参数数量不同 或 参数类型不同,就是属于方法重载; (修饰符随便,是否有返回值随便)