A High Flying Overview CS139 Fall 2006 How far we have come.
-
Upload
branden-edwards -
Category
Documents
-
view
213 -
download
0
description
Transcript of A High Flying Overview CS139 Fall 2006 How far we have come.
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…