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

Question

我正在编写一个 2d 物理引擎来娱乐。

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

正在模拟的所有对象都驻留在一个列表中。

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 接口(interface)时它才有效

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

这仍然不理想，因为每次我实现新的 PhysicsObject 时，我都必须更改接口(interface)。

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
}

Answer 1

正如已经指出的，您需要双重调度。但是，我不建议使用重量级且充满样板的访问者模式。您应该用 Java 实现您自己的调度系统。例如，构建从对象对到渗透数据计算器的映射。然后，您将拥有大量的 map.put()，而不是大量的 instanceof。您甚至可以通过使用 varargs 方法来避免重复 put，该方法可用于伪造 map 文字:

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);
}