将Object转换为最低级别

Question

Is there a way to cast an Object to its "lowest" class? In my case, "Arc" and "Line" extend "Curve". I want to save both in an ArrayList and then do something with them, depending on what class it is. This example outputs "curve", "curve" but I want it to be "arc", "line". Thanks for your help!

public class Test4 {

public static void main(String[] args) {
    ArrayList<Curve> curves = new ArrayList<>();
    Arc arc = new Arc(new Point(0, 0, 0), 0, 0, 0);
    Line line = new Line(new Point(0, 0, 0), new Point(1, 0, 0));
    curves.add(arc);
    curves.add(line);

    for (Curve i : curves) {
        test(i);
    }
}

public static void test(Line l) {
    System.out.println("line");
}

public static void test(Arc a) {
    System.out.println("arc");
}

public static void test(Curve c) {
    System.out.println("curve");
}
}

EDIT: Thank you for your answers! It works so far, but my problem is a little more complicated. What I want to do is find the intersection Point(s) of two geometrical Objects (so Line - Arc, Line - Line, Line - Circle etc.)

public class Line{
    //constructor and other methods
public Point[] intersection(Circle circle) {
    //some code
}

public Point[] intersection(Line line) {
    //some code
}

public Point[] intersection(LineSeg s) {
    //some code
}
}

I want to access these methods with Curve objects, so in abstract class Curve there is a method intersection (Curve) . When I call this method it returns an empty Array, because it called the method from Curve class. How can I tell Java to use the methods from classes Arc, Line etc and not from Curve?

public abstract class Curve {

public Point[] intersection(Curve c) {
    return new Point[] {};
}
}

Answer 1

Method overloading is resolved during compilation, based on the static type of the parameters passed to the method, therefore, when you pass a variable of type Curve , the method static void test(Curve c) is always chosen, regardless of the runtime type of the objects referenced by the variable i .

You can replace your static test methods with instance methods, and thus use method overriding:

In Line class:

public void test() {
    System.out.println("line");
}

In Arc class:

public void test() {
    System.out.println("arc");
}

In Curve class:

public void test() {
    System.out.println("curve");
}

And change your loop to

for (Curve i : curves) {
    i.test();
}

Answer 2

That's the most common design error you are making there.

As @Eran said you shall move the logic from global handler into the class instances.

The problem can be specified in another way:

You cast object like Arc and Line to its more generic form - Curve

And then try to differentiate between Arc and Line objects.

• For Arc s output message that the object is Arc
• For Line s output message that the object is Line

To differentiate the object classes you must use Java mechanisms:

• Execute its method (methods of objects are the best way to determine the type of object)

• Use instenaceof operator

So the best, proffesional approach is to implement methods test in each of the classes:

 public void test() {
     System.out.println("Your type");
 }

It's not advised to use instanceof because it generate bugs and you can write a code like this one:

public static void test(Curve c) {
    if(c instanceof Arc) {
         System.out.println("Arc");
         return;
    }
    System.out.println("Something else");
}

In that case if you add new class like OtherGeometricalObject you may forget to change implementation of test to add line:

    if(c instanceof OtherGeometricalObject) {
         System.out.println("OtherGeometricalObject");
         return;
    }

That's why instanceof is in most cases a really bad deal and should be avoided!

If you would like to differentiate between objects like in the example (do something for objects of one class and something other for other classes objects) just use class method!

It's the mechnism designed for that purpose!

I hope my explanation is rich and helpful :)

Answer 3

You want to get a OOP behavior for each subclass where the behavior depends on the runtime class but overloading with a static modifier will not allow that.
The selection of the method being done at compile time according to the declared type of the argument.

As Eran suggested, let each subclass defines its test() method and invoke the method on an instance of it.

Besides, what you want can be performed with an Object method.
The method toString() is designed for returning a String representing of the object.

You can directly use it in this way :

for (Curve curve : curves) {
   System.out.println(curve);
}

If the default toString() method doesn't suit for you, you may override it in subclasses.

In Line class :

public String toString() {
    return "line";
}

In Arc class:

public String toString() {
    return "arc";
}

In Curve class:

public String toString() {
    return "curve";
}