A Brief Intro to Classes and Objects

[comp1110-79]
  • Fabian Muehlboeck

The core concept in object-oriented programming is that of an object. An object combines data and behaviour, though this is something we will discuss later in the course. For now, we introduce some basic ideas that you will see more of very soon.

Construction 1. Class Definitions

[comp1110-80]
  • Fabian Muehlboeck

In Java, objects are instances of classes. A class definition is a kind of data definition, similar to what we have seen before for enums. However, classes are much more powerful, and they are used to model pretty much everything in our programs that cannot be modeled by a simpler data type. The core parts we will deal with for now are fields, which contain an object's data, and methods, which define an object's behaviour. The basic definition of a class consists of the keyword class and a class name, followed by curly braces, like so:

class Person { //this is where the fields and methods of a class go }

This does define a new type Person. To create a new instance of it (i.e. an object), you could write something simliar to what we did for arrays, using the keyword new:

Person p = new Person();

This is not very useful, because the Person class above has no data or behaviour, but you can add those.

By convention, class names in Java should be nouns that start with a capital letter, and use capital letters to mark the start of any word internal to the name. For example: LectureNote .

Construction 1.1. Fields

[comp1110-81]
  • Fabian Muehlboeck

Every class can have arbitrarily many fields. At the very least, each field has a type and name, just like a local variable. There are some other properties that fields can have, which we'll see later. To define a field, you declare it just like a local variable:

String name;

You can also give the field a default value, just like a local variable definitions:

String name = "Unknown";

By convention, in Java, field names are camelCased. That is, they start with a lower-case letter and otherwise contain only letters and digits, with uppercase letters indicating the start of a new combined word, as in sumOfAllParts.

In principle, you can read and write the fields of an object similar to how you can read and write individual array elements, though the syntax is more like when you ask an array for its length:

String oname = obj.name; if(oname.equals("Unknown")) { obj.name = "Timmy"; }

Warning. 

  • Fabian Muehlboeck
Note that array.length has the special property that you cannot assign values to it.

Example 1.2. Fields

[comp1110-82]
  • Fabian Muehlboeck

Say we want our Person class from earlier to have two fields: one representing the name of the person, and one representing their age. Names would typically be represented as Strings, and in our case, we only care about completed years of age, so we use int as the type for that field.

class Person { int age; String name; }

We can then create a new Person value and write to its fields:

Person p = new Person(); p.name = "Timmy"; p.age = 5;

Warning. 

  • Fabian Muehlboeck
This is not how you would typically do this; we'll learn about the right way to do this later.

Construction 1.3. Methods

[comp1110-83]
  • Fabian Muehlboeck

So far, we have sometimes written code in separate functions from the main function. But in every case so far, we had to give those functions all the arguments that they were supposed to work with.

Methods defined in a class implicitly have access to the fields defined in that class. This is because methods always need to be called on a specifc object, whose field values can then be used within the method.

So in principle, writing a method is just like writing a function, except inside a class. Within the class, you can all other methods within the class just like we called functions before.

By convention, in Java, method names are camelCased. That is, they start with a lower-case letter and otherwise contain only letters and digits, with uppercase letters indicating the start of a new combined word, as in sumOfAllParts.

class MyClass { int myMethod() { return 42; } }

Example 1.4. Methods

[comp1110-84]
  • Fabian Muehlboeck

Building on our example from Example 1.2, imagine we want to just have a way to print a nice description for any of our basic Person objects.

To do this, we'll add a printDescription method to the class:

class Person { int age; String name; void printDescription() { IO.println(name + " (Age " + age + ")"); } }

We can try this with the following main function:

void main() { Person p = new Person(); p.name = "Timmy"; p.age = 5; p.printDescription(); }

This will print:

Timmy (Age 5)

1.5. Have we seen Objects before?

[comp1110-85]
  • Fabian Muehlboeck

Yes! Every string and array is an object. When we wrote guess.charAt(5), we were calling a method of the String class on the particular String object referred to by guess.

Similarly, the difference between arr.length for arrays and str.length() for strings is that the former is a field that we can access, and the latter is a method we have to call.

Context

