java - 如何将一个存储为java对象的对象的变量传递给另一个也存储为java对象的对象的函数？

Question

我正在尝试使用 Bullet 在 Libgdx 中制作碰撞检测器。在这里，我想将一个碰撞对象的 power 变量作为参数传递给另一个对象的 onCollision() 函数。这里，Ball 和 Brick 扩展了 AbstractObject。此外，power 和 onCollision() 在 AbstractObject 中声明，但在 Brick 和 Ball 中初始化>。我在每个类中设置了 btCollisionObject.userData=this。最有效的方法是什么？这是我当前的 contactListener:

package com.anutrix.brickbreaker3d.Helpers;

import com.anutrix.brickbreaker3d.gameObjects.AbstractObject;
import com.anutrix.brickbreaker3d.gameObjects.Ball;
import com.anutrix.brickbreaker3d.gameObjects.Brick;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.g3d.ModelInstance;
import com.badlogic.gdx.physics.bullet.collision.ContactListener;
import com.badlogic.gdx.physics.bullet.collision.btCollisionObject;
import com.badlogic.gdx.utils.Array;

public class CollisionListener extends ContactListener {

    @Override
    public boolean onContactAdded(btCollisionObject ob0, int partId0, int index0, btCollisionObject ob1, int partId1, int index1) {

        Gdx.app.log("sdkjg", "fsfgsdg");
        Ball bl = null;
        Brick br = null;
        AbstractObject aO0 = (AbstractObject) ob0.userData;
        AbstractObject aO1 = (AbstractObject) ob1.userData;
        if (aO0 instanceof Ball) {
            bl = (Ball) aO0;
        } else if (aO1 instanceof Ball) {
            bl = (Ball) aO1;
        }

        if (aO0 instanceof Brick) {
            br = (Brick) aO0;
        } else if (aO1 instanceof Brick) {
            br = (Brick) aO1;
        }
        bl.onCollision(br.power);
        br.onCollision(bl.power);
        return true;
    }
}

这是Ball类:

public class Ball extends AbstractObject {

    public Integer power;

    public Ball(Integer id, Integer type, Vector3 position) {
        super(id, type, position);
        modelInstance = new ModelInstance(Assets.instance.ball.get(type));
        shape = new btSphereShape(0.2f);
        body = new btCollisionObject();
        body.setCollisionShape(shape);
        super.setPosition(position);
        this.power = type + 1;
        this.body.setCollisionFlags(this.body.getCollisionFlags() | btCollisionObject.CollisionFlags.CF_CUSTOM_MATERIAL_CALLBACK);
        active=true;
        body.userData=this;
    }

    public Integer getPower() {
        return power;
    }

    public void resetPower() {
        this.power = this.getType()+1;
    }

    public void onCollision(Integer power) {
        this.collided=true;
    }

    @Override
    public void getDetails(){
        Gdx.app.log("Life", power.toString());
        Gdx.app.log("Active", Boolean.toString(this.active));
        super.getDetails();
    }
}

这是 Brick 类:

package com.anutrix.brickbreaker3d.gameObjects;

import com.anutrix.brickbreaker3d.Helpers.Assets;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.g3d.ModelInstance;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.physics.bullet.collision.btBoxShape;
import com.badlogic.gdx.physics.bullet.collision.btCollisionObject;

/**
 *
 * @author Anutrix
 */
public class Brick extends AbstractObject {

    public Integer power;

    public Brick(Integer id, Integer type, Vector3 position) {
        super(id, type, position);
        modelInstance = new ModelInstance(Assets.instance.brick.get(type));
        shape = new btBoxShape(new Vector3(1f, 0.5f, 1f));
        body = new btCollisionObject();
        body.setCollisionShape(shape);
        super.setPosition(position);
        this.power = type + 1;
        this.body.setCollisionFlags(this.body.getCollisionFlags() | btCollisionObject.CollisionFlags.CF_CUSTOM_MATERIAL_CALLBACK);
        active=true;
        body.userData=this;
    }

    public Integer getPower() {
        return power;
    }

    public void onCollision(Integer power) {
        this.power = this.power-power;
        if(this.power<=0){
            this.active=false;
        }
        this.collided=false;//reset 
    }

    @Override
    public void getDetails(){
        Gdx.app.log("Life", power.toString());
        Gdx.app.log("Active", Boolean.toString(this.active));
        super.getDetails();
    }
}

这是 AbstractObject 类:

package com.anutrix.brickbreaker3d.gameObjects;

