Object-oriented – Should main method be only consists of object creations and method calls

object-orientedprogramming practices

A friend of mine told me that, the best practice is class containing main method should be named Main and only contains main method. Also main method should only parse inputs, create other objects and call other methods. The Main class and main method shouldn't do anything else. Basically what he is saying that class containing main method should be like:

public class Main
{
    public static void main(String[] args)
    {
        //parse inputs
        //create other objects
        //call methods
    }
}

Is it the best practice?

Best Answer

The point your friend is making is that an application should merely be bootstrapped by the main method, and nothing more. By having the main method in its own class, you are simply reinforcing that fact by keeping it independent of any application logic. The role of the main method would be to parse any inputs and to initialize the application with those, and possibly other, inputs.

public static void main(String[] args){
    new Foo().start(args[0]);
}

The idea is that you don't need the main method in order to initialize Foo. This allows you to easily initialize and start Foo in another context, potentially with different semantics.

public Foo initSomewhereElse(String arg){
    Foo f = new Foo();
    f.start(arg);
    return f;
}

Related Solutions

Java Programming – When is Method Overloading Appropriate?

You overload when you wish to support different types:

public overload void MyMethod(int value)
{ 
}

public overload void MyMethod(bool value)
{
}

public overload void MyMethod(string value)
{
}

or to support a progressive interface using different parameter lists:

public overload void MyOtherMethod()
{
    this.MyOtherMethod(DefaultValue);
}

public overload void MyOtherMethod(int value)
{
    this.MyOtherMethod(value, DefaultOtherValue);
}

public overload void MyOtherMethod(int value, bool otherValue)
{
    ...
}

You might even get a little crazy and support both different types AND a progressive interface, but you should bear in mind that you need to avoid creating variations in behaviour between overloaded methods. Each overloaded method should be functionally the same as the others in an overloaded group, otherwise it will be unclear as to how, when or why behaviour is being varied. If you want two functions to do something completely different, then you should name them accordingly.

Best Practices for Returning Read-Only Objects in C#

Besides @Jesse's answer, which is the best solution for collections: the general idea is to design your public interface of A in a way so that it does return only

value types (like int, double, struct)
immutable objects (like "string", or user defined classes which offer only read-only methods, just like your class A)
(only if you must): object copies, like your "Option B" demonstrates

IEnumerable<immutable_type_here> is immutable by itself, so this is just a special case of the above.

Best Answer

Related Solutions

Java Programming – When is Method Overloading Appropriate?

Best Practices for Returning Read-Only Objects in C#

Related Topic