How do I make a constuctor available to only the factory class?

Question

Ok, the question might not be crystal clear. Let me give some details:

Let's say I have an Shoe (CShoe) object factory class called CFactory. CFactory is a singleton class that creates and stores all instanciated shoes using a simple hashmap. It is then accessed through static methods to use the created objects.

Is there a way to force CShoe's constructor so that it can only called by the factory? (in other words, ensure that the creation of shoes can only be done by the shoes factory singleton class and not by other classes)

Answer 1

You could give the CShoe constructor package access, and put both CShoe and CFactory in the same package.

Answer 2

Since you want to add each object to the map you could as well move this logic to the CShoe constructor - the object will add itsself.

Answer 3

public class MyClass{

    // Package constructor
    MyClass(){

    }

}

By making the constructor with default access level only other classes in the same package will be able to invoke it. That's as close as you'll get.

Answer 4

You could perhaps pass the factory object into the constructor?

public CShoe(CFactory factory)
{
    if (factory == null ||
          !factory.isValid()) // or whatever
    {
        throw new IllegalArgumentException();
    }
}

Answer 5

You could make Shoe an inner class of ShoeFactory:

public class ShoeFactory {

    public static class Shoe {
     private String name;

     private Shoe() {
     }

     private Shoe(String name) {
      this.name = name;
     }
    }

    public static Shoe createShoe(String shoeName) {
     return new Shoe(shoeName);
    }
}

I think this pretty much covers all the cases except .... reflection:

public class SmellyShoe {

    public static void main(String[] args) {
     try {
      java.lang.reflect.Constructor c = Shoe.class.getDeclaredConstructors()[0];
      c.setAccessible(true);
      Shoe smelly = (Shoe)c.newInstance(null);
      // grr
     } catch (InstantiationException e) {
      e.printStackTrace();
     } catch (IllegalAccessException e) {
      e.printStackTrace();
     } catch (IllegalArgumentException e) {
      e.printStackTrace();
     } catch (InvocationTargetException e) {
      e.printStackTrace();
     }
    }
}

Answer 6

Couldn't you just pass the caller instance as argument of a static member of shoe and in there do a check like "isInstanceOf" which calls the constructor if true?

Answer 7

Firstly, if you retain all created instances, that's known as a leak. I'll carry on assuming you mean a non-strong reference, bounded or some such cache, and also that Shoe is immutable.

Simply use a static method to return the factory.

public final class Shoe implements Footwear {
    private static final FootwearFactory<Shoe,Something> FACTORY =
        new FootwearFactory<Shoe,Something>() {
            ...
            public Shoe get(Something value) {
                value = new Something(value);
                ...
                return new Show(value);
            }
        };
    private static FootwearFactory<Shoe,Something> getFactory() {
        return FACTORY;
    }

    private final Something value;
    private Shoe(Something value) {
        this.value = value;
    }
    ...
}