Java多态接口有多个实现类，如何知道在执行的时候是调用的哪一个类

在Java中，当你有一个接口，并且这个接口有多个实现类（也叫实现接口的类），你可以创建该接口类型的引用变量，并将它指向任何一个具体的实现类实例。当你通过这个引用调用接口中的方法时，会自动绑定到实际的对象类型，即运行时动态确定调用的是哪个类的方法。

这背后的机制就是Java的动态绑定（后期绑定）。当你不在特定上下文中指定具体类时，比如在方法中传入接口类型的参数并调用其方法，Java虚拟机会在运行时检查对象的实际类型，然后根据这个类型去找到正确的实现并执行相应的方法。这是多态性的核心部分，使得代码更具灵活性。

例如：

Interface MyInterface {
    void doSomething();
}

class Implementation1 implements MyInterface {
    public void doSomething() {
        // 实现1的方法
    }
}

class Implementation2 implements MyInterface {
    public void doSomething() {
        // 实现2的方法
    }
}

MyInterface obj; // 接口类型的引用
obj = new Implementation1(); // 对象可以赋值为任何实现类
obj.doSomething(); // 运行时调用的是Implementation1的doSomething()

相关问题

JAVA 如何在多个文件之间实现继承、接口与多态

在Java中，继承、接口和多态是面向对象编程的三大基本特性。它们可以在多个文件之间实现，具体实现方法如下：

1. 继承

继承是指通过一个类来派生出另一个类，新类具有基类的所有属性和方法。在Java中，可以通过extends关键字实现继承。例如：

// Animal.java
public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

// Dog.java
public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }
}

在这个例子中，Dog类继承了Animal类，并且拥有了Animal类中的eat()方法。

2. 接口

接口是一种定义了一组方法和常量的抽象类型，没有实现代码。在Java中，可以通过implements关键字实现接口。例如：

// Shape.java
public interface Shape {
    double getArea();
    double getPerimeter();
}

// Circle.java
public class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getArea() {
        return Math.PI * radius * radius;
    }

    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

在这个例子中，Circle类实现了Shape接口，并且实现了Shape接口中的getArea()和getPerimeter()方法。

3. 多态

多态是指同一种类型的对象，在不同情况下会有不同的表现形式。在Java中，多态可以通过向上转型和方法重写实现。例如：

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

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

// Main.java
public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Animal();
        Animal animal2 = new Dog();

        animal1.makeSound();
        animal2.makeSound();
    }
}

在这个例子中，animal1是Animal类型的对象，animal2是Dog类型的对象。由于Dog类继承了Animal类并重写了makeSound()方法，所以当调用animal2的makeSound()方法时会输出"Dog is barking"，而不是"Animal is making a sound"。这就是多态的表现形式。

JAVA一个接口多个实现逐个调用

可以使用多态的特性，通过接口的引用指向不同实现类的对象，然后逐个调用实现类的方法。例如：

public interface MyInterface {
    void doSomething();
}

public class MyImpl1 implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("MyImpl1 doSomething");
    }
}

public class MyImpl2 implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("MyImpl2 doSomething");
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface impl1 = new MyImpl1();
        MyInterface impl2 = new MyImpl2();
        impl1.doSomething();
        impl2.doSomething();
    }
}

输出结果为：

MyImpl1 doSomething
MyImpl2 doSomething