Building Abstractions with Data (Part 3)

Building Abstractions

with Data (Part 3)

CS 21a: Introduction to Computing I

First Semester, 2013-2014

Outline►Assignment and State►Pass by Value versus Pass by Sharing►Message Passing and Final Remarks

on OOP

Two Different Kinds of Systems

Without State With State

(Re)Assignment Produces State

Without Stateint money = 500;

int moneyAfterDeposit = deposit(money, 1000);

With Stateint money = 500;

money = deposit(money, 1000);



int moneyAfterDeposit = money + 1000;


money = money + 1000;



int moneyAfterDeposit = money + 1000;


money = money + 1000;

Assignment operator (=) not to be confused with mathematical equals (==).

By The Way, Shortcuts!money += 1000; // money = money + 1000;

money++; // money += 1;

money -= 500; // there are also *= and /=

money--; // doesn’t make sense to have ** and //


Without State► Input and output values

have different names► Make a new thing out of

an existing thing

With State► Same name for both

“input” and “output”► Changing an existing

thing


Without State► Variables are names

attached to values► Doesn’t make sense to

change what something means

With State► Variables are boxes

whose contents can be changed

► Makes sense if what a name refers to is a changing, dynamic entity


Without State► Applying the same

operations to the same variables always produces the same results.

► Operation can be understood by plain substitution

int x = 5;

int y = x + 1; // 6

int z = x + 1; // still 6

With State► Operations can produce

side effects (aside from producing output, also changes state)

► Result of operation is dependent on time, history, environment

int x = 5;int y = ++x; // now 6int z = ++x; // now 7

Pre-increment versusPost-increment

►See example here►Difference in evaluation…► Is used a lot in older programs► Is useful for some accepted idioms►Should not be abused to make

ambiguous programs►Use these expressions often for side

effects, sparingly for the value

http://javaques.com/difference-between-post-increment-n-and-pre-incrementn/

Changing Object State By Updating Fields

public class Diet{

int calories;public Diet() {

calories = 0; }public void recordBurgerEaten() {

calories += 400;}

}


public class Diet{

int calories;public Diet() {

calories = 0; }public void recordBurgerEaten() {

calories += 400;}

}Mutator method


Diet myDiet = new Diet(); // myDiet has 0 calories

myDiet.recordBurgerEaten();

println(myDiet.calories); // myDiet has 400 calories

myDiet.recordBurgerEaten();

println(myDiet.calories); // myDiet has 800 calories

When to Use Mutators?►Only where it makes sense (updating

bank account, calorie count, etc.)►Example where it does not make

sense: Fraction’s add

Outline►Assignment and State►Pass by Value versus Pass by

Sharing►Message Passing and Final Remarks

on OOP

Two Kinds of Types in Java►Primitives types

► int, double, long, short, byte, float, char, boolean

►A variable holds a valid value►Object types► Java built-ins: String, Scanner►User-defined: Fraction, BankAccount► A variable holds a pointer to an object

Primitive Type Variablesversus Object Variables

►Primitive type variables directly contain valuesint x = 5;

►Object variables contain pointers to instancesBankAccount b = new BankAccount();

5x

bbalance

0

Primitive Type Variablesand Assignment

int x = 1000;1000

x


int x = 1000;int y = x;

1000x

1000y


int x = 1000;int y = x;

1000x

1000y

Pass by value: y gets a copy of the value of x


int x = 1000;int y = x;

1000x

1000y

Pass by value: y gets a copy of 1000


int x = 1000;int y = x;y = y - 100;println( x );println( y );

1000x

900y

Prints:

1000900

Object Variablesand Assignment

BankAccount b = new BankAccount( 1000 );

bbalance

1000


BankAccount b = new BankAccount( 1000 );BankAccount c = b;

bbalance

1000c



bbalance

1000c

Pass by sharing: c gets a copy of the value of b



bbalance

1000c

Pass by sharing: c gets a copy of a pointer to the bank account. NO NEW OBJECT INSTANCE IS CREATED.


BankAccount b = new BankAccount( 1000 );BankAccount c = b;c.withdraw( 100 );println( b.getBalance() );println( c.getBalance() );

bbalance

900c Prints

:900900

What’s a Pointer?►It’s really a memory address!►Try this:BankAccount b = new BankAccount( 1000 );println(b);BankAccount c = new BankAccount( 1000 );println(c);println(c == b);c = b;println(c);println(c == b);


Doesn’t matter if the two bank accounts have the same balance. They’re different accounts!


Copies the memory address stored in b to c


c now points to the same object as b does

What’s a Pointer?►So when you do…c.withdraw(100);►The balance is changed for the

