USA: +1(669)289-8683 
Sign in
Hey,
I was looking for you but you didn’t show up…
Anyway I edited the last homework and I uploaded the new one so u can work on it.
what you need to do is put the answer here then ask for buying the answer.
it’d be like the last one 5$, and there are couple more my friend we can work on. even in other subjects.
See you here soon.
Chapter 4 – Control Statements
Conditions
if Statement
&& Logical Operator
|| Logical Operator
! Logical Operator
switch Statement
while Loop
do Loop
for Loop
Loop Comparison
Nested Loops
Boolean Variables
Input Validation
Boolean Logic
Expression Evaluation Practice
1
1
*
Conditions
Throughout this chapter, you’ll see if statements and loop statements where conditions appear within a pair of parentheses, like this:
if (
{
…
}
while (
{
…
}
Typically, each condition involves some type of comparison, and the comparisons use comparison operators….
2
2
*
Conditions
Here are Java’s comparison operators:
==, !=, <, >, <=, >=
Each comparison operator evaluates to either true or false.
==
Tests two operands for equality.
3 == 3 evaluates to true
3 == 4 evaluates to false
Note that == uses two equal signs, not one!
!=
Tests two operands for inequality.
The != operator is pronounced “not equal.”
The <, >, <=, and >= operators work as expected.
3
3
*
if Statement
Use an if statement if you need to ask a question in order to determine what to do next.
There are three forms for an if statement:
if by itself
Use for problems where you want to do something or nothing.
if, else
Use for problems where you want to do one thing or another thing.
if, else if
Use for problems where you want to do one thing out of three or more choices.
4
4
*
if Statement
pseudocode syntax
if by itself:
if
if, else:
if
else
Java syntax
if by itself:
if (
{
}
if, else:
if (
{
}
else
{
}
5
5
*
if Statement
pseudocode syntax
if, else if , else:
if
else if
.
.
.
else
Java syntax
if, else if, else:
if (
{
}
else if (
{
}
.
.
.
else
{
}
optional
more else if’s here (optional)
optional
more else if’s here (optional)
6
6
*
if Statement
Write a complete program that prompts the user to enter a sentence and then prints an error message if the last character is not a period.
sample session:
Enter a sentence:
Permanent good can never be the outcome of violence
Invalid entry – your sentence needs a period!
Italics indicates input. Never hardcode (include) input as part of your source code!!!
7
7
*
&& Logical Operator
Suppose you want to print “OK” if the temperature is between 50 and 90 degrees and print “not OK” otherwise.
Here’s the pseudocode solution:
if temp 50 and 90
print “OK”
else
print “not OK”
10
10
*
&& Logical Operator
And here’s the solution using Java:
if (temp >= 50 && temp <= 90)
{
System.out.println("OK");
}
else
{
System.out.println("not OK");
}
In Java, if two criteria are required for a condition to be satisfied (e.g., temp >= 50 and temp <= 90), then separate the two criteria with the && (and) operator. If both criteria use the same variable (e.g., temp), you must include the variable on both sides of the &&.
11
11
*
&& Logical Operator
The program on the next slide determines whether fans at a basketball game win free french fries. If the home team wins and scores at least 100 points, then the program prints this message:
Fans: Redeem your ticket stub for a free order of french fries at Yummy Burgers.
On the next slide, replace
12
12
*
&& Logical Operator
/***************************************
* FreeFries.java
* Dean & Dean
*
* This program reads points scored by the home team
* and the opposing team and determines whether the
* fans win free french fries.
***************************************/
import java.util.Scanner;
public class FreeFries
{
public static void main(String[] args)
{
Scanner stdIn = new Scanner(System.in);
int homePts; // points scored by home team
int opponentPts; // points scored by opponents
System.out.print(“Home team points scored: “);
homePts = stdIn.nextInt();
System.out.print(“Opposing team points scored: “);
opponentPts = stdIn.nextInt();
} // end main
} // end class FreeFries
13
13
*
|| Logical Operator
Provide code that prints “bye” if a response variable contains a lowercase or uppercase q (for quit). Here’s a pseudocode implementation:
if response equals “q” or “Q”
print “Bye”
To implement “or” logic in Java, use || (the or operator). Here’s the Java implementation:
if (response.equals(″q″) || response.equals(″Q″))
{
System.out.println(“bye”);
}
When using the || operator, if both criteria in the or condition use the same variable (e.g., response), you must include the variable on both sides of the ||.
14
14
*
|| Logical Operator
It’s a common bug to forget to repeat a variable that’s part of an || (or &&) condition. This code generates a compilation error:
if (response.equals(″q″ || ″Q″))
{
System.out.println(“bye”);
}
Another common bug is to use the == operator to compare strings for equality. This code compiles successfully, but it doesn’t work properly:
if (response == ″q″ || response == ″Q″)
{
System.out.println(“bye”);
}
15
15
*
|| Logical Operator
As an alternative to using the || operator with two equals method calls, you could use an equalsIgnoreCase method call like this:
if (response.equalsIgnoreCase(“q”))
{
System.out.println(“Bye”);
}
16
16
*
! Logical Operator
The ! (not) operator reverses the truth or falsity of a condition.
For example, suppose that a char variable named reply holds a q (lowercase or uppercase) if the user wants to quit, or some other character if the user wants to continue. To check for “some other character” (i.e., not a q or Q), use the ! operator like this:
if (!(reply == ‘q’ || reply == ‘Q’))
{
System.out.println(“Let’s get started….”);
…
17
17
*
switch Statement
When to use a switch statement:
If you need to do one thing from a list of multiple possibilities.
Note that the switch statement can always be replaced by an if, else if, else statement, but the switch statement is considered to be more elegant. (Elegant code is easy to understand, easy to update, robust, reasonably compact, and efficient.)
Syntax:
switch (
{
case
break;
case
break;
…
default:
} // end switch
18
18
*
switch Statement
How the switch statement works:
Jump to the case constant that matches the controlling expression’s value (or jump to the default label if there are no matches) and execute all subsequent statements until reaching a break.
The break statement causes a jump out of the switch statement (below the “}”).
Usually, break statements are placed at the end of every case block. However, that’s not a requirement and they’re sometimes omitted for good reasons.
Put a : after each case constant.
Even though statements following the case constants are indented, { }’s are not necessary.
The controlling expression should evaluate to either an int, a char, or a String.
Proper style dictates including // end switch after the switch statement’s closing brace.
19
19
*
switch Statement
Given this code fragment:
i = stdIn.nextInt();
switch (i)
{
case 1:
System.out.print(“A”);
break;
case 2:
System.out.print(“B”);
case 3: case 4:
System.out.print(“C-D”);
break;
default:
System.out.print(“E-Z”);
} // end switch
If input = 1, what’s the output?
If input = 2, what’s the output?
If input = 3, what’s the output?
If input = 4, what’s the output?
If input = 5, what’s the output?
20
20
*
switch Statement
Write a program that reads in a ZIP Code and uses the first digit to print the associated geographic area:
if zip code print this
begins with message
0-3
4-6
7
8-9
other
Note:
21
21
*
while Loop
pseudocode syntax
while
{
}
Java syntax
while (
{
}
Use a loop statement if you need to do the same thing repeatedly.
23
23
*
*
while Loop
Write a main method that finds the sum of user-entered integers where -99999 is a sentinel value.
public static void main(String[] args)
{
Scanner stdIn = new Scanner(System.in);
int sum = 0; // sum of user-entered values
int x; // a user-entered value
System.out.print(“Enter an integer (-99999 to quit): “);
x = stdIn.nextInt();
while (x != -99999)
{
sum = sum + x;
System.out.print(“Enter an integer (-99999 to quit): “);
x = stdIn.nextInt();
}
System.out.println(“The sum is ” + sum);
} // end main
24
24
*
do Loop
When to use a do loop:
If you know that the repeated thing will always have to be done at least one time.
Syntax:
do
{
} while (
Note:
The condition is at the bottom of the loop (in contrast to the while loop, where the condition is at the top of the loop).
The compiler requires putting a “;” at the very end, after the do loop’s condition.
Proper style dictates putting the “while” part on the same line as the “}”
25
25
*
do Loop
Problem description:
As part of an architectural design program, write a main method that prompts the user to enter length and width dimensions for each room in a proposed house so that total floor space can be calculated for the entire house.
After each length/width entry, ask the user if there are any more rooms.
Print the total floor space.
26
26
*
for Loop
When to use a for loop:
If you know the exact number of loop iterations before the loop begins.
For example, use a for loop to:
Print this countdown from 10:
10 9 8 7 6 5 4 3 2 1 Liftoff!
Find the factorial of a user-entered number.
Sample session:
Enter a whole number: 4
4! = 24
28
28
*
for Loop
for loop syntax
for (
{
}
for loop example
for (int i=10; i>0; i–)
{
System.out.print(i + ” “);
}
System.out.println(“Liftoff!”);
for loop semantics:
Before the start of the first loop iteration, execute the initialization component.
At the start of each loop iteration, evaluate the condition component:
If the condition is true, execute the body of the loop.
If the condition is false, terminate the loop (jump to the statement below the loop’s closing brace).
At the end of each loop iteration, execute the update component and then jump to the top of the loop.
29
29
*
for Loop
Trace this code fragment with an input value of 3.
Scanner stdIn = new Scanner(System.in);
int number; // user entered number
double factorial = 1.0; // factorial of user entry
System.out.print(“Enter a whole number: “);
number = stdIn.nextInt();
for (int i=2; i<=number; i++)
{
factorial *= i;
}
System.out.println(number + "! = " + factorial);
for loop index variables are often, but not always, named i for “index.”
Declare for loop index variables within the for loop heading.
30
30
*
for Loop
Write a main method that prints the squares for each odd number between 1 and 99.
Output:
1
9
25
49
81
...
31
31
*
Loop Comparison
for loop:
do loop:
while loop:
When to use
If you know, prior to the start of loop, how many times you want to repeat the loop.
If you always need to do the repeated thing at least one time.
If you can't use a for loop or a do loop.
Template
for (int i=0; i
}
do
{
{
32
32
*
Nested Loops
A nested loop is a loop within a loop.
Example – Write a program that prints a rectangle of characters where the user specifies the rectangle’s height, the rectangle’s width, and the character’s value.
Sample session:
Enter height: 4
Enter width: 3
Enter character: <
<<<
<<<
<<<
<<<
34
34
*
Boolean Variables
Programs often need to keep track of the state of some condition.
For example, if you're writing a program that simulates the operations of a garage door opener, you'll need to keep track of the state of the garage door's direction - is the direction up or down? You need to keep track of the direction "state" because the direction determines what happens when the garage door opener's button is pressed. If the direction state is up, then pressing the garage door button causes the direction to switch to down. If the direction state is down, then pressing the garage door button causes the direction to switch to up.
To implement the state of some condition, use a boolean variable.
38
38
*
Boolean Variables
A boolean variable is a variable that:
Is declared to be of type boolean.
Holds the value true or the value false.
Boolean variables are good at keeping track of the state of some condition when the state has one of two values. For example:
39
Values for the state of a garage door opener's direction Associated values for a boolean variable named upDirection
up true
down false
39
*
Boolean Variables
This code fragment initializes an upDirection variable to true and shows how to toggle its value within a loop.
boolean upDirection = true;
do
{
...
upDirection = !upDirection;
...
} while (
If upDirection holds the value true, this statement changes it to false, and vice versa.
40
40
*
Boolean Variables
import java.util.Scanner;
public class GarageDoor
{
public static void main(String[] args)
{
Scanner stdIn = new Scanner(System.in);
String entry; // user’s entry – enter key or q
boolean upDirection = true; // Is the current direction up?
boolean inMotion = false; // Is garage door currently moving?
System.out.println(“GARAGE DOOR OPENER SIMULATOR\n”);
do
{
System.out.print(“Press Enter, or enter ‘q’ to quit: “);
entry = stdIn.nextLine();
if (entry.equals(“”)) // pressing Enter generates “”
{
inMotion = !inMotion; // button toggles motion state
41
41
*
Boolean Variables
if (inMotion)
{
if (upDirection)
{
System.out.println(“moving up”);
}
else
{
System.out.println(“moving down”);
}
}
else
{
System.out.println(“stopped”);
upDirection = !upDirection; // direction reverses at stop
}
} // end if entry = “”
} while (entry.equals(“”));
} // end main
} // end GarageDoor class
42
42
*
Input Validation
boolean variables are often used for input validation.
Input validation is when a program checks a user’s input to make sure it’s valid (i.e., correct and reasonable). If it’s valid, the program continues. If it’s invalid, the program enters a loop that warns the user about the erroneous input and then prompts the user to re-enter.
In the GarageDoor program, note how the program checks for an empty string (which indicates the user wants to continue), but it doesn’t check for a q.
43
43
*
Input Validation
To add input validation to the GarageDoor program, replace the GarageDoor program’s prompt with the following code. It forces the user to press Enter or enter a q or Q.
validEntry = false;
do
{
System.out.print(“Press Enter, or enter ‘q’ to quit: “);
entry = stdIn.nextLine();
if (entry.equals(“”) || entry.equalsIgnoreCase(“q”))
{
validEntry = true;
}
else
{
System.out.println(“Invalid entry.”);
}
} while (validEntry == false);
What is a more elegant implementation for this?
44
44
*
Boolean Logic
Boolean logic (= Boolean algebra) is the formal logic that determines how conditions are evaluated.
The building blocks for Boolean logic are things that you’ve already seen – the logical operators &&, ||, and !.
Logical operator review:
For the && operator, both sides need to be true for the whole thing to be true.
For the || operator, only one side needs to be true for the whole thing to be true.
The ! operator reverses the truth or falsity of something.
45
45
*
Expression Evaluation Practice
Assume:
boolean ok = false;
double x = 6.5, y = 10.0;
Evaluate these expressions:
(x != 6.5) || !ok
true && 12.0 < x + y
46
46
*
not OKOKnot OK
50
o
90
o
Chapter 5 - Using Pre-Built Methods
The API Library
API Headings
Math Class
Wrapper Classes for Primitive Types
Lottery Example
String Methods:
substring
indexOf
lastIndexOf
Formatted Output with the printf Method
1
1
*
The API Library
When working on a programming problem, you should normally check to see if there are pre-built classes that meet your program's needs.
If there are such pre-built classes, then use those classes (don't "reinvent the wheel"). For example:
User input is a rather complicated task. The Scanner class handles user input. Whenever you need user input in a program, use the Scanner class's input methods (rather than writing and using your own input methods).
Math calculations are sometimes rather complicated. The Math class handles math calculations. Whenever you need to perform non-trivial math calculations in a program, use the Math class's methods (rather than writing and using your own math methods).
2
2
*
The API Library
Java's pre-built classes are stored in its class library, which is more commonly known as the Application Programming Interface (API) library. See http://docs.oracle.com/javase/7/docs/api/.
Java's API classes are not part of the core Java language. For a program to use an API class, the class first needs to be loaded/imported into the program. For example, to use the Scanner class, include this at the top of your program:
import java.util.Scanner;
The java.util thing that precedes Scanner is called a package.
A package is a group of classes.
The java.util package contains quite a few general-purpose utility classes. The only one you'll need for now is the Scanner class.
3
3
*
The API Library
Some classes are considered to be so important that the Java compiler automatically imports them for you. The automatically imported classes are in the java.lang package.
The Math class is one of those classes, so there's no need for you to import the Math class if you want to perform math operations.
The Java compiler automatically inserts this statement at the top of every Java program:
import java.lang.*;
The asterisk is a wild card and it means that all classes in the java.lang package are imported, not just the Math class.
4
4
*
API Headings
To use an API class, you don't need to know the internals of the class; you just need to know how to "interface" with it.
To interface with a class, you need to know how to use the methods within the class. For example, to perform input, you need to know how to use the Scanner class's methods - next, nextLine, nextInt, nextDouble, etc.
To use a method, you need to know what type of argument(s) to pass to it and what type of value it returns.
The standard way to show that information is to show the method's source code heading.
5
5
*
API Headings
For example, here's the source code heading for the Scanner class's nextInt method:
public int nextInt()
And here's an example of calling the nextInt method:
int days = stdIn.nextInt();
All the methods in the API library are public, which means that they are accessible from everywhere; i.e., the "public" can access them.
The return type (int in this example) indicates the type of the value that's being returned from the method.
The arguments that you pass to the method would go inside the parentheses (but no arguments are passed to the nextInt method).
6
6
*
Math Class
Source code headings for API methods are commonly referred to as API headings.
Here are the API headings for some of the more popular methods in the Math class:
public static int abs(int num)
Returns the absolute value of num.
public static double abs(double num)
Returns the absolute value of num.
public static int max(int x, int y)
Returns the larger value of x and y.
public static double max(double x, double y)
Returns the larger value of x and y.
7
7
*
Math Class
Math class API headings (continued):
public static int min(int x, int y)
Returns the smaller value of x and y.
public static double min(double x, double y)
Returns the smaller value of x and y.
public static double pow(double num, double power)
Returns num raised to the specified power.
public static double random()
Returns a uniformly distributed value between 0.0 and 1.0, but not including 1.0.
public static long round(double num)
Returns the whole number that is closest to num.
public static double sqrt(double num)
Returns the square root of num.
8
8
*
Math Class
Note the static modifier at the left of all the Math methods. All the methods in the Math class are static methods (also called class methods), which means they are called by prefacing the method's name with the name of the class in which they are defined. For example:
int position1 = 15, position2 = 18;
int distanceApart = Math.abs(position1 - position2);
Write a Java statement that updates x's value so x gets the absolute value of its original value.
Call Math methods by prefacing them with Math dot.
9
9
*
Math Class
It is legal to pass an integer value to a method that accepts a floating-point argument. Note the following example. Horton’s Law says that the length of a river is related to the area drained by the river in accordance with this formula:
length ≈ 1.4 (area)0.6
Here's how to implement Horton's Law in Java code:
int area = 10000; // square miles drained
double riverLength = 1.4 * Math.pow(area, 0.6);
A common use of computers is to model real-world activities that rely on random events.
That's because computers are good at generating random numbers and being able to repeat the random events many, many times.
OK to pass an int (area), into pow, which accepts double arguments.
10
10
*
Math Class
The Math class contains a named constant, PI.
Pi, written as in math books, is the ratio of a circle's perimeter to its diameter.
It contains this double value: 3.14159265358979323846
It's a constant, which means its value is fixed. If you attempt to assign a value to it, you'll get a compilation error.
Just like Math's methods are class methods and they are accessed using the Math class name, Math's PI is a class variable and it is accessed using the Math class name. In other words, if you need pi, specify Math.PI.
Complete this code fragment:
double radius = 3.0;
double volumeOfSphere =
11
11
*
Wrapper Classes For Primitive Types
A wrapper class is a class that surrounds a relatively simple item in order to add functionality to the simple item.
Here are wrapper classes for some of the Java primitive types:
Wrapper Class Primitive Type
Integer int
Long long
Float float
Double double
Character char
Note that the wrapper class names are the same as the primitive names except for the uppercase first letter. What are the exceptions to that rule?
The wrapper classes are defined in the java.lang package. The Java compiler automatically imports all the classes in the java.lang package, so there's no need to import the wrapper classes explicitly.
12
12
*
Wrapper Classes For Primitive Types
Most real-world Java programs use GUI I/O instead of text-based I/O. (GUI = graphical user interface. I/O = input/output.)
What is text-based I/O?
What is GUI I/O?
With GUI programs, all numeric output is string based. So to display a number, you need to convert the number to a string prior to calling the GUI display method. All numeric input is string based, too. So to read a number in a GUI program, you first read the input as a string and then convert the string to a number.
Here are string conversion methods provided by the numeric wrapper classes:
Wrapper Class string number number string
Integer Integer.parseInt(
Long Long.parseLong(
Float Float.parseFloat(
Double Double.parseDouble(
13
13
*
Wrapper Classes For Primitive Types
Conversion examples – strings to numbers:
String yearStr = “2011”;
String scoreStr = “78.5”;
int year = Integer.parseInt(yearStr);
double score = Double.parseDouble(scoreStr);
Remember – to convert a string to a numeric type, use X.parseX where X is the numeric type you’re interested in.
Conversion examples – numbers to strings :
int year = 2011;
double score = 78.5;
String yearStr = Integer.toString(year);
String scoreStr = Double.toString(score);
14
14
*
Wrapper Classes For Primitive Types
To find the largest and smallest possible values for a particular type, use the type’s wrapper class and access the wrapper class’s MAX_VALUE and MIN_VALUE named constants. For example:
Integer.MAX_VALUE
Double.MAX_VALUE
Long.MIN_VALUE
Write a lottery program that prompts the user to guess a randomly generated number between 0 and the maximum int value. The user pays $1.00 for each guess and wins $1,000,000 if the guess is correct. The user enters a “q” to quit.
15
15
*
Lottery Example
import java.util.Scanner;
public class Lottery
{
public static void main(String[] args)
{
Scanner stdIn = new Scanner(System.in);
String input;
int winningNumber =
System.out.println(“Want to win a million dollars?”);
System.out.println(“If so, guess the winning number (a” +
” number between 1 and ” + Integer.MAX_VALUE + “).”);
do
{
System.out.print(
“Insert $1.00 and enter your number or ‘q’ to quit: “);
input = stdIn.nextLine();
Initialize winningNumber to a randomly chosen integer between 1 and the largest possible int.
16
16
*
Lottery Example
if (input.equals(“give me a hint”)) // a back door
{
System.out.println(“try: ” + winningNumber);
}
else if (!input.equals(“q”))
{
if (
{
System.out.println(“YOU WIN!”);
input = “q”; // force winners to quit
}
else
{
System.out.println(
“Sorry, good guess, but not quite right.”);
}
} // end else if
} while (!input.equals(“q”));
System.out.println(“Thanks for playing. Come again!”);
} // end main
} // end Lottery class
Compare input with the winning number.
17
17
*
The String Class
In Chapter 3, you saw several String methods – charAt, length, equals, and equalsIgnoreCase.
Those methods are defined in the String class, along with quite a few other methods that help with string manipulation tasks.
The String class is defined in the java.lang package. The Java compiler automatically imports all the classes in the java.lang package, so there’s no need to import the String class explicitly.
We’ll now present several additional popular methods in the String class.
18
18
*
The String Class’s substring Method
Here are API headers and brief descriptions for two alternative forms of the substring method:
public String substring(int beginIndex)
Returns a string that is a subset of the calling-object string, starting at the beginIndex position and extending to the end of the calling-object string.
public String substring(int beginIndex, int afterEndIndex)
Returns a string that is a subset of the calling-object string, starting at the beginIndex position and extending to the afterEndIndex-1 position.
19
19
*
The String Class’s substring Method
public class StringMethodDemo
{
public static void main(String[] args)
{
String yoda =
“May the force be with you.”;
System.out.println(yoda.substring(8));
System.out.println(yoda.substring(4, 13));
} // end main
} // end StringMethodDemo
calling object
20
20
*
The String Class’s indexOf Methods
Here are API headers and brief descriptions for four alternative forms of the indexOf method:
public int indexOf(int ch)
Returns the position of the first occurrence of the given ch character within the calling-object string. Returns -1 if ch is not found.
public int indexOf(int ch, int fromIndex)
Returns the position of the first occurrence of the given ch character within the calling-object string, starting the search at the fromIndex position. Returns -1 if ch is not found.
public int indexOf(String str)
Returns the position of the first occurrence of the given str string within the calling-object string. Returns -1 if str is not found.
public int indexOf(String str, int fromIndex)
Returns the position of the first occurrence of the given str string within the calling-object string, starting the search at the fromIndex position. Returns -1 if str is not found.
21
21
*
The String Class’s indexOf Methods
public class StringMethodDemo
{
public static void main(String[] args)
{
String egyptian =
“I will not leave the square. Over my dead body.”;
int index = egyptian.indexOf(‘.’);
String egyptian2 = egyptian.substring(index + 2);
System.out.println(egyptian2);
} // end main
} // end StringMethodDemo
22
22
*
The String Class’s lastIndexOf Methods
The lastIndexOf methods are identical to the indexOf methods except that they search the calling-object string from right to left.
For the one-parameter lastIndexOf methods, the search starts from the rightmost character.
For the two-parameter lastIndexOf methods, the search starts from the position specified by the second parameter.
What does this code fragment print?
String quote =
“Peace cannot be kept by force; it can” +
” only be achieved by understanding.”
System.out.print(
quote.indexOf(“can”) + ” ” +
quote.indexOf(“can”, 7) + ” ” +
quote.lastIndexOf(“can”));
23
23
*
Formatted Output with the printf Method
You should strive to make program output be understandable and attractive. To further that goal, format your output. Here’s an example of formatted output:
Account Actual Budget Remaining
——- —— —— ———
Office Supplies 1,150.00 1,400.00 250.00
Photocopying 2,100.11 2,000.00 (100.11)
Total remaining: $149.89
The System.out.printf method is in charge of generating formatted output.
24
24
*
Formatted Output with the printf Method
Here’s how to generate the “Total remaining” line in the previous slide’s budget report:
System.out.printf(
“\nTotal remaining: $%.2f\n”, remaining1 + remaining2);
You can have as many format specifiers as you like in a given format string. For each format specifier, you should have a corresponding data item/argument.
format specifier
25
25
*
Format Specifier Details
Here’s the syntax for a format specifier:
%[flags][width][.precision]conversion-character
The square brackets indicate that something is optional. So the flags, width, and precision parts are optional. Only the % and the conversion character are required.
26
26
*
Conversion Character
The conversion character tells the Java Virtual Machine (JVM) the type of thing that is to be printed.
Here is a partial list of conversion characters:
s This displays a string.
d This displays a decimal integer (an int or a long).
f This displays a floating-point number (a float or a double) with a decimal point and at least one digit to the left of the decimal point.
e This displays a floating-point number (float or double) in scientific notation.
27
27
*
Conversion Character
This code fragment illustrates how to use the conversion characters:
System.out.printf(“Planet: %s\n”, “Neptune”);
System.out.printf(“Number of moons: %d\n”, 13);
System.out.printf(“Orbital period (in earth years): %f\n”, 164.79);
System.out.printf(
“Average distance from the sun (in km): %e\n”, 4_498_252_900.0);
Here is the output:
Planet: Neptune
Number of moons: 13
Orbital period (in earth years): 164.790000
Average distance from the sun (in km): 4.498253e+09
28
28
*
Precision and Width
Precision:
Applies only to floating-point numbers (i.e., it works only in conjunction with the f and e conversion characters).
Its syntax consists of a dot and then the number of digits that are to be printed to the right of the decimal point.
If the data item has more fractional digits than the precision specifier’s value, then rounding occurs. If the data item has fewer fractional digits than the precision specifier’s value, then zeros are added at the right so the printed value has the specified number of fractional digits.
Width:
Specifies the minimum number of characters that are to be printed. If the data item contains more than the specified number of characters, then all of the characters are printed. If the data item contains fewer than the specified number of characters, then spaces are added.
By default, output values are right aligned, so when spaces are added, they go on the left side.
29
29
*
Precision and Width
This code fragment illustrates how to specify precision and width in a format specifier:
System.out.printf(“Cows are %6s\n”, “cool”);
System.out.printf(“But dogs %2s\n”, “rule”);
System.out.printf(“PI = %7.4f\n”, Math.PI);
Here is the output:
Cows are cool
But dogs rule
PI = 3.1416
6 characters
7 characters
30
30
*
Flags
Flags allow you to add supplemental formatting features, one flag character for each formatting feature. Here’s a partial list of flag characters:
– Display the printed value using left justification.
0 If a numeric data item contains fewer characters than the width specifier’s value, then pad the printed value with leading zeros (i.e., display zeros at the left of the number).
, Display a numeric data item with locale-specific grouping separators. In the United States, that means commas are inserted between every third digit at the left of the decimal point.
( Display a negative numeric data item using parentheses, rather than a minus sign. Using parentheses for negative numbers is a common practice in the field of accounting.
31
31
*
BudgetReport Example
public class BudgetReport
{
public static void main(String[] args)
{
final String HEADING_FMT_STR = “%-25s%13s%13s%15s\n”;
final String DATA_FMT_STR = “%-25s%,13.2f%,13.2f%(,15.2f\n”;
double actual1 = 1149.999; // amount spent on 1st account
double budget1 = 1400; // budgeted for 1st account
double actual2 = 2100.111; // amount spent on 2nd account
double budget2 = 2000; // budgeted for 2nd account
double remaining1, remaining2; // unspent amounts
System.out.printf(HEADING_FMT_STR,
“Account”, “Actual”, “Budget”, “Remaining”);
System.out.printf(HEADING_FMT_STR,
“——-“, “——“, “——“, “———“);
left justification
parentheses for negatives, comma for group separators
32
32
*
BudgetReport Example
remaining1 = budget1 – actual1 ;
System.out.printf(DATA_FMT_STR,
“Office Supplies”, actual1, budget1, remaining1);
remaining2 = budget2 – actual2;
System.out.printf(DATA_FMT_STR,
“Photocopying”, actual2, budget2, remaining2);
System.out.printf(
“\nTotal remaining: $%(,.2f\n”, remaining1 + remaining2);
} // end main
} // end class BudgetReport
33
33
*
CS151- Lab Four Wiemann
Requirements:
1) Create a C++ Program to convert binary to decimal, decimal to binary,
decimal to hexadecimal, and hexadecimal to decimal.
2) When the program is first executed a menu, similar in design, should be
displayed to the user:
Michael Wiemann’s Conversion Program
————————————
1) Convert Binary to Decimal
2) Convert Decimal to Binary
3) Convert Decimal to Hexadecimal
4) Convert Hexadecimal to Decimal
5) Exit Program
Input Choice:
3) The user should be prompted for the input of a choice. If the choice ‘1’
through ‘4’ is selected, then the appropriate input and output should occur for
that option. If the user selects ‘5’, the program should be terminated,
otherwise an error message should be displayed to the user. The program
should continue to display the menu until the user types the value
of ‘5’ as his/her choice.
4) You are required to use a function/method to create the menu interface.
5) You are required to use a function/method or a collection of
functions/methods to calculate each menu option.
6) Validation of input must occur on the input of the typed data (i.e. ‘12B’ is not
a valid decimal value). An error message should be displayed to the end user
if the required menu option is not valid.
7) All shop standards are to be followed as instructed in class.
8) The output listed above must be mathematically correct, however, formatting
of the numbers with the decimal places and right justification is not required.
9) Save the source code as “mrwJavaProg04.java”.
10) You will submit the Java file to the Dropbox for this lab assignment on or
before the due date.
/************************************************/
/* Your Name */
/* Week 4 Programming Example */
/* Due Date: ______________________________ */
/* CS 151- Introduction to Programming */
/************************************************/
//This is a copy of Lab 2 redone with functions to enhance portability
//in the source code.
import java.util.*;
import java.text.*;
public class mrwJavaWeek04Example {
//Custom Format – Allows for the formatting of the output with commas
//and fixed decimal places.
static public String customFormat (String pattern, double value) {
DecimalFormat myFormatter = new DecimalFormat(pattern);
String output = myFormatter.format(value);
//String right_output = new Format(output);
return output;
}
//calcGrossPay: accepts hoursWorked and hourlyRate – returns the product for Gross Pay
static public double calcGrossPay (double hoursWorked, double hourlyRate) {
return (hoursWorked * hourlyRate);
}
//calcFederalTaxes: accepts the GrossPay and returns 15% of the gross pay as Federal Taxes
static public double calcFederalTaxes (double grossPay) {
return (0.15 * grossPay);
}
//calcStateTaxes: accepts the GrossPay and returns 8% of the gross pay as State Taxes
static public double calcStateTaxes (double grossPay) {
return (0.08 * grossPay);
}
//calcNetPay: accepts the GrossPay, Federal Taxes, and state taxes and returns the Net Pay
static public double calcNetPay (double grossPay, double fedTaxes, double stateTaxes) {
return (grossPay – fedTaxes – stateTaxes);
}
public static void main(String[] args) {
Scanner stdIn = new Scanner(System.in); //Class reference to allow input from the console
String firstName; //First Name of the employee
String lastName; //Last Name of the employee
double hoursWorked; //Hours Worked of an employee
double hourlyRate; //Hourly Rate of an employee
double grossPay; //Gross Pay of an employee
double fedTaxes; //Federal taxes of an employee
double stateTaxes; //State Taxes of an employee
double netPay; //Net Pay of an employee
//Inputs did not change in terms of what you are accepting from the end user in the process.
System.out.print(“Input your First Name: “);
firstName = stdIn.nextLine();
System.out.print(“Input your Last Name: “);
lastName = stdIn.nextLine();
System.out.print(“Input the amount of hours worked: “);
hoursWorked = stdIn.nextDouble();
System.out.print(“Input the hourly rate: “);
hourlyRate = stdIn.nextDouble();
//The next four lines of code will be the function calls
grossPay = calcGrossPay(hoursWorked, hourlyRate);
fedTaxes = calcFederalTaxes(grossPay);
stateTaxes = calcStateTaxes(grossPay);
netPay = calcNetPay(grossPay, fedTaxes, stateTaxes);
System.out.println();
System.out.println(“Payroll Information for ” + lastName + “, ” + firstName + “:”);
System.out.println();
System.out.printf(“Hours Worked: %20s\n”, customFormat(“###,###,##0.00”, hoursWorked));
System.out.printf(“Hourly Rate: %20s\n”, customFormat(“###,###,##0.00”, hourlyRate));
System.out.printf(“\n”);
System.out.printf(“Gross Pay: %20s\n”, customFormat(“###,###,##0.00”, grossPay));
System.out.printf(“Federal Taxes: %20s\n”, customFormat(“###,###,##0.00”, fedTaxes));
System.out.printf(“State Taxes: %20s\n”, customFormat(“###,###,##0.00”, stateTaxes));
System.out.printf(“Net Pay: %20s\n”, customFormat(“###,###,##0.00”, netPay));
}
}
Chapter 6 – Object-Oriented Programming
Object-oriented programming overview
objects
classes
encapsulation
UML Class Diagram
First OOP Class
private and public Access
Driver Class
Reference Variables and Instantiation
Calling a Method
Calling Object
1
1
*
The this Reference
Default Values
Variable Persistence
OOP Tracing Procedure (hidden)
UML Class Diagram for Next Version of the Mouse Program
Local Variables
return statement
void Return Type
Empty return Statement
Argument Passing
Specialized methods:
accessor methods
mutator methods
boolean methods
Chapter 6 – Object-Oriented Programming
2
2
*
Object-Oriented Programming Overview
In the old days, the standard programming technique was called “procedural programming.”
That’s because the emphasis was on the procedures or tasks that made up a program.
You’d design your program around what you thought were the key procedures.
Today, the most popular programming technique is object-oriented programming (OOP).
With OOP, instead of thinking first about procedures, you think first about the things in your problem. The things are called objects.
3
3
*
Object-Oriented Programming Overview
An object is:
A set of related data which identifies the current state of the object
+ a set of behaviors.
Example objects:
Car object in a traffic-flow simulation:
data = ?
behaviors = ?
4
human entities physical objects mathematical entities
employees cars in a traffic-flow simulation points in a coordinate system
customers aircraft in an air-traffic control system complex numbers
students electrical components in a circuit-design program time
4
*
Object-Oriented Programming Overview
Benefits of OOP:
Programs are more understandable –
Since people tend to think about problems in terms of objects, it’s easier for people to understand a program that’s split into objects.
Fewer errors –
Since objects provide encapsulation (isolation) for the data, it’s harder for the data to get messed up.
5
5
*
��
methods�
data�
rest of program�
object�
Object-Oriented Programming Overview
A class is a description for a set of objects.
On the next slide, note the three computers on a conveyer belt in a manufacturing plant:
The three computers represent objects, and the specifications document represents a class. The specifications document is a blueprint that describes the computers: it lists the computers’ components and describes the computers’ features.
Think of an object as a physical example for a class’s description. More formally, we say that an object is an instance of a class.
6
6
*
Object-Oriented Programming Overview
7
7
*
(
com
puter objects
Specifications
for a
com
puter
)
�
Object-Oriented Programming Overview
A class is a description for a set of objects. The description consists of:
a list of variables
+ a list of methods
Classes can define two types of variables – instance variables and class variables. And classes can define two types of methods – instance methods and class methods. Instance variables and instance methods are more common than class variables and class methods, and we’ll focus on instance variables and instance methods in this chapter.
8
8
*
Object-Oriented Programming Overview
A class’s instance variables specify the type of data that an object can store.
For example, if you have a class for computer objects, and the Computer class contains a hardDiskSize instance variable, then each computer object stores a value for the size of the computer’s hard disk.
A class’s instance methods specify the behavior that an object can exhibit.
For example, if you have a class for computer objects, and the Computer class contains a printSpecifications instance method, then each computer object can print a specifications report (the specifications report shows the computer’s hard disk size, CPU speed, cost, etc.).
9
9
*
Object-Oriented Programming Overview
Note the use of the term “instance” in “instance variable” and “instance method.” That reinforces the fact that instance variables and instance methods are associated with a particular object instance. For example, each computer object has its own value for the hardDiskSize instance variable.
That contrasts with class variables and class methods, which you saw in Chapter 5. Class variables and class methods are associated with an entire class. For example, the Math class contains the PI class variable and the round class method. PI and round are associated with the entire Math class, not with a particular instance of the Math class. We’ll cover class variables and class methods in more detail at the end of Chapter 7.
10
10
*
UML Class Diagram
UML:
Stands for Unified Modeling Language.
It’s a diagrammatic methodology for describing classes, objects, and the relationships between them.
It is widely accepted in the software industry as a standard for modeling OOP designs.
Example:
UML class diagram for a Mouse class:
11
Mouse class name
age : int
weight : double
percentGrowthRate : double attributes /
variables
setPercentGrowthRate(percentGrowthRate : double)
grow()
display() operations /
methods
11
*
First OOP Class
/************************************************************
* Mouse.java
* Dean & Dean
*
* This class models a mouse for a growth simulation program.
************************************************************/
public class Mouse
{
private int age = 0; // age of mouse in days
private double weight = 1.0; // weight of mouse in grams
private double percentGrowthRate; // % weight increase per day
//*********************************************************
// This method assigns the mouse’s percent growth rate.
public void setPercentGrowthRate(double percentGrowthRate)
{
this.percentGrowthRate = percentGrowthRate;
} // end setPercentGrowthRate
instance variable declarations
To access instance variables, use this dot.
parameter
method body
12
12
*
First OOP Class
//*********************************************************
// This method simulates one day of growth for the mouse.
public void grow()
{
this.weight += (.01 * this.percentGrowthRate * this.weight);
this.age++;
} // end grow
//*********************************************************
// This method prints the mouses’s age and weight.
public void display()
{
System.out.printf(
“Age = %d, weight = %.3f\n”, this.age, this.weight);
} // end display
} // end class Mouse
14
14
*
private and public Access
private and public are access modifiers. When you apply an access modifier to a member of a class, you determine how easy it is for the member to be accessed. Accessing a member refers to either reading the member’s value or modifying it.
If you declare a member to be private, then the member can be accessed only from within the member’s class. Instance variables are almost always declared with the private modifier because you almost always want an object’s data to be hidden. Making the data hard to access is what encapsulation is all about and it’s one of the cornerstones of OOP.
If you declare a member to be public, then the member can be accessed from anywhere (from within the member’s class, and also from outside the member’s class). Methods are usually declared with the public modifier because you normally want to be able to call them from anywhere.
15
15
*
Driver Class
/****************************************
* MouseDriver.java
* Dean & Dean
*
* This is a driver for the Mouse class.
****************************************/
import java.util.Scanner;
public class MouseDriver
{
public static void main(String[] args)
{
Scanner stdIn = new Scanner(System.in);
double growthRate;
Mouse gus = new Mouse();
Mouse jaq = new Mouse();
16
16
*
Driver Class
System.out.print(“Enter growth rate as a percentage: “);
growthRate = stdIn.nextDouble();
gus.setPercentGrowthRate(growthRate);
jaq.setPercentGrowthRate(growthRate);
gus.grow();
jaq.grow();
gus.grow();
gus.display();
jaq.display();
} // end main
} // end class MouseDriver
17
17
*
Reference Variables and Instantiation
To declare a reference variable (which holds the address in memory where an object is stored):
To instantiate/create an object and assign its address into a reference variable:
Example code:
Mouse gus;
gus = new Mouse();
This single line is equivalent to the two lines above :
Mouse gus = new Mouse();
declaration
instantiation
initialization
18
18
*
Calling a Method
After instantiating an object and assigning its address into a reference variable, call/invoke an instance method using this syntax:
Here are three example instance method calls from the MouseDriver class:
gus.setPercentGrowthRate(growthRate);
gus.grow();
gus.display();
19
19
*
A calling object is the object that appears at the left of the dot in a call to an instance method.
Can you find the calling objects below?
public static void main(String[] args)
{
Scanner stdIn = new Scanner(System.in);
double growthRate;
Mouse gus = new Mouse();
System.out.print(“Enter growth rate as a percentage: “);
growthRate = stdIn.nextDouble();
gus.setPercentGrowthRate(growthRate);
gus.grow();
gus.display();
} // end main
Calling Object
20
20
*
The this reference:
When used in conjunction with a dot and an instance variable, “this” is referred to as the this reference. Note this example from the Mouse class’s grow method:
this.weight += (.01 * this.percentGrowthRate * this.weight);
The this reference is used inside of a method to refer to the object that called the method; in other words, the this reference refers to the calling object.
So what’s so great about having a special name for the calling object inside of a method? Why not just use the original name, gus or jaq, inside the method?
Because if the original name were to be used, then the method would only work for the one specified calling object. By using a generic name (this) for the calling object, then the method is more general purpose. For example, by using this, the grow method is able to specify weight gain for any Mouse object that calls it. If gus calls grow, then gus’s weight is updated, whereas if jaq calls grow, then jaq’s weight is updated.
The this Reference
21
21
*
A variable’s default value is the value that the variable gets if there’s no explicit initialization.
Mouse class’s instance variable declarations:
private int age = 0;
private double weight = 1.0;
private double percentGrowthRate;
Here are the default values for instance variables:
integer types get 0
floating point types get 0.0
boolean types get false
reference types get null
Note that a String is a reference type so it gets null by default.
Default Values
explicit initializations
percentGrowthRate gets default value of 0.0
22
22
*
A variable’s persistence is how long a variable’s value survives before it’s wiped out.
Instance variables persist for the duration of a particular object. Thus, if an object makes two method calls, the second called method does not reset the calling object’s instance variables to their initialized values. Instead, the object’s instance variables retain their values from one method call to the next.
Variable Persistence
23
23
*
UML Class Diagram for Next Version of the Mouse Program
Member accessibility:
Use “-” for private access and “+” for public access.
Method notes:
We use them here to specify local variables.
Initialization values:
Use “=
32
32
*
Local Variables
A local variable is a variable that’s declared inside a method. That’s different from an instance variable, which is declared at the top of a class, outside all the methods.
A local variable is called “local” because it can be used only inside of the method in which it is declared – it is completely local to the method.
In the Mouse2Driver class on the next slide, note how the main method has three local variables – stdIn , mickey, and days. And in the Mouse2 class, note how the grow method has one local variable – i.
33
33
*
Mouse2Driver Class
import java.util.Scanner;
public class Mouse2Driver
{
public static void main(String[] args)
{
Scanner stdIn = new Scanner(System.in);
Mouse2 mickey = new Mouse2();
int days;
mickey.setPercentGrowthRate(10);
System.out.print(“Enter number of days to grow: “);
days = stdIn.nextInt();
mickey.grow(days);
System.out.printf(“Age = %d, weight = %.3f\n”,
mickey.getAge(), mickey.getWeight());
} // end main
} // end class Mouse2Driver
local variables
34
34
*
Mouse2 Class
import java.util.Scanner;
public class Mouse2
{
private int age = 0; // age in days
private double weight = 1.0; // weight in grams
private double percentGrowthRate; // % daily weight gain
//********************************************************
public void setPercentGrowthRate(double percentGrowthRate)
{
this.percentGrowthRate = percentGrowthRate;
} // end setPercentGrowthRate
//********************************************************
public int getAge()
{
return this.age;
} // end getAge
35
35
*
Mouse2 Class
//********************************************************
public double getWeight()
{
return this.weight;
} // end getWeight
//********************************************************
public void grow(int days)
{
for (int i=0; i
{
return;
}
this.weight +=
.01 * this.percentGrowthRate * this.weight;
this.age++;
} // end while
} // end grow
empty return statement
40
40
*
Empty return Statement
Code that uses an empty return statement(s) can always be replaced by code that does not use the empty return statement(s). For example, here’s a return-less version of the previous grow method:
public void grow(int days)
{
int endAge;
endAge = this.age + days;
if (endAge > 100)
{
endAge = 100;
}
while (this.age < endAge)
{
this.weight +=
(.01 * this.percentGrowthRate * this.weight);
this.age++;
} // end while
} // end grow
41
41
*
return Statement Within a Loop
Software engineering observation:
Real-world programmers are often asked to maintain (fix and improve) other people's code. In doing that, they oftentimes find themselves having to examine the loops and, even more specifically, the loop termination conditions in the program they're working on. Therefore, it's important that the loop termination conditions are clear. Normally, loop termination conditions appear in standard places: while loop heading, do loop closing, for loop heading's condition part. However, in using a return statement inside a loop, the return statement introduces a loop termination that's not in one of the standard places. For example, in the grow method two slides ago, the return statement is "hidden" inside an if statement that's embedded in a while loop.
In the interest of maintainability, you should use restraint when considering the use of a return statement inside of a loop. Based on the context, if inserting a return statement(s) inside a loop improves clarity, then feel free to insert. However, if it simply makes the coding chores easier and it does not add clarity, then don't insert.
42
42
*
The default value for a local variable is garbage.
Garbage means that the variable's value is unknown - it's whatever just happens to be in memory at the time that the variable is created.
When doing a trace, use a "?" to indicate garbage.
If a program attempts to access a variable that contains garbage, the compiler generates an error. For example, what happens when the following method is compiled?
public void grow(int days)
{
for (int i; i
