To perform the necessary validations of values, the Java language provides some symbols, referred to as Boolean operators.
A variable is referred to as Boolean if it can hold a value that is either true or false. To declare a Boolean variable, you can use the boolean keyword. Here is an example: public class Exercise {
static void main(String[] args) {
boolean drinkingUnderAge;
}
}
After the variable has been declared, you must initialize it with a true or a false value. Here is an example: public class Exercise {
static void main(String[] args) {
boolean drinkingUnderAge = true;
}
}
To display the value of a Boolean variable, you can type its name in the parentheses of the System.out.print() or the System.out.println() methods. Here is an example: public class Exercise {
static void main(String[] args) {
boolean drinkingUnderAge = true;
System.out.print("Drinking Under Age? ");
System.out.println(drinkingUnderAge);
}
}
This would produce: Drinking Under Age: True In the parentheses of System.out.print() or System.out.println(), you can concatenate a string and a boolean variable. To do this, use the + operator. Here is an example: public class Exercise {
static void main(String[] args) {
boolean drinkingUnderAge = true;
System.out.println("Drinking Under Age? " + drinkingUnderAge);
}
}
To display the value of a Boolean variable using System.out.printf(), use the %b expression. After declaring and initializing a Boolean variable, at any time and when you judge it necessary, you can change the value of the Boolean variable by assigning it a true or false value. Here is an example: public class Exercise {
static void main(String[] args) {
boolean drinkingUnderAge = true;
System.out.println("Drinking Under Age: " + drinkingUnderAge);
drinkingUnderAge = false;
System.out.println("Drinking Under Age: " + drinkingUnderAge);
}
}
This would produce: Drinking Under Age: True Drinking Under Age: False
As reviewed for the other data types, you can request the value of a Boolean variable from the user. In this case, the user must type either True (or true) or False (or false) and you can retrieve it using the Scanner.nextBoolean() methods. Here is an example: import java.util.Scanner;
public class Exercise {
static void main(String[] args) {
Scanner input = new Scanner(System.in);
boolean drivingUnderAge = false;
System.out.println("Were you driving under age?");
System.out.print("If Yes, enter True. Otherwise enter False: ");
drivingUnderAge = input.nextBoolean();
System.out.println("Was Driving Under Age: " + drivingUnderAge);
}
}
Here is an example of running the program: Were you driving under age? If Yes, enter True. Otherwise enter False: true Was Driving Under Age: True
Like the other types of variables we used in previous lessons, a Boolean variable can be made a field of a class. You declare it like any other variable, using the boolean data type. Here is an example: public class House {
String houseType;
int bedrooms;
float bathrooms;
byte stories;
boolean hasCarGarage;
int yearBuilt;
double value;
}
When initializing an object that has a Boolean variable as a member, simply assign true or false to the variable. In the same way, you can retrieve or check the value that a Boolean member variable is holding by simply accessing it. Here are examples: public class Exercise {
static void main(String[] args) {
House home = new House();
home.houseType = "Condominium";
home.bedrooms = 2;
home.bathrooms = 1.5F;
home.stories = 1;
home.hasCarGarage = false;
home.yearBuilt = 2002;
home.value = 355825;
System.out.println("=//= Altair Realty =//=");
System.out.println("=== Property Listing ===");
System.out.println("Type of Home: " + home.houseType);
System.out.println("Number of Bedrooms: " + home.bedrooms);
System.out.println("Number of Bathrooms: " + home.bathrooms);
System.out.println("Number of Stories: " + home.stories);
System.out.println("Year Built: " + home.yearBuilt);
System.out.println("Has Car Garage: " + home.hasCarGarage);
System.out.println("Monetary Value: " + home.value);
}
}
This would produce: =//= Altair Realty =//= === Property Listing === Type of Home: C Number of Bedrooms: 2 Number of Bathrooms: 1.5 Number of Stories: 18 Year Built: 2002 Has Car Garage: False Monetary Value: 155825
Like parameters of the other types, you can pass an argument of type boolean to a method. Such an argument would be treated as holding a true or false value.
Consider that, when creating a program for a real estate company that sells houses, you want the program to ask a customer the type of house that he or she wants to purchase and/or the type of garage that the desired house should have. Here is an example: import java.util.Scanner;
public class Exercise {
static void main(String[] args) {
Scanner input = new Scanner(System.in);
int TypeOfHouse = 0;
int TypeOfGarage = 0;
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("Your Choice: ");
TypeOfHouse = input.nextInt();
System.out.println("Enter the type of garage you want");
System.out.println("0 - Doesn't matter");
System.out.println("1 - Interior");
System.out.println("2 - Exterior");
System.out.print("Your Choice: ");
TypeOfGarage = input.nextInt();
System.out.println("\nHouse Type: " + TypeOfHouse);
System.out.println("Garage Type: " + TypeOfGarage);
}
}
Here is an example of running the program: Enter the type of house you want to purchase 1 - Single Family 2 - Townhouse 3 - Condominium Your Choice: 3 Enter the type of garage you want 0 - Doesn't matter 1 - Interior 2 - Exterior Your Choice: 1 House Type: 3 Garage Type: 1 For such a program, the numbers can be vague. 1 can be considered a general number but, in our program, it can represent a Single Family house or an Interior type of garage. At the same time, our program uses the constant 1 in particular meaningful ways. To make it possible to give more meaning to a constant number, when the number can be made part of a series, Java allows you to create a type of list. An enumeration is a series of constant integers that each has a specific position in the list and can be recognized by a meaningful name. Based on this, instead of just remembering that the constant 1 represents Single Family, you can create a list that has that type of house. In another list, instead of using 1 again, you can give it a name. Consequently, in each list, although the constant 1 would still be considered, at least it would mean something precise.
To create an enumeration, you use the enum keyword, followed by the name of the enumeration, followed by a name for each item of the list. The name of the enumerator and the name of each item of the list follows the rules we reviewed for names. The formula of creating an enumeration is: enum Series_Name {Item1, Item2, Item_n};
Here is an example: enum HouseType { Unknown, SingleFamily, TownHouse, Condominium }
Based on suggestions of the Java language, it is a tradition to write the members of an enumeration in uppercase: enum HouseType { UNKNOWN, SINGLEFAMILY, TOWNHOUSE, CONDOMIMIUM }
After creating an enumeration, each member of the enumeration holds a value of a natural number, such as 0, 4, 12, 25, etc. In Java, an enumeration cannot hold character values (of type char). After creating an enumeration, you can declare a variable from it. Here is an example: enum HouseType { UNKNOWN, SINGLEFAMILY, TOWNHOUSE, CONDOMIMIUM }
public class Exercise {
static void main(String[] args) {
HouseType propType;
}
}
After declaring a variable for an enumeration, to initialize it, specify which member of the enumeration would be assigned to the variable. You should only assign a known member of the enumeration. To do this, on the right side of the assignment operator, type the name of the enumeration, followed by the period operator, and followed by the member whose value you want to assign. Here is an example: enum HouseType { UNKNOWN, SINGLEFAMILY, TOWNHOUSE, CONDOMIMIUM }
public class Exercise {
static void main(String[] args) {
HouseType propType = HouseType.SINGLEFAMILY;
}
}
You can also find out what value the declared variable is currently holding. For example, you can display it using System.out.print() or System.out.println(). Here is an example: enum HouseType { UNKNOWN, SINGLEFAMILY, TOWNHOUSE, CONDOMIMIUM }
public class Exercise {
static void main(String[] args) {
HouseType propType = HouseType.SINGLEFAMILY;
System.out.println("House Type: " + propType);
}
}
This would produce: House Type: SINGLEFAMILY An enumeration is in fact a list of numbers where each member of the list is identified with a name.
By default, if you create an enumeration the way we have proceeded so far, it would be available only in the project it belongs to. As done for a class, you can make an enumeration public by creating it in its own file and preceding it with the public keyword. Here is an example:
After creating an enumeration, you can use it as a data type to declare a variable. To create a field that is of an enumeration type, follow the same rules as done for the primitive types: the name of the enumeration, followed by the name of the variable, and followed by a semi-colon. Here is an example: enum HouseType {
UNKNOWN,
SINGLEFAMILY,
TOWNHOUSE,
CONDOMINIUM
}
public class House {
HouseType PropertyType;
}
In the same way, you can create as many enumeration fields as you want. After creating the field, to initialize it, assign it the desired member of the enumeration. Here is an example: enum HouseType {
UNKNOWN,
SINGLEFAMILY,
TOWNHOUSE,
CONDOMINIUM
}
public class House {
HouseType PropertyType;
House() {
PropertyType = HouseType.UNKNOWN;
}
}
Once the field has been initialized, you can use it as you see fit as we will learn and practice in future sections and lessons. At a minimum, you can use System.out.print() or System.out.println() to display its value. Here is an example: enum HouseType {
UNKNOWN,
SINGLEFAMILY,
TOWNHOUSE,
CONDOMINIUM
}
class House {
HouseType PropertyType;
House() {
PropertyType = HouseType.UNKNOWN;
}
void Display() {
System.out.println("Property Type: " + PropertyType);
}
}
public class Exercise {
static void main(String[] args) {
House prop = new House();
prop.Display();
System.out.println();
prop.PropertyType = HouseType.SINGLEFAMILY;
prop.Display();
System.out.println();
}
}
This would produce: Property Type: UNKNOWN Property Type: SINGLEFAMILY Using it as normal data type, you can create a method that returns an enumeration. You can also pass an enumeration to a method as argument.
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||