    Lecture. Classes and Sorting

    [comp1110-2026s2-lec03a]
    • August 11, 2026
    • Fabian Muehlboeck

    A Brief Intro to Classes and Objects

    [comp1110-79]
    • Fabian Muehlboeck

    The core concept in object-oriented programming is that of an object. An object combines data and behaviour, though this is something we will discuss later in the course. For now, we introduce some basic ideas that you will see more of very soon.

    Construction. Class Definitions

    [comp1110-80]
    • Fabian Muehlboeck

    In Java, objects are instances of classes. A class definition is a kind of data definition, similar to what we have seen before for enums. However, classes are much more powerful, and they are used to model pretty much everything in our programs that cannot be modeled by a simpler data type. The core parts we will deal with for now are fields, which contain an object's data, and methods, which define an object's behaviour. The basic definition of a class consists of the keyword class and a class name, followed by curly braces, like so:

    class Person { //this is where the fields and methods of a class go }

    This does define a new type Person. To create a new instance of it (i.e. an object), you could write something simliar to what we did for arrays, using the keyword new:

    Person p = new Person();

    This is not very useful, because the Person class above has no data or behaviour, but you can add those.

    By convention, class names in Java should be nouns that start with a capital letter, and use capital letters to mark the start of any word internal to the name. For example: LectureNote .

    Construction. Fields

    [comp1110-81]
    • Fabian Muehlboeck

    Every class can have arbitrarily many fields. At the very least, each field has a type and name, just like a local variable. There are some other properties that fields can have, which we'll see later. To define a field, you declare it just like a local variable:

    String name;

    You can also give the field a default value, just like a local variable definitions:

    String name = "Unknown";

    By convention, in Java, field names are camelCased. That is, they start with a lower-case letter and otherwise contain only letters and digits, with uppercase letters indicating the start of a new combined word, as in sumOfAllParts.

    In principle, you can read and write the fields of an object similar to how you can read and write individual array elements, though the syntax is more like when you ask an array for its length:

    String oname = obj.name; if(oname.equals("Unknown")) { obj.name = "Timmy"; }

    Warning. 

    • Fabian Muehlboeck
    Note that array.length has the special property that you cannot assign values to it.

    Example. Fields

    [comp1110-82]
    • Fabian Muehlboeck

    Say we want our Person class from earlier to have two fields: one representing the name of the person, and one representing their age. Names would typically be represented as Strings, and in our case, we only care about completed years of age, so we use int as the type for that field.

    class Person { int age; String name; }

    We can then create a new Person value and write to its fields:

    Person p = new Person(); p.name = "Timmy"; p.age = 5;

    Warning. 

    • Fabian Muehlboeck
    This is not how you would typically do this; we'll learn about the right way to do this later.

    Construction. Methods

    [comp1110-83]
    • Fabian Muehlboeck

    So far, we have sometimes written code in separate functions from the main function. But in every case so far, we had to give those functions all the arguments that they were supposed to work with.

    Methods defined in a class implicitly have access to the fields defined in that class. This is because methods always need to be called on a specifc object, whose field values can then be used within the method.

    So in principle, writing a method is just like writing a function, except inside a class. Within the class, you can all other methods within the class just like we called functions before.

    By convention, in Java, method names are camelCased. That is, they start with a lower-case letter and otherwise contain only letters and digits, with uppercase letters indicating the start of a new combined word, as in sumOfAllParts.

    class MyClass { int myMethod() { return 42; } }

    Example. Methods

    [comp1110-84]
    • Fabian Muehlboeck

    Building on our example from Example [comp1110-82], imagine we want to just have a way to print a nice description for any of our basic Person objects.

    To do this, we'll add a printDescription method to the class:

    class Person { int age; String name; void printDescription() { IO.println(name + " (Age " + age + ")"); } }

    We can try this with the following main function:

