Methods are a powerful way to abstract tasks away into repeatable blocks of code. Learn how to create and use methods in Java!

Learn Java: Methods

When we print out Objects, we often see a String that is not very helpful in determining what the Object represents. In the last lesson, we saw that when we printed our `Store` objects, we would see output like:

```
Store@6bc7c054
```

where `Store` is the name of the object and `6bc7c054` is its position in memory.

This doesn't tell us anything about what the `Store` sells, the price, or the other instance fields we've defined. We can add a method to our classes that makes this printout more descriptive.

When we define a _toString()_ method for a class, we can return a `String` that will print when we print the object:

```java
class Car {

    String color;

    public Car(String carColor) {
        color = carColor;
    }

    public static void main(String[] args){
        Car myCar = new Car("red");
        System.out.println(myCar);
    }

   public String toString(){
       return "This is a " + color + " car!";
   }
}
```

When this runs, the command `System.out.println(myCar)` will print `This is a red car!`, which tells us about the Object `myCar`.


The toString() Method

When we add a non-static method to a class, it becomes available to use on an object of that class. In order to have our methods get executed, we must _call_ the method on the object we created.

Let's add a non-static `startEngine()` method to our `Car` class from the previous lesson. Inside the `main()` method, we'll call `startEngine()` on the `myFastCar` object:
```java
class Car {

  String color;

  public Car(String carColor) {
    color = carColor;
  }

  public void startEngine() {
    System.out.println("Starting the car!");
    System.out.println("Vroom!");
  }

  public static void main(String[] args){
    Car myFastCar = new Car("red");
    // Call a method on an object 
    myFastCar.startEngine();
    System.out.println("That was one fast car!");
  }
}
```
Let's take a closer look at the method call:
```java
myFastCar.startEngine();
```
First, we reference our object `myFastCar`. Then, we use the _dot operator_ (`.`) to call the method `startEngine()`. Note that we must include parentheses `()` after our method name in order to call it.

If we run the above program, we will get the following output.
```text
Starting the car!
Vroom!
That was one fast car!
```
Code generally runs in a top-down order where code execution starts at the top of a program and ends at the bottom of a program; however, methods are ignored by the compiler unless they are being called.

When a method is called, the compiler executes every statement contained within the method. Once all method instructions are executed, the top-down order of execution continues. This is why `Starting the car!` and `Vroom!` are outputted before `That was one fast car!`.

Calling Methods

Remember, variables can only exist in the _scope_ that they were declared in. We can use a value outside of the method it was created in if we _return_ it from the method. 

We return a value by using the keyword `return`:

```java
public int numberOfTires() {
   int tires = 4;
   // return statement
   return tires;
}
```

This method, called `numberOfTires()`, returns `4`. Once the return statement is executed, the compiler exits the function. Any code that exists after the return statement in a function is ignored.

In past exercises, when creating new methods, we used the keyword `void`. Here, we are replacing `void` with `int`, to signify that the _return type_ is an `int`. 

The void keyword (which means "completely empty") indicates that no value is returned after calling that method. 

A non-void method, like `numberOfTires()` returns a value when it is called. We can use datatype keywords (such as `int`, `char`, etc.) to specify the type of value the method should return. The return value's type must match the return type of the method. If the return expression is compatible with the return type, a copy of that value gets returned in a process known as _return by value_.

Unlike void methods, non-void methods can be used as either a variable value or as part of an expression like so:
```java
public static void main(String[] args){
    Car myCar = new Car("red");
    int numTires = myCar.numberOfTires();
}
```
Within `main()`, we called the `numberOfTires()` method on `myCar`. Since the method returns an `int` value of `4`, we store the value in an integer variable called `numTires`. If we printed `numTires`, we would see `4`.

**Keep Reading: AP Computer Science A Students**

We learned how to return primitive values from a method, but what if we wanted our method to return an object? Returning an object works a little differently than returning a primitive value. When we return a primitive value, a copy of the value is returned; however, when we return an object, we return a reference to the object instead of a copy of it.

