Java基础——继承与多态

继承 (Inheritance)

定义

📕继承是面向对象编程中的一个重要特性，它允许子类继承父类的属性和方法，从而实现功能的复用和扩展。

示例代码

⭐Animal 类：基类或父类，定义了 age和 color属性，以及 eat 方法。 它提供了动物的基本特征和行为。

class Animal {
    private int age;
    private String color;

    public Animal() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void eat(String something) {
        System.out.println("动物在吃东西");
    }
}

⭐Dog 和 Cat类：从 Animal类继承而来， 分别实现了不同的具体动物行为 。 例如，Dog 类有 lookHome 方法，而 Cat 类有 catchMouse 方法。

class Dog extends Animal {
    // 构造方法
    public Dog(int age, String color) {
        super(age, color);
    }

    @Override
    public void eat(String something) {
        System.out.println(getAge() + "岁的" + getColor() + "的狗两只前腿死死的抱住" + something + "猛吃");
    }

    public void lookHome() {
        System.out.println("狗在看家");
    }
}

class Cat extends Animal {
    public Cat(int age, String color) {
        super(age, color);
    }

    @Override
    public void eat(String something) {
        System.out.println(getAge() + "岁的" + getColor() + "颜色的猫咪眯着眼侧着头吃" + something);
    }

    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

多态 (Polymorphism)

定义

📕多态允许对象通过父类的引用来调用子类的方法，具体调用哪个子类的方法，取决于对象的实际类型。多态提高了代码的灵活性和可扩展性。

方法重写 (Method Overriding)

⭐子类重写父类的方法，提供特定的实现。

@Override
public void eat(String something) {
// 子类提供的特定实现
}

动态绑定

定义

📕动态绑定是指在程序运行时确定具体调用哪个方法的过程。这种机制使得同一方法名可以在不同的类中实现不同的功能，而具体的实现则取决于对象的实际类型。

特性

• 运行时决策：方法调用的具体实现是在运行时决定的，而不是在编译时。
• 支持多态：动态绑定是实现方法重写（方法重写是实现多态的一种方式）的基础。

示例代码

// 父类
class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

// 子类1
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

// 子类2
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        // 动态绑定的演示
        Animal myAnimal;

        // Dog 对象
        myAnimal = new Dog();
        myAnimal.makeSound();  // 输出: Dog barks

        // Cat 对象
        myAnimal = new Cat();
        myAnimal.makeSound();  // 输出: Cat meows
    }
}

方法重载 (Method Overloading)

定义

在同一个类中，方法名称相同但参数不同的情况。
⭐在 Person 类中的keepPet方法

class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void keepPet(Dog dog, String something) {
        // 处理 Dog 对象
        System.out.println("年龄为" + age + "岁的" + name + "养了一只" + dog.getColor() + "颜色的" + dog.getAge() + "岁的狗");
        dog.eat(something);
    }

    public void keepPet(Cat cat, String something) {
        // 处理 Cat 对象
        System.out.println("年龄为" + age + "岁的" + name + "养了一只" + cat.getColor() + "颜色的" + cat.getAge() + "岁的猫");
        cat.eat(something);
    }

    public void keepPet(Animal a, String something) {
         // 处理 Animal 对象，通过 instanceof 区分具体类型
        if (a instanceof Dog d) {
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + a.getColor() + "颜色的" + a.getAge() + "岁的狗");
            d.eat(something);
        } else if (a instanceof Cat c) {
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + a.getColor() + "颜色的" + a.getAge() + "岁的猫");
            c.eat(something);
        } else {
            System.out.println("没有这种动物");
        }
    }
}

代码分析

1. 重载方法：接收 Dog或 Cat 类型的参数，并打印相关信息，然后调用相应的 eat 方法。

2. 方法重载和多态：通过 keepPet(Animal a, String something) 方法，使用 instanceof检查具体的动物类型，展示了多态和动态绑定的结合。

示例代码的应用

✔通过创建 Person对象 p，以及 Dog和 Cat对象 d 和 c，调用 keepPet 方法展示了如何使用方法重载和多态处理不同类型的宠物。

  public class Main0 {
      public static void main(String[] args) {
          Person p = new Person("老王", 30);
          Dog d = new Dog(2, "黑");
          Cat c = new Cat(3, "灰");
          p.keepPet(d, "骨头");
          p.keepPet(c, "鱼");
      }
  }

总结

• **继承 **允许类扩展和复用父类的功能。
• **多态 **通过父类引用调用子类的方法，增强了代码的灵活性。
• **方法重载 ** 允许在同一类中定义多个同名但参数不同的方法。
• **方法重写 **是实现多态的重要机制，通过子类实现父类定义的方法，提供具体的行为。