cs121 week12 - SEIDENBERG SCHOOL OF CSIScsis.pace.edu/~ogotel/teaching/cs121_week12_big.pdf ·...

CS121/IS223 Week 12, Slide 1

CS121/IS223

Object Reference Variables

Dr Olly Gotel [email protected] http://csis.pace.edu/~ogotel

Having problems? -- Come see me or call me in my office hours -- Use the CSIS programming tutors


Agenda

•  Make sure you have completed lab 1 and the shopping questions in lab 2

•  Objects & object reference variables - what are these object things anyway?

•  Understanding parameter passing – passing objects is not the same as passing primitives

Finish Lab 2 after this week


Reminder…

class Car{ private String colour, licence; private double speed, fuel;

public void honk(){ System.out.println(“Beep Beep!”); } }

class CarTester{ public static void main(String[] args){ Car myCar = new Car(); myCar.honk(); } }

Instance variables – private data members - means can only be changed inside the class (by its methods)

Instance method – public means that it can be called from outside the class on objects of Car class

Primary class

Driver class with main() method

Make a new car object & call it myCar

Get myCar to honk its horn

Use visibility to enforce encapsulation


Object Declaration, Creation, Assignment

Car myCar = new Car();

1 - Declare a reference variable , of class type Car, called myCar

2 - Create a new Car object

3 - Link the new object to the named reference variable

What is going on here? 3 distinct things… Need to step back a moment…

(Called an object reference variable)

(1)

(2) (3)


What is Going On?

1.  Tells the JVM to allocate space for a reference variable on the stack; reference variable is called myCar; it is of type Car •  Stack – smallish area of memory; holds an address in

memory (where to find an object); we know how much memory we need to hold an address

2.  Tells the JVM to allocate space for a new Car object on the heap •  Heap - big area of memory; holds the object because we do

not know how big it will be 3.  Assigns the new Car object to the reference variable myCar;

think of the reference variable as a locator for the object


Variables in Java

•  Variables are particular shaped containers (hold data)

•  Variables can hold a value (so long as it is of the right shape)

•  The shapes are called types

Java is STRONGLY typed

Type Value 1 Value 2


Variables & Values in Java

•  Variables implemented as memory locations

•  Values implemented as 0’s & 1’s

•  Values placed in memory locations

•  The Java compiler needs to know the type of every variable - to know the values it can take and permissible operations

•  In Java, every variable must be declared before it can be used - so it can allocate space in memory


Types in Java

•  Primitive types: –  directly represented by typical processors – the

most efficient –  begin with lowercase letter

•  Class types: –  a type for objects –  begin with UPPERCASE

letter

8 primitive types in Java, others are represented using objects – sometimes called object reference types


A Recap on Types

•  A type defines: –  the set of values belonging to the type –  the set of operations that can be applied to the

values (e.g. the + operator can be applied to an integer, but not to a boolean)

•  Your Java program won’t compile if you try to apply invalid operators to values


Primitive Types in Java

•  byte – 8-bit integer •  short – 16-bit integer •  int – 32-bit integer •  long – 64-bit integer •  float – 32-bit floating point •  double – 64-bit floating point •  char – 16-bit unsigned Unicode character code •  boolean – 1 bit true or false

Values are actual integers, floats, characters, etc

Integer data types – no fractions

Floating point data types –fractions


A Way to Think of Primitives

•  We can predict these! •  Think Predict/Primitive


Perhaps Class Types Look Like This?

•  We can’t predict these! •  Think Chaotic/Class


Class Types in Java

•  Non primitive types exist & are important

•  Class types are abstractions created from primitive types (like a bank account, an address, etc)

•  A class type that is widely used in java is String – to represent a sequence of characters (char)

•  There is a class String that you use to implement strings, so strings are actually objects, which requires a bit of extra code to use

•  They are user-defined types

“This is a string” - strings are literal values


Variables in Java

•  A container of sorts

•  Must have a type & a name (identifier)

•  Can hold primitives or class types

•  When they hold primitive types they hold the values directly in the container

•  When they hold class types, they hold references to objects in the container (these are called object reference variables), the objects are elsewhere


Object Reference Variables in Java

•  An object reference variable holds bits that represent a way to access an object, it does not hold the object itself (it actually holds something that works a bit like a pointer to the address at which the object can be found)

•  Objects do not live in variables on the stack, they live on the heap

•  Object reference variables provide a way to get hold of the object on the heap

•  When you create a new object, you put a locating device in the variable container


Pointers In Java, we are VERY concerned with references

Your object reference variable actually points to the object!


Dog myDog = new Dog();

1.  Declare a reference variable: Dog myDog = new Dog();

3.  Create an object: Dog myDog = new Dog();

5.  Link the object & the reference: Dog myDog = new Dog();

Object Declaration, Creation & Assignment

1 2 3

Example from [Sierra & Bates 2003] - best ever!

Dog type

Dog type

myDog

myDog

Dog object

Dog object

Index cards


Buy Why Indirection?

•  We don’t know how big myDog will be yet - so can’t pre-allocate memory!


Type Safety

Can’t do:

Dog myDog = new Cat();

myDog can only point to a Dog object!

But we could do:

Animal myDog = new Dog();

If Dog is defined as a type of Animal. Later!

Ouch!


Assigning Ref Variables to Ref Variables

Dog myDog = new Dog(); Dog yourDog = myDog;

Dog type

myDog

Dog object

Heap – area of memory where you can request big variable-sized boxes

Dog type

yourDog

Stack - area of memory for storing variables (small boxes of known size)

An alias

myDog.equals(yourDog)

