CS/IT115 Lecture Alex Dusenbery Using Objects

Transcription

1 CS/IT115 Lecture Alex Dusenbery Using Objects

2 References what are they? References are crucial for understanding how to use objects in Java Example: writing a document, incorporate a paragraph of text from file.doc Could copy that paragraph into your document Could use a reference to file.doc: See paragraph 3.4 of file.doc Could be multiple refs to same paragraph

3 Multiple References If someone edits paragraph 3.4 of file.doc, all the readers of documents referring to it will see the new version. If a copy of files.doc was made (and then changed), all readers would see the original version of the paragraph. This type of sharing happens a lot with Java objects.

4 Scanner loop example Scanner input = new Scanner( ); } while (input.hasnextdouble()) { double next = input.nextdouble(); System.out.println(next);

5 Scanner Loop Example Example from p. 399 (slightly modified) Scanner input = new Scanner( ); //Scanner constructor call double x = input.nextdouble(); //scans 18.4 // and puts 18.4 in x; double y = input.nextdouble(); //scans 17.9 // and puts 17.9 in y; input.useradix(16); // changes scanner to a hex //scanner int x = input.nextint(); // scans 11, puts 17 //in x (one 16 plus one 1)

6 Scanner object's state Can imagine what's in the Scanner object, its object state or fields The source String A value of the current position in the String The current radix (base 10 by default).

7 After first input.hasnextdouble() call input Nothing has changed between the state from the constructor and this first method call source: position: 0 radix: 10

8 After first input.nextdouble() call input The internal position changes to 5, just at the space that delimited the first number. source: position: 4 radix: 10

9 After second input.nextdouble() call input The internal position changes to 9, just at the space after 17.9 source: position: 9 radix: 10

10 After input.useradix() call input This method call changes the radix of input to 16 source: position: 9 radix: 16

11 After input.nextint() call input This call will return the int 17, the hex value of 11. Position changes to 12, just after 11 source: position: 12 radix: 16

12 Hexadecimal (base 16) Integers Used all the time in CS/IT, for Ethernet addresses, memory locations, etc. Hex Digits: 0-9 plus a-f for (case doesn't matter, 'a' and 'A' can be used interchangeably) 2-digit hex numbers: The left digit says the number of 16s in the integer The rights gives the number of 1s

13 Hex Integers Example: 21 in hex means 2 16s plus 1 = 33 A1 = a1 = 10*16 + 1*1 = 161 Bigger example: 2af3 -> (2*16^3) + (10*16^2) + (15*16^1) + (3*16^0) 10995

14 A Scanner can interpret Hex Scanner input = new Scanner(System.in); This will read user input. When created, this scanner defaults to interpretting numbers in base 10 (or radix 10) int x = input.nextint(); // reads a base-10 int input.useradix(16); // now will //interpret hex

15 Scanners and Hex int y = input.nextint(); Now, when we type 10, y will be 16. If we type a1, y = 161 Back to references...

16 References point to objects Example above: the input variable is an object reference We can create a second reference for the same object: Scanner myscan = input; This just copies the reference into the myscan variable; there's still only one scanner object.

17 After we copy reference to myscan variable Object References input source: position: 12 radix: 16 myscan

18 Object References If we change the Scanner object through either object reference (input or myscan), it changes for both references. If we start with radix=16, and then do: myscan.useradix(10); //set to decimal This will appear as changed for the input reference, since it and myscan are both referencing the same Scanner object

19 Aliasing We call what we did above aliasing. There are two names for the same object Can be confusing, but we need to deal with it. Aliasing happens whenever we pass an object to a method. Only the reference is copied to the parameter, so the method gets to work on the object itself.

20 Aliasing and method calls A method can make permanent changes to an object (they survive the return to the method's caller). Since a scanner is an object, we can change the radix in our own method and the change will stick public static void confighex(scanner in) { in.useradix(16); }

21 Aliasing and method calls Now to this in main: Scanner input = new Scanner(System.in); confighex(input); Now input is a hex reader, b/c it was changed in the method.

22 Fun Comic Time...

23 Primitive types and method calls No references with primitive types: int x = 10; int y = x; Now if we change x, y won't be affected. When primitive types are arguments to a method, they are copied into the parameters, and caller's value is unaffected.

24 Primitive types and method calls public static void trytochangeint(int x) { x = 10; } Now call this: x1 = 5; trytochangeint(x1); x1 is still 5 we can't change a caller's int by passing it to a method.

25 Passing objects/primitives to methods Passing primitive into a method a copy of the primitive is made caller's value is safe from change. Pass an object into a method only the reference is copied The object itself can be modified so that it sticks after return from method. Important to understand which parameters of method are objects