Core Language

Java is always pass-by-value — there is no pass-by-reference. For a primitive, the value itself is copied into the parameter. For an object, the reference is copied, so the parameter points at the very same object and the method can mutate its state through it. But reassigning the parameter rebinds only that local copy, so the caller's variable still refers to the original object.

A static member belongs to the class itself: there is one shared copy for all objects, and you access it through the class without any instance. An instance member belongs to each object, so every object gets its own separate copy. A static method cannot use instance fields directly because no particular object is associated with the call.

They are three unrelated things. final is a modifier: a final variable is a constant, a final method cannot be overridden, and a final class cannot be subclassed. finally is a block after try/catch that always runs, even if an exception is thrown, so it is used for cleanup. finalize() is a deprecated Object method the GC could call before reclaiming an object.

An enum is a class whose instances are a fixed set of named constants that the JVM creates once, which makes it type-safe and usable in a switch. Because each constant is a real object, an enum can declare fields, a private constructor and methods, and a single constant may even override a method with its own body. It implicitly extends java.lang.Enum, so it may implement interfaces but cannot extend a class.

A varargs parameter, written T... xs, lets a caller pass any number of arguments. It is compiler sugar: the parameter becomes a plain array T[], and at each call site the loose arguments are wrapped into a freshly allocated array whose reference is passed by value. Inside the method xs is just an array — never null, and empty for a zero-argument call. It must be the last parameter, and a method may declare only one.

Fields — both instance and static — are automatically initialized to a type-specific default: 0 for numeric types, false for boolean, '\u0000' for char, and null for references. A local variable gets no default at all; the compiler enforces definite assignment and rejects any read of it before it has been assigned a value.

Java is object-oriented, statically and strongly typed. Source compiles to bytecode that any JVM runs, making it platform-independent (write once, run anywhere). The JVM manages memory automatically via garbage collection, so there are no raw pointers, which keeps it robust. It also has built-in multithreading support.

Static parts run once, when the class is first loaded: the parent's static fields and static blocks first, then the child's, in source order. Then per instance: the parent runs its instance-field initializers and instance-initializer blocks and its constructor, then the child does the same. So all of the parent's static, then the child's static; then the parent's instance and constructor, then the child's.

It is the JVM's entry point, so the JVM must be able to call it before any object exists. public lets the JVM call it from outside the class. static means it runs without creating an instance. void says it returns nothing to the JVM. String[] args receives the command-line arguments as an array of strings.