{"title":"Methods Basics","description":"","content":"A method is a named block of code that can be run from anywhere else in the program. Methods allow logic to be written once, given a name, and called by that name when needed. This lesson covers what a method is, why methods exist, the parts of a method declaration, how to call one, and the conventions Java programmers follow when naming them.\n\n---\n\n# Why Methods Exist\n\nSuppose the goal is to print a friendly greeting for three different customers. Without methods, the same lines would repeat over and over.\n\n\n```java\npublic class GreetWithoutMethods {\n public static void main(String[] args) {\n System.out.println(\"Hello, Alice!\");\n System.out.println(\"Thanks for shopping with us.\");\n\n System.out.println(\"Hello, Bob!\");\n System.out.println(\"Thanks for shopping with us.\");\n\n System.out.println(\"Hello, Carol!\");\n System.out.println(\"Thanks for shopping with us.\");\n }\n}\n```\n\n\nThis works, but the same two lines repeat for every customer. Changing the greeting to \"Welcome back\" instead of \"Hello\" requires editing three places. Missing one causes the messages to drift apart. With more customers, the duplication only gets worse.\n\nA method fixes this. Wrap the greeting in a method called `greetCustomer`, write the greeting once, and call the method three times.\n\n\n```java\npublic class GreetWithMethod {\n public static void main(String[] args) {\n greetCustomer(\"Alice\");\n greetCustomer(\"Bob\");\n greetCustomer(\"Carol\");\n }\n\n public static void greetCustomer(String customerName) {\n System.out.println(\"Hello, \" + customerName + \"!\");\n System.out.println(\"Thanks for shopping with us.\");\n }\n}\n```\n\n\nThe output is identical. What's different is that the greeting logic now lives in one place. Updating the message inside `greetCustomer` automatically updates every caller.\n\nMethods provide three things at once:\n\n- **No repetition.** Write the logic once, call it many times. Programmers sometimes call this DRY, short for \"Don't Repeat Yourself\".\n- **A name to think with.** `greetCustomer(\"Alice\")` reads more clearly than four lines of `System.out.println` calls. The name acts as a label for a chunk of behavior.\n- **Reuse.** Once `greetCustomer` exists, any code in the class can call it. New features get cheaper to build because they can be stitched together from existing methods.\n\nThe trade-off is small: a tiny bit of extra structure up front in exchange for code that's easier to change later. As programs grow past a few dozen lines, that trade is worth making.\n\n---\n\n# Anatomy of a Method\n\nEvery method in Java is built from the same set of parts. A typical one, broken down.\n\n\n```java\npublic static double calculateCartTotal(double itemPrice, int quantity) {\n double total = itemPrice * quantity;\n return total;\n}\n```\n\n\nReading left to right, this method has five parts:\n\n\n| Part | Value in the example | What it means |\n| --- | --- | --- |\n| Modifiers | `public static` | Who can call it and how it's called |\n| Return type | `double` | The type of value the method gives back |\n| Name | `calculateCartTotal` | What the method is called |\n| Parameter list | `(double itemPrice, int quantity)` | The values the method needs to do its work |\n| Body | `{ double total = itemPrice * quantity; return total; }` | The code that runs when the method is called |\n\n\nThe same breakdown visually.\n\n\n```mermaid\nflowchart LR\n Mod[public static]:::cyan --> Ret[double]:::orange\n Ret --> Name[calculateCartTotal]:::green\n Name --> Params[\"double itemPrice,
int quantity\"]:::teal\n Params --> Body[\"body inside { }\"]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe rest of this section walks through each part. For now, the goal is to recognize the pieces.\n\n### Modifiers\n\nModifiers are keywords that appear before the return type. They control how the method behaves and who can call it. The two most common ones for early Java code are:\n\n- `public` controls **visibility**. A `public` method can be called from any class. The other visibility levels (`private`, `protected`, package-private) come later.\n- `static` means the method belongs to the class itself, not to an instance of the class. `static` returns later in this lesson because it's the only flavor of method that can be called from `main` without first creating an object.\n\nA method can be written with no modifiers, or with several stacked together. For the early lessons in this section, every method is `public static`.\n\n### Return Type\n\nThe return type sits right before the method name and declares what kind of value the method hands back to its caller. If the method computes a cart total, the return type is `double`. If it produces a customer name, the return type is `String`. If the method does some work but doesn't produce a value, the return type is `void`, which literally means \"nothing\".\n\n\n```java\npublic static double calculateCartTotal(double itemPrice, int quantity) { ... }\npublic static String getWelcomeMessage() { ... }\npublic static void printOrderConfirmation(int orderId) { ... }\n```\n\n\nFor now, treat the return type as a label that tells the caller what to expect.\n\n### Name\n\nThe name identifies the method. It must be a valid Java identifier: start with a letter, underscore, or dollar sign, followed by letters, digits, underscores, or dollar signs. It cannot be a Java keyword like `if` or `class`. By convention, method names use **camelCase** and start with a **verb**, because methods do things. Naming is covered in more depth a few sections down.\n\n### Parameter List\n\nThe parameter list, in parentheses, declares the inputs the method needs. Each parameter has a type and a name, separated by a comma from the next one.\n\n\n```java\npublic static double calculateCartTotal(double itemPrice, int quantity) { ... }\n```\n\n\nThis method needs an `itemPrice` (a `double`) and a `quantity` (an `int`). Inside the body, `itemPrice` and `quantity` are regular local variables holding whatever values the caller passed in.\n\nA method can take zero parameters. The parentheses stay, but there's nothing between them.\n\n\n```java\npublic static void printWelcomeBanner() {\n System.out.println(\"Welcome to AlgoMart!\");\n}\n```\n\n\n### Body\n\nThe body is everything between the opening `{` and the closing `}`. It's the actual code that runs when the method is called. Inside the body, code can declare local variables, run loops, call other methods, and (if the return type isn't `void`) eventually use `return` to hand a value back.\n\n\n```java\npublic static double calculateCartTotal(double itemPrice, int quantity) {\n double total = itemPrice * quantity;\n return total;\n}\n```\n\n\nLocal variables declared inside the body, like `total` here, only exist while the method is running. As soon as the method returns, they're gone. The next time the method is called, fresh local variables start over.\n\n---\n\n# Method Signature\n\nThe **signature** of a method is the part the Java compiler uses to tell methods apart: the method's name plus the types and order of its parameters. The return type, the modifiers, and the parameter names are **not** part of the signature.\n\n\n| Declaration | Signature |\n| --- | --- |\n| `public static double calculateCartTotal(double itemPrice, int quantity)` | `calculateCartTotal(double, int)` |\n| `public static void greetCustomer(String customerName)` | `greetCustomer(String)` |\n| `public static int countItemsInStock(int[] stockCounts)` | `countItemsInStock(int[])` |\n\n\nWhy does this matter? Because Java allows multiple methods with the same name in the same class, as long as their parameter lists differ. That's called **overloading**, and the rule that makes it work is that each method has a different signature. For now, the takeaway is that a method's identity is its name and parameter types together, not just its name.\n\nA consequence to be aware of: two methods in the same class cannot share a signature and differ only in return type. The compiler can't pick between them based on what the caller does with the result.\n\n---\n\n# Declaring a Method\n\nPutting the pieces together, here's the general form of a method declaration:\n\n\n```shell\n[modifiers] returnType methodName(parameterType1 parameterName1, parameterType2 parameterName2, ...) {\n // method body\n // optional: return someValue;\n}\n```\n\n\nA few small but worth-knowing rules:\n\n- The opening `{` can go on the same line as the parameter list (the common Java style) or on the next line. Both compile.\n- A method body can be empty: `{ }`. That's legal, but the method does nothing.\n- If the return type isn't `void`, **every path** through the body must end in a `return` that gives back a value of that type. The compiler enforces this.\n- Methods live inside a class. A method cannot be declared at the top level of a file, outside any class.\n\nA small class with two methods, both fully declared.\n\n\n```java\npublic class StoreUtilities {\n public static double applyDiscount(double price, double discountPercent) {\n double discountAmount = price * (discountPercent / 100);\n return price - discountAmount;\n }\n\n public static void printDivider() {\n System.out.println(\"------------------------\");\n }\n\n public static void main(String[] args) {\n double finalPrice = applyDiscount(100.0, 20);\n printDivider();\n System.out.println(\"Final price: $\" + finalPrice);\n printDivider();\n }\n}\n```\n\n\n`applyDiscount` returns a `double`, so the body ends with a `return` statement. `printDivider` has return type `void`, so it doesn't need a `return` at all, and any `return` inside it would have to be a bare `return;` with no value.\n\n---\n\n# Calling a Method\n\nDeclaring a method just defines it. Until something **calls** it, the body never runs. A method call is written as the method's name followed by the arguments in parentheses, separated by commas.\n\n\n```java\ngreetCustomer(\"Alice\");\ndouble total = calculateCartTotal(29.99, 3);\n```\n\n\nTwo pieces of vocabulary are easy to mix up:\n\n- **Parameter** is the name in the method declaration (`String customerName`). It's a placeholder.\n- **Argument** is the actual value passed in at the call site (`\"Alice\"`). It fills the placeholder.\n\nJava sets the parameter equal to the argument before the method body runs. Inside the body, `customerName` is just a local variable holding the value `\"Alice\"`.\n\nThe arguments must match the parameter list in **count, order, and type**. Passing too few, too many, or the wrong type, prevents the code from compiling.\n\n\n```java\npublic class CallExamples {\n public static void main(String[] args) {\n greetCustomer(\"Alice\"); // OK: one String argument\n // greetCustomer(); // Compile error: missing argument\n // greetCustomer(\"Alice\", \"Bob\"); // Compile error: too many arguments\n // greetCustomer(42); // Compile error: wrong type\n }\n\n public static void greetCustomer(String customerName) {\n System.out.println(\"Hello, \" + customerName + \"!\");\n }\n}\n```\n\n\nWhen a method returns a value, the call **is** that value at the place where it appears. The result can be stored in a variable, printed, passed to another method, or used as part of a larger expression.\n\n\n```java\npublic class UseReturnValue {\n public static void main(String[] args) {\n // Store in a variable\n double cartTotal = calculateCartTotal(29.99, 3);\n System.out.println(\"Total: $\" + cartTotal);\n\n // Print directly\n System.out.println(\"Total: $\" + calculateCartTotal(49.50, 2));\n\n // Pass to another method\n printTotal(calculateCartTotal(15.00, 4));\n }\n\n public static double calculateCartTotal(double itemPrice, int quantity) {\n return itemPrice * quantity;\n }\n\n public static void printTotal(double total) {\n System.out.println(\"Computed total: $\" + total);\n }\n}\n```\n\n\nIf a method's return type is `void`, the call cannot be used as a value. Writing `double x = printDivider();` is a compile error because `printDivider` doesn't return anything to assign.\n\n### What Happens When a Method Is Called\n\nWhen a call runs, the program pauses where it is, jumps to the method's body, runs through it, and then comes back. Visually:\n\n\n```mermaid\nflowchart LR\n Caller[\"main calls
greetCustomer(Alice)\"]:::cyan --> Enter[Enter method body]:::orange\n Enter --> Run[Run statements,
print output]:::teal\n Run --> Done[Method returns]:::green\n Done --> Resume[Back in main,
next line runs]:::cyan\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe caller doesn't move on until the method returns. If `greetCustomer` prints two lines, the program prints them both before continuing past the call site.\n\n---\n\n# `main` Is Also a Method\n\nThe `main` method used in every example is a method. Consider the parts:\n\n\n```java\npublic static void main(String[] args)\n```\n\n\n- `public static` are modifiers.\n- `void` is the return type. `main` doesn't return a value.\n- `main` is the name.\n- `(String[] args)` is the parameter list: one parameter, a `String[]` named `args`.\n\nThere's nothing magic about the declaration. The only special thing about `main` is that the Java runtime looks for a method with **exactly this signature** when the program is launched with `java YourClassName`. If it finds one, it calls it. If not, it complains and exits.\n\nWriting a Java program means writing a method called `main` that the runtime invokes, and from inside `main` other methods get called. The whole program is a tree of method calls rooted at `main`.\n\n\n```java\npublic class OrderApp {\n public static void main(String[] args) {\n printWelcome();\n double total = calculateCartTotal(29.99, 2);\n System.out.println(\"Cart total: $\" + total);\n }\n\n public static void printWelcome() {\n System.out.println(\"Welcome to AlgoMart!\");\n }\n\n public static double calculateCartTotal(double itemPrice, int quantity) {\n return itemPrice * quantity;\n }\n}\n```\n\n\nThe runtime calls `main`. Inside `main`, the code calls `printWelcome` and `calculateCartTotal`. If either of those called other methods, the chain would continue. Once `main` finishes, the program ends.\n\nThe `String[] args` parameter holds command-line arguments. Running `java OrderApp alpha beta` would call `main` with `args = {\"alpha\", \"beta\"}`. This section does not use `args`, but it is available when needed.\n\n---\n\n# `static` Methods at a Glance\n\nEvery method declared so far has used `static`. The short version of what it means at this stage of the course.\n\nA `static` method belongs to the **class** rather than to any particular **object** built from the class. Calling a `static` method does not require creating an object first. It can be called by name from inside the same class, or by `ClassName.methodName(...)` from a different class.\n\nThis is why `calculateCartTotal(29.99, 3)` can be called directly from `main`. Both are `static`, both live in the same class, and `static` methods can call other `static` methods in the same class with no ceremony.\n\n\n```java\npublic class StaticDemo {\n public static void main(String[] args) {\n // Calling a static method in the same class:\n double total = calculateCartTotal(29.99, 3);\n System.out.println(\"Total: $\" + total);\n\n // Calling a static method from a different class:\n double roundedTotal = Math.round(total);\n System.out.println(\"Rounded: $\" + roundedTotal);\n }\n\n public static double calculateCartTotal(double itemPrice, int quantity) {\n return itemPrice * quantity;\n }\n}\n```\n\n\n`Math.round` is a `static` method on the `Math` class. No `Math` object had to be created. The class name plus the method name is enough.\n\nThere's also a non-`static` flavor of method, called an **instance method**, which belongs to a specific object. Calling those requires creating an object first. That's a whole separate topic. For everything in this section, `static` is the simplest option.\n\nThe reason `main` is `static`: the Java runtime needs to call it before any objects exist. If `main` were an instance method, the runtime would have to create an object first, but it has no way of knowing which object to create. `static` sidesteps that chicken-and-egg problem.\n\n---\n\n# Naming Conventions\n\nJava has firm conventions for method names. The compiler doesn't enforce them, but every Java library and every Java developer expects them. Following them makes the code feel like it belongs.\n\n- **Use camelCase.** Start with a lowercase letter, capitalize the first letter of each later word. `calculateCartTotal`, not `CalculateCartTotal`, `calculate_cart_total`, or `calculatecarttotal`.\n- **Start with a verb.** Methods do things, so the name should read like an action. `getCustomerName`, `applyDiscount`, `isInStock`, `addToCart`. Avoid noun-only names like `customerName` for a method, that's the convention for fields.\n- **Boolean methods usually start with `is`, `has`, or `can`.** `isInStock`, `hasShipped`, `canCancelOrder`. The name reads naturally inside an `if`: `if (isInStock(productId)) { ... }`.\n- **Be specific, not cute.** `processItem` doesn't describe what processing happens. `calculateShippingCost` does. A slightly longer name that explains the action is almost always better than a short name that requires reading the body to understand.\n- **Don't abbreviate aggressively.** `calculateCartTotal` is clearer than `calcCT`. The few extra characters cost nothing, and code is read far more often than it's written.\n\nA class that follows the conventions.\n\n\n```java\npublic class CartHelpers {\n public static double calculateSubtotal(double itemPrice, int quantity) {\n return itemPrice * quantity;\n }\n\n public static double applyDiscount(double subtotal, double discountPercent) {\n return subtotal - (subtotal * discountPercent / 100);\n }\n\n public static boolean isCartEmpty(int itemCount) {\n return itemCount == 0;\n }\n\n public static void printOrderConfirmation(int orderId) {\n System.out.println(\"Order \" + orderId + \" confirmed.\");\n }\n\n public static void main(String[] args) {\n double subtotal = calculateSubtotal(29.99, 3);\n double finalTotal = applyDiscount(subtotal, 10);\n System.out.println(\"Final total: $\" + finalTotal);\n System.out.println(\"Cart empty? \" + isCartEmpty(3));\n printOrderConfirmation(1042);\n }\n}\n```\n\n\nRead the method names out loud. Each one describes what the method does without requiring a look inside the body. That's the goal.\n\n---\n\n# Where Methods Live\n\nMethods always live inside a class. A method cannot sit directly in a file outside any class. The structure of a Java file is always:\n\n\n```shell\n[optional package declaration]\n[optional imports]\n\nclass ClassName {\n [fields]\n [methods]\n}\n```\n\n\nMethods inside the same class can call each other by name. There's no need to import anything or qualify the name with the class name when both methods are in the same class.\n\n\n```java\npublic class OrderProcessor {\n public static void main(String[] args) {\n processOrder(1042, 89.99);\n }\n\n public static void processOrder(int orderId, double total) {\n printDivider();\n System.out.println(\"Processing order \" + orderId);\n System.out.println(\"Total: $\" + total);\n printDivider();\n }\n\n public static void printDivider() {\n System.out.println(\"====================\");\n }\n}\n```\n\n\n`processOrder` calls `printDivider` twice. Both methods are `static` and both live in `OrderProcessor`, so the call works with no extra ceremony.\n\nThe **order** of method declarations inside a class doesn't matter to the compiler. `main` can call methods declared below it, and methods can call methods declared above or below them. Java looks at the whole class as one unit before deciding what's reachable from where.\n\n\n```java\npublic class OrderInClass {\n public static void main(String[] args) {\n // This works fine even though greetUser is declared below main.\n greetUser(\"Alice\");\n }\n\n public static void greetUser(String name) {\n System.out.println(\"Hello, \" + name + \"!\");\n }\n}\n```\n\n\nFor readability, a common style is to put `main` near the top and the methods it calls below it, or to group related methods together. The compiler doesn't care. Pick whatever helps a reader follow the flow.\n\n---\n\n# A Worked Example\n\nTo bring everything together, consider a small program that uses several methods to take a cart through to a printed total. Each method does one thing and has a name that describes it.\n\n\n```java\npublic class CartProgram {\n public static void main(String[] args) {\n printHeader();\n\n double itemPrice = 19.99;\n int quantity = 3;\n double discountPercent = 10;\n\n double subtotal = calculateSubtotal(itemPrice, quantity);\n double finalTotal = applyDiscount(subtotal, discountPercent);\n\n printItemLine(itemPrice, quantity);\n printTotalLine(finalTotal);\n }\n\n public static void printHeader() {\n System.out.println(\"=== AlgoMart Cart Summary ===\");\n }\n\n public static double calculateSubtotal(double price, int quantity) {\n return price * quantity;\n }\n\n public static double applyDiscount(double amount, double discountPercent) {\n return amount - (amount * discountPercent / 100);\n }\n\n public static void printItemLine(double price, int quantity) {\n System.out.println(\"Item: \" + quantity + \" x $\" + price);\n }\n\n public static void printTotalLine(double total) {\n System.out.println(\"Total after discount: $\" + total);\n }\n}\n```\n\n\nThree things stand out in this example:\n\n- `main` reads almost like a checklist of what the program does. Print a header, compute a subtotal, apply a discount, print the item line, print the total. The details of each step live in their own method.\n- Each helper method has a single, clear purpose. `calculateSubtotal` doesn't print anything. `printItemLine` doesn't compute anything. Mixing those two would make each method harder to reuse.\n- The methods can be reordered freely. The compiler doesn't care that `printTotalLine` appears last and is called second-to-last in `main`.\n\nThis style, where `main` orchestrates and the work happens in small focused methods, is the foundation of how larger Java programs are built. The rest of this section adds the missing pieces: how parameters work in depth, how return types behave, how to give the same method name multiple signatures, how to accept a variable number of arguments, and a couple of advanced topics like recursion.","pageType":"java"}

Methods Basics

Get Premium