import com.anutrix.brickbreaker3d.Helpers.Assets;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.g3d.ModelInstance;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.physics.bullet.collision.btCollisionObject;
import com.badlogic.gdx.physics.bullet.collision.btCollisionShape;

public class AbstractObject {

    private Integer id;
    private Integer type;
    private Vector3 position;

    public ModelInstance modelInstance;

    public btCollisionShape shape;
    public btCollisionObject body;
    public Integer power;
    public boolean collided;
    public boolean active;

    public AbstractObject(Integer id, Integer type, Vector3 position) {
        this.id = id;
        this.type = type;
        this.position = position;
        this.collided = false;
    }

    public void setPosition(float x, float y, float z) {
        this.setPosition(new Vector3(x, y, z));
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getType() {
        return type;
    }

    public void setType(Integer type) {
        this.type = type;
        this.setModelInstance(new ModelInstance(Assets.instance.brick.get(type)));
    }

    public Vector3 getPosition() {
        return position;
    }

    public void setPosition(Vector3 position) {
        this.position = position;
        this.modelInstance.transform.translate(position);
        this.body.setWorldTransform(modelInstance.transform);
    }

    public ModelInstance getModelInstance() {
        return modelInstance;
    }

    public void setModelInstance(ModelInstance modelInstance) {
        this.modelInstance = modelInstance;
    }

    public btCollisionObject getObject() {
        return body;
    }

    public void onCollision(Integer power){

    }

    public void getDetails() {
        Gdx.app.log("ID", id.toString());
        Gdx.app.log("Type", type.toString());
        Gdx.app.log("Position", position.toString());
        Gdx.app.log("Collision", Boolean.toString(collided));
        Gdx.app.log("---------------", "---------------");
    }

    public void dispose() {
        shape.dispose();
        body.dispose();
        Gdx.app.log(this.toString(), "dispose");
    }
}

除了这些选角之外，还有其他选择吗？类型转换会降低性能，对吗？

Answer 1

我认为你遇到的是主流现代语言中 OOP 设计中的一个经典问题，即缺少 multiple dispatch或multimethods 。有几种典型的方法可以对抗它，最传统的方法是使用 double dispatch以及可选的visitor pattern .

总体思路是这样的

public abstract class AbstractObject {

    ...
    
    public final void dispatchCollision(AbstractObject other) {
        other.dispatchCollisionImpl(this);
    }

    protected abstract void dispatchCollisionImpl(AbstractObject other);

    protected abstract void onCollisionWithBall(Ball ball);

    protected abstract void onCollisionWithBrick(Brick ball);
}


public class Ball extends AbstractObject {

    ...
    
    @Override
    protected void dispatchCollisionImpl(AbstractObject other) {
        other.onCollisionWithBall(this); // this is where main "magic" happens
    }

    @Override
    protected void onCollisionWithBall(Ball ball) {
        throw new UnsupportedOperationException("Ball-ball collision should never happen");
    }

    @Override
    protected void onCollisionWithBrick(Brick ball) {
        // your actual brick-ball collision logic
    }

}

Brick中的代码类与 Ball 中的代码非常对称.

然后在你的 CollisionListener 中您可以简单地执行以下操作:

public class CollisionListener extends ContactListener {

    @Override
    public boolean onContactAdded(btCollisionObject ob0, int partId0, int index0, btCollisionObject ob1, int partId1, int index1) {
        AbstractObject aO0 = (AbstractObject) ob0.userData;
        AbstractObject aO1 = (AbstractObject) ob1.userData;

        aO0.dispatchCollision(aO1);
        //aO1.dispatchCollision(aO0); // if you want to do both

        return true;
    }
} 

这种方法的主要缺点是，如果您的 AbstractObject 有许多子类， ，您需要为每个子类中的每个添加方法。另一方面，您可以在某些基类中为此类方法添加一些默认的通用逻辑。

如果您有许多子类或需要一些类似插件的支持，您可能应该采用更高级的多方法模拟技术，例如具有显式全局 Map<Tuple<Class,Class>, Handler>以便发货。

<小时/>

显式多种方法

这里有一个关于如何更明确地创建类似于多方法的东西的想法:

public class ClassesPair {
    public final Class<? extends AbstractObject> targetClass;
    public final Class<? extends AbstractObject> objectClass;

    public ClassesPair(Class<? extends AbstractObject> targetClass, Class<? extends AbstractObject> objectClass) {
        this.targetClass = targetClass;
        this.objectClass = objectClass;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        ClassesPair that = (ClassesPair) o;

        if (!targetClass.equals(that.targetClass)) return false;
        return objectClass.equals(that.objectClass);
    }

