Kotlinlearncs.online LogoJava

    ← Prev

    Index

    Next →

    Kotlin
    Java

    • References and Polymorphism : 35

    • References : 34

    • Data Modeling 2 : 33

    • Equality and Object Copying : 32

    • Polymorphism : 31

    • Inheritance : 30

    • 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

    References

    public class Person {
    private String name;
    public Person(String setName) {
    name = setName;
    }
    public String getName() {
    return name;
    }
    public void setName(String setName) {
    name = setName;
    }
    }
    Person me = new Person("Geoff");
    Person you = me;
    you.setName("Fantastic Student");
    System.out.println(me.getName());

    Here we begin a series of lessons that will deepen our understanding of Java. They will also introduce an incredibly important and prevalent idea in computer science—references. So let’s get started!

    A Puzzle
    A Puzzle

    As we frequently do, we’ll begin with a puzzle. Examine the following code (duplicated from the lesson header) and try to predict what should happen:

    public class Person {
    private String name;
    public Person(String setName) {
    name = setName;
    }
    public String getName() {
    return name;
    }
    public void setName(String setName) {
    name = setName;
    }
    }
    Person me = new Person("Geoff");
    Person you = me;
    you.setName("Fantastic Student");
    System.out.println(me.getName());

    The critical bit is the line Person you = me. There are two things that could happen here:

    1. Java could make a copy of me and save it to you, meaning that at that point there would be two Person objects; or
    2. Something else…

    Given the result, the answer is clearly the latter. On some level we should find this reassuring, since previously we had said that (1) objects are only created when you see new and (2) Java does not have a built in way of making object copies. However, it does leave us with the question: what is happening, and why?

    References
    References

    Until now we’ve been somewhat vague about exactly what is being stored in our variables. No longer. Variables in Java that store objects do not store the object instance itself. Rather, they store a reference to the instance.

    What is a reference? I’m glad you asked! Wikipedia says.

    In computer science, a reference is a value that enables a program to indirectly access a particular datum, such as a variable’s value or a record, in the computer’s memory or in some other storage device. The reference is said to refer to the datum, and accessing the datum is called dereferencing the reference.

    Let’s parse this together:

    Java Object Variables Store References
    Java Object Variables Store References

    In Java, when we assign an instance of an object to a variable, what we are really doing is creating a reference variable. The variable stores a reference to the object, not the object itself:

    String s = new String("count"); // s stores a reference to a String with value "count"
    String t = s; // t now also stores a reference to the _same_ String
    System.out.println(t.length());

    If and when you get lost here, here’s something that will help. Objects are only created when you see new. In the example above, even though we have two reference variables (s and t), we have only one String created using new.

    References Are Not What They Refer To
    References Are Not What They Refer To

    A reference is not the thing it refers to. This becomes clear when we examine some real-world examples of references:

    In each of these cases above, a reference is something that we can use to access the object it refers to. If I give you my phone number, you can call me. If I give you my address, you can visit! If I make a bunch of copies of my address, you could all come over and visit! But I would still only have one house.

    Changes to Objects Are Visible to Reference Holders
    Changes to Objects Are Visible to Reference Holders

    Let’s continue the analogy above. Imagine I give two of you the address to my house. The next day, one of you comes by and “decorates” my house with sanitary paper. If the other comes by later, they also see the change!

    public class House {
    public boolean hasTP = false;
    }
    House first = new House();
    House second = first;
    System.out.println(first.hasTP);
    second.hasTP = true; // Please don't actually do this!
    System.out.println(first.hasTP);

    So the next rule of references: changes to object instances are visible to all reference holders. This is why, in the example above, me.getName() returns “Fantastic Student” even though the change was made using the reference variable you. Both refer to the same object, the only one that was created using new.

    Primitive Types Store Values
    Primitive Types Store Values

    Note that all that we said above is not true for Java primitive types. They store their values directly in the variable:

    int i = 8;
    int j = i; // The value from i is copied into j
    j++;
    System.out.println(j);
    System.out.println(i);

    But this only works for the eight primitive types. Any variable that stores an object in Java is a reference variable, and actually stores an object reference.

    null is a Reference
    null is a Reference

    Finally, this also gives us a better understanding of null. null is the empty reference:

    String s = null;

    null indicates that a variable that could store a reference does not, and is empty. This also explains what happens if we try and follow or deference null. (Imagine if I told you to call a phone number, but then handed you a blank sheet of paper!)

    Solve: Object v. Reference Equality (Practice)

    Created By: Geoffrey Challen
    / Version: 2020.10.0

    Implement a public class method named compare on a public class Comparison that accepts two Object arguments. It should return 0 if both references are equal, 1 if both objects are equal, and -1 otherwise. Either reference can be null, so you'll need to handle those cases carefully!

    Reference Practice
    Reference Practice

    Let’s get some practice manipulating references.

    Copying Reference
    Copying Reference

    Copying a reference does not copy the object it refers to! Let’s return to our example and discuss what is actually happening:

    public class Person {
    private String name;
    public Person(String setName) {
    name = setName;
    }
    public String getName() {
    return name;
    }
    public void setName(String setName) {
    name = setName;
    }
    }
    Person me = new Person("Geoff");
    Person you = me;
    you.setName("Fantastic Student");
    System.out.println(me.getName());

    Now, let’s go through this step by step using a diagram:

    Swapping References
    Swapping References

    Imagine I have the following code, and I want to swap the objects that me and you refer to. (Searching for the fountain of youth, I guess…) Let’s walk through how we would do that:

    public class Person {
    private int age;
    Person(int setAge) {
    age = setAge;
    }
    public int getAge() {
    return age;
    }
    }
    Person me = new Person(41);
    Person you = new Person(18);

    Next, let’s examine a similar example using a diagram:

    Reference Equality v. Instance Equality
    Reference Equality v. Instance Equality

    To wrap up, we are now ready to understand the difference between == and .equals when comparing objects. == tests reference equality, while .equals tests instance equality. Let’s examine the difference:

    public class Example {
    private int value;
    public Example(int setValue) {
    value = setValue;
    }
    public boolean equals(Object o) {
    if (!(o instanceof Example)) {
    return false;
    }
    Example other = (Example) o;
    return value == other.value; // == because we are comparing primitive types
    }
    }
    Example first = new Example(88);
    Example second = new Example(88);
    Example third = first;
    System.out.println(first == second);
    System.out.println(first.equals(second));
    System.out.println(first == third);
    System.out.println(first.equals(third));

    Solve: Mystery Method 1 (Practice)

    Created By: Geoffrey Challen
    / Version: 2020.10.0

    This homework problem is a bit different. There is no description! Instead, you should use our testing suite and its error messages to help you figure out what to do! This is also known as reverse engineering. Good luck, and have fun!

    Solve: Mystery Method 2

    Created By: Geoffrey Challen
    / Version: 2021.9.0

    This homework problem is a wee bit different. There is no description! Instead, you should use our testing suite and its error messages to help you figure out what to do! This is also known as reverse engineering. Good luck, and have fun!

    More Practice

    Need more practice? Head over to the practice page.