Private constructor in Kotlin

In Java it's possible to hide a class' main constructor by making it private and then accessing it via a public static method inside that class:

public final class Foo {
	/* Public static method */
	public static final Foo constructorA() {
		// do stuff
		
		return new Foo(someData);
	}
	
	private final Data someData;
	
	/* Main constructor */
	private Foo(final Data someData) {
		Objects.requireNonNull(someData);
		
		this.someData = someData;
	}
	
	// ...
}

How can the same be reached with Kotlin without separating the class into a public interface and a private implementation? Making a constructor private leads to it not being accessible from outside the class, not even from the same file.

You can even do something more similar to "emulating" usage of public constructor while having private constructor.

class Foo private constructor(val someData: Data) {
    companion object {
        operator fun invoke(): Foo {
            // do stuff

            return Foo(someData)
        }
    }
}

//usage
Foo() //even though it looks like constructor, it is a function call

This is possible using a companion object:

class Foo private constructor(val someData: Data) {
	companion object {
		fun constructorA(): Foo {
			// do stuff
			
			return Foo(someData)
		}
	}
	
	// ...
}

Methods inside the companion object can be reached just like if they were members of the surrounding class (e.g. Foo.constructorA())

See kotlin documentation here:

https://kotlinlang.org/docs/reference/classes.html#constructors

https://kotlinlang.org/docs/reference/visibility-modifiers.html#constructors

class DontCreateMe private constructor () { /*...*/ }

This is the Answer

class Hide private constructor(val someData: Data) {

}

By declaring the constructor private, we can hiding constructor.