Kotlinlearncs.online LogoJava

    ← Prev

    Index

    Next →

    Kotlin
    Java

    • Data Modeling 1 : 29

    • Static : 28

    • Encapsulation : 27

    • Constructors : 26

    • Objects, Continued : 25

    • Introduction to Objects : 24

    • Compilation and Type Inference : 23

    • Practice with Collections : 22

    • Maps and Sets : 21

    • Lists and Type Parameters : 20

    • Imports and Libraries : 19

    • Multidimensional Arrays : 18

    • Practice with Strings : 17

    • null : 16

    • Algorithms and Strings : 15

    • Strings : 14

    • Functions and Algorithms : 13

    • Practice with Functions : 12

    • More About Functions : 11

    • Errors and Debugging : 10

    • Functions : 9

    • Practice with Loops and Algorithms : 8

    • Algorithms I : 7

    • Loops : 6

    • Arrays : 5

    • Compound Conditionals : 4

    • Conditional Expressions and Statements : 3

    • Operations on Variables : 2

    • Variables and Types : 1

    • Hello, world! : 0

    Static

    public class Math {
    public static final double PI = 3.141597;
    public static int pow(int base, int exponent) {
    assert exponent >= 0 : "No support for negative exponents";
    int result = 1;
    for (int i = 0; i < exponent; i++) {
    result *= base;
    }
    return result;
    }
    }
    System.out.println(Math.PI);
    System.out.println(Math.pow(2, 3));

    As we continue, we begin by describing a new design keyword: static. We’ll also introduce introduce one new piece of object syntax.

    Warm Up Debugging Challenge
    Warm Up Debugging Challenge

    But first, let’s warm up with another debugging challenge!

    this
    this

    this is a keyword in Java that you can use in your instance methods. It always refers to the current instance that is executing the method.

    So this:

    public class Course {
    private String number;
    Course(String setNumber) {
    number = setNumber;
    }
    }

    is equivalent to this:

    public class Course {
    private String number;
    // We are using this to distinguish between number, the instance variable, and number, the method parameter
    Course(String number) {
    this.number = number;
    }
    }

    The example above is one use of this. However, we’ll usually just go the first route, and choose parameter names that don’t conflict with our instance variable names. This helps avoid mistakes. checkstyle will help you with this, complaining (as it does above) that your parameter “hides a field”.

    However, there is one place where we will use this. Let’s go through it together:

    public class Course {
    private String number;
    Course(String setNumber) {
    number = setNumber;
    }
    }

    static Methods
    static Methods

    The object methods we have been writing so far are known as instance methods:

    public class Person {
    private String name;
    public Person(String setName) {
    name = setName;
    }
    public String getName() {
    return name;
    }
    }
    Person prof = new Person("Geoff");
    Person student = new Person("You");
    System.out.println(prof.getName());
    System.out.println(student.getName());

    Even though they share the same implementation, you can think of each Person as having its own getName method that can access its instance variables, in this case name.

    However, Java also allows us to create methods that are attached to the class, not to the instance. To do that, we use a new keyword: static. Let’s see how that works:

    public class Person {
    }

    static v. Instance
    static v. Instance

    static class methods cannot access instance variables. Let’s look at why, and the differences between class and instance methods:

    public class Person {
    private String name;
    public Person(String setName) {
    name = setName;
    }
    // Can't access name without an instance!
    public static String getName() {
    return name;
    }
    }
    Person student = new Person("You");
    System.out.println(student.getName());

    Uses for Static Methods
    Uses for Static Methods

    static class methods are not uncommon. Particularly when you have methods that don’t need an instance to function properly. Let’s look at one example of a class that consists almost entirely of static methods, Math:

    Solve: Static Adder (Practice)

    Created By: Geoffrey Challen
    / Version: 2020.9.0

    Create a class named Math. Math should have one public static method named add. add should accept two int arguments and return their sum.

    static Fields
    static Fields

    You can also use the static keyword on fields. One common use for this is to establish constants to make our code more readable and less error-prone.

    To do this, we combine static with a keyword that we haven’t seen before, final. final creates a variable that cannot be changed after it has been set. We can combine static and final to create a symbolic constant. Let’s look at how:

    public class Math {
    }

    Non-Final static Fields
    Non-Final static Fields

    Can you create modifiable—that is, non-final—static fields? Yes. However. This is extremely rare, and very easy to get wrong. We won’t test you on it, but view this walkthrough to see how this works:

    public class Course {
    }

    Solve: Toggler Object

    Created By: Geoffrey Challen
    / Version: 2021.9.0

    Define a public class named Toggler with a single public instance method named toggle that takes no parameters and returns a boolean. Toggler should also provide a single public constructor that accepts a boolean argument and sets the initial state of the Toggler instance.

    Toggler maintains one piece of private state: the boolean. Calling toggle changes the boolean from true to false or false to true and returns the new (not the old) state of the boolean. So, for example:

    Note that the internal state should be private.

    More Practice

    Need more practice? Head over to the practice page.