CSE 501N Fall ‘09 04: Introduction to Objects 08 September 2009 Nick Leidenfrost.

CSE 501NFall ‘0904: Introduction to Objects

08 September 2009

Nick Leidenfrost

2

Lecture Outline Lab 1 Static Methods Objects

Fields / Instance Variables Object Variables

Aliases Creating Objects: Constructors Accessing Fields / Invoking methods on Objects

The String Object Object Assignment Access Modifiers Variable Scopes

3

Static MethodsCalling Methods Without Objects

In Java, all methods must be defined within a class body

At times it is useful to have a method which defines functionality that does not alter the state of an objectThe Java Library class java.lang.Math is a

perfect example of useful static methods Methods in Math give us functionality that is not

native to the Java language These functions are strictly input / output functions

and do not alter the state of any Math object

4

Static MethodsCalling / Invoking

Static methods are typically invoked in the following way:

int myNum = 5;int cubed = Math.pow(myNum, 3);

<Class Name> . <Method Name> <Method Parameters>

5

Classes Further detail

A class is a template (or blueprint) for creating Objects Often representative of real-world concepts Defines state (fields) Defines behavior (methods)

public class BankAccount {

// Fields / Methods defined here.

}

6

Class Members: Fields Thinking in OO

An class’s fields (a.k.a. instance variables) define the internal state

Just as classes often mimic real-world concepts, fields often represent real attributes of those concepts

public class BankAccount {

double balance;int accountNumber;Person owner;

}

7

Class Members: Fields Referencing Fields

Fields can be used in all class methods by name

public class BankAccount {

double balance;int accountNumber;

}

public double getBalance () {return balance;

}

There is no local variable declared in this method

named balance. Therefore, Java knows we

are referring to the instance variable.

8

Objects Objects are instances of classes

(Real examples of the concept defined by a class)

Each object gets its own copy of all instance variablesThis internal state is specific to each object

George’s BankAccount

balance

accountNum

14,068.00

3988323425

Nick’s BankAccount

balance

accountNum

-573.17

1858323356

Sally’s BankAccount

balance

accountNum

1,584,001.01

225323693

9

Object VariablesDeclaring Variables with Object Types

We can declare variables to hold Object values just like we can with primitives

A class name is used as the type when declaring an object variable

Note that no object is created with this declaration

Object variables hold the special value null if they are not initialized

The object itself must be created separately

With its constructor

String title;

10

Aliases Two or more references (variables) that refer to the

same object are called aliases of each other

That creates an interesting situation: one object can be accessed using multiple reference variables

Aliases will naturally occur in programming, but should be managed carefully

Changing an object through one reference changes it for all of its aliases, because there is really only one object

11

Creating ObjectsConstructors

Constructors are special methods that create the objects of a class

Allocate Memory required to store object state (instance variables);

Initialize object state per programmer instructions

Constructors give the programmer a chance to initialize the state (instance variables) of an object

Constructors must have the same name as the class in which they are defined

Constructors have no return type specified in the method header, not even void

public class BankAccount {

public BankAccount () {// Initialization code here

}

}

12

Creating ObjectsConstructors

Can accept parameters like methods

Each class has a default constructor that accepts no parameters

The programmer does not have to define a constructor for a class - Java will define a default constructor for us if we do nothing

public BankAccount (int accountNum, double amount) {…

}

protected BankAccount () {}

Can also be overloaded like

methods

13

Creating ObjectsThe new Operator

Generally, we use the new operator to invoke an object’s constructor

BankAccount account = new BankAccount(156774, 0.0);

The new operator is used to invoke the constructor

The constructor cannot be called without new Creating an object is called instantiation

14

Creating ObjectsOverloaded Constructors

If a constructor is overloaded we can call one version from another with the this keyword

this also has other uses that we will learn about soon.

public BankAccount (int accountNumber, double initBalance) {accountNum = accountNumber;balance = initBalance;

}

