Activity 4.2 Constructors

Introduction

Activity 4.2

Constructors

Topics

What a constructor is and why objects need them
No-argument constructors
Full-argument constructors
Constructor overloading
Shadowing problem & the this
Constructor parameter validation

What is a Constructor?

A constructor initializes a new object. It sets up initial values for the instance variables and ensures the object begins in a valid state.

It has:

the same name as the class
no return type (not even void)
runs automatically when using new

No-Argument Constructor

A no-arg constructor provides default values when no information is supplied.

1
class Dog {
2
    Dog() { /* default values */ }
3
}

Full-Argument Constructor

A full constructor requires all needed info to create a valid object.

But there’s a catch: constructor parameters often shadow instance variables.

1
Dog(String name) {
2
    this.name = name;
3
}

The Shadowing Problem

When parameter names match instance variables:

1
Dog(String name) {
2
    name = name; // WRONG
3
}

This sets the parameter equal to itself, not the instance variable.

Solution: Use this

1
this.name = name;

Example: Dog Class With Both Constructors

1
class Dog {
2
    // Instance variables
3
    String name;
4
    String breed;
5
    int age;
6

7
    // No-argument constructor
8
    Dog() {
9
        name = "Unknown";
10
        breed = "Unknown";
11
        age = 0;
12
    }
13

14
    // Full-argument constructor
15
    Dog(String name, String breed, int age) {
16
        this.name = name;   // 'this' fixes the shadowing problem
17
        this.breed = breed;
18
        this.age = age;
19
    }
20

21
    void bark() {
22
        System.out.println(name + " says: Woof!");
23
    }
24
}

Constructor Overloading

Java allows multiple constructors as long as they have different parameter lists.

This is called constructor overloading (similar to method overloading).

Constructor Validation

Constructors often check whether values are valid before storing them. This pattern appears frequently on AP FRQs.

1
if (gpa < 0 || gpa > 4.0) gpa = 0.0;

Key Terms

Constructor: A special method that initializes new objects.
No-Argument Constructor: A constructor that provides default values.
Full-Argument Constructor: A constructor that receives values through parameters.
Shadowing: When a parameter name hides an instance variable name.
this: Refers to the current object; fixes the shadowing problem.

'F' → Fullscreen

Objectives

Write and use constructors to initialize objects.
Differentiate between no-argument and full-argument constructors.
Explain and resolve parameter shadowing with this.
Use constructor overloading to support different initialization needs.
Apply constructor validation to enforce valid object state.

Activity Tasks

Create a new project named 4-2-Constructors.
Complete each task individually.

Task 1: No-Arg and Full Constructors

Step 1: Create a file named Student.java and type the following code:

1
class Student
2
{
3
    String name;
4
    int gradeLevel;
5

6
    // No-argument constructor
7
    Student()
8
    {
9
        name = "Unnamed";
10
        gradeLevel = 9;
11
    }
12

13
    // Full-argument constructor
14
    Student(String name, int gradeLevel)
15
    {
16
        this.name = name;
17
        this.gradeLevel = gradeLevel;
18
    }
19

20
    void introduce()
21
    {
22
        System.out.println("Hi, I'm " + name + " and I'm in grade " + gradeLevel + ".");
23
    }
24
}

Step 2: Create a file named Program.java and type the following code:

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        Student s1 = new Student(); // Calls no-arg constructor
6
        Student s2 = new Student("Alex", 10); // Calls full constructor
7

8
        s1.introduce();
9
        s2.introduce();
10
    }
11
}

Run the program. Notice how each constructor initializes the object differently.

Task 2: Constructor Validation

Modify your Student class to include a gpa instance variable and use a full constructor that enforces valid values.

1
class Student
2
{
3
    String name;
4
    int gradeLevel;
5
    double gpa;
6

7
    // No-argument constructor
8
    Student()
9
    {
10
        name = "Unnamed";
11
        gradeLevel = 9;
12
        gpa = 0.0;
13
    }
14

15
    // Full constructor with validation
16
    Student(String name, int gradeLevel, double gpa)
17
    {
18
        this.name = name;
19
        this.gradeLevel = gradeLevel;
20

21
        if (gpa < 0.0 || gpa > 4.0)
22
        {
23
            System.out.println("Invalid GPA! Setting to 0.0...");
24
            this.gpa = 0.0;
25
        }
26
        else
27
        {
28
            this.gpa = gpa;
29
        }
30
    }
31

32
    void showInfo()
33
    {
34
        System.out.println(name + " (Grade " + gradeLevel + ") — GPA: " + gpa);
35
    }
36
}

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5

6
        Student s1 = new Student("Alex", 10, 3.8);
7
        Student s2 = new Student("Jordan", 11, 5.2); // invalid GPA triggers fix
8

9
        s1.showInfo();
10
        s2.showInfo();
11
    }
12
}

Run the program and confirm that invalid GPA values are corrected. This pattern appears frequently in AP FRQs involving class design.

Sample Output

Your output should look similar to the following:

Hi, I'm Unnamed and I'm in grade 9.
Hi, I'm Alex and I'm in grade 10.

Alex (Grade 10) — GPA: 3.8
Invalid GPA! Setting to 0.0...
Jordan (Grade 11) — GPA: 0.0

Reflection Questions

Write your answers as comments at the bottom of Main.java.

Explain the shadowing problem. Why is the this keyword necessary?
What advantages does constructor overloading give you when designing a class?

Submission

Submit your completed Student.java, Main.java, and reflection responses to the appropriate dropbox.