First Java Programs

A first Java program gives the computer a short list of instructions. The surrounding class and main method tell Java where those instructions belong and where execution begins.

Put instructions inside main

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

The outer braces enclose the class body. The inner braces enclose the method body. When this program starts, Java runs the first statement inside main. More statements placed underneath run from top to bottom. When main finishes, this small program ends.

Copy public static void main(String[] args) carefully. Here, public lets the launcher call the method, static allows it to run without first creating an object, and void says that the method returns no result. String[] args receives command-line words typed after the program name. You can print a message without using those words.

Match punctuation and names

A statement such as System.out.println("Hi"); ends with a semicolon. An opening brace { needs a closing brace }. The class and method headers shown above open blocks; do not replace those opening braces with semicolons. Indenting the statement four spaces farther than its method header makes the nesting visible.

Save public class Hello in Hello.java. The public class name and the part before .java must match exactly, including capitals. If the declaration says public class Other, the file must be Other.java. A compiler message saying that the class should be declared in another file points to this mismatch.

Java is case-sensitive. The name System must start with a capital S; system.out.println("Hi"); fails to compile. A method called Main is a different method from main. A class containing only Main can compile, yet the launcher cannot find the intended entry method when you run it.

Make the code readable

Use one statement per line and four spaces of indentation for each level of braces. Most spaces and line breaks between code elements do not affect compilation. Spaces inside quoted text do affect the output. Class names conventionally use PascalCase, as in TravelTime.

A comment explains code to people. Java ignores everything after // on that line. A block comment starts with /* and ends with */, and can span several lines. A useful comment explains a reason, such as // Convert hours to seconds, beside a conversion whose purpose might be unclear.

Recognize the shorter form

Java 25 and later also support a compact source file:

void main() {
    IO.println("Hello, world!");
}

This form omits the explicit class declaration. IO.println prints a line, and IO.readln("Your name: ") displays a prompt and returns the typed line. The classic class form works with older Java versions too; both forms provide a main method where execution starts.

Writing source code and running a program are separate steps. Java first checks and translates your code, then executes it. Knowing which step failed helps you decide where to look.

Compile the source, then launch the class

Source code is the text in a .java file. The compiler, javac, translates valid source into bytecode in a .class file. The Java Virtual Machine (JVM) executes that bytecode. A suitable JVM lets the same bytecode run on different operating systems.

Open a terminal in the folder containing Hello.java and enter:

javac Hello.java
java Hello

The first command creates Hello.class when compilation succeeds. The second starts the program. Its argument is the class name, without .class: java Hello.class asks the launcher to find the wrong class name and fails.

The JDK, or Java Development Kit, provides both commands. An IDE, such as IntelliJ IDEA, Eclipse, NetBeans, or Visual Studio Code with Java support, performs compilation and launching when you press Run. It can mark errors while you type, but those are still errors in the same Java language.

Since Java 11, source-file mode offers a shortcut for a single small program:

java Hello.java

This compiles in memory and runs the source without leaving a .class file. Keep the two forms distinct: java Hello launches a compiled class, while java Hello.java launches source.

Read compile-time errors

A compile-time error prevents successful compilation. For example, a missing semicolon can produce:

Hello.java:3: error: ';' expected
        System.out.println("Hello")
                                   ^

The message identifies the file, line, and place where the compiler noticed the problem. The real mistake may be earlier: an unclosed quote on one line can confuse later lines. Read the marked line and the one before it. Fix the first reported error and compile again before changing several other lines. One repair can remove many later messages.

Separate runtime errors from wrong answers

If an integer variable divisor contains zero, 5 / divisor fails during execution with ArithmeticException: / by zero. The arithmetic statement can be valid source even though its runtime values make it fail.

A program that prints an average of 8 when the correct value is about 8.33 has a logic error. No compiler message can tell you that this is the wrong result for your task. Test with known inputs, inspect intermediate values, and find the first incorrect calculation.

Work in a short cycle: edit, save, compile, run, test. Saving matters: compilation reads the saved file, so unsaved edits cannot change the compiled program.

Printed output is the first way to see what a program does. Java gives you control over the characters it prints and the point where the next line begins.

Follow the output position

System.out.print(...) writes its value and leaves the output position on the same line. System.out.println(...) writes its value and then starts a new line. Calling System.out.println() with empty parentheses adds just a line break.

