Chapter 4: Java Methods – The Building Blocks of Modular Code

1. Name: "Classic Omelet"
   
   
2. Inputs (Ingredients): Eggs, salt, butter.
   
   
3. Instructions: Beat the eggs, heat the pan, cook for 3 minutes.
   
   
4. Output (The Result): A delicious breakfast.
   
   

• Access Modifier (public): This defines who can see and use this method. public means any other class can use it.
  
  
• Static (static): This is a bit advanced, but for now, it means the method belongs to the class itself rather than an instance of the class. Since our main method is static, any other methods we call directly from main (without creating an "object" first) also need to be static.
  
  
• Return Type (void): This tells Java what kind of value the method sends back. void means the method performs an action but returns nothing. If it returned a whole number, this would say int.
  
  
• Method Name (main): By convention, Java methods use lowerCamelCase.
  
  
• Parameters (String[] args): These are the inputs. They are defined inside parentheses. If a method needs no input, the parentheses are empty ().
  
  

public class GreetingApp {

    public static void main(String[] args) {
        // Calling the method
        sayHello(); 
        sayHello(); // We can call it as many times as we want!
    }

    // Defining the method
    public static void sayHello() {
        System.out.println("Hello! Welcome to the Java Tutorial.");
    }
}

• Parameter: The variable listed in the method definition (the "placeholder").
  
  
• Argument: The actual value you pass into the method when you call it.
  
  

public class Calculator {
    public static void main(String[] args) {
        printSum(10, 20); // 10 and 20 are arguments
    }

    // x and y are parameters
    public static void printSum(int x, int y) {
        int sum = x + y;
        System.out.println("The sum is: " + sum);
    }
}

public class MathWizard {
    public static void main(String[] args) {
        int result = multiply(5, 4); // The method "becomes" the value 20
        System.out.println("Total: " + (result + 10)); // We can use the result in further math
    }

    public static int multiply(int a, int b) {
        return a * b; // Sends the result back to the caller
    }
}

Crucial Rule: Once a method hits a return statement, it stops immediately. Any code written after the return line inside that method will be ignored (and will actually cause a compiler error called "unreachable code").

public static int add(int a, int b) {
    return a + b;
}

public static int add(int a, int b, int c) {
    return a + b + c;
}

public static double add(double a, double b) {
    return a + b;
}

1. Local Variables: A variable declared inside a method (including the parameters) only exists inside that method. Once the method finishes, the variable is deleted from the computer's memory.
   
   
2. Class Variables (Fields): Variables declared directly inside the class but outside any methods. These can be accessed by any method in the class.
   
   

public class ScopeTest {
    static int globalCount = 0; // Class variable (accessible everywhere)

    public static void main(String[] args) {
        int localVal = 5; // Local to main
        System.out.println(globalCount); // Works
    }

    public static void anotherMethod() {
        // System.out.println(localVal); // ERROR! This method can't see main's variables.
        System.out.println(globalCount); // Works
    }
}

public class TipCalculator {

    public static void main(String[] args) {
        double bill = 150.0;
        double tipPercentage = 0.15; // 15%

        double tipAmount = calculateTip(bill, tipPercentage);
        double totalBill = bill + tipAmount;

        displaySummary(bill, tipAmount, totalBill);
    }

    public static double calculateTip(double amount, double percent) {
        return amount * percent;
    }

    public static void displaySummary(double b, double t, double total) {
        System.out.println("--- Receipt ---");
        System.out.println("Bill: $" + b);
        System.out.println("Tip:  $" + t);
        System.out.println("Total: $" + total);
    }
}

• Methods are reusable blocks of code that perform specific tasks.
  
  
• Parameters allow us to pass data into methods.
  
  
• Return Types allow methods to send data back to us.
  
  
• Method Overloading lets us use the same name for different versions of a task.
  
  
• Scope determines where our variables are "visible."