CSE 501N
Fall ‘09
04: Introduction to Objects
08 September 2009
Nick Leidenfrost
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
2
Static Methods
Calling 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 object

Java Library class java.lang.Math is a
perfect example of useful static methods
 The
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

3
Static Methods
Calling / Invoking

Static methods are typically invoked in the
following way:
<Class Name> . <Method Name> <Method Parameters>
int myNum = 5;
int cubed = Math.pow(myNum, 3);
4
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.
}
5
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;
}
6
Class Members: Fields
Referencing Fields

Fields can be used in all class methods by name
There is no local variable
declared in this method
named balance.
public class BankAccount {
Therefore, Java knows we
are referring to the
double balance;
instance variable.
int accountNumber;
public double getBalance () {
return balance;
}
}
7
Objects

Objects are instances of classes
 (Real

examples of the concept defined by a class)
Each object gets its own copy of all
instance variables
 This
internal state is specific to each object
Nick’s BankAccount
balance
accountNum
-573.17
George’s BankAccount
Sally’s BankAccount
1858323356
balance
accountNum
balance
14,068.00
accountNum 3988323425
1,584,001.01
225323693
8
Object Variables
Declaring 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
String title;

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
9
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
10
Creating Objects
Constructors

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
}
}
11
Creating Objects
Constructors

Can accept parameters like methods
public BankAccount (int accountNum, double amount) {
…
Can also be
}
overloaded like
methods
protected BankAccount () {
}

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
12
Creating Objects
The 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
13
Creating Objects
Overloaded Constructors

If a constructor is overloaded we can call
one version from another with the this
keyword
public BankAccount (int accountNumber, double initBalance) {
accountNum = accountNumber;
balance = initBalance;
}
public BankAccount (int accountNumber) {
this(accountNumber, 0.0);
}

this also has other uses that we will
learn about soon.
14
Creating Objects
Return Statements
Constructors by definition return an object
whose type is that of the constructors’
class
 You may have a return statement inside
of a constructor

 Only
for returning from the constructor call
early
 You may not return a value
15
Invoking Methods on Objects

Once an object has been instantiated, we can
use the dot operator to invoke its methods
 Dot
operator syntax:
<Object Variable Name> . <Method Name> <Method Parameters>
BankAccount acct = new BankAccount();
double balance = acct.getBalance();

A method invocation can be thought of as
asking an object to perform a service or to
manipulate its state
16
Method Control Flow

The called method may be part of another class
or object
ATM
void main ()
acct.getBalance();
BankAccount
double getBalance() void helper ()
helper();
17
Referencing Fields of Objects

Once an object has been instantiated, we can also use
the dot operator to access its fields
BankAccount account = new BankAccount();
// … omitted statements
double canSpend = account.balance;
account.balance = 15000;

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
18
The String Object
A Primitive? An Object? Superman?



Earlier, we learned about the char data type,
used to store a single character
In Java, the String object represents
Also referred toa series (or
string) of characters
as string literals
String constants in Java are encapsulated by
double quotes
 String

name = “Peter”;
Strings are Objects in Java
 Lots
 int
of predefined functionality
length = name.length();
19
The String Class

Java implicitly
calls the
Because strings are so common,
we don't
have
String constructor when a
to use the new operator to create
a String
String literal
is assigned to
String literal
variables
object with a string constant / string
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
20
The String Object

Strings can be “added” like numeric
primitives with the ‘+’ and ‘+=‘ operators
 This
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”
21
The String Object

Strings can be also concatenated with primitive
types:
String name = “George”;
double examGrade = 89.7;
String output = name + “ received an “ + examGrade + “% on
exam 1”;
// “George received an 89.7% on exam 1”

The resultant type of an expression is the widest
type of the operands of that expression
 Strings
are “wider” than any type
22
Of Strings and Objects
The toString Method

We can define a special method toString to specify
the String representation of an object
public String toString () {
return accountNum + “: “ + balance;
}


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);
23
Printing Strings to the Command Line
System.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);
24
String Methods
Immutable 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
25
Variable Declaration
Primitive Variables vs. Object Variables
If the variable is a primitive, the
When a variable is declared,
whether
it’s a
appropriate
amount is allocated
basedallocates
on the variable’s
type
primitive or an object, Java
memory
to
e.g.
store the variable
8 bytes
for athe
double
Any value
primitive
Really, a variable is just a
human-readable
“nickname” for a memory
address
4 bytes
int myCount;
String name;
Your
Computer’s
Memory
4 bytes
for
anobject,
inthave4will
If thevariable
variable
is an
will
ever
(RAM)
1are
byte
forina this
char
bytes
allocated
for
the
be
stored
memory.
object handle.…etc.
This memory will
0
later point to the object
referenced by ‘name’.
4 bytes

null
26
Variables and Assignment
Primitive Variables vs. Object Variables
Assignment Affects Object and Primitive
Variables Differently
int myCount;
String name;
Your Computer’s Memory
When the constructor is
(RAM)
invoked (called) Java
allocates
memory
fornow
the refers to
The object
handle
object.
2
0
the
store newly created object.
myCount = 2;
name = new String(“Bob”);
4 bytes 4 bytes

(Memory Address)
null
“Bob”
27
Object Variable Reassignment
Implicitly calls the
name; String constructor
String
name = new String(“Bob”);
name = “Robert”;
Your Computer’s Memory
(RAM)
(Memory Address)
“Bob”
“Robert”
28
Object Aliases
Two 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)
null
(Memory Address)
“Bob”
(Memory Address)
null
(Memory Address)
null
“Bob”
29
Primitive Assignment

Value is copied
int myCount = 2;
int numGuests;
numGuests = myCount;
Your Computer’s Memory
(RAM)
2
0
2
30
Object Interaction
Access 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


protected


Only other instances of this class and their subclasses
[default] or Package Protected


Anyone can read and write this field or invoke this method
(No access modifier specified) Only other classes in the package
private

Only this object and other instances of this class
31
Object Interaction
Access Modifiers

protected
and private
Using Modifiers
Protect
State
… into
instance
variable
default constructors can be
declarations
public class BankAccount
{
created
to prevent Java from
defining a public default
private double balance;
constructor
protected BankAccount () {
}
public boolean deposit (double amount) {
if (amount <= 0)
return false;
balance
+= amount;
… in method
Note that local
return
true;
declarations
variables (variables
}
declared within
methods) (double
cannot have
public boolean withdraw
amount) {
if (amount access
<= 0) modifiers.
return false;
double newBalance = balance – amount;
32
Object Interaction
Encapsulation


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
Generally, it is a bad
idea to allow
direct
Accessor
methods
allow
access
class’s
accesstotoarequired
new BankAccount();
fields. without
information
exposing objects fields
BankAccount account =
// ...
double balance = account.balance;
double balance = account.getBalance();
33
Object Interaction
Encapsulation

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.java
X The
field BankAccount.balance is not visible.
BankAccount account = new BankAccount();
// ...
double balance = account.balance;
34
Scopes
The 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
declared public / default / protected,
accessible from other classes as well
 If

Local variables are accessible only within the
method in which they are declared
 Local
variables “die” after the method returns
35
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
 Object

parameters are copied
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
36
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
37
Conclusion

Questions?

Lab 1 due Thursday

I will be in lab now.
38
Descargar

CSE 501N Fall ‘06 02: Machine Overview + Fundamental …