System.out.print("Hello");
System.out.print(", ");
System.out.println("world");
System.out.println("Bye");

The first two calls leave the position after the space following the comma. The third adds world at that position, then moves to a new line. The exact output is:

Hello, world
Bye

Java inserts no spaces between calls. If you remove the space in ", ", the first line becomes "Hello,world". An empty println() between the final two statements would create a blank line between the messages.

Decide whether you want text or a value

A string literal is text enclosed in double quotation marks. Printing "7 * 6" displays the text "7 * 6". Printing 7 * 6 evaluates the multiplication and displays "42". The quotation marks are code punctuation; they are not printed as part of the literal.

Likewise, if name stores "Ada", System.out.println(name); displays "Ada", while System.out.println("name"); displays "name". Use the variable without quotes when you want its stored value.

Single quotes have a different role. 'A' is one char value. 'Hello' cannot hold a multi-character message and causes a compile-time error. Use "Hello" for that text.

Put special characters in a string

An escape sequence begins with a backslash and represents a character inside the literal.

For example:

System.out.println("She said \"hi\"");
System.out.println("C:\\Users");

These statements display She said "hi" and C:\Users, on separate lines. The extra backslashes tell Java how to interpret the following character; they are not all copied to the output.

A single call can also print several lines:

System.out.println("Name:\tAda\nAge:\t36");

The tab separates the label from the value, and \n puts the age on the next line. The println call adds its own final line break too. A tab moves to a tab stop, so its visible width depends on the output environment.

An ordinary quoted string literal must open and close on the same source line. Pressing Enter in the middle of it leaves an unclosed literal. To split a long message across source lines, write two complete literals joined with +, or use separate printing calls.

A variable gives a value a name so that later statements can use it. Its type tells Java what kind of value it can hold; assignment changes the stored value.

Declare and initialize

int age;
age = 36;

The declaration introduces age as an int. The assignment stores 36. The combined form int age = 36; is called initialization. A local variable must receive a value before you read it. Declaring int age; and immediately printing age gives an error that the variable might not have been initialized.

Declare a name once in the same method body. To change its value later, write age = 37;, without repeating int. A second int age = 37; in that body tries to declare the same variable again.

Read assignment from right to left

The right side of = is calculated first. Java then stores that result in the variable on the left:

int count = 5;
count = count + 1;

The second statement reads the current 5, adds 1, and stores 6. The = sign means assignment, not a mathematical claim that a number equals itself plus one. The left side must name somewhere to store the value; 36 = age; is invalid.

Assignment copies the value at that moment:

int a = 5;
int b = a;
a = 10;

Now a holds 10 and b holds 5. There is no continuing link that recalculates b when a changes.

Trace a swap

Suppose first holds 4 and second holds 9. The sequence first = second; second = first; loses the 4 at the first step and leaves both values at 9. Preserve the original value first:

int temp = first;
first = second;
second = temp;

A trace table records each variable after each statement. For int x = 3; x = x * 2; x = x + 1;, the values are 3, then 6, then 7. Update one row at a time using the latest stored values.

Choose useful names and fixed types

Names can contain letters, digits, underscores, and dollar signs. They cannot begin with a digit or be a reserved word such as class. Case matters: total and Total differ. Use descriptive camelCase names such as distanceKm or secondsLeft.

A final variable can be assigned only once. final int SECONDS_PER_HOUR = 3600; gives a fixed conversion factor a clear name. Reassigning it fails to compile. Constants conventionally use uppercase words separated by underscores.

Since Java 10, var can infer a local variable’s type from its initializer. var count = 10; infers int; var price = 2.5; infers double. The inferred type stays fixed. var count; fails because there is no initializer from which to infer a type.

The type of a value controls its range, its literal spelling, and the calculations Java can perform with it. Use int for ordinary counts and double for ordinary measurements, while recognizing the other primitive types.

Compare the eight primitive types

Finite float values extend approximately from −3.4 × 10³⁸ to +3.4 × 10³⁸; finite double values extend approximately from −1.8 × 10³⁰⁸ to +1.8 × 10³⁰⁸. These wide ranges do not make every decimal within them exactly representable.

A char often represents a single character, such as 'A'. Some Unicode characters require two UTF-16 code units, so one char cannot represent every possible character. 'A' has numeric code 65, 'a' has 97, and '7' has 55. The character '7' is distinct from the integer 7. A boolean is not a number: boolean active = 1; fails.

