继承 (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("没有这种动物");
}
}
}
代码分析
-
重载方法:接收
Dog
或Cat
类型的参数,并打印相关信息,然后调用相应的eat
方法。 -
方法重载和多态:通过
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, "鱼");
}
}
总结
- **继承 **允许类扩展和复用父类的功能。
- **多态 **通过父类引用调用子类的方法,增强了代码的灵活性。
- **方法重载 ** 允许在同一类中定义多个同名但参数不同的方法。
- **方法重写 **是实现多态的重要机制,通过子类实现父类定义的方法,提供具体的行为。