Classes in Java: Blueprints, Components, and Syntax Rules

// Every component of a class declaration, in one compilable file.
public class ClassesInJavaDemo {
    // A compile-time constant, because it is static final with an initialiser
    private static final int MAX_NAME_LENGTH = 50;
    private static final int ONE_HUNDRED = 100;
    private static final int SENIOR_THRESHOLD_YEARS = 10;
    // A STATIC field: exactly one copy, shared by every Employee
    private static int nextId = ONE_HUNDRED;
    // INSTANCE fields: each Employee gets its own copy
    private final int id;
    private String name;
    private int yearsOfService;
    // A CONSTRUCTOR: same name as the class, no return type at all
    public ClassesInJavaDemo() {
        this("Unnamed", 0);
        // delegates to the other constructor
    } public ClassesInJavaDemo(String name, int yearsOfService) {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Name is required");
        } this.name = name;
        this.yearsOfService = yearsOfService;
        this.id = nextId++;
    } // An INSTANCE initializer block, which runs before the constructor body
{
        if (name != null && name.length() > MAX_NAME_LENGTH) {
            throw new IllegalArgumentException("Name exceeds " + MAX_NAME_LENGTH);
        }
    } public int getId() {
        return id;
    } public String getName() {
        return name;
    } public void setName(String name) {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Name is required");
        } this.name = name;
    } public void accrueYear() {
        yearsOfService++;
    } // A STATIC method: no this, so it belongs to the class
    public static int getCreatedCount() {
        return nextId - ONE_HUNDRED;
    } public static String describeNamingRules() {
        return "Classes are PascalCase, methods are camelCase, " + "constants are UPPER_SNAKE_CASE";
    } // A NESTED class: allowed any access modifier, including private
    private static class ReportingKey {
        private final String label;
        private ReportingKey(String label) {
            this.label = label;
        } private String getLabel() {
            return label;
        }
    } public String getReportLabel() {
        ReportingKey key = new ReportingKey("employee");
        return key.getLabel() + "-" + id;
    } // A LOCAL class: declared inside a method body
    public static String summarise(ClassesInJavaDemo employee) {
        class Summary {
            private final String text;
            Summary(String text) {
                this.text = text;
            } String render() {
                return text;
            }
        } Summary summary = new Summary( employee.getName() + " has " + employee.yearsOfService + " years");
        return summary.render();
    } public static void main(String[] args) {
        ClassesInJavaDemo sarah = new ClassesInJavaDemo("Sarah Connor", 4);
        ClassesInJavaDemo john = new ClassesInJavaDemo("John Connor", 12);
        System.out.println(sarah.getName() + " id is " + sarah.getId());
        System.out.println(john.getName() + " id is " + john.getId());
        // Both names refer to ONE object, so this is visible through sarah
        ClassesInJavaDemo alias = sarah;
        sarah.accrueYear();
        System.out.println("alias sees " + alias.getName() + " with " + summarise(alias));
        System.out.println("created count is " + getCreatedCount());
        System.out.println(describeNamingRules());
        System.out.println("report label: " + john.getReportLabel());
        // SHOWS THE FIVE RULES THIS FILE DEMONSTRATES
        //
        // 1) FILE NAMING. This file is ClassesInJavaDemo.java because the
        //    public class name matches it exactly, including case.
        // 2) ONE PUBLIC CLASS. Only ClassesInJavaDemo is public. Anything
        //    else declared at the top level must be package-private.
        // 3) NO PRIVATE TOP LEVEL. A top-level class can only be public or
        //    package-private, which is why ReportingKey is nested.
        // 4) CONSTRUCTORS ARE NOT METHODS. ClassesInJavaDemo() has no
        //    return type, so it is a constructor called only by new.
        // 5) MEMBERS MAY APPEAR IN ANY ORDER. Fields, constructors,
        //    initializer blocks, and methods can interleave freely.
        /*
            ACTUAL OUTPUT:

                Sarah Connor id is 100
                John Connor id is 101
                alias sees Sarah Connor with 5 years
                created count is 2
                Classes are PascalCase, methods are camelCase, constants are UPPER_SNAKE_CASE
                report label: employee-101

            THE FIVE COMPONENTS TO KNOW
            1) FIELDS. Instance fields give each object its own state.
               A static field gives the class exactly one shared copy, and
               a static final field with an initialiser is a compile-time
               constant the compiler can inline.
            2) METHODS. An instance method runs through this and needs an
               object. A static method has no this, is called on the class
               name, and cannot touch instance state at all.
            3) CONSTRUCTORS. Same name as the class, no return type, not
               even void, and called only by new. They are not inherited,
               so every subclass declares its own.
            4) INITIALIZER BLOCKS. Static and instance blocks run in order,
               before the constructor body, which makes them useful for
               setup that several constructors would otherwise repeat.
            5) NESTED TYPES. Classes, interfaces, enums, and records can be
               declared inside another class, and unlike top-level classes
               they may use any access modifier including private.
        */
    }
}