CS139 – Fall 2010 How far we have come A High Flying Overview CS139 – Fall 2010 How far we have come

We started with the notion of an algorithm A step by step process for solving a problem in a finite amount of time given a finite amount of data.

Good algorithms Require thought – and reading all of the words And are: Simple Precise Correct Complete Have levels of abstraction

Algorithm structures Sequencing Decisions Loops Abstraction (separate procedures) Abstraction (separate classes)

We learned about our lab environment mount-n Novell – n-drive submit Lab 248 Lab 250 stu – Linux?

We made containers And learned that there were different kinds that hold different data Constant numbers Strings (why is this capital?) variable letters simple (value) literal complex (several values)

And performed operations on them addition division subtraction assignment multiplication

And then we were ready to build our first program public class Hello { public static void main(String args[]) System.out.println(“Hello World”); }

But that was just the start Containers became variables, literals, and constants Operations became expressions Our programs began to really do something. Remember me? PA1 (Change Maker)

Of course that is when we also learned 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 Scanner // consume the new line More runtime errors And output System.out.print( “ blah “ + “blah”); and printf (%s, %f, %d, %c)

Then came abstraction We learned that we can break code up and refer to a segment of code by a single name. getAverage(5, 7, 9) 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.

Passing 5 to the displayValue Method 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 we played with Physics

We also began to explore object oriented 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() constructor keyboard = Scanner (System.in) new instantiation

and we learned lots of new terms formal parameter return type argument visibility modifyer static return statement qualified name

Then we added decisions else if(boolean expression) &&, ||, == { } switch & case break; MadLibs.java:56: 'else' without 'if’ and new error messages

And of course, PA3

On to the last of our “procedural” structures But of course not least…bring on the loops. 4 while pre for do/while infinite loop loop control variable off by one error post

We saw Stars! * *** ***** ******* ********* ********** ********

And yet another PA

Then we learned to make objects class – blueprint object – specific house

and more terms members attribute method visibility modifiers again this static instantiation constructor overloading mutator accessor immutable mutable

We learned to hand trace methods 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 scope inside {} local - inside method { } global – inside class { } visibility is controlled by where the declaration is made. Careful for (….);

And even further “scope” static – belongs to the class non-static – belongs to individual objects of the class static = 1 container named by the class non-static = 1 container per object

And what can we see between classes Private Public

And another PA

and finally arrays subscripted variable reference type arr1[3] One name, many items Collections loops – for each loop index

and the last pa

Think about how far we have come And how much you have learned. What was hard is now easy. What is now hard will continue to become easy.

Next semester in no particular order Objects, more and more Inheritance Input and output Exceptions Enumerated Types Abstract Classes Interfaces Polymorphism Recursion and much much more…

Tomorrow’s exam Will be much like a normal exam but the focus is on objects and arrays. Should be about the same length as other midterms Will include no big coding (but will likely include “small” coding).