Spell literals for their types

A literal writes a value directly in source. 42 is an int literal, 42L a long, 3.5 a double, and 3.5f a float. Character literals use single quotes; String literals use double quotes. Primitive type names are lowercase, while String begins with a capital letter.

Write long large = 3000000000L;. Without the L, that integer literal is too large. Write float rate = 3.5f;: plain 3.5 has type double, which Java does not silently narrow to float. A fitting whole-number constant can initialize a smaller integer type: byte b = 100; compiles, but byte b = 200; does not.

Underscores between digits make a literal readable: 1_000_000 has the same value as 1000000. Scientific notation uses e, as in 1.5e3, meaning 1500.0. Source-code decimals always use a point.

Watch the operation’s range

An integer calculation can overflow without an error message. Adding 1 to the largest int wraps to the smallest int. The product 50_000 * 50_000 uses int arithmetic and produces -1794967296. In 50_000L * 50_000, one operand is long, so the product is the correct 2500000000.

Changing only the receiving variable to long is too late to repair an int product that has already overflowed. Choose a wide enough operand before the multiplication.

Floating-point values have a different limitation. Many decimal fractions are stored as binary approximations: 0.1 + 0.2 prints 0.30000000000000004. Format such results for display. Exact money calculations can store whole cents in a long; the BigDecimal class is another exact-decimal option.

A String holds text, including spaces, digits, punctuation, or no characters at all. The + operator can combine that text with other values to build a message.

Join values into text

String firstName = "Ada";
String lastName = "Lovelace";
System.out.println(firstName + " " + lastName);

The output is "Ada Lovelace". The middle literal supplies the space. Without it, firstName + lastName would produce "AdaLovelace". Concatenation does not add separators for you.

Concatenation means joining values into a new string. If either operand of + is a String, Java converts the other value to text and joins them. Thus "Age: " + 36 becomes "Age: 36", and "Price: " + 2.5 becomes "Price: 2.5". The digits in the result are now part of a text value.

String begins with a capital S. Unlike the eight primitive types, it is a class. Writing string name = "Ada"; with a lowercase s fails to compile. The empty string "" is valid text with no characters; it is not a missing value.

Follow plus signs from left to right

Consider:

System.out.println("Sum: " + 2 + 3);

The first + joins the String and 2, making "Sum: 2". The second joins that String and 3, making "Sum: 23". Once the running result is text, the next + continues to join text.

Compare three forms:

Use parentheses when a message should contain the result of an addition or subtraction. For example, "Diff: " + (5 - 2) gives "Diff: 3". Without the parentheses, "Diff: " + 5 - 2 tries to subtract 2 from a String and fails to compile.

Multiplication and division have higher precedence than +. The expression "Area: " + 4 * 5 calculates the product first and gives "Area: 20".

Build a message in stages

String message = "Hi";
message += "!";

The updated variable holds "Hi!". For a String, += appends text by assigning the joined result back to the variable. You can assemble a short message with several statements and print it once at the end.

Be careful with characters. Two char operands do not trigger String concatenation. 'A' + 'B' adds their numeric codes, 65 and 66, producing the int 131. Starting with the empty String changes the chain: "" + 'A' + 'B' first creates "A", then "AB". Quotes determine the operand types, so they also determine the meaning of +.

An expression combines values to produce a result. Java evaluates it according to operator precedence, then a statement can store or print that result.

Write the operations explicitly

The arithmetic operators are +, -, *, /, and %: addition, subtraction, multiplication, division, and remainder. With int width = 4; and int height = 5;, width * height evaluates to 20.

Every multiplication needs *. The algebra-like form 2(3 + 4) is invalid Java; write 2 * (3 + 4). Java has no arithmetic power operator. 2 ^ 3 means a bitwise operation and produces 1, not 8. To square a value, write x * x; to calculate another power, use Math.pow.

Apply precedence before reading left to right

At the same level, these arithmetic operators group from left to right. 2 + 3 * 4 is 14; (2 + 3) * 4 is 20. In 10 - 4 - 3, the first subtraction gives 6 and the second gives 3. In 24 / 4 * 2, the division gives 6 and multiplication gives 12. Treating the denominator as 4 * 2 would require parentheses.