instance that both b and c share

What Happens to the Second Bank Account?

►Garbage collection is a feature of a programming language, where objects that can no longer be accessed are automatically destroyed.

Method Calls►A method is invoked on an object

variable but acts on the object that the variable is pointing to

BankAccount b = new BankAccount(1000);

b

balance1000

Method Calls►A method is invoked on an object

variable but acts on the object that the variable is pointing to

BankAccount b = new BankAccount(1000);b.deposit( 250 );

b

balance1250deposit(250)

The null Pointer►An object variable that doesn’t point

to an actual instance yet has a null pointer (points to nothing)

null

Method Calls on null►Calling a method on an object

variable whose value is null results in an error (NullPointerException)

BankAccount b = null;b.deposit( 250 );

b

???deposit(250)

An Analogy to Clear That UpJava World Balloon WorldObject variable name HandObject variable value orPointer

String (not the CS kind)

Object instance Balloon

An Analogy to Clear That UpJava World Balloon WorldCall to constructor Make a new balloonReturn value from constructor

String that ties the new balloon

Assigning to object variable

Make the hand hold the string




Make the hand hold the stringnew BankAccount(500); balance

500

some memory address




Make the hand hold the stringBankAccount b = new BankAccount(500); balance

b

500

An Analogy to Clear That UpJava World Balloon WorldUsing the dot operatorCalling a methodAccessing a field

Getting the balloon attached to the string and operating on it

b.deposit(500);

Three parts:1. What’s b?2. What’s the pointer pointing to?3. Apply operation to object

balance

b

500



b.deposit(500);


balance

b

500



b.deposit(500);


balance

b

500



b.deposit(500);


balance

b

1000

An Analogy to Clear That UpJava World Balloon WorldPass by sharing Share the balloon by

attaching a new string (a copy of the old string) and making the new hand hold the new string balance

b

1000

c

BankAccount c = b;

An Analogy to Clear That UpJava World Balloon WorldPass by sharing Share the balloon by

attaching a new string (a copy of the old string) and making the new hand hold the new string balance

b

1500

c

c.deposit(500);

An Analogy to Clear That UpJava World Balloon WorldNull Pointer String with no balloon

balance

b

1500

c

c = null;// c.deposit(500); -> NullPointerException

An Analogy to Clear That UpJava World Balloon WorldUnassigned variable (doesn’t even matter if Object or primitive)

Hand holding nothing

balance

b

1500

c

BankAccount d;// d.deposit(500); -> compile error

d

An Analogy to Clear That UpJava World Balloon WorldGarbage Collection Unheld balloons fly away

and eventually pop, releasing boxes which can be used again

balance

b

1500

c

b = null;

d

An Analogy to Clear That UpJava World Balloon WorldGarbage Collection Unheld balloons fly away

and eventually pop, releasing boxes which can be used again

bFree box cd

What Happens?BankAccount b = new BankAccount( 1000 );println(b == null);println(b.getBalance());

What Happens?BankAccount b = new BankAccount( 1000 );BankAccount c = new BankAccount( 500 );println(b.getBalance());println(c.getBalance());c = b;println(b.getBalance());println(c.getBalance());

What Happens?BankAccount b = new BankAccount( 1000 );println(b.getBalance());b = null;println(b == null);println(b.getBalance());

What Happens?public static void main(String args[]) {int x = 0;increment(x);println(x);

}public void increment(int x) {x++;

}

What Happens?public static void main(String args[]) {int x = 0;x = increment(x);println(x);

}public int increment(int x) {x++;return x;

}

What Happens?public static void main(String args[]) {BankAccount x = new BankAccount(500);increment(x);println(x.getBalance());

}public void increment(BankAccount x) {x = new BankAccount(x.getBalance() + 1);

}

What Happens?public static void main(String args[]) {BankAccount x = new BankAccount(500);x = increment(x);println(x.getBalance());

}public BankAccount increment(BankAccount x) {x = new BankAccount(x.getBalance() + 1);return x;

}

What Happens?public static void main(String args[]) {BankAccount x = new BankAccount(500);increment(x);println(x.getBalance());

}public void increment(BankAccount x) {x.balance = x.getBalance() + 1;

}

A Better Versionpublic static void main(String args[]) {BankAccount x = new BankAccount(500);increment(x);println(x.getBalance());

}public void increment(BankAccount x) {x.setBalance(x.getBalance() + 1);

}

An Even Better Versionpublic static void main(String args[]) {BankAccount x = new BankAccount(500);x.increment();println(x.getBalance());

}

An Even Better and Useful Version

