Java Syntax — The Complete Guide

// File: StudentGreeter.java
package com.techsustainify.tutorial;

public class StudentGreeter {

    // Entry point — JVM starts here
    public static void main(String[] args) {
        String name = "Arjun";
        int batch = 2026;
        System.out.println("Hello, " + name + "! Batch: " + batch);
    }
}

// Declaration statement
int score = 95;

// Assignment statement
score = score + 5;

// Method call statement
System.out.println("Score: " + score);

// Control flow statement (no semicolon — has a block)
if (score >= 90) {
    System.out.println("Grade: A");
}

int a = 10, b = 3;

// Arithmetic expression → evaluates to 13
int sum = a + b;

// Relational expression → evaluates to true (boolean)
boolean isPassed = sum > 10;

// String concatenation expression → "Result: 13"
String msg = "Result: " + sum;

// Method call expression → returns int
int maxVal = Math.max(a, b);

public class Blocks {               // class block — outermost

    public static void main(String[] args) {  // method block
        int x = 100;

        if (x > 50) {               // if-block
            int bonus = 10;          // only visible inside this block
            System.out.println(x + bonus);
        }
        // System.out.println(bonus); → ERROR: bonus out of scope
    }
}

// ✅ Valid identifiers
int age;
int _count;
int $price;
int studentAge2026;
int MAX_SIZE;

// ❌ Invalid identifiers — compiler error
// int 2name;        → cannot start with digit
// int my-score;     → hyphen not allowed
// int class;        → reserved keyword
// int my score;     → space not allowed
// int @email;       → @ not allowed

// 1. Single-line comment — from // to end of line
int speed = 120;  // speed in km/h

/*
 * 2. Multi-line comment — spans multiple lines
 * Useful for temporarily disabling code blocks
 * or writing long explanations
 */
int distance = 500;

/**
 * 3. Javadoc comment — used by javadoc tool to generate HTML docs
 *
 * Calculates time for a journey.
 *
 * @param distance  total distance in kilometres
 * @param speed     average speed in km/h
 * @return          time in hours as a double
 * @since           Java 1.0
 */
public static double calculateTime(int distance, int speed) {
    return (double) distance / speed;
}

// All three are identical to the compiler:

// Version 1 — standard 4-space indentation (recommended)
public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

// Version 2 — everything on one line (valid but unreadable)
public class Hello{public static void main(String[] args){System.out.println("Hello");}}

// Version 3 — extra blank lines (valid)
public   class   Hello   {
    public   static   void   main( String[]   args )   {
        System.out.println( "Hello" ) ;
    }
}

// ✅ Correct — System with capital S
System.out.println("Hello");

// ❌ Error — system with lowercase s
// system.out.println("Hello");  → cannot find symbol

// These are THREE different variables:
int age = 25;
int Age = 30;
int AGE = 35;

// Keywords must be lowercase — these are invalid as keywords:
// Int, INT, For, WHILE → these become identifiers, not keywords
// int Int = 10;  ← valid! 'Int' is an identifier here, not a keyword

package com.techsustainify.tutorial;        // package: all lowercase

public class BankAccount {                  // class: PascalCase

    private static final int MAX_OVERDRAFT = 5000;  // constant: UPPER_SNAKE

    private String accountHolder;            // variable: camelCase
    private double currentBalance;

    public void depositAmount(double amount) {       // method: camelCase
        currentBalance += amount;
    }

    public double getCurrentBalance() {
        return currentBalance;
    }
}

public class SyntaxErrors {
    public static void main(String[] args) {

        // ERROR 1: Missing semicolon
        // int x = 10       ← 'expected ;'
        int x = 10;  // ✅ fixed

        // ERROR 2: Wrong capitalization (Java is case-sensitive)
        // system.out.println("Hi");  ← 'cannot find symbol'
        System.out.println("Hi");  // ✅ fixed

        // ERROR 3: Unclosed string literal
        // String msg = "Hello;   ← 'unclosed string literal'
        String msg = "Hello";  // ✅ fixed

        // ERROR 4: Mismatched braces
        if (x > 5) {
            System.out.println("big");
        }  // ✅ every { must have a matching }

        // ERROR 5: Class name ≠ filename
        // class MyClass {} in file OtherName.java → compile error

    }
}

// Old way — messy string concatenation
String oldJson = "{\"name\": \"Arjun\", \"batch\": 2026}";

// Java 15+ Text Block — clean and readable
String json = """
        {
            "name": "Arjun",
            "batch": 2026,
            "language": "Java"
        }
        """;

// Record — immutable data class with 1 line of syntax
// Compiler auto-generates: constructor, getters, equals(), hashCode(), toString()
record Student(String name, int rollNo, double gpa) {}

public static void main(String[] args) {
    Student s = new Student("Priya", 42, 9.1);
    System.out.println(s.name());    // Priya
    System.out.println(s);            // Student[name=Priya, rollNo=42, gpa=9.1]
}

// Before Java 10 — explicit types everywhere
ArrayList<String> names = new ArrayList<String>();

// Java 10+ — compiler infers the type from right-hand side
var names   = new ArrayList<String>();  // still strongly typed!
var count   = 42;                        // inferred as int
var message = "Hello Java 21";           // inferred as String

// var is NOT dynamic typing — type is fixed at compile time
// message = 99;  ← COMPILE ERROR — String ≠ int

Object obj = "Hello, Java 21!";

// Old way — explicit cast required
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// Java 16+ pattern matching — bind variable in one step
if (obj instanceof String s) {
    System.out.println(s.length());  // s is already cast and scoped
}

// Sealed class — restricts which classes can extend it
public sealed class Shape permits Circle, Rectangle, Triangle {}

public final class Circle    extends Shape { double radius; }
public final class Rectangle extends Shape { double width, height; }
public final class Triangle  extends Shape { double base, height; }

// The compiler now knows every possible Shape subtype — enables exhaustive pattern matching