• 方法的重写:
    • 重写:其实就是覆盖
    • 当子类继承父类的时候,子类继承父类中的方法,可以增强父类中的方法的功能

    • 格式:

    • 定义一个与父类方法完全一致的方法,方法体 { } 中内容重写

    • 方法重写后,调用该方法时,不在调用父类的方法,而调用子类中重写后的方法

    父类:

    1. /**
    2. *
    3. * 父类
    4. * 动物父类中有方法
    5. *
    6. */
    7. package Test12_Demo.Demo05;/*
    8. @create 2020--11--30--14:01
    9. */
    10. public class Animal {
    11. //吃的方法
    12. public void eat() {
    13. System.out.println("eat something");
    14. }
    15. //睡觉的方法
    16. public void sleep() {
    17. System.out.println("sleeping");
    18. }
    19. }

    子类:

    1. /**
    2. *
    3. * 子类 - 狗
    4. *
    5. * 继承父类中的方法,然后在这个方法的基础上进行拓展 - 通过方法的重写
    6. *
    7. */
    8. package Test12_Demo.Demo05;/*
    9. @create 2020--11--30--14:03
    10. */
    11. public class Dog extends Animal {
    12. //方法的重写
    13. //这是一个重写的检查标记,利用这个标记修饰的方法必须是重写的,要不然会报错
    14. @Override
    15. public void eat() {
    16. System.out.println("Eat anything");
    17. }
    18. }

    测试类:

    1. package Test12_Demo.Demo05;/*
    2. @create 2020--11--30--13:58
    3. */
    4. public class OverrideDemo {
    5. public static void main(String[] args) {
    6. //测试重写
    7. //创建子类
    8. Dog d = new Dog();
    9. d.eat();//Eat anything - 子类中的方法
    10. d.sleep();//这个方法就是父类中的方法,因为没有重写
    11. Animal a = new Dog();
    12. a.eat();
    13. a.sleep();
    14. }
    15. }