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 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 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 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 4. Methods

[comp1110-84]
  • Fabian Muehlboeck

Building on our example from Example 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)

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

    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.

    Backlinks

      Construction. Access Modifiers

      [comp1110-7W]
      • Fabian Muehlboeck

      Data type definitions (e.g. Enums and Class Definitions) and members may be given an access modifier. The following access modifiers exist in Java:

      • public - this means that the data type or member should be accessible by everyone, from anywhere.
      • private - this means that the data type or member should only be accessible from within the scope of the outermost enclosing context.
      • protected - this will be explained later and is not important for now.

      In addition to these modifiers, the meaning of not having a modifier at all is called package private. These data types or members are accessible from everywhere in the same package, as if they were public, but inaccessible from outside of that package, as if they were private.

      Access modifiers are about syntactic scope, that is, about how code is written and nested. In particular, any private field can be accessed from any code within the same class, not just from within the same object.

      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.

      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. 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.

      Example. The GuestList interface (Object version)

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

      The original GuestList interface used String throughout. Replacing String with Object allows any type of value to be stored, since every Java class is a subtype of Object:

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

      Our implementations (both strict and lazy) can be easily adapted by replacing the type String with Object throughout. Because Object already specifies the equals method, we've gained a lot of flexibility for essentially no cost, which is great! The tricky part comes when we are also supposed to return values stored in our list.

      Consider our previous extension of the above interface where we also return a list of everyone who is coming, this time with Object:

      Object[] coming();

      This method now returns an array of Objects, when our testing code would presumably expect an array of Strings. We can adjust our testing code to expect Object arrays, and we can explicitly cast the elements of the array to our expected type.

      However, this approach sacrifices type safety. Nothing prevents a caller from adding a mix of unrelated types to the same list, and retrieving a value requires an explicit cast (e.g. (String) list.coming()[0]) that can fail at runtime with a ClassCastException. The compiler cannot catch such errors.

      Construction. The Object type

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

      In Java, Object is the root of the class hierarchy: every class is a subtype of Object. This means a variable of type Object can hold a value of any class: a String, an Integer, a Person, and so on.

      Object x = "hello"; // fine Object y = 42; // fine Object z = new Person("Fabian"); // fine

      The Object type, among other things, defines a .equals() method, so values of type Object can be compared for equality, but very few other operations are available. Many classes provide override .equals() to perform a deep comparison, as we have seen for Strings.

      The downside is that the compiler knows very little about the value stored in an Object variable: to use it as its original type, an explicit cast is needed.

      Construction. Type parameters

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

      A type parameter allows a class or interface to be written once and used with many different types, while retaining type safety (unlike Object). We write the type parameter in angle brackets after the class or interface name, and use it as a placeholder for a concrete type throughout. Referring to our GuestList example:

      public interface GuestList<T> { void add(T name); void remove(T name); boolean isComing(T name); // note the additional argument here T[] coming(Function<Integer, T[]> arrayCreator); }

      When using the interface, the caller fills in the placeholder with a concrete type:

      GuestList<String> list = new ArrayGuestList<String>();

      The compiler then treats every occurrence of T as String for that particular instance of the class. This means list.add(42) is a compile-time error, since 42 is not a String. Whereas using Object, such mistakes are only caught at run time.

      This feature is also known as generics in Java, or more generally as parametric polymorphism.

      Related

        Definition. Arrays

        [comp1110-15]
        • Liam O'Connor

        Arrays are a primary way to store linear, ordered collections of data. The elements of an array must all have the same type. An array type is written by appending [] to the type of the array elements. For example, the type of an array of int values is written as int[], whereas the type of an array of String values is written String[]. We create an array with the new keyword, like so:

        int[] arr = new int[50];

        The above code makes space in memory (called allocating) for a sequence of 50 int values, and stores the location of that space in memory in the newly-created variable arr.

        By default, all ints in our array will be set to zero. If we wish to initialise our array with other values, we can include them in the new invocation like so:

        // size no longer needed as javac will count the elements int[] arr = new int[]{10,100,-2,8,0};

        We can access the contents of an array by index. The ith element of the array a (starting counting at zero) can be retreived using the notation a[i], for example:

        int first = arr[0]; IO.println(first + " is the first (index 0) element!");

        We can also update elements of an array using this notation:

        arr[0] = first + 1; IO.println("The first element is now: " + arr[0]); // prints 11

        To get the length of an array a, we can write a.length:

        int len = arr.length; IO.println("The array arr has " + len + " elements.");

        Warning. 

        • Liam O'Connor

        For Strings, we write str.length() (i.e. calling a method, with the parentheses), but for arrays, we just write arr.length.

        Definition. Enums

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

        An enum (short for enumeration) is a user-definable type whose values come from a fixed finite list. Instead of using arbitrary integers or strings, we define a small set of allowed values and give each one a name. For example:

        enum Month { JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER }

        This defines a new type called Month. A variable of type Month can only hold one of these twelve values. For example:

        Month m = Month.AUGUST;

        The names (which are by convention written in ALL_CAPS) inside the enum definition are called constants. They are always written with the type name in front, such as Month.JANUARY or Month.DECEMBER. This prevents confusion if different enums contain constants with the same name.

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