A program is, in essence, data being transformed. Variables are the containers where you keep that data and types are the rules that determine what fits in each container and which operations make sense with it. In Java these rules are checked before anything runs, and that makes the type system your first safety net: much of what blows up in production in other languages does not even compile here. In this lesson you will learn the eight primitive types, the crucial difference between primitives and references, the special behaviour of String, type conversions, constants and inference with var. By the end you will have modelled the first book of the BiblioTech catalog with variables.

1. Declaration, initialisation and assignment
2. The eight primitive types
3. Literals: how values are written
4. Primitives versus references: what each variable holds
5. String: the special type
6. Type conversions
7. Wrappers, autoboxing and conversion from text
8. final and constants
9. Type inference with var
10. Modelling a BiblioTech book
11. Common Mistakes and Tips
12. Exercises

Three operations worth telling apart from the start:

• Declaring is announcing to the compiler: "there will be a variable called publicationYear that will hold integers". From then on, the compiler makes sure you do not put anything else in it.
• Initialising is giving it its first value.
• Assigning is giving it a value (the first one or any later one). The = symbol does not mean mathematical equality, but "store what is on the right in the variable on the left".

A rule Java enforces and that is worth celebrating: you cannot read a local variable before assigning it a value.

Other languages would hand you garbage or undefined; Java refuses to compile. That eliminates a whole family of subtle bugs.

You can declare several variables of the same type on one line, although one per line is preferred for readability:

Java has exactly eight primitive types. They are not objects: they are pure values the JVM manipulates directly and efficiently.

Important notes about this table:

• The "default value" column only applies to the fields of a class (module 3), not to local variables inside main, which as we have just seen must be initialised explicitly.
• In practice you will use int, double, boolean and char 95 % of the time. byte, short and float are special cases.
• long is essential when int falls short. The int limit (around 2,147 million) seems enormous until you start counting milliseconds: the number of milliseconds since 1970 overflowed int at 1970 + 24 days.
• char is not a one-character String: it is written with single quotes ('A') and it is a numeric type underneath.
• boolean in Java is not a number. There is no "0 is false, 1 is true" equivalence as in C: if (1) does not compile.

A literal is a value written directly in the code. Java accepts several notations:

Careful with octal: int x = 010; is 8, not 10. It is a classic source of bugs; avoid leading zeros.

Since Java 7 you can use _ to make long numbers readable. The compiler ignores them completely:

Restrictions: they cannot go at the beginning, at the end, or next to the decimal point.

A rule that causes many errors: a decimal literal without a suffix is a double. That is why float weight = 0.68; does not compile: you are trying to put a double into a float, which is smaller. You have to write 0.68f.

The most used escape sequences:

This is one of the most important ideas in the module, and the one that explains many behaviours that otherwise look arbitrary.

Java divides types into two families:

• Primitive types (the eight above): the variable holds the value directly.
• Reference types (String, arrays, and every class): the variable holds a reference (an address) to an object that lives in another area of memory.

A Java program's memory is organised, in simplified terms, into two areas:

• The stack: fast and small, it holds the local variables of methods.
• The heap: large, it holds the objects. It is where the garbage collector operates.

Notice the difference: publicationYear is 2018; title is not the text, but an arrow pointing to it.

Immediate practical consequences:

A reference variable can also be null, which means "it points to no object". Primitives can never be null.

Trying to use a null reference produces Java's most famous runtime error, NullPointerException. You will deal with it formally in module 6.

String is not a primitive, it is a class. But it gets such privileged treatment from the language that it behaves somewhere in between.

String is the only class that can be created with a literal, without new. Using new String(...) is an antipattern: it creates an extra object with no advantage at all.

A String can never be modified. Every method that "changes" a string actually returns a new string:

This is one of the most frequent beginner mistakes. If a String method does not seem to do anything, you have almost certainly forgotten to store the result.

Why are they immutable? For safety (a string cannot change under your feet), for efficiency (it allows identical strings to be shared in the string pool) and because it makes them thread-safe at no cost at all (module 8).

The + operator concatenates. When one of the operands is a String, Java automatically converts the other one to text. This also means that "Total: " + 2 + 3 produces "Total: 23" and not "Total: 5": it is evaluated left to right, and as soon as there is a String everything else gets glued on as text. It is fixed with parentheses: "Total: " + (2 + 3).

