Variable Classifications in Java

Java categorizes variables based on their scope and declaration context:

1. Local Variables: Defined within methods, constructors, or block scopes. They exist only during the execution of that block.
2. Instance (Member) Varriables: Delcared within a class but outside any method. These belong to a specific instance of the class.
3. Class (Static) Variables: Declared with the static keyword inside a class but outside methods. There is only one copy per class, regardless of how many objects are instantiated.

Class Structure and Execution

A standard Java class uses the public class declaration. The entry point of any application is the main method, which must be public, static, and return void.

public class EntryPoint {
    public static void main(String[] args) {
        // The system out print statement is the standard output mechanism
        System.out.println("Java Environment Ready");
    }
}

Identifier Constraints and Modifiers

Naming Rules: Identifiers (for classes, methods, and variables) must begin with a letter (A-Z, a-z), a dollar sign ($), or an underscore (_). Subsequent characters can also include digits. Java is case-sensitive and reserved keywords cannot be used as identifiers.

Modifier Types: Java utilizes modifiers to define access levels and behavioral properties:

• Access Modifiers: public, protected, private, and the default (package-private).
• Non-Access Modifiers: static, final, abstract, synchronized.

Object Lifecycle: Declaration, Instantiation, and Initialization

Creating an object involves three distinct steps:

1. Declaration: Mapping a variable name to an object type.
2. Instantiation: Using the new keyword to allocate memory.
3. Initialization: The new keyword triggers a constructor call to set initial values.

public class Device {
    public Device(String modelName) {
        System.out.println("Activating device: " + modelName);
    }

    public static void main(String[] args) {
        // Declaration and Instantiation
        Device mobile = new Device("Alpha-1");
    }
}

Interacting with Members and Methods

Instance variables and methods are accessed via the dot operator after an object has been initialized.

public class UserProfile {
    int userAge;

    public UserProfile(String username) {
        System.out.println("User: " + username);
    }

    public void updateAge(int years) {
        userAge = years;
    }

    public int fetchAge() {
        System.out.println("Retrieved Age: " + userAge);
        return userAge;
    }

    public static void main(String[] args) {
        UserProfile profile = new UserProfile("Alice");
        profile.updateAge(28);
        profile.fetchAge();
        System.out.println("Direct Access Value: " + profile.userAge);
    }
}

Source File Organization

When managing Java source files, specific structural rules apply:

1. A single source file can contain only one public class.
2. The filename must exactly match the name of the public class.
3. If a package statement is present, it must be the first line of the file.
4. import statements must be placed between the package declaration and the class definition.

Java Data Type System

Primitive Data Types

Java defines eight built-in primitives:

• Integer types: byte (8-bit), short (16-bit), int (32-bit), long (64-bit).
• Floating-point types: float (32-bit), double (64-bit).
• Character type: char (16-bit Unicode).
• Logical type: boolean (true/false).

Reference Types

Reference variables point to objects or arrays. Unlike primitives, reference variables are similar to pointers in that they store the address of the data. Thier default value is always null.

Constants

Constants are defined using the final keyword. Once assigned, their value cannot be altered during runtime.

final double GRAVITY = 9.81;
int binaryVal = 0b1010; // Binary literal
int hexVal = 0xFF;      // Hexadecimal literal

Type Conversion Mechanisms

Java supports automatic and manual type conversion. Widening (moving from a smaller to a larger capacity type) is automatic: byte → short → char → int → long → float → double.

public class TypeCasting {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter; // Automatic widening
        System.out.println("ASCII Code: " + code);

        double price = 99.99;
        int roundedPrice = (int) price; // Explicit narrowing
        System.out.println("Cast value: " + roundedPrice);
    }
}

Access Control Visibility

• private: Accessible only within the defining class. Best for data encapsulation.
• default: Accessible by classes within the same package.
• protected: Accessible within the same package and by subclasses in other packages.
• public: Accessible from any other class.

Private fields are typically managed via public getter and setter methods to maintain control over data integrity.

public class Account {
    private double balance;

    public double getBalance() {
        return balance;
    }

    public void setBalance(double amount) {
        if (amount >= 0) {
            this.balance = amount;
        }
    }
}

Static Context and Shared Data

The static keyword creates members that exist independently of class instances. Static methods cannot access instance variables directly because they operate at the class level rather than the object level.

public class MetricTracker {
    private static int hitCount = 0;

    public static void recordHit() {
        hitCount++;
    }

    public static int getHits() {
        return hitCount;
    }

    public static void main(String[] args) {
        MetricTracker.recordHit();
        MetricTracker.recordHit();
        System.out.println("Total Hits: " + MetricTracker.getHits());
    }
}

Increment and Decrement Operations

Unlike Python, Java includes the ++ and -- operators. The position (prefix vs. postfix) determines whether the increment happens before or after the value is evaluated in an expression.

public class OpCheck {
    public static void main(String[] args) {
        int x = 5;
        System.out.println("Initial: " + x);
        System.out.println("Prefix ++x: " + (++x)); // Increments then prints
        System.out.println("Postfix x++: " + (x++)); // Prints then increments
        System.out.println("Final: " + x);
    }
}