避免函数参数操作的最佳实践

Question

I have the following abstract code snippet:

// definitions
    MyClass1 mc1 = new MyClass1();
    MyClass2 mc2 = new MyClass2();
    List<String> elements = new ArrayList<>();

// some black magic...

// setters based on condition 0
    mc2.setElements(elements);
    String id = saveMyClass2(mc2)
    mc1.setMc1Id(id);

// Some other business black magic

// setters based on condition 1
    mc2.setElements(elements);
    String id = saveMyClass2(mc2)
    mc1.setMc1Id(id);

// Some other business black magic

// setters based on condition 2
    mc2.setElements(elements);
    String id = saveMyClass2(mc2)
    mc1.setMc1Id(id);

I'm using the setters flow in multiple parts of my code. I wanted to elaborate this by a wrapper function like this:

void doSettings(MyClass1 mc1, MyClass2 mc2, List<String> elements) {
        mc2.setElements(elements);
        String id = saveMyClass2(mc2)
        mc1.setMc1Id(id);
}

But I am doing a parameter manipulation in this function which I want to avoid. Also cloning the classes is not an option, they are 3 layers deep and it takes too much effort to create deep copy.

So do you know any best practice or coding pattern which helps to avoid code duplication?

Answer 1

One really good way of doing this is to use an Immutable decorator. The Immutable pattern is a wrapper around the primary object that prevents changes to the underlying data. These exist out of the box for the Collections using the Unmodifable concept:

 String[] array = ... ;
 List<String[]> list = List.<String[]>of(array);

or copyOf() in the case of another collection:

 List<String> mylist = ...;
 List<String> unmodifableList = List.copyOf(mylist);

For the other objects that you are defining, you might want to create a subclass that throws UnsupportedOperationException when a mutator is called.

class UnmodifiableMyClass1 extends MyClass1 {
    UnmodifiableMyClass1( MyClass1 copy) {
        // do copy constructor stuff here 
        // (probably just referencing the primary object)
    }
    @override void setMc1Id( int id ) {
        throw new UnsupportedOperationException("nope");
    }
}

MyClass1 mc1 = new MyClass1();
UnmodifiableMyClass1 umc1 = new UnmodifiableMyClass1(mc1);

of course, it's best if you can do this on interfaces instead of implementations, because there's less need to maintain the object state, but you gotta work with what you have, and you didn't mention having interfaces for MyClass{1,2} .