使用匿名类返回Java中的值

Question

Consider the following code:

public interface MyClass {
    public final String getMyObject1();
    public final String getMyObject2();
}

public class MyClass1 implements MyClass {
    private String myObject1;
    private String myObject2;
    public MyClass1(String myObject1, String myObject2) {
        this.myObject1 = myObject1;
        this.myObject2 = myObject2;
    }
    public String getMyObject1() {
        return myObject1;
    }
    public String getMyObject2() {
        return myObject2;
    }
}

public interface MyClass2 extends MyClass {
    public static MyClass2 newInstance(String myObject1, String myObject2) {
        return new MyClass2() {
            public String getMyObject1() {
                return myObject1;
            }
            public String getMyObject2() {
                return myObject2;
            }
        };
    }
}

And I use them like

public static void func(MyClass m) {
    m.getMyObject1();
    m.getMyObject2();
}
func(new MyClass1(o1, o2));
func(MyClass2.newInstance(o1, o2));

I wonder how they differ and if I only need to read from the values (ie to use MyClass as a "struct" to pass values), using the anonymous class can it be a simpler approach?

Otherwise, what are the draw backs?

Answer 1

One core rule of programming: try to not surprise your readers.

Your approach here to use a static class within an interface as "factory" method is very surprising (and believe me: I have seen a lot of Java code).

If at all, the more "common" way of handling such things: create a static class with a slightly similar name, you know, like there is java.lang.Object and java.lang.Objects that carries some useful static helper methods.

And beyond that, there is already a class in Java that helps with arbitrary numbers of "named" values; and that is called a Map !

Finally: there are some good arguments for "DTO"s ( data transfer objects ) but esp. for "beginners", you should rather look into "real" OO designs; based on the SOLID principles. In that sense: design real classes that exactly model your problem domain; and that provide helpful abstractions. A struct with an arbitrary number of members ... doesn't fall into either category.

Answer 2

The problem here is not the code necessarily but the design. I would be interested to know the real world use case you are trying to design here.

Surely there are limitations in the second approach like you cannot update the value of your objects at all once your class is created as you just have a way to get the value of the passed objects back.

Coming back to Design:

An interface is supposed to be an action which your class can perform if it implements that interface. In your case you are trying to return the value of two instance variables using the two methods in your interface which is a kind of action but it ignores the basic principle of encapsulation.

If your class defines/owns those instance variables it should have the getters and setters for that. You should not require an interface to do that. So ideally your interface should not be required. Any other class which uses MyClass1 object should directly use the getters and setters of the MyClass1.