Build an average correctly

Suppose int a = 7, b = 8, c = 10;. The expression a + b + c / 3 divides only c. Integer division makes 10 / 3 equal 3, and the additions then give 18.

(a + b + c) / 3 groups the whole total, 25, but both operands of / are integers. The result is 8. Using (a + b + c) / 3.0 keeps the fractional part and produces 8.333333333333334.

The operand types control the arithmetic. Two int operands produce an int result. A double operand makes the other numeric operand convert to double, as in 5 * 2.0, whose result is 10.0. The receiving variable does not change how the earlier arithmetic was done.

Update a stored value

int total = 10;
total += 5;
total *= 2;
total--;

The stored values become 10, 15, 30, and 29. For these int operands, total += 5; performs the same update as total = total + 5;. The operators -=, /=, and %= similarly combine an operation with assignment. count++; increases a variable by 1, and count--; decreases it by 1. Used as separate statements, their effect is easy to trace.

An expression such as a + b does not change either operand. To use its result, assign it or pass it to a printing call: int sum = a + b; or System.out.println(a + b);. The isolated line a + b; does not compile because Java does not allow that arithmetic expression as a standalone statement. Assignments, increments, decrements, and method calls can stand alone and can have effects.

Whole-number division answers how many complete groups fit. The remainder tells you what is left. Together, these operations split a quantity into useful parts.

Predict quotient and remainder

When both operands are integers, / discards the fractional part, moving toward zero. 7 / 2 is 3, 2 / 3 is 0, and -7 / 2 is −3. This is truncation, not rounding to the nearest integer.

The remainder operator % returns what remains after the division. 17 / 5 gives 3, and 17 % 5 gives 2. Three groups of 5 account for 15, leaving 2. For integer operands and a nonzero divisor, (a / b) * b + a % b reconstructs a using Java integer arithmetic.

The sign of a nonzero remainder follows the left operand: -7 % 3 is −1, while 7 % -3 is 1. For nonnegative integers, n % 2 is 0 for even values and 1 for odd values.

Split seconds into larger units

Start with 3725 seconds:

int totalSeconds = 3725;
int hours = totalSeconds / 3600;
int secondsAfterHours = totalSeconds % 3600;
int minutes = secondsAfterHours / 60;
int seconds = secondsAfterHours % 60;

The first division finds 1 complete hour. The remainder is 125 seconds. Dividing that remainder by 60 finds 2 minutes, with 5 seconds left. The result is 1 h 2 min 5 s. Rebuilding the total gives 3600 seconds plus 120 seconds plus 5 seconds, or 3725.

Use the remainder after removing hours to find minutes within the current hour. Dividing the original total by 60 would give all 62 complete minutes, including the minutes already counted as an hour.

The same operators extract decimal digits from a nonnegative integer. 4827 % 10 gives the last digit, 7; 4827 / 10 gives the remaining leading digits, 482.

Distinguish full groups from enough containers

For 50 eggs and boxes holding 12 eggs, 50 / 12 gives 4 full boxes and 50 % 12 gives 2 eggs left. Holding every egg needs a fifth box. For nonnegative counts and positive box sizes, the integer expression (count + size - 1) / size rounds the container count up, provided the addition does not overflow. For this example, (50 + 12 - 1) / 12 gives 5.

Choose fractional division before it happens

A double destination cannot recover a discarded fraction. Make an operand double before dividing when you need the fraction.

Division or remainder by integer zero throws ArithmeticException during execution. Floating-point division behaves differently: 5.0 / 0 gives Infinity, -5.0 / 0 gives -Infinity, and 0.0 / 0 gives NaN, meaning "not a number". A result can therefore be unusable even when execution does not stop.

Decimal arithmetic is useful for measurements and averages. The Math class adds ready-made calculations, while rounding lets you choose how to store or present a result.

Keep fractions and recognize approximations

150 / 2.5 gives 60.0, a speed in km/h when distance is 150 km and time is 2.5 hours. Because an operand is double, the division keeps a fractional result when needed. Ordinary whole-valued doubles print with a decimal part, such as 60.0.

A double stores a binary approximation of many decimal values. Consequently, 1.1 * 3 prints 3.3000000000000003, and 10.0 / 3 prints 3.3333333333333335. Keep the working value through later calculations and round when presenting it.