Let's create a second class, `carLot`, that takes in a `Car` as a parameter and contains a method which returns a `Car` object.
```java
class CarLot {
    Car carInLot;
    public CarLot(Car givenCar) {
        carInLot = givenCar;
    }

    public Car returnACar() {
        // return Car object
        return carInLot;
    }

    public static void main(String[] args) {
        Car myCar = new Car("red", 70);
        System.out.println(myCar); 
        CarLot myCarLot = new CarLot(myCar);
        System.out.println(myCarLot.returnACar());
    }
}
```
This code outputs the same memory address because `myCar` and `carInLot` have the same reference value:
```
Car@2f333739
Car@2f333739
```




Returns

A method is a task that an object of a class performs.

We mark the domain of this task using curly braces: `{`, and `}`. Everything inside the curly braces is part of the task. This domain is called the _scope_ of a method.

We can't access variables that are declared inside a method in code that is outside the scope of that method. 

Looking at the `Car` class again:

```java
class Car {
  String color;
  int milesDriven;

  public Car(String carColor) {
    color = carColor;
    milesDriven = 0;		 
  }

  public void drive() {
     String message = "Miles driven: " + milesDriven;
     System.out.println(message);
  }

  public static void main(String[] args){
     Car myFastCar = new Car("red");
     myFastCar.drive();
  }
}
```

The variable `message`, which is declared and initialized inside of `drive`, cannot be used inside of `main()`! It only exists within the _scope_ of the `drive()` method.

However, `milesDriven`, which is declared at the top of the class, can be used inside all methods in the class, since it is in the scope of the whole class. 


Scope

In the last lesson, we learned that objects have state and behavior. We have seen how to give objects state through instance fields. Now, we're going to learn how to create object _behavior_ using [methods](https://www.codecademy.com/resources/docs/java/methods?page_ref=catalog). Remember our example of a Savings Account.


<img src="https://content.codecademy.com/courses/learn-java/revised-2019/diagram%20of%20an%20object-02.png" alt="A diagram of a software object with fields and behavior" with="100%"/>
<br>


The state tells us what a savings account should know:
- The balance of money available

The behavior tells us what tasks a savings account should be able to perform:
- Depositing - increasing the amount available
- Withdrawing - decreasing the amount available
- Checking the balance - displaying the amount available.

Methods are repeatable, modular blocks of code used to accomplish specific tasks. We have the ability to define our own methods that will take input, do something with it, and return the kind of output we want.  

Looking at the example above, recreating a savings account is no easy task. How can one program tackle such a large problem? This is where methods with their ability to accomplish smaller, specific tasks come in handy. Through _method decomposition_, we can use methods to break down a large problem into smaller, more manageable problems. 

Methods are also reusable. Imagine we wrote a sandwich-making program that used 20 lines of code to make a single sandwich. Our program would become very long very quickly if we were making multiple sandwiches. By creating a `makeSandwich()` method, we can make a sandwich anytime simply by calling it.

<img src="https://content.codecademy.com/courses/learn-java/revised-2019/methods-conceptual.gif" alt="makeSandwich() adds ingredients together to make a sandwich" with="100%"/>

In this lesson, we'll learn how to create and call our very own methods inside of our programs.

**Keep Reading: AP Computer Science A Students**

If we were to share this sandwich-making program with another person, they wouldn't have to understand _how_ `makeSandwich()` worked. If we wrote our program well, all they would need to know is that if they called `makeSandwich()`, they would receive a sandwich. This concept is known as _procedural abstraction_: knowing what a method does, but not how it accomplishes it.



Introduction

We saw how a method's scope prevents us from using variables declared in one method in another method. What if we had some information in one method that we needed to pass into another method?

Similar to how we added parameters to _constructors_, we can customize all other methods to accept parameters. For example, in the following code, we create a `startRadio()` method that accepts a `double` parameter, `stationNum`, and a `String` parameter called `stationName`:

```java
class Car {

  String color;

  public Car(String carColor) {
    color = carColor;		 
  }

  public void startRadio(double stationNum, String stationName) {
    System.out.println("Turning on the radio to " + stationNum + ", " + stationName + "!");
    System.out.println("Enjoy!");
  }

  public static void main(String[] args){
    Car myCar = new Car("red");
    myCar.startRadio(103.7, "Meditation Station");
  }
}
```
Adding parameter values impacts our method's signature. Like constructor signatures, the method signature includes the method name as well as the parameter types of the method. The signature of the above method is `startRadio(double, String)`.

In the `main()` method, we call the `startRadio()` method on the `myCar` object and provide a `double` argument of `103.7` and `String` argument of `"Meditation Station"`, resulting in the following output:

