Quick Reference and Glossary

Java Language Syntax, Operators and Terminology

Compact representation of major Java syntax, keywords, structures and some fundamental classes. In addition, we explain some terminology, much like a glossary, especially where Java uses some unusual terms you might not be familiar with.

package-private classes (non-public class, but not a nested class).

Java in a Nutshell

java-logo

Java™ was released around 1994/5 by Sun Microsystems, acquired by Oracle® in 2010. James Gosling, Mike She­ri­dan and Patrick Naughton drove the project. Ora­cle finally relented, and deprecated applets in browsers with JDK 9, announced be­gin­ning of 2016. IBM® arguably helps drive Java adoption, via donations and open source con­tri­bu­tions since 2001. A big name in Java open source, is the Apache Software Foundation. Consideration should also be given to the OpenJDK.

Virtual Machine

Java code is compiled to bytecode with a file extension of .class, and run in a virtual machine (JVM), which means it should run anywhere a Java Runtime Environment (JRE) is available. For performance, it is compiled to native code “just in time” (JIT). Compiled bytecode can be pack­ag­ed in “jars” (Zip files with a .jar extension).

Memory Management

The JVM manages dynamic memory allocation on the programmer’s behalf. Java employs several garbage collection algorithms to suit different requirements, as a performance consideration.

Just in Time Compilation

To enhance performance, it is the norm today for even some scripting languages, to compile an intermediate machine language code (bytecode in Java), to native machine code, when needed. The JVM does this on the fly (just in time or JIT), when a Java program is executed. The JVM optionally allows for this native code to persist, which would speed up subsequent running of the program.

Native Code

The JRE can load and run native code (typically compiled C/C++ libraries) via the Java Native Interface (JNI) or, much easier, with the third-party library: Java Native Access (JNA), which must be downloaded separately.

Language Paradigms

The Java language adheres to the object-oriented programming (OOP) paradigm, with a nod to functional programming using lambdas. For performance, Java supports templates or generic pro­gram­ming (“generics”).

Heritage

Syntax-wise, Java superficially resembles C/C++. Curly-brace delimited blocks thus enclose all language structures, apart from comments, optional package declarations, and optional import directives. Blocks create scope, and can be nested, though not all blocks are equal: class blocks, method blocks, initialiser list blocks, compound statement blocks.

Identifiers

The names allocated to variables, types, methods, and enumerated values are formally, all identifiers. Languages have rules with regard the characters that may be used in identifiers.

SyntaxIdentifiers

  • Cannot be a keyword, and is case sensitive.
  • First character must be: _, az, AZ.
  • From second character: _, az, AZ, 09.
  • Single underscore not allowed (JDK 9).

Apart from the last point, these are the same rules employed in many C-like languages.

Typed Language

Java is statically typed, which means types of all objects must be specified at compile time, but via reflection, can load libraries and bind methods or classes at runtime. Furthermore, Java is strongly typed, which means that an object cannot change its type once created, and that only well-defined operations are allowed on each type.

Expressions

All values are expressions. Every expression results in a value. Complex expressions may contain operators. Every value has a type, thus every expression has a type (because it results in one value regardless of complexity).

User-Defined Types

The Java Platform not only provides the primitive types, but also a huge number of types via the class libraries. Programmers can create their own types, mostly class types.

SyntaxUser-Defined Types

  • accessclassident{members} reference/class type.
  • accessinterfaceident{method-headers} interface, representing list of methods.
  • accessenumident{named-values} abstract (named) values sharing a type.

In a sense, all user-defined types are classes, while interface and enum create specialised user-defined classes.

Type Conversion

Type conversions for certain types are possible — which for primitive types, means a copy is made of a value, and transformations applied to produce a new value, with a new type. This is not a general mechanism, although every type can be converted to some string representation (toString()). Explicit type conversion (type cast), when legal, is performed with a cast operator.

SyntaxCast Operator

  • (target-type)expr
  • (target-type) (expr) when operators in ‹expr› has higher precedence than cast.
  • target-type type to convert to.
  • expr value of expression with a different ‹type› than ‹target-type›.

As with the results of all operators, the return value should be passed as argument, returned, or assigned to a variable of ‹type› for it to be useful. If the ‹type› of the ‹expr›ession is the same as the ‹target-type›, it is still legal, just not useful.

Access Control

Top-level classes can have public access. If this is omitted, it is called “package-private”, but this cannot be explicitly specified. Package-private classes can only be accessed from classes in the same package. The default access for members, is also “package-private”.

SyntaxTop Level Class Access

  • public classident{members} one per file; all code have access.
  • classident{members} many per file; “package-private” access.

SyntaxMember Access Specifiers

  • access publicprotectedprivate

Member classes (nested classes), as with other members, can have public, private or protected access; where private means only code in the same class have access, while protected is like private, with the exception that derived classes also have access; and public means all code have access.

Encapsulation