public static void main(String args[]) {BankAccount x = new BankAccount(500);x.setCompoundInterestRate(0.06);x.applyInterest();println(x.getBalance());

}

Some Technical Stuff► Fields have default values. Local variables

don’t.► An object type field has a null pointer by

default if the constructor doesn’t assign anything else to it.► Does not cause a compile error if you try to invoke

a method on it► An unassigned object type local variable does

not have even a null pointer.► Compile error if you try to invoke a method

on it.

What Happens?BankAccount b;println(b.getBalance());

What Happens?BankAccount b = null;println(b.getBalance());

What Happens?static BankAccount b;public static void main(String args[]) {println(b.getBalance());

}

How to Avoid the Technical Stuff

►Always assign variables before using them!

►Never rely on default values!

Why the Trouble with Passing?

►Three sub-questions:►Why pass only copies of the value

(whether it’s a primitive or a pointer)?►Avoid accidental reassignment, unwanted

side effects


►Three sub-questions:►Why pass pointers for object types?

►To allow controlled side effects through mutator methods

►For efficiency’s sake: no new copy of the actual object (which may be big) is created

►If you really want a new copy, there are ways


►Three sub-questions:►Can it be otherwise?

►Yes! Java chooses to evaluate variables this way, but other languages have different evaluation strategies.

How to Avoid the Trouble with Passing?

►Most of the time, two strings share a balloon only because you have an object type parameter.

►Never reassign parameters!

Outline►Assignment and State►Pass by Value versus Pass by Sharing►Message Passing and Final

Remarks on OOP

Message Passing►Original view of OOP in the earlier

languages like Smalltalk.►Constructors: pass a message to tell

an object to begin with a certain state.

►Accessors: pass a message to ask about an object’s state.

►Mutators: pass a message to tell an object to change its state.

Message Passing►Each method invocation is a message

for an object.►The object responds in one of two

ways:►Reply with a value►Act to change its state►Possibly both

Message Passing►Big difference from functional view!►Functional view: same input, same

output►OO view: same input (message),

possibly different output (state) depending on time

Group Discussion►Using the idea of message passing,

explain how the web works (how you can access and modify data on the internet through your web browser).

Group Discussion► Hint: There are only

5 crucial parts. Identify which is the object, the driver program, the input to the driver program, the accessor message, the mutator message.

►URL► Browser►GET request► POST request► Internet

OOP is Modeling►Not the one with the catwalks and

platforms!►OOP is modeling real world objects?

► Not really►You don’t write classes for dogs, chairs, etc.

► OOP is modeling real world concepts.►You write classes for social network profiles,

geometric figures, and… bank accounts►Although you can argue that dog, chair, etc. are

concepts too

With Great Power Comes Great Responsibility

►Abstraction gives you power.►OOP > Procedural > imperative in

terms of abstraction.►Use OOP wisely.


►Abstraction is your tool for achieving a goal.

►Abstraction is not your goal!►Always focus on the problem, not on

the abstraction!►Appropriate level of abstraction – one

that allows you to efficiently solve the problem


►Remember:►Write for humans►Write for computers►Write generally, but not too generally

►If 10 layers of abstraction will allow you to do this, don’t go for 50.

►Don’t over-engineer.

Summary►OOP is about coupling data and

procedures.►OOP is about coupling state and

behavior.►OOP is about changing state.►OOP is about message passing.►OOP is a powerful abstraction tool

that takes time to master and must be used with care.

Mega Summary►What are algorithms?

► Concerned with computers and performance? ► Imperative: sequences of statements

► Concerned with science and generality? ►Declarative/Functional: compositions of

functions or expressions► Concerned with humans and modularity?

►Procedural: sequences of chunks of statements►Object-oriented: system of interacting objects

Mega Summary►Remember the fundamental

distinctions to avoid confusion►Thinking the Algorithm►Writing the Program►Running the Computation►Use versus Definition► Instance versus Idea►Scope versus Environment

Mega Summary►Benefits of Abstraction:►Readability

►Separating code into chunks►Reusability

►Allowing chunks to be reused►Robustness

►Allowing chunks to be changed easily without affecting other chunks

Mega Summary►The history of programming is the

history of abstraction.►Machine Language (1s and 0s)►Assembly Language (not discussed

here)► Imperative►Procedural and Functional►OOP►The next big thing?

Next Time…►We’ve tackled the first beast:

complexity►Next, we’re going to tackle infinity►But before that, a short discussion of

two useful pre-defined objects and Lab

Date post:	19-Feb-2016
Category:	Documents
Upload:	liluye
View:	25 times
Download:	0 times

Building Abstractions with Data (Part 3)

Documents