DEV Community: Sjue Bsjs

Variables and Constants

Sjue Bsjs — Mon, 09 Feb 2026 12:49:05 +0000

As in every programming language, variables are used to store values. Constants are variables whose values don't change.

Declaring Variables

In Java, every variable has a type. You declare a variable by placing the type first, followed by the name of the variable.

Here are some examples:

double salary; int vacationDays; long earthPopulation; boolean done;

Notice the semicolon at the end of each declaration. The semicolon is necessary because a declaration is a complete Java statement, which must end in a semicolon.

The identifier for a variable name (as well as for other names) is made up of letters, digits, currency symbols, and “punctuation connectors.” The first character cannot be a digit.

Symbols like '+' or '©' cannot be used inside variable names, nor can spaces. Letter case is significant: main and Main are distinct identifiers. The length of an identifier is essentially unlimited.

The terms “letter,” “digit,” and “currency symbol” are much broader in Java than in most languages. A letter is any Unicode character that denotes a letter in a language. For example, German users can use umlauts such as ä in variable names; Greek speakers could use a π. Similarly, digits are 0–9 and any Unicode characters that denote a digit. Currency symbols are $, €, ¥, and so on. Punctuation connectors include the underscore character , a “wavy low line” ﹏, and a few others. In practice, most programmers stick to _A-Z, a-z, 0-9, and the underscore _.

If you are really curious as to what Unicode characters can be used in identifiers, you can use the isJavaIdentifierStart and isJavaIdentifierPart methods in the Character class to check.

Even though $ is a valid character in an identifier, you should not use it in your own code. It is intended for names that are generated by the Java compiler and other tools.

You also cannot use a Java keyword such as class as a variable name.

Underscores can be parts of identifiers. This is common for constant names, such as Double.POSITIVE_INFINITY. However, a single underscore _ is a reserved word.

As of Java 21, a single underscore _ denotes a variable that is syntactially required but never used.

You can declare multiple variables on a single line:

int i, j; // both are integers

I don’t recommend this style. If you declare each variable separately, your programs are easier to read.

As you saw, names are case sensitive, for example, hireday and hireDay are two separate names. In general, you should not have two names that only differ in their letter case. However, sometimes it is difficult to come up with a good name for a variable. Many programmers then give the variable the same name as the type, for example

Box box; // "Box" is the type and "box" is the variable name

Other programmers prefer to use an “a” prefix for the variable:

Box aBox;

Initializing Variables

After you declare a variable, you must explicitly initialize it by means of an assignment statement, you can never use the value of an uninitialized variable. For example, the Java compiler flags the following sequence of statements as an error:

int vacationDays; System.out.println(vacationDays); // ERROR--variable not initialized

You assign to a previously declared variable by using the variable name on the left, an equal sign (=), and then some Java expression with an appropriate value on the right.

int vacationDays; vacationDays = 12;

You can both declare and initialize a variable on the same line. For example:

int vacationDays = 12;

Finally, in Java you can put declarations anywhere in your code. For example, the following is valid code in Java:

double salary = 65000.0; System.out.println(salary); int vacationDays = 12; // OK to declare a variable here

In Java, it is considered good style to declare variables as closely as possible to the point where they are first used.

You do not need to declare the types of local variables if they can be inferred from the initial value. Simply use the keyword var instead of the type:

var vacationDays = 12; // vacationDays is an int var greeting = "Hello"; // greeting is a String

This is not too important for number and string types, but, as you will see in the next chapter, this feature can make the declaration of objects less verbose.

C and C++ distinguish between the declaration and definition of a variable. For example,

int i = 10;

is a definition, whereas

extern int i;

is a declaration. In Java, no declarations are separate from definitions.

Constants

In Java, you use the keyword final to denote a constant. For example:

public class Constants
{
public static void main(String[] args)
{
final double CM_PER_INCH = 2.54;
double paperWidth = 8.5;
double paperHeight = 11;
System.out.println("Paper size in centimeters: "
+ paperWidth * CM_PER_INCH + " by " + paperHeight
* CM_PER_INCH);
}
}

