面向对象的对象转换器设计模式

Question

I was wondering what the best OOP design pattern should be put in place for my scenario.

The scenario:

I have two classes, ClassA & ClassB. I want to convert ClassA into a new ClassB, however, ClassA may change its member variables & methods. This means that one may have to update the way ClassA is translated into ClassB.

What would be the best OOP design to go about facilitating this translation from ClassA to a new ClassB?

The goal:

Create a design pattern that will allow to easily change the way ClassA will be translated to ClassB.

Example:

ClassA

public class ClassA {
    private String actionName;

    // With some getters & setters
}

ClassB

public class ClassB {
    private String action; // Note the subtle difference

    // With some getters & setters
}

Handler

public class Handler {
    ClassB classB = new ClassB();

    // Convert ClassB to ClassA

    This.publish(ClassA);
}

Answer 1

You need a type that has a knowledge of all the members of both ClassA and ClassB. It is a bad idea to couple either ClassA or ClassB to each other, so you would normally see a third type that implements an interface like this:

interface Converter<T, R> {
  R convert(T obj);
}

You could implement this interface for your classes:

class AtoBConverter implements Converter<ClassA, ClassB> {
  public ClassB convert(ClassA obj) {
    ...
  }
}

This assumes that ClassA has public methods that allow you to examine its state and ClassB has a constructor/setters that allow you to modify its state. Strictly speaking if all three classes are in the same java package you could have those methods/constructors declared package private.

Answer 2

use constructor with params (ClassA) for ClassB and vise versa

ClassA(ClassB object){
...
}

Answer 3

You should definitely opt for a separate handler class to deal with this conversion.

As a little optimization, you could have static api's on this handler class so that whenever you wish to perform a conversion between two objects you don't have to instantiate an instance of the handler class as well.

For example:

Say you need to convert an object of Type A to an object of Type B. Your converter could look like

class AToBConverter {
    
   public static B convert(A objA){
       //business logic to convert objA to objB
       return objB;
   } }

The advantage here is that whenever you need to convert object of type A to B you can simply do :

B objB = AToBConverter.convert(objA); //Note how we don't need to create an instance of the converter