Modelling a type, firstly involves defining the state (fields) and behaviour (methods) of an object, called members. Encapsulation is useful in its own right, without involving inheritance or polymorphism. The physical ordering of members in a class is not significant.

PatternEncapsulation

[public] classident{
state instance data members/fields
behaviour instance member functions/methods
construction instance methods to initialise new objects
shared-members data/methods [shared](#shared-members] by all objects of this type
static-initialiser initialiser(#static-initialiser) for shared data members
}

Fields

A class can define instance data members, called fields, which are duplicated in each object. The values of the collection of fields in an object, represents its state at any given time.

SyntaxInstance Data Members/Fields

  • access› ‹type› ‹ident;
  • access› ‹type‹ ‹ident=expr;
  • =expr field initialisation; can be run time expression; called before constructors.

Methods

Functions can also logically be duplicated as instance methods. To avoid physical duplication, Java provides instance methods with an implicit this first parameter, which it also passes automatically. References to other members inside an instance method, are implicit via the this parameter.

SyntaxInstance Member Function/Method

  • access› ‹type›┆voidident(<param) {
    local-vars›… local variables at any location
    statement›… any number of statements
    [returnexpr;] only if non-void return ‹type›.
    }
  • type return type of the function; type of ‹expr›ession in return must match.

More than one return statement is allowed, though not necessarily good programming practice. A return; statement is only legal where functions return void (nothing).

Constructors

Construction / Initialisation

To facilitate custom initialisation of new objects, Java provides a syntax for instance constructors, which, like other methods, can be overloaded. Operators cannot be overloaded. Destruction is not deterministic, and patterns have to be followed for resources that requires more deterministic cleanup (override finalize, provide a close method, etc.).

Shared Members

Shared / static fields as well as methods can be created. A shared method does not have an implicit this parameter, and can thus only access other static members.

SyntaxShared Method/Function

  • accessstatictype›┆voidident([‹param›]) {
    statement›…
    returnexpr;
    }
  • access publicprotectedprivate
  • type return type of shared method or void (no return value).
  • param optional ‹param›eters of the method:type1› ‹ident1,….

Symbolic Constants

Symbolic constants are created with the final static clause, and consequently often called “finals”. They can be initialised with run timeexpr›essions, and can be of any ‹type›. As convention, the ‹ident›ifier is often in all-capital letters.

SyntaxSymbolic Constants

  • [publicprotectedprivate] final statictype› ‹ident=expr; at class level.
  • final statictype› ‹ident=expr; inside methods.

Inheritance & Interfaces

Only single inheritance is allowed, but a class may im­ple­ment mul­ti­ple interfaces. Encapsulation supports shared (static) fields and methods, apart from the normal instance fields and methods.

Polymorphism

It is important to understand that all instance methods in Java, that are not private or final, are automatically virtual functions. This means they can be overridden in derived classes. It is good convention to use the @Override annotation when overriding methods. Note that in the example below, every public class must be in a different file:

Packages

Namespaces in Java are implemented via a nested directory structure, which must match package declarations. This is the reason behind import directives, and CLASSPATH settings. The term class path is prevalent, and almost all tools accept a command line option to specify a list of class paths to resolve names of required classes.

Modules

JDK 9

Source Code

Source code are stored in files with the .java extension. Files may be UTF-8 encoded, but must be compiled with the -encoding utf8 option to javac, the Java bytecode compiler. Only one public class per .java file is allowed, and the class name must exactly match the file name.

Structure

Free Format

Whitespace serves only to separate tokens which would otherwise be ambiguous. Formatting is thus left up to the programmer; this means Java is a free format language.

Identifiers

User-defined identifiers (names) can start with alphabetic or underscore character. Subsequent characters may include decimal digits. Identifiers cannot be keywords. Avoid Unicode identifiers.

Javadoc

Language elements like packages, classes, methods and fields can be formally documented, and are called “Javadocs”. These are in the form of special comments, and processed with the javadoc command line tool.

Building Blocks

Within a Java source file, several language elements can appear in a documented sequence and at specific locations. This form the grammar and syntax of the language, starting with the most fundamental: keywords.

Keywords

Java has a number of keywords which are reserved words, and cannot be used for purposes other than intended. In addition, the language specifies a number of reserved words, which has no purpose (yet), but should not be used for user-defined identifiers.

Note that technically, null, true and false are literals, while const and goto are reserved; so is a single underscore (_) character (since JDK 9).

JDK 9 adds a few more contextual, or restricted keywords, which are only keywords in certain places in the structure of a program. You should treat them as keywords anyway in new programs, even Java 8 programs to ensure a smooth eventual migration to JDK 9.

Primitive Types and Wrappers

Primitive types are not objects. They do not have any methods, but can be boxed in wrapper classes, which do have methods. This is a different approach compared to C#, where these are value types.

Wrappers classes for the primitive types above provides methods and makes the types effectively nullable.

Notice that String is not a primitive type, but a full-blown OOP type (reference type), even if String type values are immutable.

Literals

Some literals are keywords: null, true and false. Other literals are immediate values, each with a type (all values have a type).

Numerical Literals

Character and String Literals

Operators

Javadoc

Glossary

abstract class

When a OO design dictates that a class should only provide structure to derived classes, and that it is not intended to be instantiated as an object, we can make it an abstract class. Java will now ensure we adheres to our own design.

access control

This is a permissions control, and determines which code has the rights to access a member. It must not be confused with scope or inheritance.

annotation

Also called attributes in other languages, relating to a syntax for attaching a special value to classes or methods, that may change the behaviour of the compiler from the norm. In Java, an annotation starts with the at character (@) e.g.: @Override or @Deprecated, and immediately precedes the class or method definition.

dynamic binding

When a compiler resolves name (addresses) of classes and methods at run time, we call it dynamic binding, the opposite of which, is static binding.

expression

All values are expressions. Every expression results in a value. Complex expressions may contain operators. Every value has a type, thus every expression has a type (because it results in one value regardless of complexity).

garbage collection

A term normally employed in languages that automatically manage dynamically allocated memory. They collect unused (unreferenced) memory, using reference counting. Java has several garbage collectors for different cases, but this is transparent to the programmer.

instance member

Members that are physically or logically copies, so that each object (instance of a class), has its own copy (instance) of the member. To avoid physically copy methods, OOP languages arrange for instance methods to have an implicit this (or self) parameter, and automatically used on references to other instance members.

JDK — Java Development Kit

A superset of the JRE (Java Runtime Environment), allowing developers to create Java programs. It includes tools, classes and documentation not available in the JRE.

JNA — Java Native Access

This third party library makes it easier to call natively compiled code (normally compiled C/C++ libraries), than the official Java Native Interface (JNI). Unless you have a good reason, rather use JNA than JNI.

JNI — Java Native Interface

The official mechanism, tools and classes that allows Java code to call compiled C/C++ functions, and interchange data. It involves access to a C/C++ compiler to write wrapper functions.

JIT — Just In Time (Compilation)

In Java, this means the bytecode in class is translated “on-the-fly” to native machine code the host CPU can execute directly. This can be done ahead of time, if needed, to speed up the start up time for bigger Java programs.

JRE — Java Runtime Environment

Java Runtime Environment. The Java Virtual Machine (JVM), packaged with class loaders, the JIT (Just In Time) compiler, and a set of supporting classes. This is the minimum package required to run programs created with the JDK. There is a “compact framework” with fewer classes, for use in smaller devices or embedded systems.

literal

Unfortunately, too often called “constant”; probably because literal values are immediate (no lookup or typical data storage) and have a constant value. The term literal therefore refers to a syntax in programming languages, to represent immediate values.

nullable

A value is nullable when its type is a reference type, which in Java, means a class type. This means you can assign the null literal to the value.

object

Formally, an object is “an instance of a class”. This does not mean variable. An object is explicitly or implicitly created with the new operator in Java. Variables of the correct type, can store a reference to any object of the same type.

operator

A syntactical notation that are passed arguments (called operands), and like functions: logically a) performs a task/job and b) returns a value, or results in a value, which may or may not be of the same type as its operands. Most languages like Java, use ASCII symbols like: +, -, *, /, etc. as operators.