    void main() { Person p = new Person(); p.name = "Timmy"; p.age = 5; p.printDescription(); }

    This will print:

    Timmy (Age 5)

    Have we seen Objects before?

    [comp1110-85]
    • Fabian Muehlboeck

    Yes! Every string and array is an object. When we wrote guess.charAt(5), we were calling a method of the String class on the particular String object referred to by guess.

    Similarly, the difference between arr.length for arrays and str.length() for strings is that the former is a field that we can access, and the latter is a method we have to call.

    Understanding reference types

    [comp1110-1U]
    • Liam O'Connor, Fabian Muehlboeck

    Example. A puzzling question

    [comp1110-1P]
    • Liam O'Connor, Fabian Muehlboeck

    Without running this program, try to deduce what it will output:

    void fun1(int[] arr) { arr[0] = 100; } void fun2(int[] arr) { arr = new int[]{5,4,3,2,1}; } void fun3(int i) { i = 200; } void main() { int[] arr = new int[]{1,2,3,4,5,6}; int i = arr[0]; fun1(arr); IO.println(arr[0]); IO.println(i); fun2(arr); IO.println(arr[0]); IO.println(i); fun3(i); IO.println(arr[0]); IO.println(i); }

    You will only get the answer correct if you understand what happens in Java when values are passed to functions.

    Definition. Passing by value (or copy)

    [comp1110-1R]
    • Liam O'Connor, Fabian Muehlboeck

    A function's variables, including its parameters, are local to that invocation of the function. When we invoke a function, some memory is set aside for a frame: storage space for the local variables in the function. The values of the arguments given in the function invocation are copied into the function's frame. This is called pass by value. When the function returns, the frame is no longer needed and destroyed.

    This is why the function fun3 has no effect on its arguments in example Example [comp1110-1P].

    Definition. Value types and reference types

    [comp1110-1Q]
    • Liam O'Connor

    Variables of type int and char (for example) are called value types. This means that a variable declared of type, say int:

    int x;

    Will contain a value, a single integer. When left uninitialised as above, they are initialised to a default value of 0.

    By contrast, array types like int[] and char[] are what's called reference types. This means that a variable declared of an array type will not contain the array data itself, but instead will contain the location in memory where the data may be found. This location is called a reference or pointer.

    Any type name that begins with a capital letter (e.g. String) is also a reference type. This is why Strings should not be compared with == — it would compare locations, not contents.

    Definition [comp1110-1Q] combined with Definition [comp1110-1R] tells us that when we call a function like fun1 or fun2 in Example [comp1110-1P], the array data itself is not copied into the function's frame, but instead just the reference is. When fun1 or fun2 are called, the variable arr in their frame has the same value as the variable arr in the frame of main — they both point to the same array. This means that when we call fun1, the contents of the array in main are observably changed, as the array indexing arr[0] follows the same pointer that is in main.

    When we call fun2, however, nothing changes in the function main, because we don't follow the pointers, but instead just change the value of the local variable arr to point to a new array, then immediately discard it.

    The Waterloo Java Visualizer

    [comp1110-1S]
    • Liam O'Connor

    The Waterloo Java Visualizer is a great way to visualise what's going on in these examples. Here's a link to Example [comp1110-1P] being visualised in it. Click "forward" to step through the program's execution.

    Note that it doesn't support Java 25, so I had to include some cruft that Java 25 has since made obsolete like (a method-free) class, public static etc. We will learn about these things later in the course but they are not relevant for now.

    Reference vs. Value Equality

    [comp1110-1T]
    • Liam O'Connor, Fabian Muehlboeck

    The difference between value types and reference types explains the differences between == and other methods to decide equality.

    For value types, == happens to capture regular equality - for example, there are no two int values that represent the number 32 but are somehow different.

    On the other hand, for reference types, == describes reference equality, identifying whether two references point to the same object in memory. Since there may be two different objects representing the same value, == is too strict in many cases. We have seen this for String equality and Array equality. It is the same way in general for objects of arbitrary classes, except that for those, by default, no other notion of equality comparison exists. We'll see later how to define our own equality comparison.

