Can a Java object factory be used as a constructor?

Question

I'm pretty new to Java so hopefully this question isn't too stupid.

According to the Java documentation: "An object factory is a producer of objects. It accepts some information about how to create an object, such as a reference, and then returns an instance of that object."

How can that instance be the result of a constructor?

Here is some (totally pointless) example code that illustrates the class hierarchy I'm trying to construct (invoking it with simple integer arguments like "1 2 3" will get the point across):

package number;

public class Factory {
    public static void main(String[] args) {
        for (String arg : args) {
            // This is how I want to instantiate and use the Outer class:
            Outer outer = new Outer(arg);
            // But I don't know how to create Outer from the factory, and the results are wrong:
            System.out.println("yields: " + outer.value + ", class: " + outer.Class());
            // This is a workaround (that I can't use) that gives the correct results:
            Number number = outer.Workaround(arg);
            System.out.println("yields: " + number.value + ", class " + number.Class());
        }
    }
}

class Outer extends Inner {
    Outer(String arg) {
        super(arg);
    }
}

class Inner extends Number {
    Inner(String arg) {
        // I don't want to do this:
        super(arg);
        // I want some way of doing this:
        // return NumberFactory.getNumber(arg);
    }
    // Workaround method that I can't really use:
    Number Workaround(String arg) {
        return NumberFactory.getNumber(arg);
    }
}

class NumberFactory {
    static Number getNumber(String selection) {
        switch (selection) {
            case "1":  return new First(selection);
            case "2":  return new Second(selection);
            default:   return new Other(selection);
        }
    }
}

class First extends Number {
    First(String arg) { super(arg);  value = "first"; }
    String Class() { return "First"; }
}

class Second extends Number {
    Second(String arg) { super(arg);  value = "second"; }
    String Class() { return "Second"; }
}

class Other extends Number {
    Other(String arg) { super(arg);  value = "other"; }
    String Class() { return "Other"; }
}

class Number {
    String arg;
    String value = "default";
    Number(String arg) {
        this.arg = arg;
        System.out.print("Number(" + arg + "), ");
    }
    String Class() { return "Number"; }
}

Answer 1

please explain what you are trying to do.

but here's my attempt to answer your question.

Constructor is used when ever a new Java Object is created. When you use new SomeObject() compiler uses the constructor

SomeObject(){ 
    // some logic here
}

to create an object using the SomeObject.class. How the object is created and maintained through its life-cycle is up to the JVM. you can find more info here. https://en.wikibooks.org/wiki/Java_Programming/Object_Lifecycle

Also object factories are used to create objects, but in turn they use object constructors to instantiate the object inside them (as you have already done so). Object factories are used to delegate the logic of object creation to a central location, so that the code is not repeated and well organized. Read more about object factories here https://github.com/iluwatar/java-design-patterns/tree/master/abstract-factory

another thing you dont have to implement String Class() method inside every class you implement. SomeObject.class.toString() will do it for you.

Answer 2

I couldn't understand your main question because java object factory is java's business and I don't think we can do anything with it, although I can try to answer your question regarding instances and constructor.....

Constructors in java are the way you talk to a class, even when you don't define a constructor of a class, a default constructor with default values(i.e., false for boolean etc.) is created for your class by the compiler.....So, I guess when you want specific way of creating a connection with your class then you make specific constructors otherwise a default is always made available by the compiler.

Maybe you want to ask why do we have to use super() before anything in a subclass constructor and the reason for that is again same i.e., The parent class' constructor needs to be called before the subclass' constructor. This will ensure that if you call any methods on the parent class in your constructor, the parent class has already been set up correctly.