This is the convention I use. I mainly use c#, but java should be fairly similar.

For your specific example I would probably use Instance:

public class Robots { public static final Robot Instance = new Robot(); private Robots() { } } 

I tend to mostly use this for types where there is no fields, or any fields/properties are constants. But the Instance naming is also sometimes used for singletons. In any case you should ensure that the class is thread safe.

If you have some more complicated caching scheme I would suggest a separate factory class. This allow the factory to be injected:

public class RobotsFactory{ private Robots robotTrue; private Robots robotFalse; public Robots Get(bool myBool){ return myBool ? robotTrue : robotFalse; } 

For factory methods that actually create new objects, but may fail, take a long time, or use async code, I use Create, or possibly CreateAsync:

public class Robots { private Robots(Foo foo) {...} public async Task<Robots> CreateAsync(){ var foo = await GetFooAsync(); return new Robots(foo); } } 

For types that can be constructed in different ways using the same set of parameter types I tend to prefer FromX(...) methods. A typical case is an Angle type:

public class Angle{ private Angle(...){...} public static Angle FromRadians(double radians) {...} public static Angle FromDegrees(double degrees) {...} } 

This is the convention I use. I mainly use c#, but java should be fairly similar.

For your specific example I would probably use Instance:

public class Robots { public static final Robot Instance = new Robot(); private Robots() { } } 

I tend to mostly use this for types where there is no fields, or any fields/properties are constants. But the Instance naming is also sometimes used for singletons. In any case you should ensure that the class is thread safe.

If you have some more complicated caching scheme I would suggest a separate class, this allows more flexibility that is likely needed if you have some more complicated scheme. Normally this would be called a factory, but that implies the creation of objects. If that is not the intent I'm not sure about naming. Maybe "Repository"?

public class RobotsRepository{ private Robots robotTrue; private Robots robotFalse; public Robots Get(bool myBool){ return myBool ? robotTrue : robotFalse; } 

For factory methods that actually create new objects, but may fail, take a long time, or use async code, I use Create, or possibly CreateAsync:

public class Robots { private Robots(Foo foo) {...} public static async Task<Robots> CreateAsync(){ var foo = await GetFooAsync(); return new Robots(foo); } } 

For types that can be constructed in different ways using the same set of parameter types I tend to prefer FromX(...) methods. A typical case is an Angle type:

public class Angle{ private Angle(...){...} public static Angle FromRadians(double radians) {...} public static Angle FromDegrees(double degrees) {...} } 

This is the convention I use. I mainly use c#, but java should be fairly similar.

For your specific example I would probably use Instance:

public class Robots { public static final Robot Instance = new Robot(); private Robots() { } } 

I tend to mostly use this for types where there is no fields, or any fields/properties are constants. But the Instance naming is also sometimes used for singletons. In any case you should ensure that the class is thread safe.

For factory methods that actually create new objects, but may fail, take a long time, or use async code, I use Create, or possibly CreateAsync:

public class Robots { private Robots(Foo foo) {...} public async Task<Robots> CreateAsync(){ var foo = await GetFooAsync(); return new Robots(foo); } } 

For types that can be constructed in different ways using the same set of parameter types I tend to prefer FromX(...) methods. A typical case is an Angle type:

public class Angle{ private Angle(...){...} public static Angle FromRadians(double radians) {...} public static Angle FromDegrees(double degrees) {...} } 

This is the convention I use. I mainly use c#, but java should be fairly similar.

For your specific example I would probably use Instance:

public class Robots { public static final Robot Instance = new Robot(); private Robots() { } } 

I tend to mostly use this for types where there is no fields, or any fields/properties are constants. But the Instance naming is also sometimes used for singletons. In any case you should ensure that the class is thread safe.

If you have some more complicated caching scheme I would suggest a separate factory class. This allow the factory to be injected:

public class RobotsFactory{ private Robots robotTrue; private Robots robotFalse; public Robots Get(bool myBool){ return myBool ? robotTrue : robotFalse; } 

For factory methods that actually create new objects, but may fail, take a long time, or use async code, I use Create, or possibly CreateAsync:

public class Robots { private Robots(Foo foo) {...} public async Task<Robots> CreateAsync(){ var foo = await GetFooAsync(); return new Robots(foo); } } 

For types that can be constructed in different ways using the same set of parameter types I tend to prefer FromX(...) methods. A typical case is an Angle type:

public class Angle{ private Angle(...){...} public static Angle FromRadians(double radians) {...} public static Angle FromDegrees(double degrees) {...} }