A High Flying OverviewA High Flying Overview

CS139 – Fall 2006 CS139 – Fall 2006 How far we have comeHow far we have come

We started with the notion of an We started with the notion of an algorithmalgorithm

AlgorithmAlgorithm

• A step by step process for solving a problem in a finite amount of time given a finite amount of data.

Good algorithmsGood algorithms• Require thought – and reading all of the words• And are:

– Simple– Precise– Correct– Complete– Have levels of abstraction

Algorithm structuresAlgorithm structures

• Sequencing• Decisions• Loops• Abstraction (separate procedures)

We learned about our lab We learned about our lab environmentenvironment

stu – Linux?

Lab 250

Lab 248

Novell – n-drivem-drive???

mount-n

submit

We made containersWe made containers

And learned that there were different kinds that held different data

numbers

letters

Strings (why is thiscapital?)

simple (value)

complex (several values)

Variable

Constant

literal

And performed operations on themAnd performed operations on them

addition

assignment

subtraction

multiplication

And then we were ready to build And then we were ready to build our first programour first program

public class Hello{

public static void main(String args[]) {

System.out.println(“Hello World”);}

} But what does it mean???

But that was just the startBut that was just the start

• Containers became variable, literals, and constants

• Operations became expressions• Our programs began to really do

something.• Remember me? TripCalculator.java

Of course that is when we also Of course that is when we also learned aboutlearned about

• documentation• and the dreaded submit• and of course we had to relearn division• 3 / 6 is not .5• 3 % 6 is not something to do with percentages.• compile time errors• run time errors• logic errors

We got to know and love ScannerWe got to know and love Scanner

• and output• and printf (%s, %f, %d, %c)

Then we added decisionsThen we added decisionsif(boolean expression) else

{ }

JMmooDairyBar.java:56: 'else' without 'if'

switch & case

break;

&&, ||, ==

and new error messagesand new error messages

And yes, the JMooDairy Bar

Then came abstractionThen came abstraction

• We learned that we can break code up and refer to a segment of code by a single name.

• Functions provided a way to reuse code; write once use any number of times.

• We also learned that we can create an application with multiple classes.

• Qualified names let us link all of these pieces together.

We also began to explore object We also began to explore object oriented programmingoriented programming

• We began to use “classes” in a more purposeful way.

• We began to look at the “services” provided by java classes.– Scanner– System.out– Random– Math

variable = new ObjectName()variable = new ObjectName()

Scanner(System.in)keyboard =

constructor

instantiation

new

Passing 5 to the Passing 5 to the displayValuedisplayValue MethodMethod

displayValue(5);

public static void displayValue(int num){

System.out.println(“The value is “ + num);

}

The argument 5 is copied into the parameter variable num.

The method will display The value is 5

And of courseAnd of course

• we had a PA to go along with functions

• Conversions.java

and we learned lots of new and we learned lots of new termsterms

parameterargument

visibility modifyer

static

qualified namereturn statement

return type

On to the last of our On to the last of our “procedural” structures“procedural” structures

• But of course not least…bring on the loops.

infinite loop

loop control variableoff by one error

4

pre

post

for

do/while

while

And yet another PAAnd yet another PA

and Starsand Stars

****

************

*************************

**********************************************

* ** *** **** ***** ****** ******* ******** *******************

ObjectsObjects

• class – blueprint• object – specific house

and more termsand more terms

• members• attribute• method• visibility modifiers

again• this• static

• instantiation• constructor• overloading• mutator• accessor• immutable• mutable

We learned to hand trace We learned to hand trace methods and objectsmethods and objects

• Back to containers on a desk.• Each container holds its current value.• We must change the value as it changes

during program execution• Each container must be identified with its

scope.• And about scope….

block scopeblock scope

• inside {}• local - inside method { }• global – inside class { }

• visibility is controlled by the scope of declaration

And even further “scope”And even further “scope”

• static – belongs to the class• non-static – belongs to individual objects

of the class

• static = 1 container• non-static = 1 container per object

And another paAnd another pa

and finally arraysand finally arrays

• subscripted variable• reference type• arr1[3]• elements are individual elements of array

type.• loops – for each loop• index

and the last paand the last pa

Think about how far we have Think about how far we have comecome

• And how much you have learned.• What was hard is now easy.• What is now hard will continue to be easy.

• Preview of 239

Next SemesterNext Semester

• Objects and objects• Inheritance• Input and output• Exceptions• Enumerated Types• Polymorphism• Abstract Classes• Interfaces• Recursion• and much much more…