itm 352 simple arrays lecture #. 2/20/2003itm352 spring 2003 - © portarrays - 2 announcements r...

ITM 352Simple Arrays

Lecture #

2/20/2003 ITM352 Spring 2003 - © Port Arrays - 2

Announcements Grades for assignment #1 posted on web site

Use your class ID #

Exam questions posted on web site Study early!

For those who feel they need extra help, come to the extra lab session Friday anytime 12-3pm


Today Informal Survey Review:

Methods method definition methods and ivars parameters, parameter passing constructors

Some example programs: “mini” robot development

Simple Arrays


Informal SurveyWhere are you at now?

Understand basic OO concepts of objects, classes, variables

Can successfully modify OO code(if you are still here then attend Friday extra classand TA labs)

Can design and write simple OO apps(around 3 classes or less)

Can analysis, design complex OO apps(more than 8 classes, GUI, multiple entry,..)


Informal Survey: actionsDo you feel you have [too little, too

much, just enough] opportunities for programming practice and examples?


Informal SurveyOverall are you [happy, unhappy] with this

class as it stands now?


Review


Objects and Methods


Method calls Calling a method is a way of executing a bunch of

Java statements that appear elsewhere. Those statements appear in a method definition, which may be written by you or supplied by the system.

To invoke a method, you do not have to know what statements it contains, but you do have to know what they do, and you have to know the method name.

Methods carry out an objects behaviors


Object messaging: using methods Behaviors are the result of object interaction

through messaging

myRobot world

caller receiver

robotLocation()


Object messaging itself It is very common (and elegant when appropriate)

for an object to message itself

The special keyword this always refers to the current object any method call that does not begin with a reference implicity has

a this in from of it

myRobot

caller

receiver

this.selfTest()


Method calls (cont.) Two flavors of methods: class methods and

instance methods. SavitchIn.readLine() is a class method.

Class methods are always called using the name of the class (SavitchIn), a period, and then the name of the method (readLine).

world.robotLocation()is an instance method. Instance methods are always called using a reference to an object (i.e. an instance of a Class)


Method ParametersMethods can accept any number of

arguments of any data type each argument must be specified in the method

definition

setRobotDirection(int degrees, Engine engine, Robot robot)

Question: what might be a problem with the above?


Parameter Passing Arguments are passed from the caller to the

receiver when the method is called

movingRobotTest myEngine

caller receiver

myEngine.moveInDirection(270);


Complex messaging Calling a method may invoke the calling of other

methods indirectly

movingRobotTest myEngine

caller

receiver_1

myEngine.moveInDirection(270);

world

receiver_3

this.setDirection(270);

receiver_2

world.setDirection(270,this);


Return values from methods

Most methods return a value. SavitchIn.ReadLine() returns a String world.robotLocation() returns a Point

Such methods can appear in expressions. System.out.print(“You entered: “+ SavitchIn.ReadLine());

Documentation says what the argument types and return value are.


Return values

Return types are declared in the method definition indicate the data type of value to be returned special void keyword denotes no return value

static int readLineInt() { … } static String readLine() { … } public void moveInDirection() { … }

actual return values are passed via the return keyword inside the method implementation


Return Values Values are passed back from the receiver to the

caller when the method completes using the return keyword

myRobotTest myRobot

caller receiver

System.out.println(myRobot.getName());

“HAL200”

String getName(){ return “HAL2000;}getName()


Accessibility (scope) of methods

The accessibility of a method is defined in its definition before its return type public static int readLineInt() { … } private void setBankBalance(int amount) { … }


Constructor methods

To create an object (instance of a class), use the expression

new classname () ;Remember: variables must be initialized!

Variables with object types are no exception.Initialization is usually done within a special

method called a constructor


Multiple ConstructorsConstructors can take arguments, but never

return values (they return references) public class Robot {String name;Robot() {} // the default constructorRobot(String aName) {// use passed parameter to initialize name

name = aName;}

} This constructor is different than Robot() , both can

be defined and used when appropriate.


Object References When you do

new <classname>() ;

the constructor <classname>() is called in the class <classname> and a reference is returned

This reference usually is assigned to a variable of type <classname> Ex. Robot myRobot = new Robot();

The keyword null represents “no reference” When you declare an object type (i.e. a class), the default

initialization is to null


Reference Variables Object references can be used just like any value (int, float,

etc.) except you can not use arithmetic or most logical operators on them (unlike C++) WRONG:

myRobot++; myRobot + anotherRobot; myRobot > anotherRobot;

OK: myRobot = anotherRobot // assign ref. value myRobot = = anotherRobot // test “is same ref?”

Object references can be uses as arguments for parameter passing Robot getRobot(); return myRobot;


Basic Variable Scope

Variables are containers for values that are local to a method

public class CircleArea {

public static void main (String[] args) {

final float MY_PI = 3.1415; double radius = 4.12333422;

System.out.print("area = "); System.out.println(MY_PI*radius*radius); } }