    Finally, Enums are a special case: they are a reference type, but with a guarantee that each case of a Enum refers to the same object in memory. As such, comparing the references to Enum values using == is fine - as for ints, there are no two distinct values representing the same case.

    Back to Search

    [comp1110-86]
    • Fabian Muehlboeck

    Example. CLI driver for search procedures

    [comp1110-1M]
    • Liam O'Connor

    To make manual testing easier, we'll make a suitable main function that reads a certain number of inputs one number at a time using IO.readln() and then calls our search function.

    void main() { int length = 10; int[] a1 = new int[length]; int i = 0; while(i < length) { a1[i] = Integer.parseInt(IO.readln()); i = i + 1; } assert(binarySearch(a1, 5)); assert(binarySearch(a1, 1)); assert(binarySearch(a1, 10)); assert(binarySearch(a1, 9)); assert(!binarySearch(a1, 0)); assert(!binarySearch(a1, 15)); }

    The flexibility is nice, by but running this and manually entering a bunch of numbers every time can be a bit of a slog. You can therefore create a file, say "numbers.txt" (the file extension does not really matter), that contains those numbers:

    1 2 3 4 5 6 7 8 9 10

    You can of course create several different files with different lists of numbers.

    To use those files, you can call your program in a special way. If you normally start the program by writing:

    java BinarySearch

    You can instead write:

    java BinarySearch < numbers.txt

    The combination of a less-than sign < with a filename after it tells your terminal emulator to read that file and use it as the standard input for the program, instead of prompting the user. We use the same idea in Homework 1.

    Example. Sortedness Checker

    [comp1110-1K]
    • Liam O'Connor, Fabian Muehlboeck
     boolean isSorted(int[] haystack) { int i = 0; while(i < haystack.length - 1) { if(haystack[i] > haystack[i + 1]) { return false; } } return true; }

    Searching Arbitrary Arrays

    [comp1110-87]
    • Fabian Muehlboeck

    Binary Search is very efficient, but depends on the array being sorted. This may not be true of any array you might encounter. So, as a first attempt, you might want to use the sortedness checker from Example [comp1110-1K] to see if the array is sorted, and then depending on that either use binary search or the linear search procedure we saw in Example [comp1110-16].

    boolean search(int[] haystack, int needle) { if(isSorted(haystack)) { return binarySearch(haystack, needle); } else { return linearSearch(haystack, needle); } }

    The problem with the above approach is that when we are checking whether the array is sorted, we have to go through every element of the array. At that point, we might just check whether those elements are equal to needle right away.

    The general idea is more reasonable if there are several things that we want to search for. In that case, we only have to go through the array once, and if it happens to be sorted, we can then use binarySearch many times, efficiently finding each element.

    But better yet, in that case, we might just want to sort the array to guarantee that we can do those later searches efficiently.

    Understanding sorting

    [comp1110-1V]
    • Liam O'Connor

    Definition. A spec and a test suite for sorting

    [comp1110-1W]
    • March 10, 2026
    • Liam O'Connor

    Any in-place sorting algorithm, no matter how it is implemented, should satisfy the following spec:

    /** Sort an array in-place. There are two postconditions: - After executing, the array must be sorted. - After executing, the array must be some permutation of the values that existed before. (many programmers will get the former but forget the latter) @param arr the array to sort */ void sort(int[] arr)

    Assuming we had such a function, we might test it (using proper array comparison) as follows:

