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

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

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

普通类-覆盖：

描述Animal动物对象：

packageandroid.java.oop18;public classAnimal {public voidcry() {

System.out.println("cry");

}

}

描述Dog狗对象：

packageandroid.java.oop18;public class Dog extendsAnimal {

}

描述Cat猫对象：

packageandroid.java.oop18;public class Cat extendsAnimal {

@Overridepublic voidcry() {//super.cry();

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

}

}

main测试方法：

packageandroid.java.oop18;public classTest {public static voidmain(String[] args) {newDog().cry();newCat().cry();

}

}

执行结果：

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

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

抽象类-覆盖：

定义Animal抽象类：

packageandroid.java.oop18;/*** 定义一个抽象类，此类 可以有抽象方法，也可以有普通方法，静态方法 等等；*/

public abstract classAnimal {/*** 举例：快看快听 那个动物在叫呢，

* 由于这个动物 具体是什么动物在叫 这个是不知道的，是抽象的模糊的

* 注意：我这里只是抽象这个事物，我不执行事物，子类继承重写后 在去执行这个事物*/

protected abstract voidcry();

}

描述Cat对象:

packageandroid.java.oop18;/*** Cat属于动物类，具备动物的行为；

* Cat是 Animal 的一种 所以需要继承 Animal*/

public class Cat extendsAnimal {/*** Cat 🐱 具体的叫 行为*/@Overridepublic voidcry() {

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

}

}

描述Dog对象：

packageandroid.java.oop18;/*** Dog属于动物类，具备动物的行为；

* Dog是 Animal 的一种 所以需要继承 Animal*/

public class Dog extendsAnimal {/*** Dog 🐶 具体的叫 行为*/@Overrideprotected voidcry() {

System.out.println("狗🐶汪汪汪....");

}

}

main测试方法：

packageandroid.java.oop18;public classTest {public static voidmain(String[] args) {//让具体的狗对象 去叫

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

newCat().cry();

}

}

执行结果：

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

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

方法重载：

重载案例：

packageandroid.java.oop18;classMyDemo {public voidshowValue() {

System.out.println("my is showValue()");

}public voidshowValue(String value1) {

System.out.println("my is showValue(value1)");

}public void showValue(String value1, intvalue2) {

System.out.println("my is showValue(value1, value2)");

}public int showValue(String value1, int value2, booleanisAndroidStudy) {

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

}public String showValue(String value1, int value2, boolean isAndroidStudy, doublemoney) {

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, booleanisOK){

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

}

}public classMethodDemo {public static voidmain(String[] s) {

MyDemo myDemo= newMyDemo();

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

方法重载规则：

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