java - 根据对象类型调用适当的函数

我正在写一个2D物理引擎，很有趣。

我为不同的形状编写了不同的类，BoxObject是矩形，BallObject是圆形，LineObject是线。所有这些都实现了PhysicsObject接口。

所有要模拟的对象都位于一个列表中。

public static List<PhysicsObject> objects = new ArrayList<PhysicsObject>();

需要检查所有这些对象是否相互碰撞。

Collision类包含名为penetrationData的方法，用于获取所有可能的类型对的渗透数据，例如penetrationData(BoxObject a, BallObject b)和penetrationData(BallObject a, LineObject b)等。这是它的外观。

package com.optimus.game.physics;

public class Collision {

    // Default - no collision
    public static float[] penetrationData(PhysicsObject a, PhysicsObject b) {
        return null;
    }

    // Line vs Circle
    public static float[] penetrationData(LineObject line, BallObject ball) {
        float distance = line.distance(ball.x, ball.y);
        if (Math.abs(distance) > ball.radius) {
            return null;
        }
        float penetration = ball.radius - Math.abs(distance);
        float normalX = line.perpendicularX();
        float normalY = line.perpendicularY();
        return new float[] {normalX, normalY, penetration};
    }

    // Circle vs Line
    public static float[] penetrationData(BallObject ball, LineObject line) {
        float[] data = penetrationData(line, ball);
        // reverse the normal
        if (data != null) {
            data[0] = -data[0];
            data[1] = -data[1];
        }
        return data;
    }

    // Circle vs Circle
    public static float[] penetrationData(BallObject a, BallObject b) {

        // Vector from A to B
        float normalX = b.x - a.x;
        float normalY = b.y - a.y;
        float penetration = 0;

        // calculate the penetration and normal direction
        // ...
        // ... (code skipped)

        return new float[] {normalX, normalY, penetration};
    }

    // Rect vs Rect
    public static float[] penetrationData(BoxObject a, BoxObject b) {
        // Vector from A to B
        float normalX = b.x - a.x;
        float normalY = b.y - a.y;
        float penetration = 0;

        // calculate the penetration and normal direction
        // ...
        // ... (code skipped)

        return new float[] {normalX, normalY, penetration};
    }

    // Rect vs Circle
    public static float[] penetrationData(BoxObject box, BallObject ball) {
        // Vector from A to B
        float normalX = ball.x - (box.x + box.width / 2f);
        float normalY = ball.y - (box.y + box.height / 2f);
        float penetration = 0;

        // calculate the penetration and normal direction
        // ...
        // ... (code skipped)

        return new float[] {normalX, normalY, penetration};
    }

    // Circle vs Rect
    public static float[] penetrationData(BallObject ball, BoxObject box) {
        float[] data = penetrationData(box, ball);
        // reverse the normal
        if (data != null) {
            data[0] = -data[0];
            data[1] = -data[1];
        }
        return data;
    }


}

然后我检查是否有碰撞...

public static void checkAndResolveCollisions(List<PhysicsObject> objects) {
    // check collision between all objects in a list
    // list of objects can contain BallObject, LineObject and
    // BoxObject all of which implement PhysicsObject

    // loop over all possible pairs
    for (int i = 0; i < objects.size(); i++) {
        for (int j = i + 1; j < objects.size(); j++) {

            // here I want that apt function is called based on type
            // but objects.get(int i) always returns a PhysicsObject
            float[] data = Collision.penetrationData(objects.get(i), objects.get(j));

            // data = null implies no overlap
            if (data == null) {
                continue;
            }

            // Calculate relative velocity in terms of the normal direction
            float normalX = data[0];
            float normalY = data[1];
            float penetration = data[2];

            // Resolve the collision along the normal
            // ...
            // ... (code skipped)

        }
    }
}

但是它不起作用，每次penetrationData都会返回null。

起作用的是，如果我获得了这样的渗透数据，但是这段代码很臭，我只能看一下就能知道...

// here is what works, but I know is bad java code
float[] data = getAptPenetrationData(objects.get(i), objects.get(j));

其中getAptPenetrationData是通用函数，先进行类型转换，然后调用apt函数

