Lecture 9: More on objects, classes, strings

1. Lecture 9: More on objects, classes, strings • discuss hw3 • assign hw4 • default values for variables • scope of variables and shadowing • null reference and NullPointerException • garbage collection • more on strings • equals and == • explicit and implicit parameters • side effects • immutable classes • interned string values • console input • your input!

2. HW3

3. HW4 • Builds on our Date class • dayOfWeek method

4. Default values for variables • Data fields (instance variables) are assigned default initial values • 0 for numeric types (int, double, etc) • false for boolean • \u0000 for char • null for object references • Local variables declared inside methods are not assigned default initial values

5. Scope of variables • A variable declared inside a method is called a local variable • Its scope starts from its declaration and continues to the end of the smallest {…} block that contains the variable. • Before and after that it is not accessible. • Method parameters are also variables: their scope is the entire method • The scope of a data field (static or instance variable in a class) is the entire class, regardless of where it’s declared: good style to declare them all before the methods • They can be declared in any order unless the initial value of one depends on the initial value of another, but this is not good style anyway • See Oct10.java

6. Shadowing • Occurs when access to an instance variable is prevented by declaration of a local variable with the same name • A local variable cannot be shadowed by another local variable because their scopes are not allowed to overlap

7. Null reference • Player jack = null; • means jack does not point to any object • If we now invoke jack.flip(), a NullPointerException occurs • Player jill = jack; // now jill is null too

8. Garbage and garbage collection • Player jack = new Player(); • Player jill = new Player(); • jill = jack; // jill object is inaccessible • but if we first did • Player jasmine = jill; // copy of jill • the object IS accessible • Figuring out what is and what is not accessible is the job of the Java garbage collector: it reclaims wasted space • In C, have to explicitly release space • In Java, don’t, but can help by setting reference values to null when no longer needed

9. More on strings • A string is an object • Only thing special about a string is special syntax in the language • Concatenation operator + • Use of “…” to construct a string

10. equals and == • String s1 = “abc”; • String s2 = new String(“abc”); • String s3 = new String(“abc”); • System.out.println(s1 == s2); • System.out.println(s1.equals(s2)); • System.out.println(s2 == s3); • System.out.println(s2.equals(s3));

11. Explicit and implicit parameters • The explicit parameters in a method call are the actual parameters (arguments) matching the parameters in the signature • The implicit parameter in a call to an instance method is the object instance name • jack.multipleFlip(n) • s1.equals(s2) • complete lack of symmetry between these can be very confusing • our text book does not use these terms, but they are standard

12. Side effects • Something that happens as the result of a method call which is not the main purpose of the method is called a side effect • For example, a method intended to display information makes changes to an implicit or explicit parameter object • Generally it is undesirable to make a change to an explicit parameter object • Usually, if a change to an object is desired this is done by passing it as an implicit parameter, as in jack.multipleFlip()

13. Undesirable vs Impossible • It is impossible to change the value of a primitive type variable in a method by passing it as an explicit parameter to another method • However, it is often desirable to change the values in an array by passing it as an explicit parameter to another method • It is generally undesirable to change the data fields of an object by passing it as an explicit parameter to another method: usually better to pass it as an implicit parameter • However, when an object is immutable it is impossible to make changes to it by passing it as either an explicit or implicit parameter

14. Immutable objects • An object is immutable if it is impossible to make changes to it once it is constructed • The class is also called immutable • Strings are immutable String s1 = new String(“abc”); s1 = new String(“def”); • The string that was constructed to contain “abc” is not changed; it is lost • Requirements for an immutable class include • all data fields (instance variables) are private • there are no mutator methods, only accessor methods • But this is not enough! See p. 232 of text

15. Interned string values • String s1 = “abc”; • String s2 = “abc”; • System.out.println(s1 == s2); • Both s1 and s2 point to the same object constructed to contain “abc” • String s3 = new String(“abc”); • System.out.println(s1 == s3); • System.out.println(s1.equals(s3)); • String s4 = s3.intern(); // get interned string • System.out.println(s1 == s4);

16. String methods • You only need to know charAt • subString is also useful • There are lots of others

17. Passing strings to main • public static void main(String[] args) • up until now we have never accessed args, which is an array of String objects (any name can be used) • this can be used to pass information into main from the command line

18. Other information in Chapter 8 • A lot of technical detail that you do not need to learn, though you may find some of it useful • We’ll return to files later • The Scanner class: use this if you want to read from the console instead of using JOptionPane • Scanner builds on System.in, which is very complicated to use directly