Starting from:

Indexes start at 0, and substring(i, j) includes i but excludes j. It is the convention throughout Java; internalise it now.

An example applied to BiblioTech:

For multi-line text there is a triple-quote syntax that avoids \n and concatenations:

The details: the opening triple quote must be followed by a line break, and the indentation is computed relative to the closing line, so you can indent the block inside your code without those spaces appearing in the output. It is enormously convenient for menus, templates or JSON and SQL fragments.

When you mix numeric types, Java applies strict rules.

It goes from a smaller type to a larger one. No information is lost, so Java does it on its own:

This explains why 12 * 0.25 gives 3.0: the int is converted to double before multiplying.

It goes from a larger type to a smaller one. It may lose information, so Java forces you to ask for it explicitly with a cast, which is your signature saying "I know what I am doing":

Critical points:

• The cast to an integer truncates, it does not round. (int) 3.99 is 3. To round you use Math.round(3.99), which gives 4.
• If the value does not fit, the result is silent garbage:

There is no error and no warning here: the compiler assumes you knew what you were doing. That is why casts must be used with full awareness.

In an operation between different types, Java promotes to the larger of the two:

And the classic trap, which we will look at in depth in the operators lesson:

The division is done between integers (giving 2) and only afterwards converted to double. The solution is to force it beforehand: (double) total / parts.

Every primitive has a wrapper class that represents it as an object:

What are they for? Two reasons:

1. Collections (module 5) only accept objects, not primitives. You cannot have a list of int, but you can have one of Integer.
2. They can be null, which lets you represent "no value" (an unknown publication year, for example).

Since Java 5, conversion between a primitive and its wrapper is automatic:

It is convenient, but it has two costs worth knowing: it uses more memory and, above all, unboxing a null reference throws NullPointerException. Practical rule: use primitives unless you need null or a collection.

Here is their most immediate use in this module: converting text into a number. Remember that command-line arguments and whatever is read from the console always arrive as String.

If the text does not represent a valid number (Integer.parseInt("two thousand")), the program fails at runtime with NumberFormatException. How to catch and handle that failure is studied in module 6; for now it is enough to know it exists and to enter correct data.

The word final applied to a variable means that its value cannot change once assigned:

Why use them:

• They communicate intent. Whoever reads the code knows that value is a business rule, not a variable piece of data.
• They prevent bugs. A value that must not change cannot change by accident.
• They eliminate "magic numbers". Comparing 0.25 scattered over twenty places with a single DAILY_RATE is the difference between changing the rate in a minute or in an afternoon.

Constants are written in UPPERCASE_WITH_UNDERSCORES, as we saw in the previous lesson:

An important nuance for later on: in a reference variable, final prevents reassigning the reference, not modifying the object it points to. With String you do not notice because they are immutable, but with mutable objects (module 3) you do.

Since Java 10 you can omit the type of a local variable and let the compiler deduce it from the assigned value:

It is crucial to understand that var does not turn Java into a dynamically typed language. The type is fixed at compile time and it is as strict as ever:

Restrictions on var:

• Only for local variables (inside methods). It is not allowed for class fields or parameters.
• It forces initialisation on the same line: var x; does not compile.
• It does not accept null as an initial value: var x = null; does not compile, because there is no type to infer.

This course uses explicit types in module 1 (so that you always see which type is in play) and var from module 5 onwards, where generic types make it genuinely useful.

Let's apply everything we have learnt. The Nexus Software catalog needs to record, for each book: title, author, ISBN, publication year and availability. With what you know today, that translates into loose variables:

Output:

This approach works for one book. But Nexus Software has hundreds. With loose variables you would need title1, title2, title3… and nothing would guarantee that author2 really corresponds to title2. Data that forms a conceptual unit is scattered around.

That is exactly the gap object-oriented programming fills: in module 3 you will create a Book class that groups these five variables into a single type, and in module 5 you will store hundreds of those objects in a collection. Notice that the names you are using now (title, author, isbn, publicationYear, available) will literally be the fields of that class. You are laying the foundations.