public BankAccount (int accountNumber) {this(accountNumber, 0.0);

}

15

Creating ObjectsReturn Statements

Constructors by definition return an object whose type is that of the constructors’ class

You may have a return statement inside of a constructorOnly for returning from the constructor call

earlyYou may not return a value

16

Invoking Methods on Objects Once an object has been instantiated, we can

use the dot operator to invoke its methods

Dot operator syntax:

A method invocation can be thought of as asking an object to perform a service or to manipulate its state

BankAccount acct = new BankAccount();double balance = acct.getBalance();

<Object Variable Name> . <Method Name> <Method Parameters>

17

double getBalance()

void helper ()

helper();

acct.getBalance();

void main ()

Method Control Flow The called method may be part of another class or object

ATM BankAccount

18

Referencing Fields of Objects

Once an object has been instantiated, we can also use the dot operator to access its fields

Referencing fields in this way is generally discouraged with a few exceptions

Instance variables should typically be accessed and modified using accessor and mutator methods

BankAccount account = new BankAccount();// … omitted statementsdouble canSpend = account.balance;account.balance = 15000;

19

The String ObjectA Primitive? An Object? Superman?

Earlier, we learned about the char data type, used to store a single character

In Java, the String object represents a series (or string) of characters

String constants in Java are encapsulated by double quotes String name = “Peter”;

Strings are Objects in Java Lots of predefined functionality int length = name.length();

Also referred to as string literals

20

The String Class

Because strings are so common, we don't have to use the new operator to create a String object with a string constant / string literal

String text = “was it a rat I saw";

This is special syntax that works only for strings

Each string literal (enclosed in double quotes) represents a String object

Java implicitly calls the String constructor when a String literal is assigned

to String variables

21

The String Object Strings can be “added” like numeric

primitives with the ‘+’ and ‘+=‘ operatorsThis is referred to as concatenation

String firstName = “George”;

String lastName = “Henrichs”;

String name = firstName + “ “ + lastName;

// “George Henrichs”

// ...Or

String name = lastName;

name += “, “ + firstName; // “Henrichs, George”

22

The String Object Strings can be also concatenated with primitive

types:

The resultant type of an expression is the widest type of the operands of that expression Strings are “wider” than any type

String name = “George”;

double examGrade = 89.7;

String output = name + “ received an “ + examGrade + “% on exam 1”;

// “George received an 89.7% on exam 1”

23

Of Strings and ObjectsThe toString Method

We can define a special method toString to specify the String representation of an object

A default implementation of toString is provided for us if we don’t define one

This allows object variables to be concatenated with Strings:

BankAccount account = new BankAccount(10000, 50000.0);System.out.println(“The account: “ + account);

public String toString () {return accountNum + “: “ + balance;

}

24

Printing Strings to the Command LineSystem.out.print and System.out.println

We can print any String to the command line with two methods provided by Java System.out.print System.out.println

String name = “George”;

double examGrade = 89.7;

String output = name + “ received an “ + examGrade + “% on exam 1”;

System.out.println(output);

25

String MethodsImmutable Objects

Once a String object has been created, neither its value nor its length can be changed

Thus we say that an object of the String class is immutable

However, several methods of the String class return new String objects that are modified versions of the original

26

Variable DeclarationPrimitive Variables vs. Object Variables

Your Computer’s Memory(RAM)

int myCount;String name;

When a variable is declared, whether it’s a primitive or an object, Java allocates memory to store the variable

0

4 by

tes

null

4 by

tes

Really, a variable is just a human-readable

“nickname” for a memory address

If the variable is a primitive, the appropriate amount is allocated

based on the variable’s typee.g.

8 bytes for a double4 bytes for an int1 byte for a char

…etc.

If the variable is an object, 4 bytes are allocated for the

object handle. This memory will later point to the object

referenced by ‘name’.

