Android-Java-普通类与抽象类(覆盖)&方法重载

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

注意：重载都是方法之间  方法同名 不同参数，就属于重载；

 

普通类-覆盖：

描述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 ❌)

 

方法重载规则：

　　方法名相同，参数数量不同 或 参数类型不同，就是属于方法重载； （修饰符随便，是否有返回值随便）