If you create a program used to perform calculations as introduced above, when a user enters a new value that would be involved in the calculation, to manage that value, you can (temporarily) store it in the computer memory. Since the values entered in a reserved memory area change regularly, they are called variables. Because neither you nor the compiler can predict all possible values that would be used, there are safeguards you can use. First, you must ask the compiler to reserve an area of memory for a value you intend to use. Asking the compiler to reserve an area of memory is referred to as Declaring a Variable. Remember that when you declare a variable, the compiler reserves an area of the compiler memory for you. Eventually, you can put the desired but appropriate values in that memory space. After declaring a variable, when you need the value stored in its memory area, you can ask the compiler to retrieve it and hand it to you. To effectively handle this transaction, the compiler would need two pieces of information from you: a name of your choice for the memory area that will be reserved, and the type of value that will be stored in that area of memory. Based on this, the formula to declare a variable is: TypeOfValue VariableName As done in some languages like Pascal or Basic, we will start with the name. When you want the compiler to reserve an area of memory for some values used in your program, you must set a name, also called an identifier, that will allow you to refer to that area of memory. The name can be anything of your choice but there are rules you must follow:
Beyond these rules as a foundation, you can add yours. For example, we will follow suggested standards of the Java documentation. The rules will follow are:
After declaring a variable, you can store a value in the memory reserved for it. When you have just declared a variable, it may not hold a significant value. To know the value it has, you should put an initial value into that memory space. Putting an initial value is referred to as initializing the variable. To initialize a variable, on the right side of its name, type the assignment operator, followed by the value you want to put in the reserved memory. As we will see in the next few sections, you cannot and should not put just any type of value in a variable. We will see that there are different types used for different variables. After declaring a variable and once it has a value, to display that value, you can provide the name of the variable to the parentheses (in future lessons, we will learn that this is referred to as passing) of the System.out.print() method.
As introduced previously, when declaring a variable, besides its name, you must provide the type of information that the variable will hold. The role of this type is to tell the compiler how much memory will be needed to store the value(s) of that variable. Since your program is not the only one used in the computer, memory has to be effectively managed. The type of value that a variable will hold is called a data type. As you ay imagine, different variables can be meant to hold different types of values. Each data type uses a Java keyword to be characterized. As a modern language, Java provides even more support for its traditional data types. To do this, a class was created for each data type. This allows you to get more information from a variable declared with the particular data type you want to use. Retrieving a value in Java is not particularly busy. As seen in our introduction, to do anything, you have to go through a class. To retrieve a value, you have to go through different classes. When you type a value in a program, to retrieve it, you can the in object of the System package: System.in After getting that value, you must first store it somewhere. One of the classes you can use is called Scanner. Before using the Scanner class, you must import the java.util.Scanner package into your program. This would be done by writing the following in the top section of the file: import java.util.Scanner; To use the Scanner class to retrieve a value, use the following formula: Scanner VariableName = new Scanner(System.in); The only think we need to mention at this time is that, after the Scanner class, you must give a variable name. An example would be: Scanner scnr = new Scanner(System.in); The other details, such as why System.in is written in the parentheses after new Scanner, will be explained in future lessons. After declaring a Scanner class, its variable is ready to receive the value. The value depends on a type. We will see in the next lessons. When getting a value, the Scanner class must be able to convert it to its appropriate type. To support this, the Scanner class is equipped with a mechanism (actually called a method) for each type of value. To retrieve a value, you will write the name of the Scanner variable, followed by a period, followed by the mechanism as we will indicate, then assign it to the variable whose value you want to retrieve. The formula will be: VariableName = ScannerVariable.Mechanism(); Notice the parentheses and the semi-colon.
To display a value, you can write it in the parentheses of System.out.print(). If the value is a character, include it between single-quotes. Here is an example: public class Exercise {
public static void main(String[] args) {
System.out.print('Q');
}
}
This would produce: Q If the value is a word or a sentence, include it between double-quotes. Here is an example: public class Exercise {
public static void main(String[] args) {
System.out.print("James Harding");
}
}
This would produce: James Harding If the value is a (constant) number, simply type that number in the parentheses of System.out.print() or System.out.println(). Here is an example: public class Exercise {
public static void main(String[] args) {
System.out.print(248);
}
}
This would produce: 248 If the value is stored in a variable, you can write the name of that variable in the parentheses of System.out.print(). We will see various examples in the next sections. Instead of a constant value in the parentheses of System.out.print() or System.out.println(), you may want to add other items, such as a sentence that is made of words and values that would come from variables. Fortunately, you have many options. If you want to exercise some control as to how a value is formatted, instead of using System.out.print() or System.out.println(), use System.out.printf(). This allows you to format how data should appear when displayed to the user. Data types are divided in categories: characters, integers, floating-point numbers, and strings. To display a particular type, you type the percent operator “%”, followed by the category of data. The basic formula to follow is: System.out.printf("blah blah blah %Character blah blah", variable);
Any blah represents anything word or sentence you want to include in the display. At some point, you will write % followed by a character. We will see the examples in the appropriate section. The first section ends with a closing double-quote followed by a comma. After the comma, you must include the name of the variable whose value will be displayed in the Character placeholder. Instead of one value, you can create as many placeholders as you want. The formula to follow is: System.out.printf("blah %Char1 blah %Char1 blah %Char1 blah", var1, var2, var3);
Once again, you will replace each blah with whatever you want to add as part of your sentence. Each Char is a placeholder for a character as we will see in various examples. After the comma, you must include a variable name (or a value) for each Char placeholder, in the order they appear in the double-quotes, no more, no less.
A string is one or more characters considered as a single value. Everything entered in a program, requested from the user, or displayed as a series of characters is primarily a string. To support strings, Java is equipped with the String class. To declare a variable that would hold a string, use the String data type. To retrieve a string, you can apply next() to your Scanner class. Here is an example: import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scnr = new Scanner(System.in);
String firstName;
System.out.print("Enter the First Name: ");
firstName = scnr.next();
System.out.print("First Name: ");
System.out.print(firstName);
}
}
Here is an example of running the program: Enter the First Name: James First Name: James next() is used to get only one word that is considered terminated by an empty space. To retrieve a string made of different words, you must assume that it would be terminated by a new line. To get such a string, use nextLine(). To initialize a String variable, assign it a double-quoted value. Here is an example: public class Exercise {
public static void main(String[] args) {
String firstName = "Johua";
}
}
To display the value of a string, you can pass the name of variable to the System.out.print() method. Here is an example: public class Exercise {
public static void main(String[] args) {
String firstName = "Johua";
System.out.print("First Name: ");
System.out.print(firstName);
}
}
As an alternative, to display a string using System.out.printf(), add a %s expression in the double-quotes ass the placeholder of the variable. Here is an example: public class Exercise {
public static void main(String[] args) {
String fullName = "Patricia Katts";
System.out.printf("Full Name: %s", fullName);
}
}
This would produce: Full Name: Patricia Katts An escape sequence is a special character that displays non-visibly. For example, you can use this type of character to indicate the end of line, that is, to ask the program to continue on the next line. An escape sequence is represented by a backslash character, \, followed by another character or symbol. For example, the escape sequence that moves to the next line is \n. An escape can be included in single-quotes as in '\n', in double-quotes as "\n", or as part of a string. The Java language recognizes other escape sequences:
We mentioned that any character or group of characters is a string. To make it easy to manage strings, you can "concatenate" one string with another to create a new string. The concatenation is done by adding one string to another, which is done using the addition operator. Here is an example: public class Exercise {
public static void main(String[] args) {
String firstName = "Johua ";
String lastName = "Yacomo";
String fullName = firstName + lastName;
System.out.print("Full Name: ");
System.out.print(fullName);
}
}
In the same way, you can concatenate as many strings as you want, using the addition operator the same way you would in algebra. When writing System.out.print("First Name: ");, the First Name value is a string. This allows you to also add strings locally where they are used, such as in the print() method. Here is an example: public class Exercise {
public static void main(String[] args) {
String firstName = "Johua";
String strSeparator = ", ";
String lastName = "Yacomo";
System.out.print("Full Name: " + lastName + strSeparator + firstName);
}
}
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
