Java – Why does Java have `void` methods

What you are probably looking for is called Aspect Oriented Programming. It works with the Proxy-Pattern, which is just what you need.

You can create a dynamic proxy for each object and tell that proxy to intercept said calls and perform your logic. All you need is one dynamic proxy class that contains your interception logic. It will wrap around any object you give it and try to perform your logic.

Start to look here:

• http://www.javaworld.com/javaworld/jw-11-2000/jw-1110-proxy.html

• http://docs.oracle.com/javase/1.3/docs/guide/reflection/proxy.html

• http://www.devx.com/Java/Article/21463

• http://www.ibm.com/developerworks/java/library/j-jtp08305/index.html

I haven't read that articles, though. Just browse the web for the implementation/library that fits your needs best.

You might also want to check out AspectJ.

Since you are working on a geometric API, I guess you are not only interested in intersection of lines and spheres, but have also more exciting projects.

A natural approach to solve your problem of representing values for intersection would be to define a type for geometric figures so that you can represent:

• Points
• Lines
• Spheres
• Intersections that you cannot compute (kind of symbolic intersection)
• Union of figures

Once you have done that, your intersection algorithm can gobble two figures and return a figure, computed by using

(A + B + ...).(C + D + ...) = A.C + A.D + B.C + B.D + ...

where I denote the union by + and the intersection by . and where A, B, C, D and the dots can be a point, a sphere, a line or an intersection you cannot compute.

To some extent, this approach gives satisfying results and may give the feeling that it is the right solution to the problem.

There are however a lot of problems with this approach, that you should be aware of:

1. Intersection that you cannot compute tend to absorb everything, i.e. intersecting anything with an intersection that you cannot can yield an intersection that you cannot compute.

2. If you intersect two spheres, it yields a circle, that you cannot compute, not because you cannot find which circle it is, but because you cannot represent circles. If you choose to add circles to your vocabulary, you have to figure out how to compute intersections with all other figures you may have. So if you have n base figures you should deal with n^2 type of intersections. So, choosing a rich vocabulary of figures without relying on ``intersections you cannot compute'' is not an option.

3. Even if you restrict yourself to the rassuring realm of algebraic figures (defined by polynomial equations), computing intersections is far from trivial. What you are trying to do is to compute a minimal set of generators of the reduced ideal defined by your intersection, so do not expect to be able to do this on more than a few examples. You should regard anything you are able to compute as a lucky accident.