    @Override
    public int hashCode() {
        int result = targetClass.hashCode();
        result = 31 * result + objectClass.hashCode();
        return result;
    }
}

public interface CollisionHandler<T extends AbstractObject, O extends AbstractObject> {
    void handleCollision(T target, O object);
}

public class CollisionsDispatcher {
    private final Map<ClassesPair, CollisionHandler> originalDispatchMap = new HashMap<>();
    private Map<ClassesPair, CollisionHandler> extendedDispatchMap = new HashMap<>();

    private CollisionHandler getHandlerOrParent(Class<? extends AbstractObject> targetClass, Class<? extends AbstractObject> objectClass) {
        //Need to decide on the rules, for now target is more important
        Class stopClass = AbstractObject.class.getSuperclass();
        for (Class tmpTarget = targetClass; tmpTarget != stopClass; tmpTarget = tmpTarget.getSuperclass()) {
            for (Class tmpObject = objectClass; tmpObject != stopClass; tmpObject = tmpObject.getSuperclass()) {
                CollisionHandler collisionHandler = originalDispatchMap.get(new ClassesPair(tmpTarget, tmpObject));
                if (collisionHandler != null)
                    return collisionHandler;
            }
        }
        return null;
    }

    public CollisionHandler getHandler(Class<? extends AbstractObject> targetClass, Class<? extends AbstractObject> objectClass) {
        ClassesPair key = new ClassesPair(targetClass, objectClass);
        CollisionHandler collisionHandler = extendedDispatchMap.get(key);
        if (collisionHandler == null) {

            // choice #1
            // Just fail every time nothing was found
            //throw new UnsupportedOperationException("Collision of " + targetClass.getName() + " with " + objectClass.getName() + "' is not supported");

            // choice #2 go through handlers for parents.
            // It provides ability to put some generic logic only once
            // Need to decide on the rules, for now target is more important
            collisionHandler = getHandlerOrParent(targetClass, objectClass);
            if (collisionHandler != null) {
                extendedDispatchMap.put(key, collisionHandler); // put it back for faster future usages
            } else {
                throw new UnsupportedOperationException("Collision of " + targetClass.getName() + " with " + objectClass.getName() + "' is not supported");
            }

            // choice #3
            // Just do nothing. Everything that has no explicit handler is not affected by collision
            // return null;
        }
        return collisionHandler; // God save Java with its type erasure for generics!
    }

    public void handleCollision(AbstractObject target, AbstractObject object) {
        CollisionHandler handler = getHandler(target.getClass(), object.getClass());
        if (handler != null) { // this check only for choice #3
            handler.handleCollision(target, object); // God save Java with its type erasure for generics!
        }
    }

    public <T extends AbstractObject, O extends AbstractObject> void registerHandler(Class<T> targetClass, Class<O> objectClass, CollisionHandler<? super T, ? super O> handler) {
        ClassesPair key = new ClassesPair(targetClass, objectClass);
        originalDispatchMap.put(key, handler);
        // just clear extended cache. It is much easier than to track all possible propagated values
        // and handle them properly. On the other hand registerHandler should be called only a few
        // time during set up so it shouldn't be real penalty in performance
        extendedDispatchMap = new HashMap<>();
    }
}

现在作为一个使用示例，假设您想要使用 3 种砖 block 创建一些类似打砖 block 的游戏:

• 一击砖 block 始终是蓝色的
• 两次击中的砖 block 在第一次击中后颜色从红色变为粉红色
• 黑色的 super 砖 block ，根本无法被破坏

public abstract class AbstractBrick extends AbstractObject {

    protected int hitCount;

    public AbstractBrick(int hitCount) {
        this.hitCount = hitCount;
    }

    public int getHitCount() {
        return hitCount;
    }

    public void setHitCount(int hitCount) {
        this.hitCount = hitCount;
    }

    public abstract Color getColor();

    @Override
    protected void dispatchCollisionImpl(AbstractObject other) {
        other.onCollisionWithBrick(this);
    }

    @Override
    protected void onCollisionWithBall(Ball ball) {

    }

    @Override
    protected void onCollisionWithBrick(AbstractBrick ball) {

    }

}

// takes one hit to break
public class SimpleBrick extends AbstractBrick {
    public SimpleBrick() {
        super(1);
    }

    @Override
    public Color getColor() {
        return Color.BLUE;
    }
}

// takes two hits to break
public class DoubleBrick extends AbstractBrick {
    public DoubleBrick() {
        super(2);
    }

