Java中利用接口与多态实现灵活的对象方法调用与类解耦

public class Main {
    public static void main(String[] args) {
        Orchestra orchestra = new Orchestra(); // 初始乐团实例

        Drum drum = new Drum();
        Xylophone xylophone = new Xylophone();

        // 乐器尝试将自身“发送”给乐团
        drum.sendToOrchestra();
        xylophone.sendToOrchestra();
    }
}

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

    public void sendToOrchestra(){
        // 这里创建了一个新的Orchestra实例，而非将自身添加到现有乐团
        Orchestra orchestra = new Orchestra(this); 
    }
}

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

    public void sendToOrchestra(){
        // 同上，创建了新的Orchestra实例
        Orchestra orchestra = new Orchestra(this);
    }
}

public class Orchestra {
    // 使用Object数组存储乐器，容量固定
    static Object[] instrumentsArray = new Object[2]; 

    public Orchestra(){
        // 默认构造器
    }

    // 针对Xylophone的构造器，耦合度高
    public Orchestra(Xylophone xylophone){
        // xylophone.play() 在这里可以直接调用，因为类型已知
        instrumentsArray[0] = xylophone;
        // 但一旦存入Object数组，就无法直接调用：instrumentsArray[0].play() 会导致编译错误
    }

    // 针对Drum的构造器，耦合度高
    public Orchestra(Drum drum){
        // drum.play() 在这里可以直接调用
        instrumentsArray[1] = drum;
        // 同理，存入Object数组后无法直接调用：instrumentsArray[1].play() 会导致编译错误
    }

    public void playInstruments(){
        // 期望在这里遍历 instrumentsArray 并调用每个乐器的 .play() 方法
        // 但由于数组元素类型是Object，无法直接实现
    }
}

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

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

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

import java.util.ArrayList;
import java.util.List;

public class Orchestra {
    // 使用List<Instrument>存储乐器，支持动态增删，且类型安全
    private List<Instrument> instruments;

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

    // 允许通过构造器初始化乐器列表（可选）
    public Orchestra(List<Instrument> instruments) {
        this.instruments = instruments;
    }

    // 添加乐器的方法，接受任何实现Instrument接口的对象
    public void add(Instrument instrument) {
        this.instruments.add(instrument);
    }

    // 演奏所有乐器的方法
    public void play() {
        System.out.println("Orchestra is playing...");
        // 遍历乐器列表，调用每个乐器的play方法
        // 这里的 i 是 Instrument 类型，可以安全地调用 play() 方法
        this.instruments.forEach(i -> i.play("b flat")); 
        System.out.println("Orchestra finished playing.");
    }
}

public class Main {
    public static void main(String[] args) {
        Orchestra orchestra = new Orchestra(); // 创建乐团实例

        // 创建乐器实例并添加到乐团
        orchestra.add(new Drum());
        orchestra.add(new Xylophone());
        // 可以轻松添加其他乐器，只要它们实现了Instrument接口
        // orchestra.add(new Piano()); 

        orchestra.play(); // 让乐团演奏
    }
}

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