Java基础之面向对象机制（多态、继承）底层实现

Java基础之面向对象机制（多态、继承）底层实现

Java作为一种面向对象的语言，通过多态和继承两种机制来实现面向对象的特性。本文将从底层角度分别探究多态和继承的实现方式。

多态的底层实现

多态通过方法重写和方法重载来实现，方法重写是指子类重写父类的方法，而方法重载是指在同一个类中，两个或多个方法具有相同的名称，但具有不同的参数列表。

下面是一个多态的例子：

public class Animal {
    public void makeSound() {
        System.out.println("Animal is making sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog is barking");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat is meowing");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal dog = new Dog();
        Animal cat = new Cat();

        animal.makeSound();
        dog.makeSound();
        cat.makeSound();
    }
}

这个程序首先创建了一个Animal对象，然后创建了一个Dog对象和一个Cat对象，它们都是Animal类型。接着分别调用它们的makeSound()方法，会发现输出的结果是：

Animal is making sound
Dog is barking
Cat is meowing

这就是多态的效果，因为在运行时，动态绑定调用了子类的makeSound()方法，而不是父类的方法。这个动态绑定的过程就是多态的底层实现。它通过运行时的类型信息来动态决定调用哪个方法。

继承的底层实现

继承通过将一个类的属性和方法继承到另一个类来实现代码重用，Java中继承使用extends关键字来实现，子类通过继承父类来获得父类的属性和方法。

下面是一个继承的例子：

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void bark() {
        System.out.println(name + " is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Tommy");
        dog.eat();
        dog.bark();
    }
}

这个程序定义了一个Animal类和一个Dog类，Dog类继承自Animal类。在Dog类中增加了一个bark()方法。在Main函数中，创建了一个Dog对象，调用了它的eat()方法和bark()方法。

输出的结果是：

Tommy is eating
Tommy is barking

这就是继承的效果，因为Dog类继承了Animal类的属性和方法，所以它可以直接使用Animal类中的属性和方法，同时还可以在它自己的类中增加一些方法。

在继承中，子类可以使用父类的字段和方法，但不能直接访问它们的私有成员变量和方法。在子类中，可以使用super关键字来调用父类中的方法和属性。

示例二：

public class Fruit {
    private String name;
    private String color;

    public Fruit(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public void printColor() {
        System.out.println(color);
    }
}

public class Apple extends Fruit {
    private String type;

    public Apple(String name, String color, String type) {
        super(name, color);
        this.type = type;
    }

    public void printType() {
        System.out.println(type);
    }
}

public class Main {
    public static void main(String[] args) {
        Apple apple = new Apple("apple", "red", "sweet");
        apple.printColor();
        apple.printType();
    }
}

这个程序定义了一个Fruit类和一个Apple类，Apple类继承自Fruit类。在Main函数中，创建了一个Apple对象，调用了它的printColor()方法和printType()方法。

输出的结果是：

red
sweet

这就是继承的效果，因为Apple类继承了Fruit类的属性和方法，所以它可以直接使用Fruit类中的属性和方法。在Apple类中增加了一个type属性和一个printType()方法，来实现自己的特殊需求。