Nov 5, Fall 2006 IAT 800 1

IAT 800

Lecture 5Objects, Classes

Nov 5, Fall 2006 IAT 800 2

Today

Primitive types– byte, short, int, long

Object-oriented programming– objects– classes

• sets (mutators) and gets (accessors)• object methods

Nov 5, Fall 2006 IAT 800 3

Primitive types

Primitive types are determined by machine architecturebyte: 8bits reference: (JVM Dependent)short: 16bitsint: 32bitslong: 64bitsfloat: 32bitsdouble: 64bits

Nov 5, Fall 2006 IAT 800 4

Reference

Like a remote control a reference is a

primitive thing that points at objects

the new keyword causes the reference to point at a new instance of the object

Nov 5, Fall 2006 IAT 800 5

Nov 5, Fall 2006 IAT 800 6

Arrays

int[] nums = new int[7] ;

Nov 5, Fall 2006 IAT 800 7

Array of objects

Dog[] pets = new Dog[7]; It starts as an array of null

references

Nov 5, Fall 2006 IAT 800 8

Array of objects

Dog[] pets = new Dog[7] ;pets[0] = new Dog();pets[1] = new Dog();

Nov 5, Fall 2006 IAT 800 9

Objects

Nov 5, Fall 2006 IAT 800 10

Real Objects

Real-world objects have– State– Behavior

Bicycle– State

• selected gear, current pedal cadence, speed

– Behavior• Change Gear, Set Cadence, Apply Brakes

Nov 5, Fall 2006 IAT 800 11

Software Object

Stateint gear ;float speed ;float cadence ;

BehaviorChangeGears(int g);Brake( float level );ChangeCadence( float c );int GetGear();float GetSpeed(); …

Nov 5, Fall 2006 IAT 800 12

Java directly supports Objects Java has direct syntactic and semantic support for

ObjectsSyntax:

class Bicycle { private int cadence = 0; private int speed = 0; private int gear = 1; void changeCadence(int newValue) { cadence = newValue; } void changeGear(int newValue) { gear = newValue; }}

Nov 5, Fall 2006 IAT 800 13

Java directly supports Objects Java has direct syntactic and semantic support for

ObjectsSemantics:

class Bicycle { private int cadence = 0;

private int speed = 0; private int gear = 1;

void changeCadence(int newValue) { cadence = newValue; } void changeGear(int newValue) { gear = newValue; }}

Only these methods can read or write Bicycle private data

Nov 5, Fall 2006 IAT 800 14

Java Semantic support

Programming usually takes place with objects:ClockClass clock = new ClockClass();

clock.setSecond( 12 );clock.setMinute( 18 );clock.setHour( 3 );

Nov 5, Fall 2006 IAT 800 15

Even Arrays are objects

int[] bob = new int[10] ;bob[4] = 123 ;println( bob.size() );

Bicycle[] bikes = new Bicycle[10] ;bikes[0] = new Bicycle();

Nov 5, Fall 2006 IAT 800 16

Sets and Gets

what can you do with private data?– to set it: setVarName( varType

newValue)– to get it: varType getVarName()

Why?

Nov 5, Fall 2006 IAT 800 17

temperature objectclass temp { private float kelvin ; setCelsius( float C ); { if( C < -273.15 )

return ; // perhaps an error message would be in order else kelvin = C + 273.15 ;

} float getCelsius() { return( kelvin - 273.15 ); } float setKelvin( float k ) { if( k < 0 )

return ; else kelvin = k ;

}}

Nov 5, Fall 2006 IAT 800 18

temperature object

Controls access Ensures correctness

– can only run a setXYZ() to change temp– can only do getXYZ() to get the value in

the desired scale Who cares?

Nov 5, Fall 2006 IAT 800 19

Who cares?

When you want to:– Solve the problem once and forget it– Reuse the solution elsewhere– Establish rules for use and change of data

The principle:– Information hiding– By interacting only with an object's methods,

the details of its internal implementation remain hidden from the outside world.

Nov 5, Fall 2006 IAT 800 20

Principle: Code re-use

If an object already exists, you can use that object in your program.

Specialists build, you use

Nov 5, Fall 2006 IAT 800 21

Principle: Define the Interface

Define the interface:– The list of methods with Defined Operation

The interface is the thing that other people use

If you have the same interface with the same meaning– You can plug in a better

implementation!

Nov 5, Fall 2006 IAT 800 22

Define the Interface

If you have the same interface with the same meaning– You can plug in a better

implementation!– You can plug in a More Interesting

implementation!

Nov 5, Fall 2006 IAT 800 23

Summary of principles

Hide unnecessary details Clearly define the interface Allow and support code re-use

Build on the work of others

Nov 5, Fall 2006 IAT 800 24

How do we build on other work?

Divide and conquer– Cut the problem into smaller pieces– Solve those smaller problems– Aggregate the smaller solutions

Two approaches:– Top-down– Bottom-up

Nov 5, Fall 2006 IAT 800 25

Nov 5, Fall 2006 IAT 800 26

Top Down

Take the big problem– Cut it into parts

• Analyze each part

– Design a top-level solution that presumes you have a solution to each part

then…– Cut each part into sub-parts

Nov 5, Fall 2006 IAT 800 27

Bottom-up

Cut the problem into parts, then sub-parts, then sub-sub parts…– build a solution to each sub-sub-part

• aggregate sub-sub solutions into a sub-solution

Nov 5, Fall 2006 IAT 800 28

How do we build on other work?

Recognize the problem as another problem in disguise– It’s a sorting problem!– It’s a search problem!– It’s a translation problem!– It’s an optimization problem!

Nov 5, Fall 2006 IAT 800 29

The challenge

Software design is typically done top-down

Software implementation is typically done bottom-up