Download Jan 26

COMP 14
Introduction to Programming
Mr. Joshua Stough
January 26, 2005
Monday/Wednesday 11:00-12:15
Peabody Hall 218
Announcements
• Program 1 and Homework 1 due today
at 11:59pm
Review
• Identifiers
– can be composed of any combination of letters,
digits, underscore (_), and dollar sign ($)
– cannot begin with a digit
– Java is case-sensitive
• Data Types
– main integer type: int
– main floating-point type: double
– others: char, boolean
Review
• Arithmetic Operators:
addition
subtraction
multiplication
division
remainder (mod)
+
*
/
%
• If one of the operands is floating-point, the result is a
floating-point
• Can only use % with two integer operands
• Casting
– (int) (54.9) - truncates the floating-point number
– (double) (23) - adds a .0 to the integer
Review
• String to int
Integer.parseInt(strExpression)
Integer.parseInt("6723")
6723
• String to float
Float.parseFloat(strExpression)
Float.parseFloat("345.76")
345.76
• String to double
Double.parseDouble(strExpression)
Double.parseDouble("1234.56")
1234.56
Review Questions
1. If you go to Best Buy and the
salesperson tells you that they have a
new 2.1 GHz P4 with 512 MB RAM
and a 40 GB drive, what does this
mean?
2. 3 % 2
3. 4 % 2
4. 5 % 2
1
0
1
CPU: Pentium 4 processor
(made by Intel) running at
2.1 GHz
main memory: 512 MB
secondary storage: 40 GB
Storing Data in Memory
1. Instruct the computer to allocate memory
(declaration)
•
•
how much? based on data type
how to access? name the memory location
2. Include statements in the program to put
data into the allocated memory
•
•
assign a particular value to a particular memory
location
initialization - putting the first (initial) value into
the memory location
Types of Storage
• Named Constant
– once the value is stored in memory, it can't
be changed
• Variable
– the value stored in memory can be
changed (can vary)
Named Constant
static final dataType IDENTIFIER = value;
• Declared by using the reserved word final
• Always initialized when it is declared
• Identifier should be in ALL CAPS, separate
words with underscore (_)
• Example:
– 1 inch is always 2.54 centimeters
final double CM_PER_INCH = 2.54;
Variable
dataType identifier;
• Must be declared before it can be used
• Can be (but doesn't have to be) initialized when
declared
• Identifier should start in lowercase, indicate separate
words with uppercase
• Example:
– number of students in class
int numStudents;
• Multiple variables (of the same data type) can be
declared on a single line
int numStudents, numGrades, total;
Variable
• A variable can be
given an initial value
in the declaration
• When a variable is
referenced in a
program, its current
value is used
int total = 16;
int base = 32, max = 149;
9278
9279
9280
9281
9282
9283
16
total
Naming Variables
• Variables should be descriptively named
• We should be able to tell what type of
information the variable holds by its
name
• Remember Java is case-sensitive!
Assignment
variable = expresssion;
• Assignment Operator (=)
• expression can be a value (3) or a
mathematical expression (2 + 1)
• The expression must evaluate to the
same data type as the variable was
declared
Assignment
• assignment statement
total = 54+1;
– changes the value of a
variable
• Expression on right is
evaluated and result is
stored in variable on the
left
• Value that was in
total is overwritten
9278
9279
9280
9281
9282
9283
55
16
total
Assignment
• The assignment operator has a lower precedence
than the arithmetic operators
First the expression on the right hand
side of the = operator is evaluated
answer
=
4
sum / 4 + MAX * lowest;
2
3
1
Then the result is stored in the
variable on the left hand side
Assignment
• The right and left hand sides of an assignment
statement can contain the same variable
First, one is added to the
original value of count
count
=
count + 1;
Then the result is stored back into count
(overwriting the original value)
Questions
What is stored in the memory location
referred to by the identifier num after each
of the following statements is executed in
order?
int
num
num
num
num
num;
= 3;
= 5 + 4 - 2;
= num * 2;
= 3.4 + 5;
nothing
would give an error since 3.4 + 5 would
not result in an int
3
7
14
14
Questions
1.
Write Java statements to accomplish the following:
Declare int variables x and y int x, y;
2.
Update the value of an int variable x by adding 5
to it
x = x + 5;
3.
Declare and initialize an int variable x to 10 and a
char variable ch to 'B'
int x = 10;
char ch = 'B';
4.
Declare int variables to store four integers
int num1, num2, num3, num4;
The Value of Variables
• We can use variables to save the result of
expressions for use later in our programs.
int sum, count;
double average;
sum = 3 + 4 + 5;
count = 3;
average = (double) sum / count;
Questions
Which of the following are valid Java
assignment statements? Assume that i, x,
and percent have been declared as double
variables and properly initialized.
1.
2.
3.
4.
i = i +
x + 2 =
x = 2.5
percent
5;
x;
* x;
= 10%
valid
invalid
valid
invalid
Reading Keyboard Input
• We can let the user assign values to
variables through keyboard input
• Java input is accomplished using objects
that represent streams of data
• A stream is an ordered sequence of bytes
• The System.in object represents a
standard input stream, which defaults to the
keyboard
Reading Keyboard Input
The input stream is made up of multiple objects:
InputStreamReader charReader = new
InputStreamReader (System.in);
BufferedReader keyboard = new
BufferedReader (charReader);
OR, all on one statement:
BufferedReader keyboard = new
BufferedReader (new InputStreamReader
(System.in));
Reading Keyboard Input
BufferedReader keyboard = new BufferedReader
(new InputStreamReader (System.in));
• The System.in object is used to create an
InputStreamReader object
– creates an input stream
– treats input as single characters
• The InputStreamReader object is used to create a
BufferedReader object
– buffers characters
– input can be read a line at a time (instead of one character per line)
Reading Keyboard Input
• The readLine method of the BufferedReader class
reads an entire line of input as a String
String line = keyboard.readLine();
int num = Integer.parseInt(line);
OR
int num = Integer.parseInt(keyboard.readLine());
String to Numbers
• String to int
Integer.parseInt(strExpression)
Integer.parseInt("6723")
6723
• String to float
Float.parseFloat(strExpression)
Float.parseFloat("345.76")
345.76
• String to double
Double.parseDouble(strExpression)
Double.parseDouble("1234.56")
1234.56
Initializing Variables
•
•
•
Initialize - give a variable some initial value
Must initialize variables before using them
(i.e., before they appear on the right-hand side
of an assignment statement)
Two ways to initialize variables:
1. assignment statement
feet = 35;
2. user input
create BufferedReader object keyboard
ask user for input
feet = Integer.parseInt (keyboard.readLine());
Questions
What is stored in the variables numStudents and
line after the following statements have been
executed? (Assume that keyboard is a
BufferedReader object.)
int numStudents;
String line;
// user asked for # of students
// user enters 140
line = keyboard.readLine();
numStudents = Integer.parseInt(line);
numStudents
nothing
nothing
nothing
140
line
n/a
nothing
"140"
"140"
More Operators
Increment and Decrement
• Increment (++)
– adds 1 to any integer or floating point
count++;
count = count + 1;
• Decrement (--)
– subtracts 1 from any integer or floating
point
count--;
count = count - 1;
Increment and Decrement
• Prefix
(++count or --count)
– value used in a larger expression is the new value
of count (after the increment/decrement)
• Postfix
(count++ or count--)
– value used in a larger expression is the original
value of count (before the increment/decrement)
– increment/decrement is the last operation
performed (even after assignment)
Increment and Decrement
• If count currently contains 45, then the statement
total = count++;
assigns 45 to total and 46 to count
• If count currently contains 45, then the statement
total = ++count;
assigns the value 46 to both total and count
Questions
• What is stored in total and count in the
following statements?
double total = 15.5;
total++;
total
16.5
int total = 10, count = 5;
total = total + count++;
total
15
count
6
int total = 20, count = 3;
total = total / --count;
total
10
count
2
String Concatenation
• A string cannot be split between two lines
String greeting = "How are you doing
today";
X
• Concatenation (+) - produces one string where
the second string has been appended to the
first string
String greeting = “How are you doing” +
“ today?”;
greeting How are you doing today?
String Concatenation
• Operator + can be used to concatenate
two strings or a string and a numeric value
or character
• Precedence rules still apply
• Example:
String str;
int num1 = 12, num2 = 26;
str = "The sum = " + num1 + num2;
str
The sum = 1226
Questions
What is the result of the following String
concatenations?
String str1 = "Hello";
String str2 = "World";
String str3 = str1 + " " + str2;
str3 Hello World
int num1 = 10;
int num2 = 2;
String str = "The difference is " +
(num1 - num2);
str
The difference is 8
Summary
• Constants
final datatype IDENTIFIER = value;
– cannot be changed
• Variables
declaration
datatype identifier;
– can be changed
• Assignment
identifier = expression;
Summary
• Assignment
– overwrites previous value
– can use the variable on both sides of the
expression
• count = count + 1;
• Increment/Decrement
– prefix / postfix
– count++;
– ++count;
Summary
• Reading Keyboard Input
BufferedReader keyboard = new BufferedReader
(new InputStreamReader (System.in));
int num = Integer.parseInt (keyboard.readLine());
• String Concatenation
int courseNum = 14;
String str = "This is COMP " + courseNum;
str
This is COMP 14
Take a Breath….And more
• Output
– printing to the screen
• Parts of a Java Program
• Reading: Ch 2 (pgs. 58-88)
COMP 14
Introduction to Programming
Mr. Joshua Stough
January 26, 2005
Monday/Wednesday 11:00-12:15
Peabody Hall 218
Review
Constants
static final dataType IDENTIFIER = value;
• Declared by using the reserved word final
• Always initialized when it is declared
• Identifier should be in ALL CAPS, separate
words with underscore (_)
• Example:
– 1 inch is always 2.54 centimeters
final double CM_PER_INCH = 2.54;
Review
Variables
dataType identifier;
• Must be declared before it can be used
• Can be (but doesn't have to be) initialized when
declared
• Identifier should start in lowercase, indicate separate
words with uppercase
• Example:
– number of students in class
int numStudents;
• Multiple variables (of the same data type) can be
declared on a single line
int numStudents, numGrades, total;
Review
Assignment
• assignment statement
total = 54+1;
– changes the value of a
variable
• Expression on right is
evaluated and result is
stored in variable on the
left
• Value that was in
total is overwritten
9278
9279
9280
9281
9282
9283
55
16
total
Review
Reading Keyboard Input
BufferedReader keyboard = new BufferedReader (new
InputStreamReader (System.in));
String line = keyboard.readLine();
int num = Integer.parseInt (keyboard.readLine());
double fpNum = Double.parseDouble(keyboard.readLine());
Review
Increment and Decrement
• Prefix
(++count or --count)
– value used in a larger expression is the new value
of count (after the increment/decrement)
• Postfix
(count++ or count--)
– value used in a larger expression is the original
value of count (before the increment/decrement)
– increment/decrement is the last operation
performed (even after assignment)
Review
String Concatenation
• Operator + can be used to concatenate
two strings or a string and a numeric value
or character
• Precedence rules still apply
• Example:
String str;
int num1 = 12, num2 = 26;
str = "The sum = " + num1 + num2;
str
The sum = 1226
Review Questions
• Assume that a and b are int variables.
What is the value of b?
a = 3;
b = 4 + (++a);
8
• Given the following assignments, What is the
value in str?
String str;
The answer is 1017
str = "The answer is ";
str = str + 10 + (13 + 4);
Output
• Standard output device is usually the
monitor
• Access the monitor using the standard
output object
– System.out
• Two methods to output a string:
1.print
2.println
Using System.out
System.out.print (stringExp);
System.out.println (stringExp);
• print vs. println
– after displaying stringExp, println will advance to
the next line, while print does not
• stringExp
– can be any expression where the result is a String,
including string concatenation
– if stringExp results in a primitive data type, it will
automatically be converted to a String and output
Examples
System.out.println ("Hi");
System.out.println ("There");
Hi
There
System.out.print ("Hi");
System.out.println ("There");
HiThere
int num = 5+3;
System.out.println (num);
8
int num = 5;
System.out.println ("The sum is " +
(num + 3));
The sum is 8
Escape Sequences
• Escape character \
• Used to represent special characters inside
Strings
• Escape sequences
– \n - newline
– \t - tab
– \b - backspace
• Note: typo in book -- no space between \ and b
–
–
–
–
\r - return
\\ - backslash
\' - single quote
\" - double quote
Examples
System.out.println ("I said, \"Hi There!\"");
I said, "Hi There!"
System.out.println ("Hi\b\bHello");
Hello
System.out.println ("Hello\rWorld");
World
System.out.println ("Hello\tWorld");
Hello
World
System.out.print ("Hello\n");
System.out.println ("World");
Hello
World
Questions
What is output by the following
statements?
System.out.println ("Helen says " +
"\"What\'s up?\"");
Helen says "What's up?"
System.out.print ("Enter a number ");
System.out.println ("between 1-10");
System.out.print ("\n\tplease!");
Enter a number between 1-10
please!
Terms
• Class - used to group a set of related
operations (methods), allows users to
create their own data types
• Method - set of instructions designed to
accomplish a specific task
• Package - collection of related classes
• Library - collection of packages
Class Libraries
• A collection of classes that we can use
when developing programs
• The Java standard class library is part
of any Java development environment
• The System class and the String
class are part of the Java standard
class library
Packages
• The classes of the Java standard class library
are organized into packages.
• Some of the packages in the standard class
library are:
Package
Purpose
java.lang
java.applet
java.awt
javax.swing
java.net
java.util
javax.xml.parsers
General support
Creating applets for the web
Graphics and graphical user interfaces
Additional graphics capabilities and components
Network communication
Utilities
XML document processing
Using Packages
We need to import some of the packages we
want to use
– java.io for BufferedReader
– not java.lang because it's automatically
imported for us
import packageName;
– import java.io.*;
• imports all of the classes in the java.io package
– import java.io.BufferedReader;
• imports only the BufferedReader class from the
java.io package
Using Predefined Classes
and Methods
• To use a method you must know:
– Name of class containing method (Math)
– Name of package containing class
(java.lang)
– Name of method (round), its parameters
(double a), what it returns (long), and
function (rounds a to the nearest integer)
• See Appendix E for more Java
predefined classes
Using Predefined Classes
and Methods
• Example method call:
int num = (int) Math.round (4.6);
– why don't we have to import the Math
class?
• (Dot) . Operator: used to access the
method in the class
Creating a Java Program
• Java application program - collection of one
or more classes
– every application must have at least one class
• Class
– basic unit of a Java program
– collection of methods and data members
• Method - set of instructions designed to
accomplish a specific task
– print, readLine
Programming in Java
• Java programming language
– object-oriented approach to problem solving
• In the Java programming language:
– a program is made up of one or more classes
– a class contains one or more methods
– a method contains program statements
• A Java application always contains a method
called main
Creating a Java Program
• All Java application programs must have a
method called main
– there can be only one main method in any Java
application program
• For most of the semester, our programs will
have only one class
• Name of source file must be
ClassNameWithMain.java
Anatomy of a Java Program
• Syntax of class
public class ClassName
{
classMembers
}
• Syntax of main method
public static void main (String[] args) throws clause
{
statement1
...
statementn
}
Throws Clause
• throws clause - exceptions thrown by the
main method
• exception - occurrence of an undesirable
situation that can be detected during program
execution
– can either be handled or thrown
• readLine throws the exception
IOException
• We won't handle the exception, we'll just
throw it
Throws
• If we're allowing user input to the
program, the heading of the main
method should look like:
public static void main (String[] args) throws IOException
Import Statements
• Tell the compiler which packages are used in
the program
• Import statements and program statements
constitute the source code
• Source code saved in a file with the extension
.java
• Source code file must have the same name
as the class with the main method
The main method
• Heading
public static void main (String[] args) throws IOException
• Body
– statements enclosed by { }
– declaration statements
• used to declare things such as variables
– executable statements
• perform calculations, manipulate data, create output,
accept input, etc.
Skeleton
import statements if any
public class ClassName
{
declare named constants and/or stream objects
public static void main (String[] args)
throws IOException
{
variable declarations
executable statements
}
}
static
• Heading of the main method has the
reserved word static
• Statements to declare named constants
and input stream objects are outside the
main method
• These must also be declared with the
static reserved word
Style
• Syntax
– beware! a syntax error in one place might lead to
syntax errors in several other places
• Use of semicolons, braces, commas
– all Java statements end with semicolon
– braces {} enclose the body of a method and set it
off from other parts of the program (also have
other uses)
– commas separate list items
Style
• Semantics
– set of rules that gives meaning to a language
– beware! the compiler will not be able to tell you
about semantic errors (example: missing
parentheses in mathematical expression)
• Documentation
– comments - shown in green in the textbook
– naming rules
• use meaningful identifiers
– prompt lines
• let the user know what type of input is expected
Style and White Space
• White space
–
–
–
–
blanks, tabs, blank lines
used to separate words and symbols
extra space is ignored by computer
blank line between variable declaration and rest of
code
• Programs should be formatted to enhance
readability, using consistent indentation
Comments
• Not used by the computer
– only for human consumption
• Used to help others understand code
– explain and show steps in algorithm
– comments are essential!
• Should be well-written and clear
• Comment while coding
• Also called inline documentation
Java Comments
// this is a one-line comment
– “comments out” the rest of the line after
marker //
/* this is a multi-line
comment */
– “comments out” everything between
markers /* and */
Block-Like Multi-Line
Comment
• Pledge
Start
/***************************************************************
* Program Insert assignment number: Insert assignment name
*
* Programmer: Insert your name
*
* Due Date: Insert due date
*
* Class: COMP 14
Instructor: Dr. Michele Weigle
* Recitation Section: Insert section
*
* Pledge: I have neither given nor received unauthorized aid
* on this program.
(signature on file)
**************************************************************/
End
/****************************************************************
* Program 0: Hello World
*
* Programmer: Michele Weigle
*
* Due Date: January 14, 2004
*
* Class: COMP 14
Instructor: Dr. Michele Weigle
* Recitation Section: 600
*
* Pledge: I have neither given nor received unauthorized aid
* on this program.
(signature on file)
*
* Description: This program prints out a greeting to the world.
*
* Input: None
* comment
* Output: A friendly greeting
***************************************************************/
public class HelloWorld
{
public static void main(String[] args)
{
System.out.println ("Hello World!");
}
method
main method
}
class declaration
call
Summary
• Output
System.out.print (stringExp);
System.out.println (stringExp);
– print vs. println
• Comments
// this is a one-line comment
– “comments out” the rest of the line after //
/* this is a multi-line
comment */
– “comments out” everything between /* and */
Summary - MyProgram.java
/****************************************************************
* My Program - Header and Pledge
***************************************************************/
import java.io.*;
public class MyProgram
{
static BufferedReader keyboard = new BufferedReader (new
InputStreamReader (System.in));
public static void main(String[] args) throws IOException
{
int num;
// ask the user for a number
System.out.print ("Enter a number between 1-100: ");
num = Integer.parseInt (keyboard.readLine());
// output the user's number
System.out.println ("You entered " + num);
}
}
Next Time in COMP 14
• Objects
• Methods
• The String class
• Reading: Ch 3 (pgs. 97-112)