Classes and objects

The big idea: Defining a class writes the template. Instantiating creates an actual object from it.

The class is written once; objects are created as often as you need them.

The big idea: Defining a class writes the template. Instantiating creates an actual object from it.

The class is written once; objects are created as often as you need them.

class Book:
    def __init__(self, title, author):   # the CONSTRUCTOR
        self.title  = title              # set this object's attributes
        self.author = author
        self.onLoan = False              # a sensible starting state

    def borrow(self):
        if self.onLoan:
            return False
        self.onLoan = True
        return True

b1 = Book("Dune", "Herbert")             # instantiation
print(b1.borrow())                       # True
print(b1.borrow())                       # False — already out

class Book {
    String title;
    String author;
    boolean onLoan;

    Book(String title, String author) {   // the CONSTRUCTOR
        this.title  = title;              // set this object's fields
        this.author = author;
        this.onLoan = false;              // a sensible starting state
    }

    boolean borrow() {
        if (this.onLoan) {
            return false;
        }
        this.onLoan = true;
        return true;
    }
}

Book b1 = new Book("Dune", "Herbert");       // instantiation
System.out.println(b1.borrow());             // true
System.out.println(b1.borrow());             // false — already out

A class and its objects in memory: The class is stored once and holds only class-level (static) data. Each object gets its own block of memory on the heap for its instance variables: 20 Car objects means 20 blocks, one class.

A variable such as b1 holds a reference (the object's address), not the object itself.

What self means: self is the object the method was called on.

self.title is this book's title; another object's method call has a different self. It is what lets one method definition serve every object.

What self means: this is the object the method was called on.

this.title is this book's title; another object's method call has a different this. It is what lets one method definition serve every object.

Not every attribute is a parameter: title and author come from outside, because they differ per book.

onLoan is set inside to a sensible default — a new book is never on loan, so asking the caller would be pointless and error-prone.

library = [
    Book("Dune", "Herbert"),
    Book("Emma", "Austen"),
]

library.append(Book("Hamlet", "Shakespeare"))

for book in library:                 # objects go in lists like anything else
    if book.borrow():
        print("Borrowed:", book.title)
    else:
        print("Unavailable:", book.title)

ArrayList<Book> library = new ArrayList<>();
library.add(new Book("Dune", "Herbert"));
library.add(new Book("Emma", "Austen"));

library.add(new Book("Hamlet", "Shakespeare"));

for (Book book : library) {          // objects go in lists like anything else
    if (book.borrow()) {
        System.out.println("Borrowed: " + book.title);
    } else {
        System.out.println("Unavailable: " + book.title);
    }
}

Many objects in one array. Papers often store objects in an array and reach each one by its index.

shelf = [None] * 3              # room for 3 Book objects
shelf[0] = Book('Dune', 'Herbert')
shelf[1] = Book('Emma', 'Austen')

print(shelf[1].title)            # Emma: index first, then the dot
count = 2                        # how many places are filled

Book[] shelf = new Book[3];      // room for 3 Book objects, all null at first
shelf[0] = new Book("Dune", "Herbert");
shelf[1] = new Book("Emma", "Austen");

System.out.println(shelf[1].getTitle());   // Emma: index first, then the dot
int count = 2;                   // how many places are filled

Default constructor

A constructor with no parameters that gives every attribute a sensible starting value, so an object can be created before its details are known.

Reference

A variable holding an object stores where the object is, not a copy of it: two variables can refer to the same object.

Java, briefly: Java names the constructor after the class — public Book(String title) — and writes this.title where Python writes self.title.

The structure and the reasoning are the same; only the spelling differs.

toString() and __str__(): toString() in Java, or __str__() in Python, returns the object's attribute values as one readable string.

One call prints the whole object, which beats calling every accessor, and it is handy when debugging.

How this is tested — you must write a constructor that sets every attribute, and methods that return. It comes up two ways:

The classic trap: Forgetting to set an attribute in the constructor. An object then exists with a missing value, and the failure appears much later — somewhere that has nothing to do with the cause.