Basics

In this part of the Java tutorial, we will cover some basic programming concepts of the Java language. We begin with some simple programs. We will work with variables, constants, and basic data types. We will read and write to console. We will also mention string formatting.

We start with a very simple code example. The following code is placed into the Simple.java file. The naming is important here. A public class of a Java program must match the name of the file.

Simple.java
package com.zetcode;

public class Simple {

    public static void main(String[] args) {
        
        System.out.println("This is Java");
    }
}

Java code is strictly organized from the very beginning. A file of a Java code may have one or more classes, out of which only one can be declared public.

package com.zetcode;

Packages are used to organize Java classes into groups, which usually share similar functionality. Packages are similar to namespaces and modules in other programming languages. For a simple code example, a package declaration may be omitted. This will create a so called default package. However, in this tutorial we will use a package for all examples. Another important thing is that a directory structure must reflect the package name. In our case the source file Simple.java with a package com.zetcode must be placed into a directory named com/zetcode/. The package statement must be the first line in the source file.

public class Simple {

   ...
}

A class is a basic building block of a Java program. The public keyword gives unrestricted access to this class. The above code is a class definition. The definition has a body that starts with a left curly brace { and ends with a right curly brace }. Only one class can be declared public in a source file. Also note the name of the class. Its name must match the file name. The source file is called Simple.java and the class Simple. It is a convention that the names of classes start with an uppercase letter.

public static void main(String[] args) {
    ...
}

The main() is a method. A method is a piece of code created to do a specific job. Instead of putting all code into one place, we divide it into pieces called methods. This brings modularity to our application. Each method has a body in which we place statements. The body of a method is enclosed by curly brackets. The specific job for the main() method is to start the application. It is the entry point to each console Java program. The method is declared to be static. This static method can be called without the need to create an instance of the Java class. First we need to start the application and after that we are able to create instances of classes. The void keyword states that the method does not return a value. Finally, the public keyword makes the main() method available to the outer world without restrictions. These topics will be later explained in more detail.

System.out.println("This is Java");

In the main() method, we put one statement. The statement prints the "This is Java", which is a string literal, to the console. Each statement must be finished with a semicolon ; character. This statement is a method call. We call the println() method of the System class. The class represents the standard input, output, and error streams for console applications. We specify the fully qualified name of the println() method.

$ pwd
/home/janbodnar/programming/java/basics/simple
$ javac com/zetcode/Simple.java

Java source code is placed into files with the .java extension. The javac tool is the Java compiler. We compile the Java source into Java classes. Note the directory structure. The structure must match the Java package.

$ ls com/zetcode/
Simple.class  Simple.java  Simple.java~

After we compile the source, we get a Java class file with the .class extension. It contains a Java bytecode which can be executed on the Java Virtual Machine (JVM). Simple.class is a Java program which can be executed with the java tool.

$ java com.zetcode.Simple 
This is Java

We execute the program with the java tool. The java tool launches a Java application. It does this by starting a Java runtime environment, loading a specified class, and invoking that class's main method. The parameter to the java tool is the fully qualified name of the Java class. Note that the .class extension is omitted.

Reading values

The second example will show, how to read a value from a console.

ReadLine.java
package com.zetcode;

import java.util.Scanner;

public class ReadLine {

    public static void main(String[] args) {
        
        System.out.print("Write your name:");

        Scanner sc = new Scanner(System.in);
        String name = sc.nextLine();

        System.out.println("Hello " + name);
    }
}

A prompt is shown on the terminal window. The user writes his name on the terminal and the value is read and printed back to the terminal.

import java.util.Scanner;

The Java standard library has a huge collection of classes available for programmers. They are organized inside packages. The Scanner class is one of them. When we import a class with the import keyword, we can refer later to the class without the full package name. Otherwise, we must use the fully qualified name. The import allows a shorthand referring for classes. This is different from some other languages. For instance in Python, the import keyword imports objects into the namespace of a script. In Java, the import keyword only saves typing by allowing to refer to types without specifying the full name.

System.out.print("Write your name:");

We print a message to the user. We use the print() method which does not start a new line. The user then types his response next to the message.

Scanner sc = new Scanner(System.in);

A new instance of the Scanner class is created. New objects are created with the new keyword. The constructor of the object follows the new keyword. We put one parameter to the constructor of the Scanner object. It is the standard input stream. This way we are ready to read from the terminal. The Scanner is a simple text scanner which can parse primitive types and strings.

String name = sc.nextLine();

Objects have methods which perform certain tasks. The nextLine() method reads the next line from the terminal. It returns the result in a String data type. The returned value is stored in the name variable which we declare to be of String type.

System.out.println("Hello " + name);

We print a message to the terminal. The message consists of two parts. The "Hello " string and the name variable. We concatenate these two values into one string using the + operator. This operator can concatenate two or more strings.

$ java com.zetcode.ReadLine 
Write your name:Jan Bodnar
Hello Jan Bodnar