Only “seen” in main block


Class Variables

A class can introduce variables (or symbolic constants) that can be referred to by classname . Variablename Do not need an instance of the Class to use Examples: Math.PI, System.out



final float MY_PI = (float) Math.PI double radius = 4.12333422;

System.out.print("area = "); System.out.println(MY_PI*radius*radius); } }

“seen” anywhereclass isavailable


Instance variables and class variables An object can contain variables referred to by

object . Variablename or anywhere inside the class definition block (available to all methods)


double radius = 4.12333422;


System.out.print("area = "); System.out.println(Math.PI*radius*radius); } } ---------- in another object that has “aCircleArea” as a reference ----------System.out.print(”the radius is ”, aCircleArea.radius);

“seen” in classblock or outside throughreference


Summary

Objects have: Instance methods: expression . methodname (arg’s) Instance variables: expression . variablename

Variables declared inside main (or other methods) are called local variables. These are different from class variables and instance variables, and are referred to simply by their names.


And now an extended example!


“mini” Robot ExampleA robot has attributes:

name represent using a string

environment represent using a RobotEnvironment object

And behaviors: check status

battery, damage level use parts

only need to add parts, get parts


Robot Robot

Environmentworld

Robot

Test

myRobot theWorld


The Robotpublic class Robot {/* This is the robot representation */

public String name; // the name ivarpublic RobotEnvironment world; // the world attr ivar

Robot(RobotEnvironment theEnv) { // constructor for a Robotthis.world = theEnv;usePart(new RobotPart(“lazer”);

}

public String checkStatus() {return world.checkRobotStatus(this);

}

public void usePart(RobotPart aPart) {world.addPartForRobot(this, aPart)

}}

Implies RobotEnvironment will have these methods

Implies another class called RobotPart


“mini” Robot Test Class

public class RobotTest {

public static void main(String[] args) {Robot theRobot = new Robot( new RobotEnvironment() );System.out.println(“Status:”+ theRobot.checkStatus());

}}

Define methods that implement behaviors


End of Review


Simple Arrays


Arrays

CollectionsArray basics

Declaration, allocation, and initialization Subscripting

Processing arrays by iteration and recursionReading and writing arrays


CollectionsA collection is a value that contains other

values. Arrays are a kind of collection. We have already seen a kind of collection, strings. These in turn could be used to create another kind of collection, lists (to be discussed later). Both are ordered collections. Strings: collections of characters. Note operation charAt (get nth character, counting from zero).


Arrays

Another kind of ordered collection.Special features:

Built-in to language, has special syntax. Elements are variables, so can be changed as

well as referenced. Collection has fixed size (once created) Access to nth element takes constant time.


Arrays (cont.)

Definition An array is a fixed-size collection of variables, all of the same type.

an arrayof ints 17 4 9 20 47

an arrayof Strings

“Don’t” “forget” “to vote” “tomorrow”


Declaring and allocating arrays

Declaring: Each array has a name. Declare arrays like this:

N.B. As with any other variable declaration, this creates the variable, but puts nothing in it:

int[] grades;String[] message;Time[] clocks;

grades message clocks


Declaring and allocating arrays (cont.)

To create the actual collection of variables, use new:

Array is allocated in a heap and the variable gets reference value to it (just like an object):grades = new int[100];message = new String[4];clocks = new Time[8];

heapallocation


Declaring and allocating arrays (cont.)

As usual, allocation can be done in declaration: int[] grades = new int[100];

Never forget to allocate an array (very common error).

grades message clocks


Initializing arrays

Note that allocating an array initializes the array variable itself, but does not initialize the variables contained in the array.

Variables in the array must be initialized before use, like any other variables.


Initializing arrays (cont.) One method: initialization list.

This allocates the array as a 3-element array and initializes its elements. Any type of array can be initialized with this notation, e.g.

We’ll see a more general method of initialization shortly.

double[] angles = {3.5, 9.7, 15.01};

Time[] clocks = {new Time(3,30), new Time(4,30)};


Subscripting Principal feature of arrays: ability to access each

component easily. Use notation

to access elements of an array. If the integer-expression has value n, this returns the n th elements in array-name, counting from zero.

Note that the expression denotes a variable, so can appear on the left-hand side of assignment statements, as well as in expressions.

array-name[integer-expression]


Subscripting (cont.)

Examples: Suppose we have declarations as above:

Then these statements are legal:

int[] grades = new int[100];String[] message = new String[4];Time[] clocks = new Time[8];

grades[0] = 75;message[0] = “Don’t”;int i = 2;clocks[i-1] = new Time(3,30);


Subscripting (cont.)

But these statements are illegal:// subscripts range from zero to// size of array - 1grades[-1] = 90; // illegalgrades[100] = 75; // illegal// must assign correct type of value// to array elementmessage[0] = grades[0]; // illegal// subscripts are always int’sdouble i = 2;clocks[i-1] = new Time(3,30); // illegal


Subscript out of Range Error