    void sortAndCheck (int[] toSort, int[] toCheck) { sort(toSort); assert Arrays.equal(toSort, toCheck); } void main (String[] args) { // already sorted sortAndCheck(new int[]{1,2,3,4,5,6,7,8,9}, new int[]{1,2,3,4,5,6,7,8,9}); // inversely sorted sortAndCheck(new int[]{9,8,7,6,5,4,3,2,1}, new int[]{1,2,3,4,5,6,7,8,9}); // random order sortAndCheck(new int[]{6,-5,212,42,19,0,0,5,9718}, new int[]{-5,0,0,5,6,19,42,212,9718}); // negative and inverse sortAndCheck(new int[]{-1,-2,-3,-4,-5}, new int[]{-5,-4,-3,-2,-1}); // empty sortAndCheck(new int[]{}, new int[]{}); // singleton sortAndCheck(new int[]{0}, new int[]{0}); // two sortAndCheck(new int[]{100,100}, new int[]{100,100}); }

    Definition. Quadratic sorting methods

    [comp1110-1X]
    • August 11, 2026
    • Liam O'Connor, Fabian Muehlboeck

    We demonstrated two sorting algorithms in the lecture:

    • Selection sort: We divide the array into an "unsorted zone" and a "sorted zone". The sorted zone begins empty at the start of the array, and the unsorted zone begins by occupying the whole array. Each loop iteration, we look through the unsorted zone, find the minimum, and swap it with the first element of the unsorted zone (right next to the sorted zone). This means that the sorted zone can be expanded by one element. Repeat until the unsorted zone is of size zero.
    • Bubble sort: Here, the "sorted zone" grows from the end of the array rather than the beginning. Loop through the unsorted zone comparing adjacent elements. If they are not in order, swap them. This will result in the highest element reaching the top. This means we can increase the size of the sorted zone. Repeat until all sorted.

      If we go through the unsorted zone without doing any swaps, we can immediately stop — the array is sorted. This is called an early exit trick.

    I briefly mentioned another one at the start of the workshop:

    • Insertion sort: The most popular of these three, and somewhat similar to selection sort, in that the sorted zone begins empty and grows from the left. Instead of finding the minimum, however, we take the first element from the unsorted zone and remember it (call it X) and shift everything greater than X in the sorted zone to the right one spot. Then we place X in the slot left over.

    These algorithms are called "quadratic" because they take a quadratic amount of key operations (in terms of the size of the array), in this case comparisons and moves/swaps to perform.

    While insertion sort is generally the most popular of the three, each of them have their own advantages, depending on your particular situation. On arrays:

    • Selection sort minimizes the number of times you have to move an array element.
    • Bubble sort only swaps adjacent elements and has an easy way to exit early on sorted arrays.
    • Insertion sort can minimize the number of comparisons that you do (these can become expensive on more complex data types).

    Which of these you actually get depends on the particulars of your implementation, and minor variations (say starting from the other direction) can make a huge difference for certain scenarios.

    Example. Selection sort

    [comp1110-1Y]
    • August 11, 2026
    • Liam O'Connor, Fabian Muehlboeck
     void selectionSort(int[] arr) { int i = 0; while(i < arr.length) { //INV : arr[0..i-1] is sorted AND for every j in // [i..arr.length-1], arr[j] >= every element // in arr[0..i-1] int currentMin = arr[i]; // could as well be always referred // to as arr[currentPos] int currentPos = i; int j = i + 1; while(j < arr.length) { //INT: arr[currentPos] is the minimum element in arr[i..j-1] if(arr[j] < currentMin) { currentMin = arr[j]; currentPos = j; } j = j + 1; } //arr[currentPos] is the minimum element in arr[i..arr.length-1] // from above, we know that it is greater than or equal to every // element in arr[0..i-1] int swap = arr[i]; arr[i] = arr[currentPos]; arr[currentPos] = swap; //therefore, swapping arr[currentPos] with arr[i] makes arr[0..i] // still sorted, and every element in arr[i+1..arr.length-1] // is >= every element in arr[0..i] . i = i + 1; } }

    Example. Bubble sort

    [comp1110-1Z]
    • August 11, 2026
    • Liam O'Connor

    Bubble sort swaps a lot of elements, but the key idea is that once it finds the maximum element in the unsorted part of the array, it keeps "bubbling" it up further and further, until we reach the end of the unsorted part, where a sorted array of elements larger than the new element is waiting. In that sense, it works like selection sort (either one of them could also just work in the other direction), but with more elements being moved around. We include the "early exit" trick mentioned by Definition [comp1110-1X]:

    void bubbleSort(int[] arr) { int i = arr.length - 1; while(i > 0) { // INV: arr[i..arr.length-1] is sorted, and // for every j in [0..i], arr[j] <= every element // in arr[i+1..arr.length-1] int j = 0; boolean swapped = false; while(j < i) { // INV: for every k < j, arr[k] < arr[j] // and if swapped == false, then arr[0..j-1] is sorted if(arr[j] > arr[j + 1]) { int swap = arr[j]; arr[j] = arr[j + 1]; arr[j+1] = swap; swapped = true; } j = j + 1; } // for every k < i, arr[k] < arr[i], and if // swapped == false, then arr[0..i-1] is sorted if(!swapped) { // at this point, both arr[0..i-1] and arr[i..arr.length-1] // are sorted, and we know that every element in // arr[0..i-1] is less than or equal to every element in // arr[i..arr.length-1]. hence, the whole array is sorted i = 0; } i = i - 1; } // arr[0..arr.length-1] is sorted }

    Definition. In-place

    [comp1110-20]

      An algorithm is in-place if only modifies existing structures, rather than create new ones. For example, for sorting an in-place function returns void, as they don't produce a new array, they just modify an old one. All our sorting algorithms in this section are in-place.

      Backlinks

        Construction. Abstract classes and methods

        [comp1110-5N]
        • Liam O'Connor, Fabian Muehlboeck

        An abstract class is a class that cannot be instantiated directly: it exists only to be extended. It may define fields and concrete methods that subclasses inherit, as well as abstract methods that subclasses must implement. Abstract classes occupy a middle ground between interfaces (no implementation) and concrete classes (full implementation).

        In Java, abstract classes and methods are declared with the abstract keyword.

        Exercise. Box inheritance

        [comp1110-5X]
        • Liam O'Connor, Fabian Muehlboeck

        Consider the following interface, implemented by four classes that each draw a box to the terminal (here "colour" just means the character to draw to the terminal):

        public interface Box { int width(); int height(); void setFrameColour(char c); void draw(); }

        The four classes are:

        • WhiteBox(width, height, frame) — fill colour is always ' '.
        • BlackBox(width, height, frame) — fill colour is always the same as the frame colour.
        • GreyBox(width, height, frame, fill) — fill colour is the given fill character.
        • ColouredBox(width, height, frame, fill) — like GreyBox but with an additional setFillColour(char c) method.

        Which subtyping relationships are LSP compliant?

        Solution. 

        • Liam O'Connor, Fabian Muehlboeck
        • WhiteBox extends GreyBox — compliant. WhiteBox is a GreyBox with fill fixed to ' '. Since constructors are not inherited, a caller of GreyBox's interface methods has no expectation about how the fill colour was initially chosen. WhiteBox satisfies all of GreyBox's method contracts, with a stronger invariant on fill.
        • BlackBox extends GreyBox — not compliant. BlackBox ties the fill colour to the frame colour, so calling setFrameColour has a side effect on getFillColour. A caller of GreyBox would not expect setFrameColour to change the fill — this violates the history constraint.
        • ColouredBox extends GreyBox — not compliant. Although ColouredBox does not change the behaviour of any existing method, the additional setFillColour method allows the fill colour to be mutated after construction. GreyBox has an implicit history constraint — once constructed with a fill colour, that fill does not change. ColouredBox violates this.
        • GreyBox extends WhiteBox — not compliant. WhiteBox has an invariant that fill is always ' '. GreyBox allows any fill colour, breaking this invariant.
        • ColouredBox extends WhiteBox — not compliant. Violates both the fill invariant of WhiteBox and the history constraint, since setFillColour allows the fill to be changed after construction.
        • BlackBox extends WhiteBox — not compliant. The fill colour is the frame character, which is not necessarily ' ', breaking WhiteBox's fill invariant.

        Construction. Final classes and methods

        [comp1110-5S]
        • Liam O'Connor

        A class declared final cannot be subclassed. A method declared final cannot be overridden. These are guarantees to the compiler and to readers of the code that no subclass will change the behaviour of the class or method in question.

        This final keyword is useful when a class has been carefully designed with a specific contract and allowing subclasses to override behaviour could silently violate it.

        Definition. Linked Lists

        [comp1110-2S]
        • Liam O'Connor, Fabian Muehlboeck

        A linked list is a way to store a sequence of items, one after another, where each item points to the next. Unlike arrays, it is not necessary to know ahead of time how many items the list will contain. It is a very common example of a recursive data type, where a type occurs as a field of itself. Here, we describe a linked list of integers by defining a recursive class type:

        // An IntList is either // null - representing the empty list // an IntList object, representing a part of a non-empty list class IntList { int value; IntList rest; IntList(int v, IntList r) { value = v; rest = r; } }

        Here value is the first integer in the list, rest is the rest of the list (or null if there are no more integers). Therefore, null plays the role of the base case of our recursion, while an IntList object (which contains another IntList) is the recursive case.

        // Start with an empty list IntList list = null; // Add 3 first list = new IntList(3, list); // Add 2 in front of 3 list = new IntList(2, list); // Add 1 in front of 2 list = new IntList(1, list);

        More on classes

        [comp1110-7E]
        • Fabian Muehlboeck

        So far, we have seen class definitions with fields and methods, but always had to initialise the fields of a new object explicitly. We can make this more convenient.

        Definition. Class Member

        [comp1110-7B]
        • Fabian Muehlboeck

        Member is the generic term for parts of a class, such as fields or methods.

        Construction. Constructors

        [comp1110-7C]
        • Fabian Muehlboeck

        A constructor is a class member that is used to initialise objects of a class when they are created. By default, every class has a parameterless constructor that does nothing, and for a class named MyClass, can be called using:

        new MyClass()

        You can define your own constructors. As soon as you do, the default parameterless constructor does not exist anymore. Constructors are special because, unlike normal methods, they do not have a name or return type. In Java, you specify them using the class type, as in:

        class MyClass { /** * An empty, parameterless constructor for MyClass */ MyClass() { } }

        Example. Initialising Objects

        [comp1110-7D]
        • Fabian Muehlboeck

        The most common use of constructors is to initialise the fields of an object:

        class Person { String name; int age; /** * Constructs a Person with a given age and name * @param n the name of the new Person * @param a the age of the new Person */ Person(String n, int a) { name = n; age = a; } }

        This way, new instances of the above class can be created using:

        new Person("Julia", 22)

        Construction. Reading Files

        [comp1110-96]
        • Fabian Muehlboeck

        Interacting with files is risky business, much more so than all the other things we have done in the course so far. This is because they are shared with other programs and users that might work with them at the same time we do. Files might exist one moment and then not anymore, without our program having done anything, just because some other program deleted it. They might exist but cannot be opened, because the user running our program does not have permission to read it, or because there is some deeper problem with the file system.

        For that reason, Java specifies a number of checked exceptions that you need to deal with when opening files and reading, usually under the umbrella of IOException. In principle, when opening a file, you can have access to the raw bytes in the file. However, for now, we use the FileReader class, which implicitly assumes that the file is encoded using UTF-8 (though you can specify a different encoding when creating the FileReader; that won't be necessary in this course). The FileReader's role is to interpret the files in the appropriate encoding, and so it's core functionality is to read UTF-16 (Java's internal encoding) code points one by one. It has a utility method that gives you all lines in a file at once, but that is often undesirable, especially for large files.

        To be able to easily read a file line-by-line, we have to use a BufferedReader. A BufferedReader requires some underlying reader, like a FileReader, to provide the actual data. The main thing it does is provide a readLine() method, which reads the next line in the file since the last time you called it.

        This is a way in which objects have behavior that changes their state. A FileReader starts at the beginning of a file and moves forward in it with every byte that it reads. As the BufferedReader asks it to keep reading data until it reaches a line ending, each call of readLine() moves the internal state ahead by as many bytes as are needed to represent the line.

        File f = new File(pathToFile); try { BufferedReader reader = new BufferedReader(new FileReader(f)); // use reader.readLine() to read the next line from the file // when the reader reaches the end of the file, reader.readLine() // will return null } catch(IOException e) { // handle error }

        Construction. Static fields

        [comp1110-8J]
        • Fabian Muehlboeck

        A static field belongs to the class itself rather than to any particular instance. It is declared with the static keyword and accessed via the class name rather than on an object:

        public class Person { private static int nextId = 1; int id; public Person() { // within the person class, equivalent to Person.nextId this.id = nextId; } }

        Static fields can be useful to share information across the instances of a class - they are essentially global variables. Global variables - especially the ones that change their values - can be very dangerous, so use them sparingly!

        Construction. Static methods

        [comp1110-4F]
        • Liam O'Connor, Fabian Muehlboeck

        A static method belongs to the class itself rather than to any particular instance. It is declared with the static keyword and called on the class name rather than on an object:

        public class MathUtils { public static int square(int x) { return x * x; } } // called on the class, not an instance: int result = MathUtils.square(5);

        Because a static method has no associated instance, it cannot access instance fields or call instance (non-static) methods. It can only work with its arguments and other static members of the class — it is essentially a function.

        Static methods are useful for utility functions that are logically associated with a class but do not depend on any particular object's state. You have already seen examples of this in the standard library, such as the utility functions for characters or array comparison.

        Example. The GuestList interface (String version)

        [comp1110-3X]
        • Liam O'Connor, Fabian Muehlboeck

        Our GuestList interface will represent a set of names. The interface exposes three operations:

        public interface GuestList { // record that a guest is coming void add(String name); // record that a guest is no longer coming void remove(String name); // query whether a guest is coming boolean isComing(String name); }

        The semantics are set-like: a guest is either coming or not; adding the same guest twice has the same effect as adding them once. The interface says nothing about how this is implemented — that is left to implementing classes.

        Why Java Programs Crash

        [comp1110-89]
        • Fabian Muehlboeck

        Generally, programs crash when they try to execute an invalid operation. For example, so far we have seen that a program crashes when we try to access an array at an invalid index (say a negative index or in index larger than or equal to the array's size). Another reason might be that we are trying to divide a number by zero, or to parse an integer from a string that does not represent a number. There are many more potential reasons, some of which are related to things computers simply cannot or should not do, and some of which just relate to things that should not happen within the logic of a particular program.

        In many modern programming languages, including Java, all of these kinds of problems are handled through a single exception mechanism. Exceptions are thrown at the point where the program itself or the language runtime detects an error. They then try to find an exception handler, which may execute code in response to the exception, and potentially re-throw it. If no handler is found, the program crashes, and simply prints information about the exception that made it crash.

        In Java, exceptions are objects belonging to certain exception classes, for example NumberFormatException or ArrayIndexOutOfBoundsException. The different classes make it possible to distinguish between different kinds of exceptions, and because exceptions are objects, they can carry relevant data about the particular problem that caused the exception to be thrown. In general, the exception classes belong to one of three groups:

        • Checked Exceptions

          This is the standard kind of exception in Java, meant to express both error cases in the normal program logic and certain standard kinds of errors that are common and should usually be handled gracefully. Java is a bit of an outlier among major programming languages in that its compiler enforces that a programmer either handles such exceptions where they can occur or explicitly declares that such exceptions might be thrown within their code.

        • Runtime Exceptions

          These encompass all exceptions we have seen in the course so far. These are either very special or so common that it would be highly impractical to demand that they be checked or annotated everywhere they could occur, and so get an exemption from the above rule.

        • Errors

          These are the kinds of problems that might occur in the execution of a program, but are not necessarily the program's fault, and in any case, one cannot reasonably expect that a program can recover from them. Generally, you should not try to handle those.

        bars magnifying-glass caret-down plus minus arrow-right xmark