IB Computer Science Topic B3.1.4: Constructing Code to Define Classes and Instantiate Objects Notes

From Class Definition to Living Object

1. A class definition is only text in a file, and it reserves no memory and holds no data.
2. An object appears when the class is instantiated, which allocates memory and runs the constructor to set the starting values.
3. This statement is a construct statement, so it is examined by asking you to write the code rather than describe it.
4. What a class and an object are as concepts is covered in B3.1.1; here the concern is the syntax that produces them.

The Four Parts of a Class Definition in Code

1. Every class you write for this course is built from the same four pieces, in this order.
2. The class declaration names the class.
   1. Java uses public class Bird, Python uses class Bird:.
   2. Class names are singular and start with a capital letter in both languages.
3. The instance variables hold the state of each object.
   1. In Java they are declared at the top of the class with a type, and marked private.
   2. In Python they are created inside the constructor by assigning to self, so there is no separate declaration.
4. The constructor sets those variables when an object is created.
5. The methods define what the object can do.
   1. A method that returns a value states its return type in Java; Python does not declare one.

Writing the Bird Class

1. The class below stores two facts about a bird and gives it one behaviour, which is enough to show all four parts at once.
2. Read the constructor first, because it is the line that decides what an object needs before it can exist.

class Bird:
    # Constructor: runs automatically when a Bird is created
    def __init__(self, species, age):
        self.species = species      # instance variables
        self.age = age

    # Method (behaviour)
    def sing(self):
        print(f"{self.species} is singing!")

    # Accessor
    def get_age(self):
        return self.age

public class Bird {
    // Instance variables, private so they are encapsulated
    private String species;
    private int age;

    // Constructor: same name as the class, no return type
    public Bird(String species, int age) {
        this.species = species;
        this.age = age;
    }

    // Method (behaviour)
    public void sing() {
        System.out.println(species + " is singing!");
    }

    // Accessor
    public int getAge() {
        return age;
    }
}

Referring to the Current Object: this and self

1. Inside a method, this in Java and self in Python refer to the object the method was called on.
2. In the constructor, this.species = species assigns the parameter on the right to the instance variable on the left, which is why the two can share a name.
   1. Without this, Java would read species as the parameter on both sides and the instance variable would stay empty.
3. Python requires self as the first parameter of every instance method, and it is passed automatically when the method is called.
   1. Writing species = species in a Python constructor creates a local variable that is discarded when the constructor ends.

Instantiating Objects

1. Instantiation is the act of creating an object from a class.
2. Java uses the new keyword, which allocates the memory and then calls the constructor.
3. Python calls the class name as though it were a function, and __init__ runs on the new object.
4. Each call produces a separate object with its own copy of every instance variable.
   1. Changing parrot's age leaves sparrow's age untouched, which is the whole point of instance variables.

# Instantiation: each call to Bird(...) builds a separate object
sparrow = Bird("Sparrow", 2)
parrot  = Bird("Parrot", 5)

sparrow.sing()                        # Sparrow is singing!
parrot.sing()                         # Parrot is singing!
print("Parrot age:", parrot.get_age())  # Parrot age: 5

# The two objects are independent
parrot.age = 6
print(sparrow.get_age(), parrot.get_age())   # 2 6

public class Main {
    public static void main(String[] args) {
        // Instantiation: new allocates memory and calls the constructor
        Bird sparrow = new Bird("Sparrow", 2);
        Bird parrot  = new Bird("Parrot", 5);

        sparrow.sing();                    // Sparrow is singing!
        parrot.sing();                     // Parrot is singing!
        System.out.println("Parrot age: " + parrot.getAge());  // Parrot age: 5

        // The two objects are independent
        System.out.println(sparrow.getAge() + " " + parrot.getAge());  // 2 5
    }
}

Common Errors When Defining and Instantiating

The Role of the Constructor

1. The constructor's job is to leave the object in a valid starting state, so that no method can be called on a half-built object.
2. It is named for the class. In Java it carries the class name exactly; in Python it is always __init__.
3. It has no return type. Not even void in Java, which is how the compiler tells a constructor from a method.
4. It runs automatically on instantiation and cannot be called again on an existing object.
5. It can validate its inputs, rejecting an age below zero before the object is ever used.
6. A class whose constructor takes no parameters forces every attribute to be set afterwards, which is where objects in invalid states come from.

Default and Parameterised Constructors

1. A parameterised constructor takes values as arguments, which is the form used almost everywhere.
2. A default constructor takes no arguments and supplies starting values itself.
3. Java provides a default constructor for free, but only while you write no constructor at all.
   1. The moment you write Bird(String, int), the free no-argument constructor disappears, and new Bird() stops compiling.
   2. If both forms are needed, write both, which is constructor overloading.
4. Python supplies no default constructor, so __init__ must be written whenever initialisation is needed.
   1. Default parameter values give the same flexibility in a single constructor.

class Bird:
    def __init__(self, species="Unknown", age=0):
        self.species = species
        self.age = age

b1 = Bird()                     # uses both defaults
b2 = Bird("Robin")              # uses the default age only
b3 = Bird("Owl", 3)             # supplies both

print(b1.species, b1.age)       # Unknown 0
print(b2.species, b2.age)       # Robin 0
print(b3.species, b3.age)       # Owl 3

public class Bird {
    private String species;
    private int age;

    // No-argument constructor, written explicitly
    public Bird() {
        this.species = "Unknown";
        this.age = 0;
    }

    // Parameterised constructor
    public Bird(String species, int age) {
        this.species = species;
        this.age = age;
    }
}

// Bird b1 = new Bird();              species "Unknown", age 0
// Bird b2 = new Bird("Owl", 3);      species "Owl", age 3

Construct Questions in Paper 2

Tracing What Happens on Instantiation

1. Being able to say what the machine does in order is what separates a memorised answer from an understood one.
2. The class is loaded and any static members are set up, once, before any object exists.
   1. Memory is allocated for one object, large enough for its own copy of every instance variable.
   2. The instance variables are set to default values, so a Java int starts at 0 and an object reference at null.
   3. The constructor runs, replacing those defaults with the values passed in.
   4. The constructor's validation can reject a value here, before any other code sees the object.
   5. A reference to the finished object is handed back and stored in the variable on the left of the assignment.
   6. The variable holds a reference, not the object, so two variables can point at the same object.
3. This is why Bird b; on its own creates no bird in Java: the reference exists but nothing has been instantiated.