Java Fundamentals Tutorial: Hello World

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

Classes and methods (including other flow-control structures) are always defined in blocks of code enclosed by curly braces ({ }).

All other statements are terminated with a semi-colon (;).

Java language is case-sensitive! This means that HelloWorld is not the same as helloworld, nor is String the same as string.

There is an generally accepted naming convention in the Java community to capitalize the names of Java classes and use the so-called CamelCase (or CamelHump) notation, where the first letter of each word is capitalized, but the words are joined together (i.e. no dashes or underscores).

	Note
	Java source files can be encoded in UTF-8 to support internationalized characters (even for class, method, and variable names). In most situations however, Java sources are stored in US-ASCII character set, and internationalized strings are loaded from external resource files.

Keywords goto and const are reserved, but never used.

Keyword strictfp was added in Java 1.2.

Keyword assert was added in Java 1.4.

Keyword enum was added in Java 1.5.

In addition to these 50 keywords, Java also defined three special literals: true, false, and null.

Keywords in our HelloWorld program are in bold:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

Identifiers in our HelloWorld program are in bold:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

Use the javac -help option to get a full list of available options:

Usage: javac <options> <source files>
where possible options include:
  -g                         Generate all debugging info
  -g:none                    Generate no debugging info
  -g:{lines,vars,source}     Generate only some debugging info
  -nowarn                    Generate no warnings
  -verbose                   Output messages about what the compiler is doing
  -deprecation               Output source locations where deprecated APIs are used
  -classpath <path>          Specify where to find user class files and annotation processors
  -cp <path>                 Specify where to find user class files and annotation processors
  -sourcepath <path>         Specify where to find input source files
  -bootclasspath <path>      Override location of bootstrap class files
  -extdirs <dirs>            Override location of installed extensions
  -endorseddirs <dirs>       Override location of endorsed standards path
  -proc:{none,only}          Control whether annotation processing and/or compilation is done.
  -processor <class1>[,<class2>,<class3>...]Names of the annotation processors to run; bypasses default discovery process
  -processorpath <path>      Specify where to find annotation processors
  -d <directory>             Specify where to place generated class files
  -s <directory>             Specify where to place generated source files
  -implicit:{none,class}     Specify whether or not to generate class files for implicitly referenced files
  -encoding <encoding>       Specify character encoding used by source files
  -source <release>          Provide source compatibility with specified release
  -target <release>          Generate class files for specific VM version
  -version                   Version information
  -help                      Print a synopsis of standard options
  -Akey[=value]              Options to pass to annotation processors
  -X                         Print a synopsis of nonstandard options
  -J<flag>                   Pass <flag> directly to the runtime system

You can view the generated byte-code, using the -c option to javap, the Java class disassembler. For example:

javap -c HelloWorld

Figure 2. Compiling and running a Java program

It is the Java virtual machine that provides the layer of insulation to Java programs so that they do not depend on the underlying operating system or hardware semantics.

This allows compiled Java applications to run on any platform that has a Java virtual machine written for it:

/**
 * My first class
 * @author student
 * @version 1.0
 */
public class HelloWorld {

    /**
     * Main method that runs when the program is started.
     * @param args command-line arguments
     */
    public static void main (String[] args) {
        /*
        This is how you can print to STDOUT
         */
        System.out.println("Hello World"); // don't forget the semi-colon

        /*
        System.out.println("I was also going to say...");
        System.out.println("but I changed my mind");
        */
    }
}

Applets and servlets do not have a main() method because they are run through template methods in the context of a framework. For example, a web container is responsible for instantiating a servlet object. It then invokes a standard set of methods defined by the Servlet class at appropriate points in the servlet lifecycle; for example, init() to initialize the servlet, doGet() to handle an HTTP GET message, destroy() when the web container is about to destroy the object, and so on. The parent class provides default implementations of these methods, but the derived servlet class can override any of the template methods to provide servlet-specific functionality.