Large or small values can print in scientific notation. 1.23456789E7 represents 12345678.9, and 1.0E-4 represents 0.0001. For positive finite values, ordinary notation is used from 0.001 up to, but not including, 10000000. Scientific notation changes the displayed form, not the underlying value.

Call useful Math methods

Math is in java.lang, so no import is needed.

Math.sqrt and Math.pow return double. The constant Math.PI is approximately 3.141592653589793. For a circle with radius 2.5 cm, Math.PI * 2.5 * 2.5 gives 19.634954084936208 cm², about 19.63 cm². For a right triangle with legs of 3 cm and 4 cm, Math.sqrt(3 * 3 + 4 * 4) first adds the squared legs to get 25, then gives 5.0 cm.

Choose a rounding direction

round chooses the nearest whole number, with exact halfway values going toward positive infinity. floor goes down toward negative infinity; ceil goes up toward positive infinity. For negatives, "down" means a more negative value, so flooring −2.7 gives −3.0.

For a double argument, Math.round returns a long. Store that result in a long, or explicitly convert it when an int is appropriate: int rounded = (int) Math.round(2.7); stores 3. floor and ceil return double values.

To round a stored value to two decimal places, use Math.round(12.3456 * 100) / 100.0, which gives 12.35. The scale-up step makes the hundredths position the whole-number boundary. Dividing by 100.0 scales back with floating-point division; dividing by integer 100 would discard the fraction and give 12. If only the printed text needs rounding, printf can format the original value directly.

Java sometimes converts a numeric value automatically. Other conversions need an explicit cast. A cast changes the type of a value at a particular point in an expression, so its position affects the answer.

Widen automatically

The main numeric widening path is byte → short → int → long → float → double. A char also widens to int and onward. For example, double d = 5; stores 5.0, and any int value fits exactly in a long.

Widening into a floating-point type can lose precision. int to float, long to float, and long to double may round a large integer. Converting an int to a double is exact. For example, (float) 16777217 becomes 1.6777216E7, representing 16777216.

Cast a narrowing conversion

A cast writes the target type in parentheses before the value:

int n = (int) 3.99;

The stored result is 3. Without (int), Java rejects assigning the double literal to an int. Converting a finite, in-range double to an integer truncates toward zero: (int) -3.99 gives −3 too. Truncation differs from rounding; (int) Math.round(3.99) gives 4.

Narrowing conversions generally need a cast. One useful exception allows a fitting constant integer expression to initialize a byte, short, or char. Thus byte b = 100; is valid without (byte). A nonconstant int variable does not receive this constant-assignment exception simply because its current value fits.

Put the cast before the operation that needs it

Let int sum = 25; and int count = 3;.

A cast binds more tightly than multiplication and division. Parentheses determine whether it applies to one operand or a completed calculation. Casting after integer division cannot restore discarded information.

Predict changes to characters and small integers

(int) 'A' gives its character code, 65. Adding 1 to 'A' produces the int 66. To turn the complete result back into a character, write (char) ('A' + 1), giving 'B'. Without the outer parentheses around the sum, the cast would apply only to 'A'.

Narrowing between integer types keeps only the lower bits. (byte) 200 becomes −56; (int) 3_000_000_000L becomes −1294967296. A cast permits the conversion but does not check that the original value fits.

Compound assignment has a built-in conversion to the left-hand type. With int x = 10;, x += 2.7; calculates 12.7 and narrows it to 12. The plain assignment x = x + 2.7; fails because its right side is double.

Text can contain digits without being a number. To calculate with typed or stored text, parse it into a numeric type. To build a message, convert a numeric value back into text.

Parse text before calculating

The expression "42" + 1 produces "421". Because the left operand is a String, + performs concatenation. Integer.parseInt("42") + 1 produces 43 because parsing supplies an int before addition.

String first = "12";
String second = "30";
int total = Integer.parseInt(first) + Integer.parseInt(second);

Here total holds 42. Joining the original strings would give "1230". Choose conversion based on the value’s intended use, not on whether its characters happen to look numeric.

Integer.parseInt(text) returns an int; Long.parseLong(text) returns a long. Integer.valueOf("42") returns an Integer object, which Java automatically converts to int when an int is required. For a direct text-to-int operation, parseInt states the intended result clearly.

Parse decimals and truth values

