Java面向对象设计：通过接口实现类间方法的多态访问与解耦

// Main.java (简化版，仅展示核心问题)
public class Main {
    public static void main(String[] args) {
        Orchestra orchestra = new Orchestra();
        Drum drum = new Drum();
        Xylophone xylophone = new Xylophone();

        // 假设通过某种方式将drum和xylophone添加到orchestra内部的Object[]
        // Orchestra orchestra = new Orchestra(drum); // 构造函数接收
        // Orchestra orchestra = new Orchestra(xylophone); // 构造函数接收
        // ...
        // 最终在Orchestra内部尝试调用 instrumentsArray[0].play()
        // 这会引发编译错误，因为编译器不知道Object类型有play方法。
    }
}

// Drum.java
public class Drum {
    public void play(String note) {
        System.out.println("Playing... drums (note " + note + ")");
    }
}

// Xylophone.java
public class Xylophone {
    public void play(String note) {
        System.out.println("Playing... xylophone (note " + note + ")");
    }
}

// Orchestra.java (问题代码示例)
public class Orchestra {
    static Object[] instrumentsArray = new Object[2]; // 使用Object数组

    public Orchestra() {}

    // 假设通过构造函数添加乐器，实际可能通过其他方法
    public Orchestra(Xylophone xylophone) {
        instrumentsArray[0] = xylophone;
        // 此时 xylophone.play() 可以直接调用
        // 但如果从 instrumentsArray[0] 访问，则 instrumentsArray[0].play() 会报错
    }

    public Orchestra(Drum drum) {
        instrumentsArray[1] = drum;
        // 此时 drum.play() 可以直接调用
        // 但如果从 instrumentsArray[1] 访问，则 instrumentsArray[1].play() 会报错
    }

    public void playInstruments() {
        // 在这里迭代 instrumentsArray，并尝试对每个元素调用 .play()
        // 例如：((Drum)instrumentsArray[0]).play("note"); // 需要强制类型转换，且不通用
        // 更好的方式是利用多态
    }
}

// Instrument.java
public interface Instrument {
    void play(String note);
}

// Drum.java
public class Drum implements Instrument {
    @Override
    public void play(String note) {
        System.out.println("Drums: " + note);
    }
}

// Xylophone.java
public class Xylophone implements Instrument {
    @Override
    public void play(String note) {
        System.out.println("Xylophone: " + note);
    }
}

// Orchestra.java
import java.util.ArrayList;
import java.util.List;

public class Orchestra {
    private List<Instrument> instruments; // 存储Instrument接口类型

    public Orchestra() {
        this.instruments = new ArrayList<>();
    }

    // 可以通过构造函数初始化，或提供添加方法
    public Orchestra(List<Instrument> instruments) {
        this.instruments = instruments;
    }

    public void add(Instrument instrument) {
        this.instruments.add(instrument);
    }

    public void play() {
        System.out.println("Orchestra is playing...");
        // 遍历集合，调用每个乐器的play方法，利用多态性
        this.instruments.forEach(i -> i.play("b flat")); // 示例音符
    }
}

// Main.java
public class Main {
    public static void main(String[] args) {
        Orchestra orchestra = new Orchestra(); // 创建乐队

        // 添加乐器
        orchestra.add(new Drum());
        orchestra.add(new Xylophone());
        // 如果有新的乐器，只需创建并添加即可，无需修改Orchestra或Main的逻辑
        // orchestra.add(new Violin()); // 假设有Violin类实现Instrument接口

        orchestra.play(); // 指挥乐队演奏
    }
}

Orchestra is playing...
Drums: b flat
Xylophone: b flat