The keyword final indicates that you can assign to the variable once, and then its value is set once and for all. It is customary to name constants in all uppercase.

It is probably more common in Java to create a constant so it's available to multiple methods inside a single class. These are usually called class constants. Set up a class constant with the keywords static final. Here is an example of using a class constant:

public class Constants2
{
public static final double CM_PER_INCH = 2.54;
public static void main(String[] args)
{
double paperWidth = 8.5;
double paperHeight = 11;
System.out.println("Paper size in centimeters: "
+ paperWidth * CM_PER_INCH + " by " + paperHeight
* CM_PER_INCH);
}
}

Note that the definition of the class constant appears outside the main method. Thus, the constant can also be used in other methods of the same class. Furthermore, if the constant is declared, as in this example, public, methods of other classes can also use it, in our example, as Constants2.CM_PER_INCH.

Some coding style guides state that uppercase letters should only be used for static final variables. If you need to follow such a style guide, and you have a local constant, decide what is more important to you, the fact that it is local (and lowercase), or that it is visibly a constant (static and uppercase).

const is a Java keyword, but it is not currently used for anything. You must use final for a constant.

Enumerated Types

Sometimes, a variable should only hold a restricted set of values. For example, you may sell clothes or pizza in four sizes: small, medium, large, and extra large. Of course, you could encode these sizes as integers 1, 2, 3, 4 or characters S, M, L, and X. But that is an error-prone setup. It is too easy for a variable to hold a wrong value (such as 0 or m).

You can define your own enumerated type whenever such a situation arises. An enumerated type has a finite number of named values. For example,

enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };

Now you can declare variables of this type:

Size s = Size.MEDIUM;

A variable of type Size can hold only one of the values listed in the type declaration, or the special value null that indicates that the variable is not set to any value at all.

Simple Java Program, Comments and Data Types

Sjue Bsjs — Wed, 04 Feb 2026 12:54:14 +0000

A Simple Java Program

Let’s look more closely at one of the simplest Java programs you can have one that merely 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. For now, think of a class as a container for the program logic that defines the behavior of an application. Classes are the building blocks with which all Java applications 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 a class name.

The standard naming convention (used in the name FirstSample) is that 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. This use of uppercase letters in the middle of a name is sometimes called “camel case” or, self-referentially, “CamelCase.”

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.)

You compile the file with the command

javac FirstSample.java

If you have named the file correctly and not made any typos in the source code, you end up with a file containing the bytecodes for this class. The Java compiler 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:

java FirstSample

(Remember to leave off the .class extension.) When the program executes, it simply displays the string We will not use 'Hello, World!' on the console. When you use

java ClassName

to run a compiled program, 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 of 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.

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. As whitespace is irrelevant to the Java compiler, you can use whatever brace style you like.

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 } }

The byzantine complexity of public static void main is about to give way to something simpler. Java 21 has a preview feature, described in Java Enhancement Proposal (JEP) 445, that allows you to write the main method like this:

class FirstSample { void main() { System.out.println("We will not use 'Hello, World!'"); } }

That is nicer. No public, no static, no String[] args.

For now, you need to compile and run the program
with a command-line flag:

javac --enable-preview --source 21 FirstSample.java java --enable-preview FirstSample

Even simpler, since there is a single source file, you
can skip the javac step:

java --enable-preview --source 21 FirstSample.java

for very simple programs, JEP 445 allows you to omit the class, provided, of course, there is only one. The file FirstSample.java can simply contain:

void main() { System.out.println("We will not use 'Hello, World!'"); }

Since these features are still in preview, we won't use them, but in the future, the first sample program will be a bit simpler.

As a C++ programmer, you know what a class is. Java classes are similar to C++ classes, but there are a few differences that can trap you. For example, in Java all functions are methods of some class. (The standard terminology refers to them as methods, not member functions.) Thus, in Java you must have a shell class for the main method. You may also be familiar with the idea of static member functions in C++. These are member functions defined inside a class that do not operate on objects.