Double.parseDouble("3.75") returns the double 3.75. Its text format uses a decimal point on every computer, regardless of regional settings. Double.parseDouble("3,5") fails. Java source literals also use a point, though keyboard-reading methods can follow a locale.

Boolean.parseBoolean(text) follows a separate rule: it returns true for "true" in any mix of capital and lowercase letters, such as "TRUE". Every other text returns false, including "yes". It does not interpret a general affirmative word as true.

Recognize invalid numeric text

Invalid numeric text causes a NumberFormatException while the program runs. Integer.parseInt("4.5") fails because decimal text is not an integer representation. Integer.parseInt("") and Integer.parseInt(" 42") fail too. The exception message identifies the text that could not be converted.

Whitespace handling depends on the parser. Double.parseDouble ignores spaces at the start and end, while Integer.parseInt does not. Choose test inputs that reveal these differences when reading user data.

A convenient input pattern is to read one whole line and parse it:

int age = Integer.parseInt(scanner.nextLine());
double height = Double.parseDouble(scanner.nextLine());

Each call consumes its entire line, including the line ending. That keeps text and numeric input consistent and avoids mixing token reads with whole-line reads.

Turn a number into text

String.valueOf(42), Integer.toString(42), and "" + 42 all produce the String "42". Double.toString(2.50) produces "2.5". The original decimal spelling does not remain attached to the stored number, so this conversion does not add a trailing zero to preserve it.

Use String.format when you need stored text with a fixed number of decimal places. Use printf when you want to print that formatted text directly. Neither a numeric cast nor basic concatenation supplies a fixed two-place display.

Keyboard input arrives as text. A Scanner can read a whole line, one word, or a word converted into a number. Choose a consistent reading plan before asking the user for values.

Create one Scanner and read a line

import java.util.Scanner;

public class Greeting {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("What is your name? ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name + "!");
    }
}

The import goes before the class. The creation statement goes inside main and connects the Scanner to System.in. One Scanner is enough for this program. nextLine() waits for the typed line and returns its text without the line break. Typing "Ada" makes the final statement print "Hello, Ada!". Using print for the prompt keeps typing beside the question.

Choose lines or tokens

For "Ada Lovelace", next() returns "Ada". A following nextLine() returns " Lovelace", including its leading space. Two nextInt() calls can read "3 4" from one line. A numeric token that does not fit the method, such as "4.5" or "abc" for nextInt(), causes an InputMismatchException.

Account for the unread line ending

Suppose the user types "30", presses Enter, then types "Ada Lovelace" and presses Enter. This code does not read the name as intended:

int age = scanner.nextInt();
String name = scanner.nextLine();

nextInt() consumes 30 but leaves the line ending. nextLine() immediately consumes the empty remainder of that same line, so name is "". Add scanner.nextLine(); between the two statements to discard that remainder before reading the name on the next line.

Another solution is to read every answer with nextLine() and parse numeric lines: int age = Integer.parseInt(scanner.nextLine());. This avoids switching between two different units of input.

Make the decimal convention clear

nextDouble() follows the Scanner’s locale, initially the computer’s default formatting locale. A comma-decimal locale accepts "3,5" as a decimal and rejects "3.5" in this example. To read point decimals consistently, add import java.util.Locale; and create:

Scanner scanner = new Scanner(System.in).useLocale(Locale.US);

Reading a whole line with Double.parseDouble(scanner.nextLine()) also uses a point. Changing the Scanner locale does not change Java source-code literals or the locale used by later printf calls.

Read values in the order requested by the prompts. If you ask for a name and then an age, the first read must store the name. A misplaced read can either put data in the wrong variable or trigger a conversion error.

Formatted output controls how values appear inside a message. printf can show a fixed number of decimal places, add a line break, and align values in columns without changing their stored values.

Match placeholders with values

A format string contains ordinary text plus specifiers that begin with %. Each value-consuming specifier takes the next value supplied after the format string:

System.out.printf("%s is %d years old%n", "Ada", 36);

This prints "Ada is 36 years old" and starts a new line. %s displays text or another value as text, %d displays an integer such as an int or long, and %f displays a floating-point value. %n inserts a line break without consuming a value. %% prints one percent sign.

printf adds no line break automatically. Include %n when the next output should start on a new line. An ordinary \n escape also represents a newline character inside Java text; %n is the formatter’s platform-specific line separator.

Set decimal places for display

