Java 从抽象类在数组上的扩展类调用方法

我试图在抽象超类的数组上，从扩展抽象类的类调用某个方法。有没有可能那样做

users[findUser(userName)].setVehicle(vehicles[counterVehicles])

---

如果您知道

users[findUser（userName）]

的结果总是某种类型的，您可以这样做：

((ConcreteUser)users[findUser(userName)]).setVehicle(vehicles[counterVehicles])

否则，在进行调用之前，您必须使用

instanceof

特定类型进行测试

为了避免所有这些，您可以做的最好的事情是实现访问者模式。这是怎么可能的：

interface UserVisitor {
    public void visit(ConcreteUser1 user1);

    public void visit(ConcreteUser2 user2);
}


static class VehicleVisitor implements UserVisitor {

    private Vehicle vehicle;
    private Bus bus;

    VehicleVisitor(Vehicle vehicle, Bus bus) {
        this.vehicle = vehicle;
        this.bus = bus;
    }

    public void visit(ConcreteUser1 user1) {
        user1.setVehicle(vehicle);
    }

    public void visit(ConcreteUser2 user2) {
        user2.setBus(bus);
    }
}

static abstract class AbstractUser {
    public abstract void accept(VehicleVisitor visitor);
}

static class ConcreteUser1 extends AbstractUser {

    private Vehicle vehicle;

    public void accept(VehicleVisitor visitor) {
        visitor.visit(this);
    }

    public void setVehicle(Vehicle vehicle) {
        this.vehicle = vehicle;
    }

    public Vehicle getVehicle() {
        return vehicle;
    }
}

static class ConcreteUser2 extends AbstractUser {

    private Bus bus;

    public void accept(VehicleVisitor visitor) {
        visitor.visit(this);
    }

    public void setBus(Bus bus) {
        this.bus = bus;
    }

    public Bus getBus() {
        return bus;
    }
}

static class Vehicle {

    @Override
    public String toString() {
        return "CAR";
    }
}
static class Bus {

    @Override
    public String toString() {
        return "BUS";
    }
}

public static void main(String[] args) {
    List<AbstractUser> users = new ArrayList<AbstractUser>();
    ConcreteUser1 user1 = new ConcreteUser1();
    users.add(user1);
    ConcreteUser2 user2 = new ConcreteUser2();
    users.add(user2);

    for (AbstractUser user : users) {
        VehicleVisitor visitor = new VehicleVisitor(new Vehicle(), new Bus());
        user.accept(visitor);
    }

    System.out.println(user1.getVehicle());
    System.out.println(user2.getBus());
}

interface用户访问者{
公开无效访问（ConcreteUser1 user1）；
公开无效访问（ConcreteUser2 user2）；
}
静态类VehicleVisitor实现UserVisitor{
私家车；
私家巴士；
车辆驾驶员（车辆、公共汽车）{
本车=车辆；
这辆公共汽车=公共汽车；
}
公共无效访问（ConcreteUser1 user1）{
用户1.设置车辆（车辆）；
}
公共无效访问（ConcreteUser2 user2）{
user2.setBus（总线）；
}
}
静态抽象类AbstractUser{
公开摘要无效接受（车辆或访客）；
}
静态类ConcreteUser1扩展了AbstractUser{
私家车；
公众无效接受（车辆或访客）{
访客。访问（本）；
}
公共车辆（车辆）{
本车=车辆；
}
公共车辆{
返回车辆；
}
}
静态类ConcreteUser2扩展了AbstractUser{
私家巴士；
公众无效接受（车辆或访客）{
访客。访问（本）；
}
公共巴士（巴士）{
这辆公共汽车=公共汽车；
}
公共巴士{
回程巴士；
}
}
静态级车辆{
@凌驾
公共字符串toString（）{
归还“汽车”；
}
}
静态类总线{
@凌驾
公共字符串toString（）{
返回“总线”；
}
}
公共静态void main（字符串[]args）{
列表用户=新建ArrayList（）；
ConcreteUser1 user1=新的ConcreteUser1（）；
users.add（user1）；
ConcreteUser2 user2=新的ConcreteUser2（）；
users.add（user2）；
for（抽象用户：用户）{
VehicleVisitor visitor=新车驾驶员（新车（），新公交车（））；
用户接受（访客）；
}
System.out.println（user1.getVehicle（））；
System.out.println（user2.getBus（））；
}

---

现在，在这个示例中，我只有一个访问者来缩短它，但是您可以有多种类型的访问者，每个访问者对不同类型的用户执行不同的操作。

您试图处理的界面是什么？

AbstractClassExtension.method（super.array）

？但除非我们知道确切的数据结构是什么，否则这是不可能的。