- Let's look more closely at one of the simplest Java programs you can have - one that simply prints a message to console:
public class FirstSample {
public static void main(String[] args){
System.out.println("We will not use 'Hello, World!'");
}
}
- It is worth spending all the time you need to become comfortable with the framework of this sample; the pieces will recur in all applications. First and foremost,
Java is case sensitive.
If you made any mistakes in capitalization (such as typing
Main instead of
main), the program will not run.
- Now let's look at this source code line by line. The keyword
public is called an
access modifier; these modifiers control the level of access other parts of a program have to this code. The keyword
class reminds you that everything in a Java program lives inside a class. Class as a container for the program logic that defines the behavior of an applications. Classes are the building blocks with which all Java applications and applets are built. Everything in a Java program must be inside a class.
- Following the keyword
class is the name of the class. The rules for class names in Java are quite generous. Names must begin with a letter, and after that, they can have any combination of letters and digits. The length is essentially unlimited. You cannot use a Java reserved word (such as
public or
class) for class name.
- The standard naming convention (which we follow in the name
FirstSample) is the class names are nouns that start with an uppercase letter. If a name consists of multiple words, use an initial uppercase letter in each of the words.
- You need to make the file name for the source code the same as the name of the public class, with the extension
.java appended. Thus, you must store this code in a file called
FirstSample.java. (Again, case is important - don't use
firstsample.java).
- If you have named the file correctly and not made any typos in the source code, then when you compile this source code, you end up with a file containing the bytecodes for this class. The Java compiler automatically names the bytecode file
FirstSample.class and stores it in the same directory as the source file. Finally, launch the program by issuing the following command:
- Remember to leave off the
.class extension when the program executes, it simply display the string
We will not use 'Hello, World!' on the console.
- When you use
java ClassName to run a compiled, the Java virtual machine always starts execution with the code in the main method in the class you indicate. (The term "method" is Java-speak for a function). Thus, you must have a
main method in the source file for your class for your code to execute. You can, of course, add your own methods to a class and call them from the
main method.
* Node: According to the Java Language Specification, the
main method must be declared
public . However, several version of the Java launcher were willing to execute Java programs even when the
main method was not
public.
- Notice the braces { } in the source code. In Java, as in C/C++, braces delineate the parts (usually called blocks) in your program. In Java, the code for any method must be started by an opening brace '{ '{' and ended by a closing brace '}'.
- Brace styles have inspired an inordinate amount of useless controversy. We follow a style that lines up matching braces. As white space in irrelevant to the Java compiler, you can use whatever brace style you like. We will have more to say about the use of braces when we talk about the various kinds of loops.
- For now, don't worry about the keywords
static void - just think of them as part of what you need to get a Java program to compile. The point to remember for now is that every Java application must have a
main method that is declared in the following way:
public class ClassName
{
public static void main(String[] args)
{
program statements
}
}
- Next, turn your attention to this fragment:
{
System.out.println("We will not use 'Hello, World!'");
}
- Braces mark the beginning and end of the body of the method. This method has only one statement in it. As with most programming language, you can think of Java statements as sentences of the language. In Java, every statement must end with a semicolon. In particular, carriage returns do not mark the end of a statement, so statements can span multiple lines if need be.
- The body of the
main method contains a statement that outputs a single line of text to the console.
- Here, we are using the
System.out object and calling its
println method. Notice the periods used to invoke a method. Java uses the general syntax:
object.method(parameters) as its equivalent of a function call.
- In this case, we are calling the
println method and passing it a string parameter. The method displays the string parameter on the console. It when terminates the output line, so that each call to
println displays its output on a new line. Notice that Java, like C/C++, uses double quotes to delimit strings.
- Methods in Java, like function in any programming language, can use zero, one, or more parameters (some programmer call them arguments). Even if a method takes no parameters, you must still use empty parentheses. For example, a variant of the
println method with no parameters just prints a blank line. You invoke it with the call:
* Note: System.out also has a print method that doesn't add a newline character to the output. For example,
System.out.print("Hello"); prints
Hello without a newline.
* Example:
=> File: FirstSample.java
package com.webmobileaz;
public class FirstSample {
public static void main(String[] args){
System.out.println("We will not use 'Hello, World!'");
System.out.print("We will not use 'Hello, World!'");
System.out.println("We will not use 'Hello, World!'");
}
}
=> Result:
We will not use 'Hello, World!'
We will not use 'Hello, World!'We will not use 'Hello, World!'
View Example
DownLoad Example