• Forgetting to store the result of a String method. title.toUpperCase(); changes nothing. It must be title = title.toUpperCase();.
• float x = 3.75; does not compile. Decimal literals are double; you have to write 3.75f.
• long x = 10000000000; does not compile. The literal is read as an int and overflows. You have to write 10000000000L.
• Confusing 'A' with "A". Single quotes mean char, double quotes mean String. They are not interchangeable.
• Expecting (int) 3.99 to be 4. The cast truncates. To round, use Math.round().
• Using == to compare String. It compares references, not content. You use equals(). It is so important that the next lesson devotes a whole section to it.
• Declaring variables without initialising them and then reading them. The compiler prevents it for local variables; be grateful.
• Overusing var. var result = calculate(); forces the reader to go and look up the method signature. Use it only when the type is obvious.
• Tip: declare final everything that is not going to change. It is free and it turns a potential bug into a compilation error.
• Tip: use names that say what the variable holds, not what type it is. daysLate is better than integerNumber1.
• Tip: when in doubt about a String method, open JShell and try it. Five seconds versus ten minutes of guessing.

Without running the code, write down what each line prints and justify why. Then check it in JShell or by compiling it.

Write the class FullCard that declares the variables needed for the book "Design Patterns" (ISBN 978-0000000002, year 1994, author "Erich Gamma et al.", available) and computes and displays:

1. The book's age in years relative to 2026.
2. The ISBN without the 978- prefix.
3. The title in uppercase.
4. Whether the title is longer than 10 characters (use a boolean variable and compute the value with a comparison, without if).

Use final constants where appropriate and respect the naming conventions.

The following code has six compilation errors related to types. Find them, explain each one and write the corrected version.

Solution 1

Line-by-line justification:

• a / b → 3. Both are int, so integer division happens: the result 3.5 is truncated to 3. It is Java's most classic gotcha.
• (double) a / b → 3.5. The cast applies to a before the division, so the operation is 7.0 / 2 and promotion gives 3.5.
• (int) 3.99 → 3. The cast to an integer truncates the decimal part; it does not round.
• Math.round(3.99) → 4. This one does round to the nearest integer.
• title → Effective Java. toUpperCase() returns a new string that is discarded, because it was not assigned. Strings are immutable.
• substring(0, 9) → Effective. From index 0 included up to 9 excluded: characters 0 through 8.
• length() → 14. "Effective Java" has 9 + 1 space + 4 = 14 characters.
• "Total: " + 2 + 3 → Total: 23. It is evaluated left to right: "Total: " + 2 gives "Total: 2", and the 3 is glued onto that string.
• "Total: " + (2 + 3) → Total: 5. The parentheses force the numeric addition first.
• (byte) 300 → 44. A byte only reaches 127. The value overflows and only the low 8 bits of 300 are kept (100101100 → 00101100 = 44). There is no warning at all: it is a silent loss.

Solution 2

Output:

The key idea in point 4: a comparison such as title.length() > 10 is a boolean expression. You do not need an if to obtain true or false; the if is for deciding what to do with that value, and that arrives in module 2.

Solution 3

The six errors:

1. float dailyRate = 0.25; — the literal 0.25 is a double; it does not fit in a float without a suffix. Fix: 0.25f (or better, use double).
2. long identifier = 100000000045; — the literal is read as an int and overflows its range. The L suffix is missing.
3. char section = "J"; — double quotes create a String. A char needs single quotes: 'J'.
4. int fine = 3.75; — assigning a double to an int is a narrowing conversion and requires an explicit cast (or, better, declaring fine as a double, which is the right thing for money).
5. LOAN_DAYS = 20; — the variable is final; it cannot be reassigned.
6. System.out.println(pages); — pages has been declared but never initialised, and local variables must have a value before being read.

Corrected version:

You now know how to declare, initialise and assign variables; you know the eight primitive types with their ranges and which ones you will really use; you write literals in any base and with the right suffixes; you tell primitives (which hold the value) apart from references (which hold an arrow into the heap); you have a grip on String, its immutability and its essential methods, including text blocks; you convert between types understanding when the conversion is automatic and when it truncates; you use wrappers and Integer.parseInt to turn text into numbers; you protect your business rules with final; and you know when var helps and when it gets in the way. With all of that you have modelled the first BiblioTech book.

In the next lesson, Operators, we will put that data in motion: arithmetic (including the integer-division trap and the modulo), compound assignment, increment and decrement, comparisons, logical operators with short-circuit evaluation, the ternary operator, bitwise operations, precedence, and the classic mistake of comparing strings with == instead of equals. The thread will be calculating the late fine for a BiblioTech loan.