    @Override
    public Color getColor() {
        if (hitCount == 2)
            return Color.RED;
        else
            return Color.PINK;
    }
}

// never breaks
public class SuperBrick extends AbstractBrick {
    public SuperBrick() {
        super(-1);
    }

    @Override
    public Color getColor() {
        return Color.BLACK;
    }
}

现在您创建 CollisionsDispatcher 的特定实例并在其中注册了所有必要的处理程序

public class MyCollisionsDispatcher extends CollisionsDispatcher {

    public MyCollisionsDispatcher() {
        // Pre-register all required handlers
        // using Java-8 syntax for "::" instead of anonymous classes
        registerHandler(Ball.class, AbstractBrick.class, this::handleBallBrick);
        registerHandler(AbstractBrick.class, Ball.class, this::handleUsualBrickBall);
        registerHandler(SuperBrick.class, Ball.class, this::handleSuperBrickBall);
    }

    void handleBallBrick(Ball ball, AbstractBrick brick) {
        // bounce of the ball
        // in this case it is not important which brick we hit
        System.out.println("Ball hit some brick");
    }

    void handleUsualBrickBall(AbstractBrick brick, Ball ball) {
        int newCount = brick.getHitCount() - 1;
        if (newCount != 0) {
            brick.setHitCount(newCount);
        } else {
            // remove brick
        }

        System.out.println("Usual brick was hit by a ball. newCount =  " + newCount);
    }

    void handleSuperBrickBall(SuperBrick brick, Ball ball) {
        // do nothing. Super brick is so super!
        System.out.println("Super brick was hit by a ball but nothing happened");
    }
}

这样你就可以做这样的事情:

public void test() {
    AbstractObject simpleBrick = new SimpleBrick();
    AbstractObject doubleBrick = new DoubleBrick();
    AbstractObject superBrick = new SuperBrick();
    AbstractObject ball = new Ball();

    CollisionsDispatcher dispatcher = new MyCollisionsDispatcher();

    dispatcher.handleCollision(ball, simpleBrick);
    dispatcher.handleCollision(simpleBrick, ball);

    dispatcher.handleCollision(ball, doubleBrick);
    dispatcher.handleCollision(doubleBrick, ball);
    dispatcher.handleCollision(doubleBrick, ball);

    dispatcher.handleCollision(ball, superBrick);
    dispatcher.handleCollision(superBrick, ball);
    dispatcher.handleCollision(superBrick, ball);
}

输出与预期一模一样:

Ball hit some brick

Usual brick was hit by a ball. newCount = 0

Ball hit some brick

Usual brick was hit by a ball. newCount = 1

Usual brick was hit by a ball. newCount = 0

Ball hit some brick

Super brick was hit by a ball but nothing happened

Super brick was hit by a ball but nothing happened

所以在你的 CollisionListener 中你可以打电话

@Override
public boolean onContactAdded(btCollisionObject ob0, int partId0, int index0, btCollisionObject ob1, int partId1, int index1) {
    AbstractObject aO0 = (AbstractObject) ob0.userData;
    AbstractObject aO1 = (AbstractObject) ob1.userData;


    dispatcher.handleCollision(aO0, aO1);
    // dispatcher.handleCollision(aO1, aO0); // if you want to do both

    return true;
}

这里的主要缺点是主要优点的其他方面:

• 您可以将所有与碰撞相关的代码放在一个位置 MyCollisionsDispatcher但那个“单一地点”可能会变得相当大。
• 另一个好处是，通过这种方法，您可能拥有一个“插件”系统，即有人可以添加新的 AbstractObject只需在调度程序中注册适当的处理程序即可子类化，而无需触及现有代码中的任何内容。这样做的缺点是，在任何主流语言中，我知道您会失去编译时检查，以确保每个必要的处理程序实际上都像在双分派(dispatch)中一样实现。

摘要(以及一些比较)

就长期管理和代码清晰度而言，我认为选择哪种解决方案只是品味问题，除非您有其他限制导致其中一些解决方案不适用。每一种合适的技术都是相对先进的，并且可能会在开发人员不知情的情况下让开发人员陷入困境。

就性能而言，首要规则是:衡量它!。尽管如此，我还是会打破它并做出我的预测，双重调度比显式 Map 更快，显式 Map 比一堆 instanceof 更快。如果有很多子类(仍然，YMMV)至于内存消耗，我没有看到任何显着差异。

正如有人所说Software Engineering Is Art Of Compromise所以最后取决于你做出正确的权衡。