Using a subscript larger than length-1 causes a run time (not a compiler) error an ArrayOutOfBoundsException is

thrownyou do not need to catch it or declare it in a

throws-clauseyou need to fix the problem and recompile

your code


Array initialization (revisited) Assignment to array elements provides a more general method of initializing arrays.

Using assignment in loops also makes it easy to initialize large arrays (examples later).

String[] message = new String[4];message[0] = “Don’t”;message[1] = “forget”;message[2] = “to vote”;message[3] = “tomorrow”;


Finding the length of an array Size of array A is value of instance variable A.length. Useful when an array is passed as an argument to a method:

Note: subscripts range from 0 to A.length-1

void dosomethingtoarray ( double[] Xs ) { . . .} How big is Xs? Can’t tell from

declaration. Use Xs.length.


Summary Array variable must be declared, then it must be

initialized by allocating an array, then the array must be initialized.

The following typical sequences have the same effect:

String[] holidays = {“Labor Day”, “Thanksgiving”, “Christmas”};

declareallocate and initialize


Summary (cont.)

String[] holidays = new String[3];holidays[0] = “Labor Day”;holidays[1] = “Thanksgiving”;holidays[2] = “Christmas”;

declare

allocateinitialize

String[] holidays;holidays = new String[3];holidays[0] = “Labor Day”;holidays[1] = “Thanksgiving”;holidays[2] = “Christmas”;

declare

allocate

initialize


Three Ways to Use [ ] (Brackets)with an Array Name

1. To create a type name, e.g. int[] pressure; creates a name with the type "int array" note that the types int and int array are different it is the type of the name, not the type of the data

2. To create a new array, e.g. pressure = new int[100];

3. To name a specific element in the array- also called an indexed variable, e.g.pressure[3] = SavitchIn.readLineInt();System.out.println("You entered" + pressure[3]);


Some Array Terminology

temperature[n + 2]

temperature[n + 2]

temperature[n + 2]

temperature[n + 2] = 32;

Array name

Index - also called a subscript - must be an int, - or an expression that evaluates to an int

Indexed variable - also called an element or subscripted variable

Note that "element" may refer to either a single indexed variable in the array or the

value of a single indexed variable.

Value of the indexed variable- also called an element of the array


Why arrays? Lists can be “subscripted” using nth method. Plus,

could define a method assign that would allow us to change elements in a list. So why do we need arrays?

Efficiency: access to array elements takes constant time, whereas nth(L,i) takes time proportional to i. The difference in efficiency has a deep effect on the design of algorithms using these data structures.


Simple array processingArrays can be processed using iteration or

recursion.Standard array-processing loop:

Historically, arrays most common kind of collection; iteration most common method of processing them.

for (i=0; i<A.length; i++) { // process array element A[i]}


Simple array processing (cont.)When processing arrays recursively, need to

pass a smaller array in the recursive call. It is inefficient to construct new arrays, so instead we will pass an additional integer (or integers) representing a part of the array.

void processArray (double[] A, int i) { if (i != A.length) { // process A[i], then make recursive call // processArray(A, i+1) }}


Printing arraysPrint an integer array A:Iteration:

Recursion (call: printArray(A,0)):

for (i=0; i<A.length; i++) System.out.println(A[i]);

void printArray (int A[], int i) { if (i != A.length) { System.out.println(A[i]); printArray(A, i+1); }}


Reading arraysRead 10 elements into array A:Iteration:

Recursion (call: printArray(A,0)):

for (i=0; i<10; i++) A[i] = Keyboard.readInt();

void readArray (int A[], int i) { if (i < 10) { A[i] = Keyboard.readInt(); readArray(A, i+1); }}


Reading up to eofDisadvantage of arrays: they cannot grow

once allocated.How can you read all the values into an

array without knowing beforehand how many there are? Make an array large enough to hold as many inputs as you’re likely to get. Suppose A is very large:

int[] A = new int[1000];


Reading up to eof (cont.)Read integers up to eof:Iteration:

i = 0;while (true) { A[i] = Keyboard.readInt(); if (Keyboard.eof()) break; i = i+1;}// i = number of integers read// N.B. i != A.length


Reading up to eof (cont.)

Recursion:

int readArray (int[] A, int i) { A[i] = Keyboard.readInt(); if (Keyboard.eof()) return i; readArray(A, i+1);}

// Call: readArray(A, 0). Return value// is number of integers read.


Another Mystery Resolved!!

public static void main(String[] args) {

for (int i=0; i<args.length; i++)

System.out.println(“input argument “ + i + ”=“ + args[i]);

}

Java MyClass a b c d e f g

Will print out “a b c d e f g” each of which are elements ofthe array String[] args

itm 352 simple arrays lecture #. 2/20/2003itm352 spring 2003 - © portarrays - 2 announcements r...

Documents

r constructors r

2202003itm352 spring

method parameters r

methods r behaviors

actions r

r informal survey r

class slide

class methods