Download presentation
Presentation is loading. Please wait.
1
CS139 – Fall 2010 How far we have come
A High Flying Overview CS139 – Fall 2010 How far we have come
2
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.
3
Good algorithms Require thought – and reading all of the words
And are: Simple Precise Correct Complete Have levels of abstraction
4
Algorithm structures Sequencing Decisions Loops
Abstraction (separate procedures) Abstraction (separate classes)
5
We learned about our lab environment
mount-n Novell – n-drive submit Lab 248 Lab 250 stu – Linux?
6
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)
7
And performed operations on them
addition division subtraction assignment multiplication
8
And then we were ready to build our first program
public class Hello { public static void main(String args[]) System.out.println(“Hello World”); }
9
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)
10
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
11
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)
12
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.
13
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
14
And we played with Physics
15
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
16
variable = new ObjectName()
constructor keyboard = Scanner (System.in) new instantiation
17
and we learned lots of new terms
formal parameter return type argument visibility modifyer static return statement qualified name
18
Then we added decisions
else if(boolean expression) &&, ||, == { } switch & case break; MadLibs.java:56: 'else' without 'if’ and new error messages
19
And of course, PA3
20
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
21
We saw Stars! * *** ***** ******* ********* ********** ********
22
And yet another PA
23
Then we learned to make objects
class – blueprint object – specific house
24
and more terms members attribute method visibility modifiers again
this static instantiation constructor overloading mutator accessor immutable mutable
25
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….
26
block scope inside {} local - inside method { }
global – inside class { } visibility is controlled by where the declaration is made. Careful for (….);
27
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
28
And what can we see between classes
Private Public
29
And another PA
30
and finally arrays subscripted variable reference type arr1[3]
One name, many items Collections loops – for each loop index
![and finally arrays subscripted variable reference type arr1[3]](http://slideplayer.com./slide/14449953/90/images/30/and+finally+arrays+subscripted+variable+reference+type+arr1%5B3%5D.jpg "One name, many items. Collections. loops – for each loop. index.")
31
and the last pa
32
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.
33
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…
34
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).
Similar presentations
![Hello.java Program Output 1 public class Hello { 2 public static void main( String [] args ) 3 { 4 System.out.println( “Hello! ); 5 } // end method main.](/25/7902006/big_thumb.jpg "Hello.java Program Output 1 public class Hello { 2 public static void main( String [] args ) 3 { 4 System.out.println( “Hello! ); 5 } // end method main.>")
