Introduction
The main() method is probably one of the most familar structures in the Java language. It can easily be auto-generated in Eclipse by typing “main” followed by Ctrl-Space and in NetBeans by typing “psvm” followed by a space. It’s the entry point into thousands of applications and while it’s familiar, it also has a few hidden secrets. In this article we’ll look at more than a dozen variations of the main() method. Some will compile and run as expected. Others will not compile at all. Still others will compile and run, but can’t be used as an entry point into an application.The Methods
Look at the methods below. Which ones will not compile? Which ones will compile, but can’t be used as entry points into an application? Which ones compile and act as you would expect a main method to act?
public static void main(String[] args) {
System.out.println("Main1!");
}
public static void main(String[] someOtherName) {
System.out.println("Main2!");
}
public static void main(String... args) {
System.out.println("Main3!");
}
public static void main(String[] args)
throws Exception {
System.out.println("Main4!");
}
static void main(String[] args) {
System.out.println("Main5!");
}
public void main(String[] args) {
System.out.println("Main6!");
}
public static void main(String args[]) {
System.out.println("Main7!");
}
public static void main(String[] args[]) {
System.out.println("Main8!");
}
public static void main(String[][] args) {
System.out.println("Main9!");
}
public static void main(String args) {
System.out.println("Main10!");
}
public static void main(String[] args)
throws IOException {
System.out.println("Main11!");
}
static public void main(String[] args) {
System.out.println("Main12!");
}
public strictfp static void main(String[] args) {
System.out.println("Main13!");
}
void public static main(String[] args) {
System.out.println("Main14!");
}
public static void main(int[] args) {
System.out.println("Main15!");
}
public static void main(String[] args) {
System.out.println("Main16!");
}
public static void Main(String[] args) {
System.out.println("Main17!");
}
The Answers
/**
* Fine.
*
* This is the most common form of the main method.
*/
public static void main(String[] args) {
System.out.println("Main1!");
}
/**
* Fine.
*
* This is the most common form of the main method except
* that the variable accepting command line arguments has
* been renamed to someOtherName. The name of the variable
* is insignificant.
*/
public static void main(String[] someOtherName) {
System.out.println("Main2!");
}
/**
* Fine.
*
* Varargs form of the main method. New with Java 5.
*/
public static void main(String... args) {
System.out.println("Main3!");
}
/**
* Fine.
*
* This is the most common form of the main method, except
* that it throws an exception. This is completely valid.
*/
public static void main(String[] args)
throws Exception {
System.out.println("Main4!");
}
/**
* Compiles, but cannot be executed from the command line.
*
* Method must be public.
*
* Since the signature doesn't match it's a completely
* different method that just happens to be called main.
*
*/
static void main(String[] args) {
System.out.println("Main5!");
}
/**
* Compiles, but cannot be executed from the command line.
*
* Method must be static.
*
* Since the signature doesn't match it's a completely
* different method that just happens to be called main.
*
*/
public void main(String[] args) {
System.out.println("Main6!");
}
/**
* Fine.
*
* This is the most common form of the main method
* except that the square
* brackets for the String array have been put beside
* the variable. This is valid, but many think, harder
* to read.
*/
public static void main(String args[]) {
System.out.println("Main7!");
}
/**
* Although the syntax is strange, this compiles, but
* cannot be executed from the command line.
*
* This is the most common form of the main method, but
* the square brackets for the args array are beside the
* type as well as beside the args variable. They should
* be beside one or the other, not both.
*
* While I would have guessed that this would not
* compile at all, it turns out that this is equivalent
* to main taking a two-dimensional array as a parameter.
* String[] args[] is the same as String[][] args or String
* args[][]. While it's certainly valid for a method to
* accept a two-dimensional array of Strings, this does
* not fit the required signature for a main method
* that is to be invoked from the command line. Attempting
* to execute this will result in the following error
* message: Exception in thread "main"
* java.lang.NoSuchMethodError: main
*
*/
public static void main(String[] args[]) {
System.out.println("Main8!");
}
/**
* Compiles, but cannot be executed from the command line.
*
* The main() method needs to accept an array of Strings
* as a parameter. The method below accepts a
* two-dimensional array of Strings.
*
* Since the signature doesn't match it's a completely
* different method that just happens to be called main.
*
*/
public static void main(String[][] args) {
System.out.println("Main9!");
}
/**
* Compiles, but cannot be executed from the command
* line.
*
* The main() method needs to accept an array of Strings
* as a parameter. The method below accepts a single
* String called args.
*
* Since the signature doesn't match it's a completely
* different method that just happens to be called main.
*
*/
public static void main(String args) {
System.out.println("Main10!");
}
/**
* Fine.
*
* Throwing a checked exception, like IOException,
* is legal.
*
*/
public static void main(String[] args)
throws IOException {
System.out.println("Main11!");
}
/**
* Fine.
*
* This is the most common form of the main method except
* that static and public keywords are reversed. Their
* order does not matter.
*
*/
static public void main(String[] args) {
System.out.println("Main12!");
}
/**
* Fine.
*
* It's perfectly acceptable to have a strictfp main
* method.
*
*/
public strictfp static void main(String[] args) {
System.out.println("Main13!");
}
/**
* Does not compile.
*
* The return type (void in this case) must come
* immediately before the method name.
*
*/
void public static main(String[] args) {
System.out.println("Main14!");
}
/**
* Compiles, but cannot be run from the command line.
*
* The main() method must accept an array of Strings,
* not ints, as a parameter.
*
* Since the signature doesn't match it's a completely
* different method that just happens to be called main.
*
*/
public static void main(int[] args) {
System.out.println("Main15!");
}
/**
* Fine.
*
* This is the most common form of the main method
* except that there aren't any spaces between the
* type, the square brackets and the variable name.
* It's still legal.
*
*/
public static void main(String[] args) {
System.out.println("Main16!");
}
/**
* Compiles, but cannot be run from the command line.
*
* The main() method must be all lower case.
*
* Since the signature doesn't match it's a completely
* different method that just happens to be called main.
*
*/
public static void Main(String[] args) {
System.out.println("Main17!");
}
So why would you want to know so much about the main() method anyway? Well, besides being essential if you’re taking the Sun Certified Java Programmer (SCJP) exam, there are a few alternate formulations of the method that might come in handy. Plus, with the examples above it mind, I bet you’ll spot a flawed main() method quicker than most if you come across one.