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; } }

Context

    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.

    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.

      Definition. Data invariants

      [comp1110-44]
      • Liam O'Connor

      A data invariant (also called a representation invariant) is a condition on the fields of a class that must hold after every constructor call and after every method call. It is not enforced by the compiler; it is the programmer's responsibility to maintain it.

      Data invariants document the assumptions an implementation relies on internally. Like loop invariants, they make it easier to reason about correctness: if every method both assumes the invariant holds on entry and ensures it holds on exit, then by induction it holds throughout the lifetime of the object.

      Definition. Encapsulation

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

      By marking fields as private, we hide the internal state. We then provide public methods (the interface) as the only way to interact with that state. This is important for two reasons:

      • Integrity - we can maintain data invariants about the object's internal state: properties that should be true before and after each call to a method on the object. For example, in Example [comp1110-3E],because balance is private, a user cannot write account.balance = -500;. They are forced to use deposit(), where we can include logic to ensure that the balance never goes negative. This enforces the data invariant that the account balance is always \(\geq 0\).
      • Abstraction - we can separate the interface (what methods are exposed to the public) from the implementation (the private fields and method implementations). This means that users of this class need only know about the interface, which reduces cognitive load on the programmer — essential for large programs. It also enables flexibility. For example, in Example [comp1110-3E], if we later decide to store the balance in a different currency or a different data type, we only change the code inside the class. Anyone calling getBalance() won't even notice the change.

      Warning. Encapsulation and defensive copying

      [comp1110-47]
      • Liam O'Connor

      Encapsulation means that the internal state of an object can only be changed through its defined methods. This is broken if a method returns a direct reference to an internal array or other mutable object, because the caller can then modify it from outside.

      The fix is to return instead a defensive copy: a fresh object with the same contents. The caller is then free to do whatever they like with the copy without affecting the internal state of the object.

      Construction. Extending interfaces

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

      Interfaces can form hierarchies using the extends keyword. When one interface extends another, it inherits all method signatures from the parent. This allows you to create specialised versions of an abstraction without duplicating the original definitions.

      Interfaces may extend arbitrarily many other interfaces.

      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.

      Construction. Inheritance

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

      Inheritance allows a class to be defined as an extension of another, inheriting its fields and methods. The extending class is called the subclass; the class being extended is the superclass. In Java, inheritance is expressed with extends:

      public class SavingsAccount extends BankAccount { ... }

      The subclass gains all the fields and methods of the superclass, and can add new ones or override existing ones. Unlike interfaces, which define only a contract, class inheritance also reuses implementation. Partly for this reason, each class can extend only one superclass. If no specific superclass is specified using the extends keyword, a class is taken to extend the special class Object (in Java, every kind of reference type at least transitively extends Object, which forms the top of the type hierarchy).

      Warning. 

      • Liam O'Connor, Fabian Muehlboeck
       Constructors are not inherited. A subclass must define its own. To invoke the superclass constructor, use super() as the first statement in the subclass constructor.

      Construction. Interfaces

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

      An interface is a reference type in Java that specifies a set of method signatures but does not provide their implementations. It serves as a contract: any class that implements the interface promises to provide the logic for those methods.

      An interface is typically open: any number of classes can implement it across different parts of a codebase.

      You cannot create instances of interfaces directly, they must always be objects of a class implementing the interface.

      Example. JUnit tests for GuestList

      [comp1110-3Y]
      • Liam O'Connor

      The following unit tests exercise the GuestList interface in a black-box fashion. To use JUnit in IntelliJ, create a new Java file and include the following imports at the top. You can run all tests in the file by pressing the green play button next to the class name, or run a single test by pressing the play button next to that test method.

      import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; public class GuestListTests { //Unit Tests - test the parts of your program separately //Black-Box tests - on the interface @Test void test() { GuestList gl = new GuestArrayUniqueList(); assertFalse(gl.isComing("Fabian")); gl.add("Fabian"); assertTrue(gl.isComing("Fabian")); assertFalse(gl.isComing("Nicholas")); gl.add("Nicholas"); assertTrue(gl.isComing("Fabian")); assertTrue(gl.isComing("Nicholas")); gl.remove("Fabian"); assertFalse(gl.isComing("Fabian")); assertTrue(gl.isComing("Nicholas")); gl.add("Fabian"); assertTrue(gl.isComing("Fabian")); assertFalse(gl.isComing("Ann")); gl.remove("Ann"); assertFalse(gl.isComing("Ann")); gl.add("Nicholas"); assertTrue(gl.isComing("Nicholas")); gl.remove("Nicholas"); assertFalse(gl.isComing("Nicholas")); } @Test void removeFromEmpty() { GuestList gl = new GuestArrayList(); gl.remove("Fabian"); assertFalse(gl.isComing("Fabian")); } }

      Notice that the variable gl is declared as GuestList, not as a specific implementation class. This ensures the test targets the interface contract rather than any implementation detail, respecting abstraction boundaries. Each @Test method is independent: JUnit creates a fresh instance of the test class for each one, so the two tests do not interfere with each other.

      Construction. Overriding and super

      [comp1110-5R]
      • Liam O'Connor

      A subclass can override a method inherited from its superclass by redeclaring it with the same signature. The @Override annotation, which you may have already seen before, is optional but recommended: the compiler will catch cases where the signature doesn't actually match anything in the superclass.

      Within an overriding method, super.method(...) calls the superclass's version of the method. This is useful when the subclass wants to extend rather than replace the superclass behaviour. Similarly, super() in a constructor calls the superclass constructor.

      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.

      Definition. Unit testing with JUnit

      [comp1110-40]

        A unit test checks a single, small piece of a program in isolation from the rest of the system. Unit tests contrast with integration tests, which test how multiple components work together.

        JUnit is the standard unit-testing framework for Java. A JUnit test is an ordinary Java method annotated with @Test. Inside the method, special JUnit methods are used similarly to the assertions were used previously in this course:

        • assertTrue(expr) — fails if expr is false
        • assertFalse(expr) — fails if expr is true
        • assertEquals(expected, actual) — fails if the two values differ
        • Many more, see the JUnit documentation for a full list.

        If any assertion fails, JUnit reports the test as failed and shows which assertion was violated.

        Related

          Construction. Defining Functions

          [comp1110-0N]
          • Liam O'Connor

          As we have seen in Example [comp1110-0C], we can define functions in Java by stating their return type, then their name, then their parameters (types and names) in parentheses. The function body is surrounded by braces.

          int square(int x) { return (x * x); }

          When the return type is not void, we must include a return statement in the function body, which, when executed, will immediately cease execution of the function body and return the result to the caller.

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