polymorphism

A desirable feature of OOP, where methods are dynamically bound at run time, based on the actual type of the object being referenced (not the type of the reference necessarily). In Java, this requires virtual methods, that can be overridden in derived classes.

reference

A reference is an abstraction of a memory address. It is not called pointer or address, because you cannot use it directly as a number (which is what an address is). This term is common in most OO languages, except in C++, where you can manipulate a pointer as a number, even perform arithmetic on it (although it does have a special notation to create references). Using JNI/JNA, Java can deal with pointers.

reflection

In some programming language, either via syntax, or libraries (as in Java), code can dynamically (at runtime) resolve (or bind) the locations of classes or methods. This is called reflection, and depending on support, may even allow for the dynamic creation of language elements, even code.

shared member

When, by design, a data member (field) or member function (method) are to be shared by all objects, and not each object having its own instance of the member, we can make it shared in Java, with the static keyword.

static binding

When the compiler resolves addresses of types and methods at run time, we call it static binding, which has nothing to do with the static keyword. The opposite of this, is dynamic binding.

statically typed

Java is a statically typed language, which means all types must be known at compile time. The concept of types is a compile-time abstraction, that determines storage size in memory or in ob­ject files; and the bytecode instructions emitted to work with values.

type

An abstraction employed in many programming languages, including Java. All values have a type, which determines the operations (methods and operators) which can be applied to the value. In some instances, a value of one type, can be converted (cast) to a value with another type.

2017-12-25: Created. [brx]