Our real estate company has single family homes, townhouses,
and condominiums. All of the condos have only one level, also referred to as a
story. Some of the single family homes have one story, some have two and some
others have three levels. All townhouses have three levels.
Another customer wants to buy a home. The customer says that
he primarily wants a condo, but if our real estate company doesn't have a
condominium, that is, if the company has only houses, whatever it is, whether a
house or a condo, it must have only one level (story) (due to an illness, the
customer would not climb the stairs). When considering the properties of our
company, we would proceed with these statements:
If we find a condo, since all of our condos have only one
level, the criterion set by the customer is true. Even if we were considering
another (type of) property, it wouldn't matter. This can be resumed in the
following table:
The other properties would not be considered, especially if
they have more than one story:
To check for either of two conditions, in Boolean algebra,
you can use an operator called OR. We can show this operation as follows:
In Boolean algebra, this type of comparison is performed
using the OR operator. In Java, the OR operator is performed using the ||
operator. Here is an example:
import java.util.Scanner;
public class Exercise {
static void main(String[] args) {
Scanner scnr = new Scanner(System.in);
String houseType = "Unknown";
int choice = 0;
int stories = 1;
System.out.println("Enter the type of house you want to purchase");
System.out.println("1. Single Family");
System.out.println("2. Townhouse");
System.out.println("3. Condominium");
System.out.print("You Choice? ");
choice = scnr.nextInt();
if (choice == 1)
houseType = "Single Family";
if (choice == 2)
houseType = "Townhouse";
if (choice == 3)
houseType = "Condominium";
System.out.print("How many stories? ");
stories = scnr.nextInt();
System.out.println("Desired House Type: " + houseType);
System.out.println("Number of Stories: " + stories);
if( (houseType == "Condominium") || (stories == 1) )
System.out.println("Desired House Matched");
else
System.out.println("The House Doesn't Match the Desired Criteria");
}
}
Here is an example of running the program:
Enter the type of house you want to purchase
1. Single Family
2. Townhouse
3. Condominium
You Choice? 3
How many stories? 6
Desired House Type: Condominium
Number of Stories: 6
Desired House Matched
Suppose that, among the properties our real estate company
has available, there is no condominium. In this case, we would then consider the
other properties:
If we have a few single family homes, we would look for one
that has only one story. Once we find one, our second criterion becomes true:
This can be illustrated in the following run of the above
program:
Enter the type of house you want to purchase
1. Single Family
2. Townhouse
3. Condominium
You Choice? 1
How many stories? 1
Desired House Type: SingleFamily
Number of Stories: 1
Desired House Matched
If we find a condo and it is one story, both criteria are
true. This can be illustrated in the following table:
The following run of the program demonstrates this:
Enter the type of house you want to purchase 1. Single Family 2. Townhouse 3. Condominium You Choice? 3 How many stories? 1 Desired House Type: Condominium Number of Stories: 1 Desired House Matched
A Boolean OR operation produces a false result only if BOTH
conditions ARE FALSE:
Here is another example of running the program:
Enter the type of house you want to purchase 1. Single Family 2. Townhouse 3. Condominium You Choice? 2 How many stories? 2 Desired House Type: Townhouse Number of Stories: 2 The House Doesn't Match the Desired Criteria
As opposed to evaluating only two conditions, you may face a
situation that presents three of them and must consider a combination of more
than two conditions.
Computer programming presents you with various options to
manage the flow of processing an application. You can nest a condition in
another. You can ask the compiler to skip a processing for any reason you judge
necessary. Or, you can control how a method would return, if any.
Consider the following program:
import java.util.Scanner;
public class Exercise {
static void main(String[] args) {
Scanner scnr = new Scanner(System.in);
int typeOfHome = 0;
do {
System.out.println("What Type of House Would you Like to Purchase?");
System.out.println("1 - Single Family");
System.out.println("2 - Town House");
System.out.println("3 - Condominium");
System.out.print("Your Choice? ");
typeOfHome = scnr.nextInt();
} while ((typeOfHome < 1) || (typeOfHome > 3));
if (typeOfHome == 1)
System.out.println("\nType of Home: Single Family");
else if (typeOfHome == 2)
System.out.println("\nType of Home: Town House");
else if (typeOfHome == 3)
System.out.println("\nType of Home: Condominium");
}
}
This is used to request one of the numbers 1, 2, or
3 from the user. Any number below 1 or above 3 is not accepted. Here is
an example of running the program:
What Type of House Would you Like to Purchase? 1 - Single Family 2 - Town House 3 - Condominium Your Choice? 8 What Type of House Would you Like to Purchase? 1 - Single Family 2 - Town House 3 - Condominium Your Choice? 6 What Type of House Would you Like to Purchase? 1 - Single Family 2 - Town House 3 - Condominium Your Choice? 3 Type of Home: Condominium
If the user enters an invalid value, the question is
simply being asked again. It would be professional to let the user know
why the request came back even though what appears as a normal number
was entered. To solve this and other types of problems, you can write
one conditional statement inside of another. This is referred to as nesting.
To create a conditional statement inside of another, simply proceed as
we have done so far to create them. Here is an example:
import java.util.Scanner;
public class Exercise {
public static int Main(String[] args) {
int typeOfHome = 0;
do {
System.out.println("What Type of House Would you Like to Purchase?");
System.out.println("1 - Single Family");
System.out.println("2 - Townhouse");
System.out.println("3 - Condominium");
System.out.print("Your Choice? ");
typeOfHome = scnr.nextInt();
if ((typeOfHome < 1) || (typeOfHome > 3))
System.out.println("Invalid Choice: Please try again");
} while ((typeOfHome < 1) || (typeOfHome > 3));
if (typeOfHome == 1)
System.out.println("Type of Home: Single Family");
else if (typeOfHome == 2)
System.out.println("Type of Home: Townhouse");
else if (typeOfHome == 3)
System.out.println("Type of Home: Condominium");
}
}
Here is another example of running the program:
What Type of House Would you Like to Purchase? 1 - Single Family 2 - Town House 3 - Condominium Your Choice? 0 Invalid Choice: Please try again What Type of House Would you Like to Purchase? 1 - Single Family 2 - Town House 3 - Condominium Your Choice? 6 Invalid Choice: Please try againe What Type of House Would you Like to Purchase? 1 - Single Family 2 - Town House 3 - Condominium Your Choice? 2 Type of Home: Town House
The break statement is used to stop a loop for any
reason or condition when necessary.
The formula of the break statement is:
break;
Although made of only one word, the break statement
is a complete statement; therefore, it can (and should always) stay on
its own line (this makes the program easy to read).
The break statement applies to the most previous
conditional statement to it; provided that previous statement is
applicable. The break
statement can be used in a while condition, in a
do…while or a for loops to stop an ongoing action. Here is
an example that is used to count the levels of a house from 1 to 12 but
it is asked to stop at 3:
public class Exercise {
static void main(String[] args) {
for (int stories = 1; stories <= 12; stories++) {
System.out.println("Story " + stories);
if (stories == 3)
break;
}
}
}
This would produce:
Story 1 Story 2 Story 3
The continue statement uses the following
formula:
continue;
When processing a loop, if the statement finds a
false value, you can use the continue statement inside of a while,
a do…while or a for conditional statements to ignore the subsequent
statement or to jump from a false Boolean value to the subsequent valid
value, unlike the break statement that would exit the loop. Like the
break statement, the continue keyword applies to the most previous
conditional statement and should stay on its own line. Here is an
example when a program is supposed to count the levels of a house from 1
to 6:
public class Exercise {
static void main(String[] args) {
for (int stories = 1; stories <= 6; stories++) {
if (stories == 3)
continue;
System.out.println("Story " + stories);
}
}
}
This would produce:
Story 1 Story 2 Story 4 Story 5 Story 6
Notice that, when the compiler gets to 3, it ignores it.
The break keyword allows a program execution
to jump to another section of the function in which it is being used. In order to use the goto statement, insert a
name on a particular section of your function so you can refer to that
name. The name, also called a label, is made of one word and follows the
rules we have learned about names (the name can be anything), then
followed by a colon.
Some functions are meant to return a value that is
conditional of their processing. The fact that a function indicates the type of
value it would return may not be clear at the time the function is closed but a function defined other than
void must always
return a value. You can write a conditional statement, such as if,
inside of a function and return a value from that condition. Here is an example:
import java.util.Scanner;
enum HouseType {
UNKNOWN,
SINGLEFAMILY,
TOWNHOUSE,
CONDOMINIUM
}
public class Exercise {
static void main(String[] args) {
HouseType propType = specifyHouseType();
switch(propType) {
case SINGLEFAMILY:
System.out.println("\nType of Home: Single Family");
break;
case TOWNHOUSE:
System.out.println("\nType of Home: Townhouse");
break;
case CONDOMINIUM:
System.out.println("\nType of Home: Condominium");
break;
case UNKNOWN:
System.out.println("\nType of Home. Unknown");
break;
}
}
static HouseType specifyHouseType() {
int type = 0;
Scanner scnr = new Scanner(System.in);
System.out.println("What Type of House Would you Like to Purchase?");
System.out.println("1 - Single Family");
System.out.println("2 - Townhouse");
System.out.println("3 - Condominium");
System.out.print("Your Choice? ");
type = scnr.nextInt();
if (type == 1)
return HouseType.SINGLEFAMILY;
else if (type == 2)
return HouseType.TOWNHOUSE;
else if (type == 3)
return HouseType.CONDOMINIUM;
}
}
This specifyHouseType() method indicates when one of three
values is returned. In reality, this method could get a value other than the
three that are considered. If the user enters such a value, the current version
of the method would not know what to do. For this reason, the program will not
compile. To solve this problem, you must provide a statement that
would include any value other than those considered. You can do this by writing
a final return that has its own value. Here is an example:
import java.util.Scanner;
enum HouseType {
UNKNOWN,
SINGLEFAMILY,
TOWNHOUSE,
CONDOMINIUM
}
public class Exercise {
static void main(String[] args) {
HouseType propType = specifyHouseType();
switch(propType) {
case SINGLEFAMILY:
System.out.println("\nType of Home: Single Family");
break;
case TOWNHOUSE:
System.out.println("\nType of Home: Townhouse");
break;
case CONDOMINIUM:
System.out.println("\nType of Home: Condominium");
break;
case UNKNOWN:
System.out.println("\nType of Home. Unknown");
break;
}
}
static HouseType specifyHouseType() {
int type = 0;
Scanner scnr = new Scanner(System.in);
System.out.println("What Type of House Would you Like to Purchase?");
System.out.println("1 - Single Family");
System.out.println("2 - Townhouse");
System.out.println("3 - Condominium");
System.out.print("Your Choice? ");
type = scnr.nextInt();
if (type == 1)
return HouseType.SINGLEFAMILY;
else if (type == 2)
return HouseType.TOWNHOUSE;
else if (type == 3)
return HouseType.CONDOMINIUM;
else
return HouseType.UNKNOWN;
}
}
Imagine that you want to count the positive odd numbers from
a certain maximum to a certain minimum. For example, to count the odd numbers
from 1 to 9, you would use:
9, 7, 5, 3, and 1
Notice that, to perform this operation, you consider the
highest. Then you subtract 2 to get the previous. Again, you subtract 2 from the
number to get
the previous. What you are simply doing is to subtract a constant to what you already
have and you invent very little. In computer programming, you can solve this type of problem
by first writing a function, and then have the function call itself. This is the
basis for recursion.
A type of formula to create a recursive method is:
ReturnValue Function(Arguments, if any){
Optional Action . . .
Function();
Optionan Action . . .
}
A recursive method
starts with a return value. If it would not return a value, you can define it
with void. After its name, the method can take one or more
arguments. Most of the time, a recursive method takes at least one argument
that it would then modify. In the body of the method, you can take the
necessary actions. There are no particular steps to follow when implementing a
recursive method but there are two main rules to observe:
For our example of counting decrementing odd numbers, you
could start by creating a method that takes an integer as argument. To
exercise some control on the lowest possible values, we will consider only
positive numbers. In the body of the method, we will display the current value
of the argument, subtract 2, and recall the method itself. Here is our
function:
public class Exercise {
static void showOddNumber(int a) {
if (a >= 1) {
System.out.println(a);
a -= 2;
showOddNumber(a);
}
}
static void main(String[] args) {
final int Number = 9;
System.out.println("Odd Numbers");
showOddNumber(Number);
}
}
Notice that the method calls itself in its body. This would produce:
Odd Numbers 9 7 5 3 1
Recursive methods provide a valuable mechanism for
building lists or series, which are value that are either increment or decrement
but follow a pattern. Imagine that, instead of simply displaying odd numbers as
we did above, you want to add them incrementally. If you have 1, it would also
produce 1. If you have 5, you would like to add 1 to 3, then the result to 5,
and so on. This can be illustrated as follows:
To perform this operation, you would consider 1. If the
number is less than or equal to 1, the method should return 1. Otherwise, add
2 to 1, then add 2 to the new result. Continue this until you get to the value
of the argument. The method can be implemented as follows:
public class Exercise {
static int getAdditionalOdd(int a) {
if (a <= 1)
return 1;
return a + getAdditionalOdd(a - 2);
}
static void showOddNumbers(int a) {
if (a >= 1) {
System.out.println(a);
a -= 2;
showOddNumbers(a);
}
}
static void main(String[] args) {
final int number = 9;
System.out.println("Odd Numbers");
showOddNumbers(number);
System.out.println("Sum of Odds: " + getAdditionalOdd(number));
}
}
This would produce:
Odd Numbers
9
7
5
3
1
Sum of Odds: 25
|
Looping and Compounding Statements
Practical Learning: Controlling the Conditional Statements
Subscribe to:
Post Comments (Atom)
Related Scripting
No comments:
Post a Comment