Scope and Access

Ethan Taylor

5 min read

Listen to this study note

Study Guide Overview

This study guide covers scope (local and global) and access modifiers (private, package/default, protected, public) in Java. It explains how these concepts control variable and method visibility and accessibility within a class and from external classes. The guide uses a Student class example to illustrate these concepts and provides final exam tips, focusing on distinguishing scope types, understanding access implications, and applying modifiers correctly.

#Scope and Access in Java

Welcome to a crucial review of scope and access in Java! This guide is designed to be your go-to resource the night before the exam, providing clear explanations and strategic insights to boost your confidence. Let's dive in!

# Scope

Key Concept

Scope determines where a variable can be used within your code.

There are two primary types of scope:

#Local Scope

Variables declared inside a method or constructor have local scope.
This includes:
- Method parameters
- Variables declared within the method body

Quick Fact

Local variables are only accessible within the block of code they are defined in.

#Global Scope

Variables declared outside of any method or constructor have global scope.
This includes:
- Instance variables (non-static variables belonging to an object)
- Methods of the class

Quick Fact

Global variables are accessible throughout the class.

Common Mistake

Confusing local and global variables with the same name can lead to unexpected behavior. Remember, the local variable takes precedence within its scope.

# Access Modifiers

Key Concept

Access modifiers control the visibility and accessibility of variables and methods from outside the class.

Access modifiers, in order of restrictiveness:

#Private

private members are only accessible within the class where they are declared.

Exam Tip

Instance variables are often declared private to encapsulate data.

* Example: `private int gradeLevel;`

#Package (Default)

No explicit modifier is used.
Accessible by other classes within the same package (folder).

Quick Fact

Not commonly used in AP CS A.

#Protected

Accessible by classes in the same package and by subclasses in other packages.

Quick Fact

Less common in AP CS A, but important for inheritance (Unit 9).

#Public

public members are accessible from any class.

Exam Tip

Methods and constructors are often declared public to provide an interface to the class.

* Example: `public Student(int gradeLev, String fullName, int ageNum) { ... }`

#Example: Student Class

Let's analyze the provided Student class snippet:

java
/** Represents a high school student
*/
public class Student {
    private int gradeLevel; // a grade between 9-12
    private String name; // the students name in the form "FirstName LastName"
    private int age; // the student's age, must be positive
    private Assignment assignment; // the current assignment the student is working on
    private int assignmentsComplete; // numbers of assignments completed
    private int correctAssignments; // number of correct assignments

    private static final double A_BOUNDARY = 0.9;
    private static final double B_BOUNDARY = 0.8;
    private static final double C_BOUNDARY = 0.7;
    private static final double D_BOUNDARY = 0.6;
    private static String school = "The Fiveable School";

    // More code follows

Key Concept

All instance variables (gradeLevel, name, age, etc.) are declared private. This means they can only be accessed or modified from within the Student class.

Key Concept

Static variables (A_BOUNDARY, B_BOUNDARY, C_BOUNDARY, D_BOUNDARY, school) are also declared private. They can be accessed or modified from any method (static or non-static) within the Student class.

java
/** Makes a new student with grade gradeLev, name fullName, and age ageNum
*/
public Student(int gradeLev, String fullName, int ageNum) {
    gradeLevel = gradeLev;
    name = fullName;
    age = ageNum;
    assignment = null; // There is no active assignment at the moment
    assignmentsComplete = 0; // no assignments complete yet
    correctAssignments = 0;
}

// More code follows

Key Concept

The constructor parameters (gradeLev, fullName, ageNum) have local scope and are only accessible within the constructor. The constructor itself is public, meaning it can be called from anywhere.

#Memory Aid

Think of scope like a building 🏢. Local variables are like items inside a specific room (method), while global variables are like items in the main lobby (class). Access modifiers are like the locks on the doors: private means only people inside the room can access it, public means anyone can enter.

# Final Exam Focus

High-Value Topics:
- Distinguishing between local and global scope.
- Understanding the implications of private, public, and package access.
- Applying access modifiers correctly in class design.
Common Question Types:
- Identifying the scope of variables in code snippets.
- Determining which variables and methods can be accessed from different parts of a program.
- Explaining the purpose of access modifiers.
Last-Minute Tips:
- Time Management: Quickly scan code for variable declarations and access modifiers.
- Common Pitfalls: Confusing local and global variables, misinterpreting access modifiers.
- Strategies: Draw diagrams to visualize scope and access if needed. Remember the building analogy!