Creating and using methods is the single most important skill for organising your Java code so that it does not become an unreadable mess. For the 1Z0-811 exam, you need to know how to define a method, how to call one, how to pass information into it, and how to get a result back out – because these skills underpin every real-world Java program.
Jump to a section
A simple way to picture Creating and Using Methods
A head chef in a busy restaurant kitchen does not rewash, chop, and boil every single vegetable every time a customer orders a soup. Instead, the chef writes a recipe card – a standard set of instructions – for 'prepare vegetable stock'. That recipe card lives in the kitchen's recipe book. When a ticket for minestrone comes in, the chef calls out 'Prepare vegetable stock!' to the sous chef. The sous chef follows the steps on that card exactly: take carrots, peel, chop, add water, simmer for 1 hour, strain. The result is a pot of stock that the chef then uses to build the minestrone. If the head chef later wants a different soup – say, a creamy pumpkin – she can call the same 'prepare vegetable stock' recipe again. She does not have to explain the chopping and simmering steps all over again; she just invokes the recipe by name. This saves time, keeps the kitchen consistent, and hides the messy details of peeling and chopping. In Java, a method is exactly that recipe card. It is a named block of code that you write once and can 'invoke' (call) by its name from anywhere in your program. You pass it ingredients (arguments), it performs its steps, and it can hand you back a finished dish (a return value). The recipe does not change just because you use it for different soups – it always does the same job, which is what makes methods so powerful.
A method in Java is a named block of code that performs a specific task. Think of it as a mini-program inside your larger program. Methods exist for two main reasons: they help you avoid repeating yourself (the 'Don't Repeat Yourself' or DRY principle), and they help you break a complex problem into smaller, more manageable pieces.
Why you need methods Imagine you are writing a program that calculates the total price for a shopping basket, including tax. Without methods, you would write the tax-calculation logic every single time you need it – in the checkout section, in the refund section, in the invoice printing section. If the tax rate changes, you have to hunt down every single copy and change it. That is error-prone and exhausting. With a method, you write the tax calculation once, call it whenever you need it, and change it in only one place when the rules update.
How to define a method Every method in Java has a structure. The most important parts are:
Access modifier (like public or private) – this controls who can use the method. For the 1Z0-811 exam, you mostly deal with public.
Return type – what kind of data the method gives back. For example, int for whole numbers, double for decimals, String for text, or void if it gives nothing back.
Method name – a descriptive camelCase name like calculateTax or printReceipt.
Parameters – variables in parentheses that receive values from the caller. These act like containers that hold the data you send in.
Method body – the block of code in curly braces {} that does the work.
Here is what a simple method definition looks like:
public double calculateTax(double price, double taxRate) {
double tax = price * taxRate;
return tax;
}This method is called calculateTax. It expects two pieces of data: a price and a taxRate, both double numbers. It multiplies them to get the tax, then uses the keyword return to send that tax value back to whoever called it.
How to invoke (call) a method Using a method is simple: you write its name followed by parentheses, and inside those parentheses you put the values you want to send (the arguments). For the method above, you would call it like this:
double result = calculateTax(100.0, 0.08);Here, 100.0 is passed into the price parameter, and 0.08 is passed into taxRate. The method runs, computes 8.0, and that value is returned and stored in the variable result.
Passing arguments
Arguments are the actual values you send into a method when you call it. They must match the parameters in order and type. If the method expects (int, double), you cannot give it (String, int) – the compiler will stop you. This is called 'type safety'.
Returning values
The return keyword does two things: it immediately exits the method, and it sends a value back to the caller. If a method declares a return type other than void, it must always return a value of that type. A void method can use return; without a value just to exit early.
The anatomy of a method signature
The method signature is the method name plus the parameter list. For example, calculateTax(double, double) is the signature. Two methods can have the same name if they have different signatures – this is called method overloading, which you will also see in the exam.
Common terms to know - Parameter: the variable defined in the method definition that receives the argument. - Argument: the actual value you pass when calling the method. - Return type: the data type of the value the method sends back. - Method body: the code inside the curly braces. - Calling/invoking a method: the act of using the method’s name with arguments to execute its code.
When you call a method, the program's execution 'jumps' to that method, runs its code line by line, and then 'jumps' back to where it was called, picking up where it left off. This flow is fundamental to understanding how programs are structured.
Identify the task the method will perform
Before writing any code, decide what single, specific job the method should do. For example, 'calculate the tax on a given price'. This keeps the method focused and reusable.
Choose the access modifier and return type
For most exam examples, use `public`. Decide if the method returns data – if so, pick the correct type (e.g., `double` for decimals, `int` for whole numbers). If it just performs an action like printing, use `void`.
Name the method and list the parameters
Use a descriptive camelCase name (e.g., `getTotal`). Inside parentheses, declare each parameter with its type and name, separated by commas. For zero parameters, leave the parentheses empty.
Write the method body inside curly braces
The body contains the statements that accomplish the task. Use the parameters as variables. If the method returns something, use `return` with the value. Ensure every code path that reaches the end of a returning method has a `return` statement.
Call the method by name with the correct arguments
When invoking the method, write its name followed by parentheses containing the arguments in the same order and type as the parameters. If the method returns a value, you can assign it to a variable or use it directly in an expression.
A junior developer at an e-commerce company is assigned to build the checkout system for the website. The system needs to calculate the final price for an order, which includes applying a discount, adding tax, and adding shipping cost. Without methods, the junior developer writes hundreds of lines of spaghetti code inside a single main method. The code is hard to read, and when the business team changes the discount rule from '10% off orders over $50' to '15% off orders over $75', the developer must manually search through the entire block to find the discount logic. That is risky and time-consuming.
Instead, the senior developer shows them how to break the task into methods:
A calculateDiscount method that takes the order total and returns the discount amount.
A calculateTax method that takes the discounted total and the tax rate, and returns the tax amount.
A calculateShipping method that decides the shipping cost based on weight and distance.
A calculateFinalPrice method that calls all three and adds everything up.
Now, changing the discount rule is simple: the developer opens just the calculateDiscount method, updates the logic, and the change propagates everywhere that method is called. The business team tests only that method, not the entire checkout flow.
Step-by-step in a real sprint
- The developer writes a unit test for calculateDiscount with sample inputs (e.g., order total of $100 should give a $15 discount).
- They run the test – it fails because the method is not implemented yet.
- They write the method body: double discount = total * 0.15; return discount;.
- They run the test again – it passes.
- They repeat for calculateTax, calculateShipping, and calculateFinalPrice.
- Finally, they integrate these methods into the main checkout flow. Each method is independently testable, reusable, and easy to maintain.
This approach is standard practice in professional software development. Every major codebase – from banking apps to video games – relies on well-named methods to keep code organised. When you interview for IT roles, you will often be asked to 'refactor' a long block of code into methods, which shows that you understand how to write clean, maintainable code.
The exam tests these fundamentals because they are not just academic – they are the day-to-day reality of every Java developer.
The 1Z0-811 exam tests Creating and Using Methods through several distinct question patterns. You must be prepared for each.
Method definition syntax
The exam loves to give you a method header with deliberate mistakes – missing return type, wrong access modifier, curly braces in the wrong place. You must recognise that a method always requires a return type (or void) and parentheses. A typical question: 'Which of the following defines a valid method?' with options like:
- public void myMethod() {...} – valid.
- public myMethod() {...} – invalid because the return type is missing.
- void public myMethod() {...} – invalid because the modifier order is wrong (modifier before return type).
Calling methods
You will see questions where you must trace the output of a program that calls methods. For example, the main method calls a method that changes a variable and returns something. The trick: primitive types (like int, double) are passed by value, meaning the method gets a copy of the value – changes inside the method do not affect the original variable. The exam often sets a trap where a method doubles a number inside itself but the original variable outside stays unchanged.
Return types
Multiple-choice questions will ask: 'What does this method return?' with a snippet. You must identify the return type from the method header and know that a void method cannot have a return statement with a value. Also, if a method declares a non-void return type, every code path must return a value. The exam likes to show a method with an if-else where only the if branch returns, and the else branch does not – that is a compile error.
Parameters vs arguments
A classic trap: the question uses the terms 'parameter' and 'argument' interchangeably. You must know that the method definition has parameters (placeholders), and the method call has arguments (actual values). The exam may define a method void foo(int x) and call it with foo(5). They will ask: 'What is the parameter?' (answer: x). 'What is the argument?' (answer: 5).
Method overloading
The exam expects you to understand that methods can have the same name if their parameter lists differ in type, number, or order. A common question: 'Which of these methods overloads void print(int a)?' The correct answer must have the same name print but a different parameter list (e.g., void print(double a) or void print(int a, int b)). A method with a different return type but same parameters is not overloading – it is a duplicate, which causes a compile error.
Common traps
- Forgetting that the method execution stops immediately when it hits return. Sometimes a question shows code after a return statement and asks if it compiles – it does not.
- Confusing System.out.println() with a method that returns something. println is void – it does not produce a value you can assign to a variable.
- Thinking that changing a primitive parameter inside a method affects the caller – it does not.
What to memorise
- The exact syntax: modifier returnType methodName(parameterList) { body }.
- The difference between void and a returning method.
- How method overloading works: same name, different parameter list.
- That arguments must match parameters in type and order.
- The return keyword exits the method and sends a value.
Practise by writing small methods on paper and tracing the flow. The exam is closed-book, so understanding the flow is essential.
A method is a named block of code that is defined once and can be invoked multiple times from different places in a program.
Every method must have a return type – use `void` if the method does not give back a value.
Arguments are the actual values passed into a method call; parameters are the placeholders defined in the method header.
Java passes primitive types by value – changes to the parameter inside the method do not affect the original argument.
Method overloading allows multiple methods with the same name but different parameter lists (type, number, or order).
The `return` keyword immediately exits the current method and optionally sends a value back to the caller.
These come up on the exam all the time. Here's how to tell them apart.
Parameter
Defined in the method declaration inside parentheses.
Acts as a placeholder variable that receives a value.
Exists only within the method body.
Example: In `void foo(int x)`, `x` is a parameter.
Argument
Passed in the method call inside parentheses.
The actual value or variable being passed.
Exists in the calling code.
Example: In `foo(5);`, `5` is the argument.
void Method
Declares `void` as the return type.
Does not give back any value after execution.
May use `return;` to exit early, but no value is returned.
Cannot be used on the right side of an assignment.
Returning Method
Declares a specific return type (e.g., `int`, `String`).
Must use `return value;` to send back a value.
The return value can be assigned to a variable or used in an expression.
Every code path must return a value of the declared type.
Method Signature
Consists of method name and parameter list.
Used by the compiler to distinguish overloaded methods.
Does not include the access modifier or return type.
Example: `calculateTax(double, double)` is the signature.
Method Body
The code block inside curly braces {} following the signature.
Contains the statements that execute when the method is called.
Can include variable declarations, loops, and other method calls.
The size and complexity vary based on the method's task.
Mistake
Changing a primitive parameter inside a method changes the original variable in the calling code.
Correct
Java passes primitives by value, so the method works on a copy. The original variable outside the method remains unchanged.
This is confusing because many languages allow pass-by-reference, and learners assume Java does the same. The exam explicitly tests this misconception.
Mistake
A method must always have at least one parameter.
Correct
A method can have zero parameters. For example, `public void greet() { ... }` defines a method with an empty parameter list.
Beginners see examples with parameters and think they are mandatory, but methods that need no external data (like printing a fixed message) are perfectly valid.
Mistake
If a method has a non-void return type, you must store the returned value in a variable when you call it.
Correct
You can call a returning method and ignore its return value. For example, `getNumber();` is valid even if `getNumber()` returns an `int`. The value is simply discarded.
Many beginners assume the compiler forces you to use the return value, but Java allows you to ignore it. The exam may show a call without assignment and ask if it is legal – it is.
Mistake
A method can return multiple values at once using multiple `return` statements.
Correct
A method can only return one value. The `return` statement immediately exits the method, so only the first `return` encountered is executed.
Learners see `return` used in if-else blocks and think multiple returns happen, but only one executes. They confuse the ability to have multiple `return` lines (with only one running) with returning multiple values.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
No, you cannot. In Java, methods must be defined directly inside a class, not inside another method. If you try to nest a method, the code will not compile.
The code will not compile. Java's compiler checks that every code path inside a non-void method ends with a `return` statement that provides a value of the declared type.
Yes, that is called recursion – a method calling itself. It is allowed as long as there is a condition to stop the recursion, otherwise you will get a `StackOverflowError`.
Yes, the arguments must match the parameters in the exact order they are declared in the method definition. Passing them in the wrong order will cause a type mismatch or logical errors.
Yes. You can declare a method with return type `String` and use `return "some text";`. Strings are objects in Java, but they are perfectly valid return types.
`println` is a `void` method – it prints something to the screen but does not give any value back. A returning method, like `int getNumber()`, gives a value back that you can assign to a variable or use in calculations.
You've finished Creating and Using Methods. Continue through the 1Z0-811 study guide to build a complete picture of the exam.
Done with this chapter?