Plain %f prints six places after the decimal separator: formatting 2.5 gives "2.500000". The precision in %.2f requests two places:

System.out.printf("Total: %.2f%n", 12.3456);

With US formatting, the output is "Total: 12.35". The value is rounded in the displayed text. A variable containing 12.3456 still contains that working value after printing.

For System.out.printf("%d items at %.2f each, total %.2f%n", 3, 1.5, 3 * 1.5);, the values fill the three placeholders in order. With US settings the output is "3 items at 1.50 each, total 4.50".

Line up fields with width

A width is a minimum field size. %5d right-aligns an integer within at least five characters; %-6s left-aligns text within at least six. %6.1f combines width 6 with one decimal place.

System.out.printf("[%5d][%-6s][%6.1f]%n", 42, "Ada", 9.25);

With US settings, the exact output is [ 42][Ada ][ 9.3]. The square marks make the padding visible. A value longer than its width is still printed in full; width does not cut characters off.

A mismatched specifier causes a runtime error. printf("%d%n", 2.5) compiles but throws IllegalFormatConversionException because %d expects an integer value. Too few supplied values, as in printf("%d %d%n", 2), cause MissingFormatArgumentException.

Choose printing or stored text

String.format applies the same formatting rules but returns a String:

String line = String.format("%.1f km", 12.345);

With US settings, line holds "12.3 km"; nothing has been printed by that statement.

Both formatting methods use the default locale unless you pass one. Add import java.util.Locale;, then use System.out.printf(Locale.US, "%.2f%n", 12.3456); to ensure "12.35" instead of the "12,35" used by a comma-decimal locale. String.format can take Locale.US first too. Printing a double with println uses a point independently of the formatting locale.

A complete calculation program connects three stages: read the inputs, calculate with them, and print the results. Planning the values and their units before typing helps you choose types and test the result.

Plan a travel-time program

The inputs are distance in kilometers and average speed in km/h. Dividing distance by speed gives time in hours. Both measurements need double so the division can keep a fraction. The output will be whole hours and minutes, rounded to the nearest minute.

import java.util.Scanner;

public class TravelTime {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Distance (km): ");
        double distance = Double.parseDouble(scanner.nextLine());
        System.out.print("Speed (km/h): ");
        double speed = Double.parseDouble(scanner.nextLine());
        int totalMinutes = (int) Math.round(distance / speed * 60);
        int hours = totalMinutes / 60;
        int minutes = totalMinutes % 60;
        System.out.println("Travel time: " + hours + " h " + minutes + " min");
    }
}

For 150 km at 80 km/h, division gives 1.875 hours. Multiplication by 60 gives 112.5 minutes. Math.round returns the long 113, and the cast converts it to int. Integer division and remainder then give 1 hour and 53 minutes. The output is "Travel time: 1 h 53 min".

If distance and speed were both int, 150 / 80 * 60 would produce 60. The fraction disappears at the division, before the multiplication. Type choices belong in the plan, not just in the final output statement.

Choose display and arithmetic separately

For a bill total of 87.60 shared among 4 people, store the total in double and the count in int. double share = total / people; gives 21.9. With US formatting, System.out.printf("Each person pays %.2f%n", share); prints "Each person pays 21.90". Formatting supplies the second decimal place without changing the calculation.

For whole-number scores 7, 8, and 10, double average = (a + b + c) / 3.0; gives 8.333333333333334, displayed as "8.33" with %.2f. Parentheses group the total and the decimal divisor keeps its fraction.

Test against results you know

Work out expected results before running the program. For travel time, 120 km at 60 km/h should print 2 h 0 min. A distance of 0 km at a positive speed should print 0 h 0 min. Try inputs near a rounding boundary and larger valid distances to exercise more than the simplest calculation.

Include zero, negative, and large inputs when checking the program’s behavior. Decide whether each input makes sense for the task. A count of zero people makes total / people produce Infinity when total is a nonzero double; integer division by zero throws ArithmeticException. Successful execution alone does not establish a useful answer.

When output differs from your expectation, print intermediate values or trace them in a table. Find the first value that is wrong, fix the responsible statement, and rerun the known tests. Compare spaces and labels as well as numbers.

Use names such as totalMinutes, named constants such as MINUTES_PER_HOUR, units in prompts, and short comments that explain the purpose of a calculation.