```
Turning on the radio to 103.7, Meditation Station!
Enjoy!
```
Note that when we call on a method with multiple parameters, the arguments given in the call must be placed in the same order as the parameters appear in the signature. If the argument types do not match the parameter types, we'll receive an error.

**Keep Reading: AP Computer Science A Students**

Through method overloading, our Java programs can contain multiple methods with the same name as long as each method's parameter list is unique. For example, we can recreate our above program to contain two `startRadio()` methods:

```java
// Method 1
public void startRadio(double stationNum, String stationName) {
  System.out.println("Turning on the radio to " + stationNum + ", " + stationName + "!");
  System.out.println("Enjoy!");
}
  
// Method 2
public void startRadio(double stationNum) {
  System.out.println("Turning on the radio to " + stationNum + "!");
}

public static void main(String[] args){
  Car myCar = new Car("red");
  // Calls the first startRadio() method
  myCar.startRadio(103.7, "Meditation Station");

  // Calls the second startRadio() method
  myCar.startRadio(98.2);
}

```

Adding Parameters

Great work! Methods are a powerful way to abstract tasks away and make them repeatable. They allow us to define behavior for classes, so that the Objects we create can do the things we expect them to. Let's review everything we have learned about methods so far.

- _Defining a method_ : Method declarations will declare a method’s return type, name, and parameters
- _Calling a method_ : Methods are invoked with a `.` and `()`
- _Parameters_ : Inputs to the method and their types are declared in parentheses in the method signature
- _Changing Instance Fields_ : Methods can be used to change the value of an instance field
- _Scope_  : Variables only exist within the domain that they are created in
- _Return_ : The type of the variables that will be output are declared in the method declaration

As you move through more Java material, it will be helpful to frame the tasks you create in terms of methods. This will help you think about what inputs you might need and what output you expect.



Review

If we were to define a `checkBalance()` method for the Savings Account example we talked about earlier, it would look like the following:

```java
public void checkBalance(){
  System.out.println("Hello!");
  System.out.println("Your balance is " + balance);
}
```
The first line, `public void checkBalance()`, is the method declaration. It gives the program some information about the method:
- `public` means that other classes can access this method. We will learn more about that later in the course.
- The `void` keyword means that there is no specific output from the method. We will see methods that are not `void` later in this lesson, but for now, all of our methods will be `void`.
- `checkBalance()` is the name of the method.

Every method has its own unique _method signature_ which is composed of the method's name and its parameter type. In this example, the method signature is `checkBalance()`.

The two print statements are inside the _body_ of the method, which is defined by the curly braces: `{` and `}`.

Anything we can do in our `main()` method, we can do in other methods! All of the Java tools you know, like the math and comparison operators, can be used to make interesting and useful methods.

**Keep Reading: AP Computer Science A Students**

`checkBalance()` is considered a non-static method because its signature does not include the keyword `static` like the `main()` method does. We'll learn more about non-static methods later in this course.

Defining Methods

Earlier, we thought about a Savings Account as a type of object we could represent in Java.

Two of the methods we need are depositing and withdrawing:

```java
public class SavingsAccount{
  double balance;
  public SavingsAccount(double startingBalance){
    balance = startingBalance;
  }

  public void deposit(double amountToDeposit){
     //Add amountToDeposit to the balance
  }

  public void withdraw(double amountToWithdraw){
     //Subtract amountToWithdraw from the balance
  }

  public static void main(String[] args){

  }
}
```

These methods would change the value of the variable `balance`. We can _reassign_ balance to be a new value by using our assignment operator, `=`, again.

```java
public void deposit(double amountToDeposit){
  double updatedBalance = balance + amountToDeposit;
  balance = updatedBalance;
}
```

Now, when we call `deposit()`, it should change the value of the instance field `balance`:

```java
public static void main(String[] args){
  SavingsAccount myAccount = new SavingsAccount(2000);
  System.out.println(myAccount.balance);
  myAccount.deposit(100);
  System.out.println(myAccount.balance);
}
```

This code first prints `2000`, the initial value of `myAccount.balance`, and then prints `2100`, which is the value of `myAccount.balance` after the `deposit()` method has run.

Changing instance fields is how we change the state of an object and make our objects more flexible and realistic.