// generic function that calls others
    public static float[] getAptPenetrationData(PhysicsObject a, PhysicsObject b) {
        // bad java code...
        boolean aIsBall = a instanceof BallObject;
        boolean aIsBox = a instanceof BoxObject;
        boolean aIsLine = a instanceof LineObject;

        boolean bIsBall = b instanceof BallObject;
        boolean bIsBox = b instanceof BoxObject;
        boolean bIsLine = b instanceof LineObject;

        float[] data = null;
        // circle vs circle
        if (aIsBall && bIsBall) {
            data = Collision.penetrationData((BallObject)a, (BallObject)b);
        // box vs box
        } else if (aIsBox && bIsBox) {
            data = Collision.penetrationData((BoxObject)a, (BoxObject)b);
        // box vs circle
        } else if (aIsBox && bIsBall) {
            data = Collision.penetrationData((BoxObject)a, (BallObject)b);
        // circle vs box
        } else if (aIsBall && bIsBox) {
            data = Collision.penetrationData((BallObject)a, (BoxObject)b);
        // circle vs line
        } else if (aIsBall && bIsLine) {
            data = Collision.penetrationData((BallObject)a, (LineObject)b);
        // line vs circle
        } else if (aIsLine && bIsBall) {
            data = Collision.penetrationData((LineObject)a, (BallObject)b);
        }
        return data;
    }

我一定想念一些东西，并且必须有一种更好的方法来做我想做的事情。任何帮助表示赞赏。谢谢。

编辑：

根据Zim-Zam的建议，现在可以像这样解决碰撞...

public static void checkAndResolveCollisions(List<PhysicsObject> objects) {
    // check collision between all objects in a list
    // list of objects can contain BallObject, LineObject and
    // BoxObject all of which implement PhysicsObject

    // loop over all possible pairs
    for (int i = 0; i < objects.size(); i++) {
        for (int j = i + 1; j < objects.size(); j++) {

            // does not work, goes into infinite recursion
            // still calls PhysicsObject.penetrationData(PhysicsObject)
            float[] data = objects.get(i).penetrationData(objects.get(j));

            // data = null implies no overlap
            if (data == null) {
                continue;
            }

            // Calculate relative velocity in terms of the normal direction
            float normalX = data[0];
            float normalY = data[1];
            float penetration = data[2];

            // Resolve the collision along the normal
            // ...
            // ... (code skipped)

        }
    }
}

但是仅当我在PhysicsObject接口中添加以下方法签名时，该方法才有效

public PenetrationData penetrationData(PhysicsObject other);
public PenetrationData penetrationData(BallObject other);
public PenetrationData penetrationData(BoxObject other);
public PenetrationData penetrationData(LineObject other);

这仍然不是理想的原因，因为每次我实施新的PhysicsObject时，都必须更改接口。

PhysicsObject实现（仅penetrationData函数）-

BallObject.java

public class BallObject implements PhysicsObject {

    @Override
    public float[] penetrationData(PhysicsObject other) {
        return other.penetrationData(this);
    }
    @Override
    public float[] penetrationData(LineObject line) {
        return Collision.penetrationData(this, line);
    }
    @Override
    public float[] penetrationData(BoxObject box) {
        return Collision.penetrationData(this, box);
    }
    @Override
    public float[] penetrationData(BallObject ball) {
        return Collision.penetrationData(this, ball);
    }

    // ... rest of the code
}

BoxObject.java

public class BoxObject implements PhysicsObject {

    @Override
    public float[] penetrationData(PhysicsObject other) {
        return other.penetrationData(this);
    }
    @Override
    public float[] penetrationData(LineObject line) {
        return null; // not implemented
    }
    @Override
    public float[] penetrationData(BoxObject box) {
        return Collision.penetrationData(this, box);
    }
    @Override
    public float[] penetrationData(BallObject ball) {
        return Collision.penetrationData(this, ball);
    }

    // ... rest of the code
}

LineObject.java

public class LineObject implements PhysicsObject {

    @Override
    public float[] penetrationData(PhysicsObject other) {
        return other.penetrationData(this);
    }
    @Override
    public float[] penetrationData(LineObject line) {
        return null; // not implemented
    }
    @Override
    public float[] penetrationData(BoxObject box) {
        return null; // not implemented
    }
    @Override
    public float[] penetrationData(BallObject ball) {
        return Collision.penetrationData(this, ball);
    }

    // ... rest of the code
}

最佳答案

如前所述，您需要双重调度。但是，我不建议您使用重量级且反复无常的访客模式。您应该使用Java实现自己的调度系统。例如，构建从对象对到渗透数据计算器的地图。然后，您将有很多instanceof，而不是很多map.put()。您甚至可以通过使用varargs方法来避免put的重复，该方法可用于伪造地图文字：

static Map<ObjPair, CollisionCalc> map(Object... kvs) {
   final Map<ObjPair, CollisionCalc> ret = new HashMap<>();
   for (int i = 0;;i < kvs.length)
     ret.put((ObjPair)kvs[i++], (CollisionCalc)kvs[i++]);
   return ret;
}

在客户端，这应该类似于以下内容：

public static float[] penetrationData(PhyObject o1, PhyObject o2) {
  return map.get(new ObjPair(o1, o2)).penetrationData(o1, o2);
}