This is a sample execution of the second program.

Command line arguments

Java programs can receive command line arguments. They follow the name of the program when we run it.

CommandLineArgs.java
package com.zetcode;

public class CommandLineArgs {

    public static void main(String[] args) {
        
        for (String arg : args) {
            
            System.out.println(arg);
        }
    }
}

Command line arguments can be passed to the main() method.

public static void main(String[] args)

The main() method receives a string array of command line arguments. Arrays are collections of data. An array is declared by a type followed by a pair of square brackets []. So the String[] args construct declares an array of strings. The args is an parameter to the main() method. The method then can work with parameters which are passed to it.

for (String arg : args) {
    
    System.out.println(arg);
}

We go through the array of these arguments with a for loop and print them to the console. The for loop consists of cycles. In this case, the number of cycles equals to the number of parameters in the array. In each cycle, a new element is passed to the arg variable from the args array. The loop ends when all elements of the array were passed. The for statement has a body enclosed by curly brackets {}. In this body, we place statements that we want to be executed in each cycle. In our case, we simply print the value of the arg variable to the terminal. Loops and arrays will be described in more detail later.

$ java com.zetcode.CommandLineArgs 1 2 3 4 5
1
2
3
4
5

We provide four numbers as command line arguments and these are printed to the console.

When we launch programs from the command line, we specify the arguments right after the name of the program. In Integraged Development Environments (IDE) like NetBeans, we specify these parameters in a dialog. In NetBeans, we right click on the project and select Properties. From the Categories list, we select the Run option. In the Arguments edit control, we write our arguments.

Command line arguments
Figure: Command line arguments

Variables

A variable is a place to store data. A variable has a name and a data type. A data type determines what values can be assigned to the variable. Integers, strings, boolean values etc. Over the time of the program, variables can obtain various values of the same data type. Variables in Java are always initialized to the default value of their type before any reference to the variable can be made.

Variables.java
package com.zetcode;

public class Variables {

    public static void main(String[] args) {
        
        String city = "New York";
        String name = "Paul"; int age = 34;
        String nationality = "American";

        System.out.println(city);
        System.out.println(name);
        System.out.println(age);
        System.out.println(nationality);

        city = "London";
        System.out.println(city);
    }
}

In the above example, we work with four variables. Three of the variables are strings. The age variable is an integer. The int keyword is used to declare an integer variable.

String city = "New York";

We declare a city variable of the string type and initialize it to the "New York" value.

String name = "Paul"; int age = 34;

We declare and initialize two variables. We can put two statements into one line. Since each statement is finished with a semicolon, the Java compiler knows that there are two statements in one line. But for readability reasons, each statement should be on a separate line.

System.out.println(city);
System.out.println(name);
System.out.println(age);
System.out.println(nationality);

We print the values of the variables to the terminal.

city = "London";
System.out.println(city);

We assign a new value to the city variable and later print it.

$ java com.zetcode.Variables 
New York
Paul
34
American
London

This is the output of the example.

Constants

Unlike variables, constants cannot change their initial values. Once initialized, they cannot be modified. Constants are created with the final keyword.

Constants.java
package com.zetcode;

public class Constants {

    public static void main(String[] args) {
        
        final int WIDTH = 100;
        final int HEIGHT = 150;
        int var = 40;

        var = 50;
        
        //WIDTH = 110;        
    }
}

In this example, we declare two constants and one variable.

final int WIDTH = 100;
final int HEIGHT = 150;

We use the final keyword to inform the compiler that we declare a constant. It is a convention to write constants in uppercase letters.

int var = 40;

var = 50;

We declare and initialize a variable. Later, we assign a new value to the variable. It is legal.

// WIDTH = 110;

Assigning new values to constants is not possible. If we uncomment this line, we will get a compilation error: "Uncompilable source code - cannot assign a value to final variable WIDTH".

String formatting

Building strings from variables is a very common task in programming. Java language has the System.format() method to format strings.

Some dynamic languages like Perl, PHP, or Ruby support variable interpolation. Variable interpolation is replacing variables with their values inside string literals. Java language does not allow this. It has string formatting instead.

StringFormatting.java
package com.zetcode;

public class StringFormatting {

    public static void main(String[] args) {
    
        int age = 34;
        String name = "William";

        String output = String.format("%s is %d years old.", name, age);
        
        System.out.println(output);
    }
}

In Java, strings are immutable. We cannot modify an existing string. We must create a new string from existing strings and other types. In the code example, we create a new string. We also use values from two variables.

int age = 34;
String name = "William";

Here we have two variables, one integer and one string.

String output = String.format("%s is %d years old.", name, age);

We use the format() method of the built-in String class. The %s and %d are control characters which are later evaluated. The %s accepts string values, the %d integer values.

$ java com.zetcode.StringFormatting 
William is 34 years old.

This is the output of the example.

This chapter covered some basics of the Java language.