Any value the primitive variable will ever have will be stored in this memory.

27

Variables and AssignmentPrimitive Variables vs. Object Variables

Assignment Affects Object and Primitive Variables Differently

Your Computer’s Memory(RAM)

0

4 by

tes

int myCount;String name;

myCount = 2;name = new String(“Bob”); null

4 by

tes

“Bob”

store 2

(Memory Address)

When the constructor is invoked (called) Java

allocates memory for the object.

The object handle now refers to the newly created object.

28

Object Variable Reassignment

Your Computer’s Memory(RAM)

String name;name = new String(“Bob”);name = “Robert”;

(Memory Address)

“Bob”

“Robert”

Implicitly calls the String constructor

29

Object AliasesTwo References to the Same Object

(Multiple References to

the Same Object)

String name = “Bob”;String aName;aName = name;name = null;String anotherName = “Bob”;

Your Computer’s Memory(RAM)

(Memory Address)

“Bob”

null(Memory Address)

null

“Bob”

(Memory Address)

null

30

Primitive Assignment

Value is copied

int myCount = 2;int numGuests;numGuests = myCount;

Your Computer’s Memory(RAM)

2

02

31

Object InteractionAccess Modifiers

Access modifiers allow us to control who has access to an object’s members Who can reference Fields (internal state) Who can invoke Methods (behavior) Who can invoke Constructors

Java provides four types of access modifiers public

Anyone can read and write this field or invoke this method protected

Only other instances of this class and their subclasses [default] or Package Protected

(No access modifier specified) Only other classes in the package private

Only this object and other instances of this class

32

Object InteractionAccess Modifiers

Using Modifiers to Protect State

public class BankAccount {

private double balance;

protected BankAccount () {}

public boolean deposit (double amount) {if (amount <= 0)

return false;balance += amount;return true;

}

public boolean withdraw (double amount) {if (amount <= 0)

return false;double newBalance = balance – amount;balance = newBalance;return true;

}

}

… in instance variable declarations

… in method declarations

Note that local variables (variables

declared within methods) cannot have

access modifiers.

protected and private default constructors can be

created to prevent Java from defining a public default

constructor

33

Object InteractionEncapsulation

We may not want to give others unlimited access to an object’s state

Force the outside world to interact with a class and its state through predefined methods

BankAccount account = new BankAccount();// ...double balance = account.balance;double balance = account.getBalance();

Generally, it is a bad idea to allow direct access to a class’s

fields.

Accessor methods allow access to

required information without exposing

objects fields

34

Object InteractionEncapsulation

If an access modifier is used when a class member is declared, any access prohibited by that access modifier becomes a compilation error

public class BankAccount {

private double balance;

// Omitted methods, etc}

// Outside of BankAccount.javaBankAccount account = new BankAccount();// ...double balance = account.balance;

The field BankAccount.balance is not visible.X

35

ScopesThe Lifespan and Visibility of a Variable A scope of a variable defines the context in which it is accessible

Usually surrounded by brackets: { }

State or instance variables are accessible from any method in the class

If declared public / default / protected, accessible from other classes as well

Local variables are accessible only within the method in which they are declared

Local variables “die” after the method returns

36

Local Variables As we’ve seen, local variables can be declared inside a method

The formal parameters of a method create automatic local variables when the method is invoked

Primitive parameters are copied

Object parameters are aliased

What happens in the method doesn’t necessarily stay in the method

When the method finishes, all local variables are destroyed (including the formal parameters)

Keep in mind that instance variables, declared at the class level, exists as long as the object exists

37

Garbage Collection Automatic Memory Management

When an object no longer has any valid references to it, it can no longer be accessed by the program

The object is useless, and therefore is called garbage

Java performs automatic garbage collection periodically, returning an object's memory to the system for future use

In other languages, the programmer is responsible for performing garbage collection

38

Conclusion

Questions?

Lab 1 due Thursday

I will be in lab now.