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.

Context

    Construction. Static members

    [comp1110-8I]
    • Fabian Muehlboeck

    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.

    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 nested classes

    [comp1110-8K]
    • Fabian Muehlboeck

    Like inner classes, static nested classes are class definitions nested within another class definition:

    class Foo { class Bar { // inner class // ... } static class Baz { //static nested class // ... } }

    The key difference is that the instances of a static nested class do not have to be associated with an instance of the enclosing class. In exchange, they also do not have access to the instance fields of the enclosing class.

    Essentially, static nested classes are treating their enclosing class as a package. The main point of having them is for encapsulation.

    Backlinks

      Factory methods in the collections API

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

      The Java collections API provides convenient factory methods for creating collections with a fixed set of elements. These are static methods named of() on the collection interfaces:

      import java.util.Set; import java.util.List; import java.util.Map; //... Set<String> guests = Set.of("Fabian", "Nicholas", "Ann"); List<Integer> numbers = List.of(1, 2, 3, 4, 5); Map<String, Integer> ages = Map.of("Fabian", 30, "Fabian", 25);

      These are particularly handy in tests where you need a quick collection to work with without constructing it element by element.

      Warning. 

      • Liam O'Connor, Fabian Muehlboeck

      Note that collections created with of() are immutable: calling add() or remove() on them will throw an UnsupportedOperationException at runtime. If you need a mutable collection, construct one explicitly using e.g. new TreeSet<>(Set.of(...)).

      Related

        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.

        Note. Array Equality

        [comp1110-73]
        • Fabian Muehlboeck

        We've seen earlier that String Equality requires special attention compared to the more common equality operator ==. This is because the operator == expresses sameness, either of a numerical value, or of something larger within computer memory. Sameness implies equality, but not necessarily the other way around. We will look at the technical reasons for this later in the course.

        Similar to Strings, Arrays are also larger things in computer memory. But in contrast to Strings, the contents of arrays can change. What that means is that if your idea of equality is that two arrays contain equal values in the same order, then that may be true at one point in your program, and false at a different point, as the contents of one or both of the arrays may change in the meantime. This means that the identity of each array matters a lot more than it does for Strings.

        For that reason, a.equals(b) on arrays is the same as a == b. However, the Java Standard Libraries contain a number of standard functions dealing with arrays, among them a suitable equality function. To use it, you need to add an import declaration for java.util.Arrays to the top of your file. You can then use the expression Arrays.equals(a,b) to compare two arrays for equality based on the equality of their elements.

        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.

        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.

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

        Definition. The char type

        [comp1110-0V]
        • Liam O'Connor

        The type char (characters) is for single symbols (a letter, a number, a newline, etc.). Strings are sequences of characters. In Java, we write characters with single-quotes, unlike Strings which require double-quotes. For example, the first character of the string "Hello" is 'H'. To get the nth character of a string, use the method charAt(), for example: "Hello".charAt(0) == 'H'.

        Characters themselves are just numbers, where each symbol has a number according to this ASCII table (the story is more complicated for non-English characters, but this suffices for now). In particular, note that the digit character '4' and the number 4 are very different numbers, however the digits occur consecutively in the ASCII table, so we can convert digit characters to their associated number by subtracting the digit '0', that is: '4' - '0' == 4.

        The module class Character includes a variety of useful functions for working with char, including Character.isLetterOrDigit() and Character.isDigit().

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