Please enable JavaScript to use CodeHS

AP Computer Science A Textbook

1. Primitive Types

2. Using Objects

3. Boolean Expressions and if Statements

4. Iteration

5. Writing Classes

5.1 Anatomy of a Class

5.2 Constructors

5.3 Documentation with Comments

5.4 Accessor Methods

5.5 Mutator Methods

5.6 Writing Methods

5.7 Static Variables and Methods

5.8 Scope and Access

Variables Inside Constructors and Methods

Formal Parameters

Method Decomposition

Instance Variable Scope

Local Variable Scope

Variable Shadowing

Method Decomposition with Trivia

Check Your Understanding

Exercise: Broken Calculator

5.9 this Keyword

5.10 Ethical and Social Implications of Computing Systems

6. Arrays

7. ArrayLists

8. 2D Arrays

9. Inheritance

10. Recursion

Chapter 5

Writing Classes

5.8 Scope and Access

Think back to some of the examples where you had variables in methods. Some of these variables had the same name as other variables in your program, but they didn’t have the same values. How can that be? Each variable has a specific scope and access level where that variable is defined. Outside that scope, a different variable can be defined with the same name. In this section, you will look at how variable scope is determined.

Variables Inside Constructors and Methods

When declaring a variable inside the body a constructor or a method, you create a local variable for that method. What does this mean? By local variable, it means that the variable is only defined for that specific constructor or method. These variables may only be used within the constructor or method and cannot be declared to be public or private.

Likewise, another variable with the same name can be used outside the constructor or method and it will be considered a different variable.

public void addFive() {
  int num = 10; // num is only defined inside the addFive method
  int result = num + 5;
  System.out.println(result); // prints 15
}

public void addTen() {
  int num = 20; // This is a different num variable that needs to be declared
  int result = num + 10;
  System.out.println(result); // prints 30
}
Java

Sometimes you will see a local variable inside a method or constructor sharing the same name as an instance variable. When this happens, the variable name in the method by default will refer to the local variable instead of the instance variable.

public class MyClass {
  private int myNum = 10;

  public void addFive() {
    int myNum = 7;
    // Will print 12 since the local myNum is used instead
    // of the instance variable.
    System.out.println(myNum + 5); 
  }
}
Java

Formal Parameters

When variables are declared as formal parameters, they act the same as a variable that has been declared inside a constructor or method. That means that they are only available inside the constructor or method where they are declared and that they will take precedence over any instance variables that have the same name.

public class Name {
  private String name = "Karel";

  public Name(String name) {
    // Will print the value passed in, not the value of the instance variable
    System.out.println(name); 
  }
}
Java

Method Decomposition

Method decomposition is the process of breaking down large problems into smaller sub-problems by creating methods to solve the individual sub-problems.

For example, if you want to create a program that asks users a random trivia question and informs them if they got the answer correct, you could break the problem into several parts:

  • Build a Trivia class.
  • Create Program that uses Trivia class.

You can then break each of these problems into several parts. For example, the program that uses the trivia class might break into the following parts:

  1. Create a Trivia Object
  2. Ask User a random trivia question
  3. Allow User to Respond
  4. Check if Response Matches Answer
  5. Provide User with a Reply

By breaking the problem down into smaller parts, you create sub-problems that are easy to solve and combined together, they can solve a much more complicated problem.

Instance Variable Scope

Local Variable Scope

Variable Shadowing

Method Decomposition with Trivia

Check Your Understanding

  1. Incorrect Correct No Answer was selected Invalid Answer

    What would be printed the first time printGreeting was called from main?

    public class Greeting
{
    private static String greet = "Hi there!";

    public static void printGreeting()
    {
        String phrase = "Hello!";
        System.out.println(phrase);
        phrase = "Hola!";
    }
}
    Plain text

Exercise: Broken Calculator

For this exercise, we are going to take a look at an alternate Calculator class, but this one is broken. There are several scope issues in the calculator class that are preventing it from running.

Your task is to fix the Calculator class so that it runs and prints out the correct results. The CalculatorTester is completed and should function correctly once you fix the Calculator class.

Vocabulary

Term Definition
Method Decomposition

The process of breaking down large problems into smaller problems, each with a method that defines a subproblem in the larger problem.
Shadowing

If two variables within the same scope have the same name, the variable with the more specific scope will be called.
Local Variable

A variable that is defined in a method or constructor. It only exists in the context of the method that it belongs to.