Variables #

// Declaration separate from initialization
int count;         // declaration — no value yet
count = 42;        // initialization — given its first value

// Declaration + initialization at once (the more common way)
int price     = 15000;
double discount = 0.1;
String name   = "Budi";
boolean active = true;

// Declaring multiple variables of the same type in one line
// (allowed, but it hurts readability — avoid for variables with different meanings)
int x = 1, y = 2, z = 3;

public class LocalExample {

    public double calculateArea(double length, double width) {
        // area is a local variable — only exists inside this method
        double area = length * width;
        return area;
    } // area is removed here

    public void processData() {
        int total = 0;

        for (int i = 0; i < 10; i++) {
            // i is a local variable of the for block
            // temp is a local variable of the for block
            int temp = i * 2;
            total += temp;
        }
        // System.out.println(i);    // COMPILE ERROR: i is out of scope
        // System.out.println(temp); // COMPILE ERROR: temp is out of scope

        System.out.println("Total: " + total); // total is still in scope
    }
}

public class Product {
    // Instance variables — one per object
    String name;        // default: null
    double price;       // default: 0.0
    int stock;          // default: 0
    boolean available;  // default: false

    public Product(String name, double price, int stock) {
        this.name    = name;   // this. distinguishes the field from the parameter
        this.price   = price;
        this.stock   = stock;
        this.available = stock > 0;
    }
}

// Each object has its own copy of the instance variables
Product p1 = new Product("Laptop", 12_000_000, 5);
Product p2 = new Product("Mouse",  150_000,    20);

p1.price = 11_500_000; // only changes p1's price
System.out.println(p1.price); // 11500000.0
System.out.println(p2.price); // 150000.0 — unchanged

public class Employee {
    // Static variables — one for the whole class
    static int totalEmployees = 0;
    static String companyName = "PT Example";

    // Instance variables — one per object
    String name;
    int id;

    public Employee(String name) {
        totalEmployees++; // each new object increments the shared counter
        this.id   = totalEmployees;
        this.name = name;
    }
}

Employee e1 = new Employee("Andi");
Employee e2 = new Employee("Budi");
Employee e3 = new Employee("Cici");

// Access static variables via the class name (not via an object)
System.out.println(Employee.totalEmployees);  // 3
System.out.println(Employee.companyName); // PT Example

public class ScopeExample {
    int x = 10; // scope: the whole class (instance variable)

    public void method() {
        int y = 20; // scope: this method only

        if (true) {
            int z = 30; // scope: this if block only
            System.out.println(x); // ✓ can access x
            System.out.println(y); // ✓ can access y
            System.out.println(z); // ✓ can access z
        }

        System.out.println(x); // ✓
        System.out.println(y); // ✓
        // System.out.println(z); // ✗ COMPILE ERROR: z is out of scope
    }
}

public class Account {
    String name = "default"; // instance variable

    public void setName(String name) { // the parameter 'name' hides the field 'name'
        // ANTI-PATTERN: forgetting this. — the field isn't assigned, only the parameter to itself
        name = name; // ✗ does nothing useful

        // CORRECT: use this. to distinguish the field from the parameter
        this.name = name; // ✓ the field 'name' is assigned from the parameter 'name'
    }
}

// Without var — explicit type
ArrayList<Map<String, Integer>> data = new ArrayList<Map<String, Integer>>();
BufferedReader reader = new BufferedReader(new FileReader("file.txt"));

// With var — the compiler infers the type, code is more concise
var data   = new ArrayList<Map<String, Integer>>(); // type: ArrayList<Map<String, Integer>>
var reader = new BufferedReader(new FileReader("file.txt")); // type: BufferedReader
var number  = 42;       // type: int
var name   = "Budi";   // type: String
var price  = 99.9;     // type: double

// ANTI-PATTERN: var without immediate initialization — the compiler can't infer the type
var x;           // ✗ COMPILE ERROR
var y = null;    // ✗ COMPILE ERROR — the type of null can't be inferred

// ANTI-PATTERN: var for a variable name that doesn't explain the type
var d = getDashboardData(); // ✗ readers don't know d's type without looking at the method
var r = process(x);         // ✗ what type is r?

// CORRECT: var for types already clear from the context
var list = new ArrayList<String>();  // ✓ clear: ArrayList<String>
var map  = new HashMap<String, Integer>(); // ✓ clear
var i    = 0; // ✓ clear: int

// CORRECT: var is very useful in try-with-resources
try (var conn = DriverManager.getConnection(url);
     var stmt = conn.prepareStatement(sql)) {
    // ...
}

public class DefaultExample {
    int number;          // 0
    double decimal;      // 0.0
    boolean flag;        // false
    String text;         // null
    int[] arr;           // null (not an empty array!)

    public void check() {
        System.out.println(number);   // 0
        System.out.println(decimal);  // 0.0
        System.out.println(flag);     // false
        System.out.println(text);     // null

        // DON'T: access a null array directly
        // System.out.println(arr.length); // ✗ NullPointerException!

        // CORRECT: check for null first
        if (arr != null) {
            System.out.println(arr.length);
        }
    }
}

public void process(final String input) {
    // input = "other"; // ✗ COMPILE ERROR: a final parameter can't be changed

    final int limit = 100;
    // limit = 200; // ✗ COMPILE ERROR

    final List<String> list = new ArrayList<>();
    list.add("item"); // ✓ the list's contents can change
    // list = new ArrayList<>(); // ✗ the reference itself can't be reassigned
}

// ✗ ANTI-PATTERN 1: non-descriptive names
int a = getUserCount();
String s = getCustomerName();
double d = calculateTotalPrice();

// ✓ CORRECT: names explain the content and purpose
int userCount = getUserCount();
String customerName = getCustomerName();
double totalPrice = calculateTotalPrice();

// ✗ ANTI-PATTERN 2: declaring all variables at the top of the method (old C style)
public void processOrder() {
    int i, j, total, discount, price;
    String name, address, city;
    // ... 30 lines of code ...
    total = calculateTotal(); // readers must scroll up to see the types
}

// ✓ CORRECT: declare variables as close as possible to their usage
public void processOrder() {
    int total = calculateTotal();
    int discount = calculateDiscount(total);
    String shippingAddress = getAddress();
    // ...
}

// ✗ ANTI-PATTERN 3: reusing a variable for different things
int result = calculateArea(5, 3);
System.out.println("Area: " + result);
result = calculatePerimeter(5, 3); // 'result' now means something different
System.out.println("Perimeter: " + result);

// ✓ CORRECT: different variables for different values
int area      = calculateArea(5, 3);
int perimeter = calculatePerimeter(5, 3);
System.out.println("Area: " + area + ", Perimeter: " + perimeter);

// ✗ ANTI-PATTERN 4: accessing a static variable via an object — misleading
Employee e = new Employee("Andi");
System.out.println(e.totalEmployees); // ✗ looks like it belongs to object e

// ✓ CORRECT: access static variables via the class name
System.out.println(Employee.totalEmployees); // ✓ clear that this belongs to the class