Question

Computer languages, like human languages, have a lexical structure. A source code of a Java program consists of tokens. Tokens are atomic code elements. In Java we have comments, identifiers, literals, operators, separators, and keywords.

Java programs are composed of characters from the Unicode character set.

Comments

Comments are used by humans to clarify source code. There are three types of comments in Java.

Comment type	Meaning
// comment	Single-line comments
/* comment */	Multi-line comments
/** documentation */	Documentation comments

If we want to add some small comment we can use single-line comments. For more complicated explanations, we can use multi-line comments. The documentation comments are used to prepare automatically generated documentation. This is generated with the javadoc tool.

package com.zetcode;

/*
  This is Comments.java 
  Author: Jan Bodnar
  ZetCode 2013
*/

public class Comments {

  // Program starts here
  public static void main(String[] args) {

    System.out.println("This is Comments.java");
  }
}

Comments are ignored by the Java compiler.

/*
  This is Comments.java 
/*  Author: Jan Bodnar */
  ZetCode 2013
*/

Comments cannot be nested. The above code does not compile.

White space

White space in Java is used to separate tokens in the source file. It is also used to improve readability of the source code.

int i = 0;

White spaces are required in some places. For example between the int keyword and the variable name. In other places, white spaces are forbidden. They cannot be present in variable identifiers or language keywords.

int a=1;
int b = 2;
int c  =  3;

The amount of space put between tokens is irrelevant for the Java compiler.

Identifiers

Identifiers are names for variables, methods, classes or parameters. Identifiers can have alphanumerical characters, underscores and dollar signs ($). It is an error to begin a variable name with a number. White space in names is not permitted.

Identifiers are case sensitive. This means that Name , name or NAME refer to three different variables. Identifiers also cannot match language keywords.

There are also conventions related to naming of identifiers. The names should be descriptive. We should not use cryptic names for our identifiers. If the name consists of multiple words, each subsequent word is capitalized.

String name23;
int _col;
short car_age;

These are valid Java identifiers.

String 23name;
int %col;
short car age;

These are invalid Java identifiers.

The following program demonstrates that the variable names are case sensitive. Event though the language permits this, it is not a recommended practice to do.

package com.zetcode;

public class CaseSensitiveIdentifiers {

  public static void main(String[] args) {
    
    String name = "Robert";
    String Name = "Julia";

    System.out.println(name);
    System.out.println(Name);     
  }
}

Name and name are two different identifiers. In Visual Basic, this would not be possible. In this language, variable names are not case sensitive.

$ java com.zetcode.CaseSensitiveIdentifiers 
Robert
Julia

Literals

A literal is a textual representation of a particular value of a type. Literal types include boolean, integer, floating point, string, null, or character. Technically, a literal will be assigned a value at compile time, while a variable will be assigned at runtime.

int age = 29;
String nationality = "Hungarian";

Here we assign two literals to variables. Number 29 and string "Hungarian" are literals.

package com.zetcode;

public class Literals {

  public static void main(String[] args) {

    int age = 23;
    String name = "James";
    boolean sng = true;
    String job = null;
    double weight = 68.5;
    char c = 'J';

    System.out.format("His name is %s%n", name);
    System.out.format("His is %d years old%n", age);

    if (sng) {
      
      System.out.println("He is single");
    } else {
      
      System.out.println("He is in a relationship");
    }

    System.out.format("His job is %s%n", job);
    System.out.format("He weighs %f kilograms%n", weight);
    System.out.format("His name begins with %c%n", c);
  }
}

In the above example, we have several literal values. 23 is an integer literal. "James" is a string literal. The true is a boolean literal. The null is a literal that represents a missing value. 68.5 is a floating point literal. 'J' is a character literal.

$ java com.zetcode.Literals 
His name is James
His is 23 years old
He is single
His job is null
He weighs 68.500000 kilograms
His name begins with J

This is the output of the program.

Operators

An operator is a symbol used to perform an action on some value. Operators are used in expressions to describe operations involving one or more operands.

+  -  *  /  %  ^  &  |  !  ~
=  +=   -=   *=   /=   %=  ^=  ++  --
==   !=  <   >  &=  >>=   <<=   >=   <= 
||   &&  >>  <<  ?:

This is a partial list of Java operators. We will talk about operators later in the tutorial.

Separators

A separator is a sequence of one or more characters used to specify the boundary between separate, independent regions in plain text or other data stream.

[ ]   ( )   { }   ,   ;   . 

String language = "Java";

The double quotes are used to mark the beginning and the end of a string. The semicolon ; character is used to end each Java statement.

System.out.println("Java language");

Parentheses (round brackets) always follow a method name. Between the parentheses we declare the input parameters. The parentheses are present even if the method does not take any parameters. The System.out.println() method takes one parameter, a string value. The dot character separates the class name ( System ) from the member ( out ) and the member from the method name ( println() ).

int[] array = new int[5] { 1, 2, 3, 4, 5 };

The square brackets [] are used to denote an array type. They are also used to access or modify array elements. The curly brackets {} are also used to initiate arrays. The curly brackets are also used enclose the body of a method or a class.

int a, b, c;

The comma character separates variables in a single declaration.

Keywords

A keyword is a reserved word in Java language. Keywords are used to perform a specific task in the computer program. For example, to define variables, do repetitive tasks or perform logical operations.

Java is rich in keywords. Many of them will be explained in this tutorial.

abstract    continue    for       new       switch 
assert      default     goto      package     synchronized
boolean     do        if        private     this
break       double      implements    protected     throw
byte      else      import      public      throws
case      enum      instanceof    return      transient
catch       extends     int       short       try
char      final       interface     static      void
class       finally     long      strictfp    volatile
const       float       native      super       while

In the following small program, we use several Java keywords.

package com.zetcode;

public class Keywords {

  public static void main(String[] args) {

    for (int i = 0; i <= 5; i++) {
      
      System.out.println(i);
    }
  }
}

The package , public , class , static , void , int , for tokens are Java keywords.

Conventions

Conventions are best practices followed by programmers when writing source code. Each language can have its own set of conventions. Conventions are not strict rules; they are merely recommendations for writing good quality code. We mention a few conventions that are recognized by Java programmers. (And often by other programmers too).

• Class names begin with an uppercase letter.
• Method names begin with a lowercase letter.
• The public keyword precedes the static keyword when both are used.
• The parameter name of the main() method is called args.
• Constants are written in uppercase.
• Each subsequent word in an identifier name begins with a capital letter.

In this part of the Java tutorial, we covered some basic lexis for the Java language.