1 object can be referenced by lots of variables


Remember

•  The object reference variable (ORV) and the object are

2 distinct things!


Getting Rid of a Value in a Ref Variable

myDog = null;

Dog type

myDog Dog object

Heap

Dog type

yourDog

x

A reference variable that doesn’t point to an object is called a null reference

Check for a null reference before you follow it!


Getting Rid of a Value in a Ref Variable

yourDog = null;

Dog type

myDog Dog object

Heap

Dog type

yourDog

x

When an object is not referenced it is a candidate for garbage collection – we get to reuse the memory

Farewell poor dog…we knew him well

x


What if you try to Follow a Null Reference?

NullPointerException


References to Different Objects BUT of Same Class

Dog myDog = new Dog(“snowy”); Dog yourDog = new Dog(“spot”);

Dog type

myDog

Dog object name=“snowy”

Heap

Dog type

yourDog

Dog object name=“spot”

class Dog{ private String name=“”;

public Dog(String dogName){ name=dogName; } }


Recap So Far…

•  When you declare a variable of class type, you get a container that holds an object reference

•  Object reference variables hold bits that represent a way to access an object –  doesn’t hold the object itself –  JVM uses the reference to access the object

•  Equality (==) compares values of reference variables and not the objects they reference - need to use equals() - and so now you know that is why we use this with String types!

•  When objects are passed as method arguments, the reference to the object is copied into the method’s formal parameter

… & this last point is where the fun begins!


Placeholder … polymorphic variables


Parameter Passing

•  Passing an object reference as a parameter to a method

•  Pass/call by value (default in Java): –  Local copy stored in method’s parameter –  Changes are only made to the local copy –  Old value remains in calling method when returns

•  Pass/call by reference (objects): –  Passes a reference to the object (i.e. its address) –  Local copy is therefore an alias for the object –  Change the object, change remains once returned from the

method, as actual parameter references the same object –  Change the object reference & make it point to a new object,

the actual parameter still refers to the original object

Trace the code in listings: 5.1-5.3 & fig 5.3 (for text ed. 3) 6.15-6.17 & fig 6.5 (for text ed. 4+) http://duke.csc.villanova.edu/jss1/examples.html

Important!

void myMethod(int number){…}

void myMethod(Dog myDog){…}

copy

ref

Do the remaining questions in Lab 2


Special Things!

•  The null reference: a reference that doesn’t point to a valid object (watch for NullPointerException)

•  The this reference: a reference to the current executing object

•  The final reserved word – used to indicate that a variable holds a constant value (i.e. one that cannot be changed), often used when the variable is static

•  final can also be used with classes & methods … discussed when we get to inheritance

private static final int MAX = 100;

class Example{ private int i;

public int foo(int i){ this.i=i; } }


Static Modifiers

•  Variables: –  instance variables (each object of a class gets its own copy) –  local variables (used temporarily inside a method) –  static variables (single copy shared by all instances of a

class; they are class variables)

•  Methods: –  instance methods must be called for an object of the class –  static methods are class methods & do not need to be called

for an object – if private, any method in the class can call them; if public, any other method in any class can call them

private int instanceVariable; private static int classVariable;

Examine the code in listings 5.4 & 5.5 (3rd ed.) or 6.1 & 6.2 (4th + ed.)

Try to initialise a variable as close to the point of declaration as possible


Wrappers

•  Wrapper classes – a way to represent primitive types so they too can be treated like objects

int i = 42; Integer myInt = new Integer(i);

int unWrap = myInt.intValue()

•  Wrapper classes for each primitive type •  Helps for polymorphism - another cool thing for later!

primitive int value passed to the wrapper constructor

class type for treating ints as objects so object myInt has 42 as a private instance variable

Wrapper classes have methods to convert objects back to primitives

int

Integer

NOTE for Java 5.0+ - autoboxing & auto-unboxing


Outer & Inner Classes

•  Outer & inner classes – safe nesting

•  We will return to this when we look at GUIs, event-driven programming & listeners in the next course

Examine the code in listings 5.7 & 5.8 (3rd ed.) or 4.10 & 4.11 (4th + ed.)


Key Points

•  Java has primitive types & class types: –  variable of primitive type – bits represent the value

of the variable –  variable of class type (called object reference

variable) – bits represent how to access the object

•  Be aware of what you are actually doing when you pass objects as parameters to methods - it is not the same as passing primitives


To Do…

•  Complete reading Chapter 5 of (ed 3) or Chapter 6 of (ed 4+)… & use the book website for downloads of code to experiment with. Prepare for next class by reading Chapter 6.0 & 6.1 (ed 3) or Chapter 7.1-7.3 (ed 4+)

•  Complete programming project 5.2 (ed 3) or 6.4 (ed 4+)

•  Complete LAB2 – get as far as you can … seek help if you need it

•  Go through the lecture slides again & ask me if you have any questions … don’t forget your projects!

Try PP 5.3-5.5 (ed 3) or 6.5-6.7 (ed 4+) if you have lots of spare time

Extra task – find out about autoboxing & auto-unboxing


Coming Up Next

•  PRACTICE AND REVISION

•  More practice with OO program design - a bit more UML and putting it all together

•  Project clinics where needed – if you are working as a pair, you must tell me this week!

•  Sample exam questions

cs121 week12 - SEIDENBERG SCHOOL OF CSIScsis.pace.edu/~ogotel/teaching/cs121_week12_big.pdf ·...

Documents

Transcript of cs121 week12 - SEIDENBERG SCHOOL OF CSIScsis.pace.edu/~ogotel/teaching/cs121_week12_big.pdf ·...