The main method in Java is always static. Finally, as in C/C++, the void keyword indicates that this method does not return a value. Unlike C/C++, the main method does not return an “exit code” to the operating system. If the main method exits normally, the Java program has the exit code 0, indicating successful completion. To terminate the program with a different exit code, call System.exit(code).

Now that you have seen the basic structure of all Java
programs, turn your attention to the contents of the main method:

{ 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 languages, 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(arguments)

as its equivalent of a function call.

In this case, the println method receives a string argument. The method displays the string argument on the console. It then 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 functions in any programming language, can use zero, one, or more arguments. Even if a method has no arguments, you must still use empty
parentheses. For example, a variant of the println method with no arguments just prints a blank line. You invoke it with the call

System.out.println();

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. The next output appears immediately after the letter o.

Comments

Comments in Java, as in most programming languages, do not show up in the executable program. Thus, you can add as many comments as needed without fear of bloating the code. Java has three ways of marking comments. The most common form is a //. Use this for a comment that runs from the // to the end of the line.

System.out.println("We will not use 'Hello, World!'"); // is this too cute?

When longer comments are needed, you can mark each line with a //, or you can use the /* and / comment delimiters that let you block off a longer comment.
Finally, a third kind of comment is used to generate documentation automatically. This comment uses a /* to start and a */ to end.

/* / comments do not nest in Java. That is, you might not be able to deactivate code simply by surrounding it with / and */ because the code you want to deactivate might itself contain a */ delimiter.

Data Types

Java is a strongly typed language. This means that every variable must have a declared type. There are eight primitive types in Java. Four of them are integer types; two are floating-point number types; one is the character type char, used for UTF-16 code units in the Unicode encoding scheme; and one is a boolean type for truth values.

Java has an arbitrary-precision arithmetic package. However, “big numbers,” as they are called, are Java objects and not a primitive Java type.

Integer Types
The integer types are for numbers without fractional parts. Negative values are allowed. Java provides the four integer types:

byte 1 byte –128 to 127
short 2 bytes –32,768 to 32,767
int 4 bytes –2,147,483,648 to 2,147,483,647 (just over 2 billion)
long 8 bytes –9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

In most situations, the int type is the most practical. If you want to represent the number of inhabitants of our planet, you’ll need to resort to a long. The byte and short types are mainly intended for specialized applications, such as low-level file handling, or for large arrays when storage space is at a premium.

Under Java, the ranges of the integer types do not depend on the machine on which you will be running the Java code. This alleviates a major pain for the programmer who wants to move software from one platform to another, or even between operating systems on the same platform. In contrast, C and C++ programs use the most efficient integer type for each processor. As a result, a C program that runs well on a 32-bit processor may exhibit integer overflow on a 16-bit system. Since Java programs must run with the same results on all machines, the ranges for the various types are fixed.

Long integer numbers have a suffix L or l (for example, 4000000000L). Hexadecimal numbers have a prefix 0x or 0X (for example, 0xCAFE). Octal numbers have a prefix 0 (for example, 010 is 8)—naturally, this can be confusing, and few programmers use octal constants.

You can write numbers in binary, with a prefix 0b or 0B. For example, 0b1001 is 9. You can add underscores to number literals, such as 1_000_000 (or 0b1111_0100_0010_0100_0000) to denote one million. The underscores are for human eyes only. The Java compiler simply removes them.

In C and C++, the sizes of types such as int and long depend on the target platform. On a 16-bit processor such as the 8086, integers are 2 bytes, but on a 32-bit processor like a Pentium or SPARC they are 4-byte quantities. Similarly, long values are 4-byte on 32-bit processors and 8-byte on 64-bit processors. These differences make it challenging to write cross-platform programs. In Java, the sizes of all numeric types are platform-independent.

Note that Java does not have any unsigned versions of the int, long, short, or byte types. If you work with integer values that can never be negative and you really need an additional bit, you can, with some care, interpret signed integer values as unsigned. For example, instead of having a byte value b represent the range from –128 to 127, you may want a range from 0 to 255. You can store it in a byte. Due to the nature of binary arithmetic, addition, subtraction, and multiplication will work provided they don't overflow. For other operations, call Byte.toUnsignedInt(b) to get an int value between 0 and 255, then process the integer value and cast back to byte. The Integer and Long classes have methods for unsigned division and remainder.

Floating-Point Types
The floating-point types denote numbers with fractional parts. The two floating-point types:

float 4 bytes Approximately ±3.40282347 ×10^38 (6–7 significant decimal digits)
double 8 bytes Approximately ±1.79769313486231570 ×10^308 (15 significant decimal digits)

The name double refers to the fact that these numbers have twice the precision of the float type. (Some people call these double-precision numbers.) The limited precision of float (6-7 significant digits) is simply not sufficient for many situations. Use float values only when you work with a library that requires them, or when you need to store a very large number of them.

Java 20 adds a couple of methods (Float.floatToFloat16 and Float.float16toFloat) for storing “half-precision” 16-bit floating-point numbers in short values. These are used for implementating neural networks.

Numbers of type float have a suffix F or f (for example, 3.14F). Floating-point numbers without an F suffix (such as 3.14) are always considered to be of type double. You can optionally supply the D or d suffix (for example, 3.14D). An E or e denotes a decimal exponent. For example, 1.729E3 is the same as 1729.

You can specify floating-point literals in hexadecimal. For example, 0.125 = 2^–3 can be written as 0x1.0p-3. In hexadecimal notation, you use a p, not an e, to denote the exponent. (An e is a hexadecimal digit.) Note that the mantissa is written in hexadecimal and the exponent in decimal. The base of the exponent is 2, not 10.

All floating-point computations follow the IEEE 754 specification. In particular, there are three special floating-point values to denote overflows and errors:

Positive infinity
Negative infinity
NaN (not a number)

For example, the result of dividing a positive floating-point number by 0 is positive infinity. Dividing 0.0 by 0 or the square root of a negative number yields NaN.

The constants Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, and Double.NaN (as well as corresponding Float constants) represent these special values, but they are rarely used in practice. In particular, you cannot test

if (x == Double.NaN) // is never true

to check whether a particular result equals Double.NaN. All “not a number” values are considered
distinct. However, you can use the Double.isNaN method:

if (Double.isNaN(x)) // check whether x is "not a number"

Floating-point numbers are not suitable for financial calculations in which roundoff errors cannot be tolerated. For example, the command System.out.println(2.0 - 1.1) prints 0.8999999999999999, not 0.9 as you would expect. Such roundoff errors are caused by the fact that floating-point numbers are represented in the binary number system. There is no precise binary representation of the fraction 1/10, just as there is no accurate representation of the fraction 1/3 in the decimal system. If you need precise numerical computations without roundoff errors, use the BigDecimal class.

The char Type

The char type was originally intended to describe individual characters. However, this is no longer the case. Nowadays, some Unicode characters can be described with one char value, and other Unicode characters require two char values.

Literal values of type char are enclosed in single quotes. For example, 'A' is a character constant with value 65. It is different from "A", a string containing a single character. Values of type char can be expressed as hexadecimal values that run from \u0000 to \uFFFF.

Besides the \u escape sequences, there are several escape sequences for special characters. You can use these escape sequences inside quoted character literals and strings, such as '\u005B' or "Hello\n". The \u escape sequence (but none of the other escape sequences) can even be used _outside _quoted character constants and strings. For example,

public static void main(String\u005B\u005D args)

is perfectly legal \u005B and \u005D are the encodings for [ and ].

\b Backspace \u0008
\t Tab \u0009
\n Line feed \u000a
\r Carriage return \u000d
\f Form feed \u000c
\" Double quote \u0022
\' Single quote \u0027
\\ Backslash \u005c
\s Space. Used in text blocks to retain trailing whitespace. \u0020
\newline In text blocks only: Join this line with the next —

Unicode escape sequences are processed before the code is parsed. For example, "\u0022+\u0022" is not a string consisting of a plus sign surrounded by quotation marks (U+0022). Instead, the \u0022 are converted into " before parsing, yielding ""+"", or an empty string.

Even more insidiously, you must beware of \u inside comments. The comment

// \u000A is a newline

yields a syntax error since \u000A is replaced with a newline when the program is read. Similarly, a comment

// look inside c:\users

yields a syntax error because the \u is not followed by four hex digits.

You can have any number of u in a Unicode escape sequence: \u00E9 and \uuu00E9 both denote the character é. There is a reason for this oddity. Consider a programmer happily coding in Unicode who is forced, for some archaic reason, to check in code as ASCII only. A conversion tool can turn any character > U+007F into a Unicode escape and add a u to every existing Unicode escape. That makes the conversion reversible. For example, \uD800 é is turned into \uuD800 \u00E9 and can be converted back to \uD800 é.

Unicode and the char Type

To fully understand the char type, you have to know about the Unicode encoding scheme. Before Unicode, there were many different character encoding standards: ASCII in the United States, ISO 8859-1 for Western European languages, KOI-8 for Russian, GB18030 and BIG-5 for Chinese, and so on. This caused two problems. First, a particular code value corresponds to different letters in the different encoding schemes. Second, the encodings for languages with large character sets have variable length: Some common characters are encoded as single bytes, others require two or more bytes.

Unicode was designed to solve both problems. When the
unification effort started in the 1980s, a fixed 2-byte code was more than sufficient to encode all characters used in all languages in the world, with room to spare for future expansion or so everyone thought at the time. In 1991, Unicode 1.0 was released, using slightly less than half of the available 65,536 code values. Java was designed from
the ground up to use 16-bit Unicode characters, which was a major advance over other programming languages that used 8-bit characters.

Unfortunately, over time, the inevitable happened. Unicode grew beyond 65,536 characters, primarily due to the addition of a very large set of ideographs used for Chinese, Japanese, and Korean. Now, the 16-bit char type is insufficient to describe all Unicode characters.

We need a bit of terminology to explain how this problem is resolved in Java. A code point is an integer value associated with a character in an encoding scheme. In the Unicode standard, code points are written in hexadecimal and prefixed with U+, such as U+0041 for the code point of the Latin letter A. Unicode has code points that are grouped into 17 code planes, each holding 65536 characters. The first code plane, called the basic multilingual plane, consists of the “classic” Unicode characters with code points U+0000 to U+FFFF. Sixteen additional planes, with code points U+10000 to U+10FFFF, hold many more characters called supplementary characters.

How a Unicode code point (that is, an integer ranging from 0 to hexadecimal 10FFF) is represented in bits depends on the character encoding. You could encode each character as a sequence of 21 bits, but that is impractical for computer hardware. The UTF-32 encoding simply places each code point into 32 bits, where the top 11 bits are zero. That is rather wasteful. The most common encoding on the Internet is UTF-8, using between one and four bytes per character.

Java strings use the UTF-16 encoding. It encodes all Unicode code points in a variable-length code of 16-bit units, called code units. The characters in the basic multilingual plane are encoded as a single code unit. All other characters are encoded as consecutive pairs of code units. Each of the code units in such an encoding pair falls into a range of 2048 unused values of the basic multilingual plane, called the surrogates area ('\uD800' to '\uDBFF' for the first code unit, '\uDC00' to '\uDFFF' for the second code unit). This is rather clever, because you can immediately tell whether a code unit encodes a single character or it is the first or second part of a supplementary character. For example, the beer mug emoji 🍺 has code point U+1F37A and is encoded by the two code units '\uD83C' and '\uDF7A'. Each code unit is stored as a char value. The details are not important. All you need to know is that a single Unicode character may require one or two char values.

You cannot ignore characters with code units above U+FFFF. Your customers may well write in a language where these characters are needed, or they may be fond of putting emojis such as 🍺 into their messages.

Nowadays, Unicode has become so complex that even code
points no longer correspond to what a human viewer would perceive as a single character or symbol. This happens with languages whose characters are made from smaller building blocks, with emojis that can have modifiers for gender and skin tone, and with an ever-growing number of other compositions.

Consider the ITALY flag. You perceive a single symbol: the flag of Italy. However, this symbol is composed of two Unicode code points: U+1F1EE (regional indicator symbol letter I) and U+1F1F9 (regional indicator symbol letter T). About 250 flags can be formed with these regional indicators. The pirate flag, on the other hand, is composed of U+1F3F4 (waving black flag), U+200D (zero width joiner), U+2620 (skull and crossbones), and U+FE0F (variation selector-16). In Java, you need four char values to represent the first flag, five for the second.

In summary, a visible character or symbol is encoded as a sequence of some number of char values, and there is almost never a need to look at the individual values. Always work with strings and don't worry about their representation as char sequences.

The boolean Type

The boolean type has two values, false and true. It is used for evaluating logical conditions. You cannot convert between integers and boolean values.

In C++, numbers and even pointers can be used in place of boolean values. The value 0 is equivalent to the bool value false, and a nonzero value is equivalent to true. This is not the case in Java. Thus, Java programmers are shielded from accidents such as

if (x = 0) // oops... meant x == 0

In C++, this test compiles and runs, always evaluating to false. In Java, the test does not compile because the integer expression x = 0 cannot be converted to a boolean value.m

The Java Programming Environment

Sjue Bsjs — Fri, 16 Jan 2026 10:32:46 +0000

Installing the Java Development Kit

You can download the Java Development Kit from Oracle at https://www.oracle.com/java/technologies/downloads.

Setting Up the JDK

After downloading the JDK, you need to install it and figure out where it was installed - you'll need that information later. If you run Windows or have a Mac, simply launch the setup program and choose the default options. On Linux, uncompress the .tar.gz file to a location of your choice, such as your home directory or /opt. Then set the PATH to the bin subdirectory of the directory into which the JDK was placed, such as /opt/jdk-21.0.4/bin. This is usually achieved by adding a line such as the following to the end of your ~/.bashrc or ~/.bash_profile file:

export PATH=/opt/jdk-21.0.4/bin:$PATH

Here is how you test whether you did it right. Start a terminal window. Type the line

javac --version

and press the Enter key. You should get a display such as this one:

javac 21.0.4

If instead you get a message such as "javac: command not found" or "The name specified is not recognized as an internal or external command, operable program or batch file," then you need to double-check your installation.

It is often useful to know where the JDK is installed on your system. The installation directory is denoted as jdk. For example, when referring to the jdk/bin directory, I mean the directory such as /opt/jdk-17.0.4/bin or C:\Program Files\Java\jdk-21\bin.

On Windows, the Oracle JDK installer adds the directory C:\Program Files\CommonFiles\Oracle\Java\javapath to the PATH environment variable. That directory only contains the javac, javaw, java, and jshell executables. The javaw executable is a Windows-only feature for launching a program without a console window. The other tools in the Java Development Kit can be found in the bin subdirectory of the JDK installation directory. When invoking those programs, either specify the complete path (such as C:\Program Files\Java\jdk-21\bin\javadoc for the javadoc tool), or add the bin subdirectory to the PATH environment variable. One way to achieve this is with the setx command

setx PATH "%PATH%;c:\Program Files\Java\jdk-21\bin"

Open another terminal window for the change to take effect.

Installing Source Files and Documentation

The library source files are delivered in the JDK as a compressed file jdk/lib/src.zip. Unpack that file to get access to the source code. Simply do the following:

Make sure the JDK is installed and the jdk/bin directory is on the executable path.
Make a directory javasrc in your home directory. If you like, you can do this from a terminal window.

mkdir javasrc

Inside the jdk/lib directory, locate the file src.zip.
Unzip the src.zip file into the javasrc directory. In a terminal window, you can execute the commands

cd javasrc jar xvf jdk/lib/src.zip cd ..

The src.zip file contains the source code for all public libraries.

You can read the JDK documentation at https://docs.oracle.com/en/java/javase/21/docs/. If you prefer to have an offline version, follow these steps:

Download the documentation zip file from https://www.oracle.com/java/technologies/downloads. It is called jdk-21.0.x_doc-all.zip.
Unzip the file and rename the doc directory into something more descriptive, like jdk-21-docs. If you like, you can do this from the command line:

jar xvf Downloads/jdk-21.0.x_doc-all.zip mv docs jdk-21-docs

In your browser, navigate to jdk-21-docs/index.html and add this page to your bookmarks.

You should also install the Core Java program examples. You can download them from https://horstmann.com/corejava. The programs are packaged into a zip file corejava.zip. Just unzip them into your home directory. They will be located in a directory corejava. If you like, you can do this from the command line:

jar xvf Downloads/corejava.zip

Using the Command-Line Tools

If your programming experience comes from a development environment such as Microsoft Visual Studio, you are accustomed to a system with a built-in text editor, menus to compile and launch a program, and a debugger. The JDK contains nothing even remotely similar. You do everything by typing in commands in a terminal window. This may sound cumbersome, but it is nevertheless an essential skill. When you first install Java, you will want to troubleshoot your installation before you install a development environment. Moreover, by executing the basic steps
yourself, you gain a better understanding of what a development environment does behind your back.

However, after you have mastered the basic steps of compiling and running Java programs, you will want to use a professional development environment. You will see how to do that in the following section.

Let's get started the hard way: compiling and launching a Java program from the command line.

Open a terminal window.
Go to the corejava/v1ch02/Welcome directory. (The corejava directory is where you installed the source code for the book examples)
Enter the following commands:

javac Welcome.java java Welcome

In the terminal window, you should see the output below

Welcome to Core Java! =====================

Congratulations! You have just compiled and run your first Java program.

What happened? The javac program is the Java compiler. It compiles the file Welcome.java into the file Welcome.class. The java program launches the Java virtual machine. It executes the bytecodes that the compiler placed in the class file.
The Welcome program is extremely simple. It merely prints a message to the terminal. You may enjoy looking inside the program below

/** * This program displays a greeting for the reader. */ public class Welcome { public static void main(String[] args) { String greeting = "Welcome to Core Java!"; System.out.println(greeting); for (int i = 0; i < greeting.length(); i++) System.out.print("="); System.out.println(); } }

In the age of integrated development environments, many programmers are unfamiliar with running programs in a terminal window. Any number of things can go wrong, leading to frustrating results.

Pay attention to the following points:

If you type in the program by hand, make sure you correctly enter the uppercase and lowercase letters. In particular, the class name is Welcome and not welcome or WELCOME.
The compiler requires a file name (Welcome.java). When you run the program, you specify a class name (Welcome) without a .java or .class extension.
If you get a message such as “Bad command or file name” or “javac: command not found,” go back and double-check your installation, in particular the executable path setting.
If javac reports that it cannot find the file Welcome.java, you should check whether that file is present in the directory. Under Linux, check that you used the correct capitalization for Welcome.java. Under Windows, use the dir command, not the graphical Explorer tool. Some text editors (in particular Notepad) insist on adding an extension .txt to every file's name. If you use Notepad to edit Welcome.java, it will actually save it as Welcome.java.txt. Under the default Windows settings, Explorer conspires with Notepad and hides the .txt extension because it belongs to a “known file type.” In that case, you need to rename the file, or save it again placing quotes around the file name: "Welcome.java".
If you launch your program and get an error message complaining about a java.lang.NoClassDefFoundError, then carefully check the name of the offending class. If you get a complaint about welcome (with a lowercase w), then you should reissue the java Welcome command with an uppercase W. As always, case matters in Java. If you get a complaint about Welcome/java, it means you accidentally typed java Welcome.java. Reissue the command as java Welcome.

Using an Integrated Development Environment

These environments are so powerful and convenient that it simply doesn’t make much sense to labor on without them. Excellent choices are the freely available Eclipse, IntelliJ IDEA, and NetBeans. In this section, you will learn how to get started with Eclipse.

Get started by downloading Eclipse from
https://eclipse.org/downloads. Versions exist for Linux, MacOS X, and Windows. Run the installation program and pick the installation set called “Eclipse IDE for Java Developers.”

Here are the steps to write a program with Eclipse:

After starting Eclipse, select File → New → Project from the menu.
Select “Java Project” from the wizard dialog.
Click the Next button. Uncheck the “Use default location” checkbox. Click on Browse and navigate to the corejava/v1ch02/Welcome directory.
Click the Finish button. The project is now created.
Click on the triangles in the left pane next to the project until you locate the file Welcome.java, and double-click on it. You should now see a pane with the program code.
With the right mouse button, click on the project name (Welcome) in the left pane. Select Run → Run As → Java Application. The program output is displayed in the console pane.

Presumably, this program does not have typos or bugs. (It was only a few lines of code, after all.) Let us suppose, for the sake of argument, that your code occasionally contains a typo (perhaps even a syntax error). Try it out—ruin your file, for example, by changing the capitalization of String as follows:

string greeting = "Welcome to Core Java!";

Note the wiggly line under string. In the tabs below the source code, click on Problems and expand the triangles until you see an error message that complains about an unknown string type. Click on the error message. The cursor moves to the matching line in the edit pane, where you can correct your error. This allows you to fix your errors quickly.

Often, an Eclipse error report is accompanied by a lightbulb icon. Click on the lightbulb to get a list of suggested fixes.

JShell

The JShell program provides a “read-evaluate-print loop,” or REPL. You type a Java expression; JShell evaluates your input, prints the result, and waits for your next input. This is an excellent way to experiment—much faster than writing a complete program in an integrated development environment.

To start JShell, simply type jshell in a terminal window.

JShell starts with a greeting, followed by a prompt:

| Welcome to JShell -- Version 21.0.4 | For an introduction type: /help intro jshell>

Now type an expression, such as

"Core Java".length()

JShell responds with the result—in this case, the number of characters in the string “Core Java”.

$1 ==> 9

Note that you do not type System.out.println. JShell
automatically prints the value of every expression that you enter.

The $1 in the output indicates that the result is available in further calculations. For example, if you type

5 * $1 - 3

the response is

$2 ==> 42

If you need a variable many times, you can give it a more memorable name. For example,

jshell> var answer = 6 * 7 answer ==> 42

Another useful feature is tab completion. Type

Math.

followed by the Tab key. Because there are so many
completions, you are prompted to hit the Tab key again. You get a list of all methods that you can invoke with the Math class:

jshell> Math. E IEEEremainder( PI TAU abs( absExact( acos( addExact( asin( atan( atan2( cbrt( ceil( ceilDiv( ceilDivExact( ceilMod( clamp( class copySign( cos( cosh( decrementExact( divideExact( exp( expm1( floor( floorDiv( floorDivExact( floorMod( fma( getExponent( hypot( incrementExact( log( log10( log1p( max( min( multiplyExact( multiplyFull( multiplyHigh( negateExact( nextAfter( nextDown( nextUp( pow( random() rint( round( scalb( signum( sin( sinh( sqrt( subtractExact( tan( tanh( toDegrees( toIntExact( toRadians( ulp( unsignedMultiplyHigh(

Now type l and hit the Tab key again. The method name is completed to log, and you get a shorter list:

jshell> Math.log log( log10( log1p(

Now you can fill in the rest by hand:

jshell> Math.log10(0.001) $4 ==> -3.0

To repeat a command, hit the ↑ key until you see the line that you want to reissue or edit. You can move the cursor in the line with the ← and → keys, and add or delete characters. Hit Enter when you are done. For example, hit the ↑ key and replace 0.001 with 1000, then hit Enter:

jshell> Math.log10(1000) $5 ==> 3.0

You exit JShell with the command

/exit

JShell makes it easy and fun to learn the Java language and library without having to launch a heavy-duty development environment and without fussing with a program and a main method.