Looking for a pattern to solve double-sided dependency

Question

Hi,
i'm facing a problem in which i have the following code:
public class A {
       public B createB(Class<? extends B> kindOfB, String information1, int information2, Object information3, int information4) {
              if (kindOfB.equals(B1.class)
                 return new B1(information1);
              if (kindOfB.equals(B2.class)
                 return new B2(information2);
              if (kindOfB.equals(B3.class)
                 return new B3(information3, information4);
              throw UnsupportedKindOfBException();
public class B {}
public class B1 extends B {
       public B1(String information1) {}
public class B2 extends B {
       public B2(int information2) {}
public class B3 extends B {
       public B2(Object information3, int information4) {}
}I'm looking for a way to convert this dirty code into something nice, anyone thinking of a pattern that could help me to do that? or maybe reflection could save me?
Thanks a lot

Answer 1

I was thinking about the abstract factory pattern, the class A is a factory for objects of type B.
But then I saw that each subclass of B is created with different types of objects.
If this is really what you want, my guess is that you first should put all these arguments in a separate class:
     public class Data {
          private String information1;
          private int information2;
          private Object information3;
          private int information4;
          // Omitted constructors and getters/setters
     }Then there are several ways you could proceed.
One way would be to throw away class A and simply create constructors in each Bi class which takes a Data object:
     public class B {}
     public class B1 extends B {
            public B1(Data data) {
                 this.information = data.getInformation1();
     public class B2 extends B {
            public B2(Data data) {
                 this.information = data.getInformation2();
     public class B3 extends B {
            public B2(Data data) {
                 this.information1 = data.getInformation3();
                 this.information2 = data.getInformation4();
     }The drawback of this is that each Bi gets coupled to the Data object of which it does not need everything.
So another way would be to keep Bi untouched and similar to what you had, but now replacing the parameters in A with the Data object:
     public class A {
            public B createB(Class<? extends B> kindOfB, Data data) {
                   if (kindOfB.equals(B1.class)
                      return new B1(data.getInformation1());
                   if (kindOfB.equals(B2.class)
                      return new B2(data.getInformation2());
                   if (kindOfB.equals(B3.class)
                      return new B3(data.getInformation3(), data.getInformation4());
                   throw UnsupportedKindOfBException();
     }Depending on your use case you can indeed refactor this to use the abstract factory pattern:
     public interface BFactory {
            B createB(Data data);
     public class B1Factory implements BFactory {
          public B createB(Data data) {
               return new B1(data.getInformation1());
     public class B2Factory implements BFactory {
          public B createB(Data data) {
               return new B2(data.getInformation2());
     public class B3Factory implements BFactory {
          public B createB(Data data) {
                return new B3(data.getInformation3(), data.getInformation4());
     }     This works particularly well if you have code that needs to create only one type of B at a time but it doesn't matter which type:
public class BStructureBuilder(BFactory bFactory) {
     createSomething(List<Data> datas) {
         someStructure.add(bFactory.createB(datas.get(i)));
}It has the added advantage that you can never request a B that doesn't exists because if class B4 comes along you would have to write a B4factory. Again depending on your usecase this can be a maintenance nightmare, so let me know if this helps and if it doesn't we could try to think of another pattern...