Question

I am trying to learn Java now and this is the hello world program and it already have started to baffle me. I am used to python and I found this tutorial (ebook) simple and concise for programmers who have python background.

Hello world program in Java from the book:

public class Hello {

public static void main (String[] args) {

     System.out.println("Hello World!");
}
}

As the book says, the equivalent code for this in python is:

class Hello(object):
  @staticmethod
  def main(args):
     print "Hello World!"

I completely understand the python code. However, I have a problem with Java code and I want to be clear before I proceed further so that I get the root knowledge of language in my brain.

The book says (as copied from book):

…we have one parameter. The name of the parameter is args however,
because everything in Java must have a type we also have to tell the
compiler that the value of args is an array of strings. For the moment
You can just think of an array as being the same thing as a list in
Python. The practical benefitt of declaring that the method main must
accept one parameter and the parameter must be a an array of strings
is that if you call main somewhere else in your code and and pass it
an array of integers or even a single string, the compiler will flag
it as an error.

This does not make any sense to me. Why can I not pass anything since my function doesn’t require anything? What happens if I just pass (String args).

Since I am completely newbie to Java, please bear with me.

Answer 1

As you know, Python uses “duck typing”: it doesn’t matter what type something is, only what it can do. As a result, you never need to declare types for your variables.

In Java, that’s not true: every variable has a declared type, and the compiler enforces that type. Trying to store, for example, a String reference in an int-declared variable will produce a compile-time error. Proponents of duck typing claim that this decreases flexibility, but strong-typing enthusiasts point out that compile-time errors are easier to fix than run-time bugs.

But the same is true of your method arguments. Since your method requires an argument of type String[], it must be provided an argument of type String[]. Nothing else will do.

Fortunately, since it’s the main method, the Java interpreter takes care of passing in an argument: specifically, an array of the command-line args with which your program was executed. If you’d like to ignore it, feel free. Your program will run just fine without paying attention to the argument, but it’s invalid if one isn’t passed in.

(By the way, if this were any method but the main method, you’d be free to declare it with whatever argument types you’d like, including no arguments at all. But since the Java interpreter will be passing in an array of the command line arguments, this particular method must be prepared to accept them.)