Blakes 21 Days Chapter 2 Document

• External Links
  • Version (23) | Blakes 21 Days: Chapter 1 & Appendix A | Book's Website | 21 Days | Download JDK 8 (Oracle) | Download NetBeans 8.0.2 (netbeans) | reserve
  • Chapter 1 & Appendix A | (1) | (2) | (3) | (4) | (5) | (6) | (7) | (8) | (9) | (10) | (11) | (12) | (13) | (14) | (15) | (16) | (17) | (18) | (19) | (20) | (21) | (A) | (D) | reserve | Project Files | Grid | Blank

• Internal Links
  • Chapter 2 pages 037 to 065 | 65 - 37 = 28 pages | reserve
  • page 037 | Statements and Expressions | Variables and Data Types | Creating Variables | Naming Variables | Variables Types | Assigning Values to Variables | reserve
  • First Project | Comments | Literals | Number Literals | Boolean Literals | Character Literals | String Literals | Expressions and Operators | Arithmetic Operators | reserve
  • Second Project | More About Assignment | Incrementing and Decrementing | Comparisons | Logical Operators | Operator Precedence | StringArithmetic | reserve
  • reserve | reserve

Day 2, The ABCs of Programming

• page 037 A Java program is made up of classes and objects
  • which are made up of methods and variables
  • Methods are made up of statements and expressions, which are made up of operators
• page 037 The following subjects are covered
  • Statements and expressions
  • Variables and primitive data types
  • Constants
  • Comments
  • Literals
  • Arithmetic
  • Comparisons
  • Logical operators

Statements and Expressions

• Top
• page 038 Statements and Expressions
  • statement is a simple command that causes something to happen
  • Statements represent a single action taken in a Java program
  • examples:
    • int weight = 225;
    • System.out.println("Free the bound periodicals");
    • song.duration = 230;
  • some statements convey a value
    • such as when two numbers are added
    • or two variables are compared to find out if they are equal
  • Expression - a statement that produces a value
    • The value can be stored for later use
    • or used immediately in another statement
    • or disregarded
  • Return Value - the value produced by a statement
• page 038 some expressions produce a numeric return value, as when two numbers are added or multiplied
  • others produce a Boolean value - either true or false
  • or even produce a Java object
• page 038 many Java programs contain one statement per line, but they can have more than one statement per line
  • each statement ends with a semicolon character ;
  • you can place more that one statement per line
  • ie: spirit.speed = 2; spirit.temperature = -60; this will compile
  • to make code easier to read, place one statement per line
• page 038 statements in Java are grouped using an opening brace { and a closing brace }.
  • block - a group of statements organized between these characters is called a block (or block statements).

Variables and Data Types

• Top | Back to Chap 5: Defining Instance Variables
• page 038 Variable - a place where information is stored while a program is running
  • the value can be changed at any time or point in the coding
• page 039 to create a variable, you must give it a name and a type
  • you can also give it an initial value at the time you create it.
• page 039 Java has three types of variables
  • instance variables
  • class variables
  • local variables
• page 039 Instance variables - define an objects attributes
• page 039 Class variables - define the attributes of an entire class of objects and apply all instances of it
• page 039 Local variables - are used inside method definitions or even smaller blocks of statements within a method
  • you can use them only while the method or block is being executed by the Java Virtual Machine
  • they cease to exist afterward
• page 039 the three kinds of variables are created in much the same way
  • class and instance variables are used in a different manner than local variables

Creating Variables

• Top
• page 039 before using a variable, you must create the variable by declaring its name and type
  • the type is listed first, followed by the name
  • examples:
    • int loanLength;
    • String message;
    • boolean gameOver;
  • local variables can be declared at any place inside a method, but they must be declared before their use
• page 039 the following example displays three variables declared at the top of a program's main() method
  • 
    public static void main(String[] arguments) {
        int total;
        String reportTitle;
        boolean active;
    }
• page 040 you can declare several variables of the same type on one line by separating them with comas
  • example: String street, city, state;
• page 040 you can give them initial values by using an equal sign
  • examples:
    • String zipCode = "07008";
    • int box = 350;
    • boolean pbs = true;
    • String name = "John", city = "Providence", state = "RI";
• page 040 local variables must have values before using them, or your program won't compile successfully
• page 040 Instance and Class variables are given an initial value depending on their type
  • examples:
    • Numeric variables: 0
    • Characters: "/0"
    • Booleans: false
    • Objects: null

Naming Variables

• Top
• page 040 variable names must start with a letter, an underscore character _, or a dollar sign $
  • variable names cannot start with a number
  • after the first character, they can include any combination of letters, numbers, underscore, or dollar sign
• page 040 the Java language uses the Unicode character set, which includes thousands of character sets to represent international alphabets.
  • Accented characters and other symbols can be used in variable names as long as they have a Unicode character number.
• page 041 Java is case-sensitive so car & Car are two different variable names
• page 041 naming conventions used when creating Java variables, espcially when combining words to define the name
  • the first letter of a variable name is lowercase
  • each successive word begins with a capital letter
  • all other characters are lowercase
  • examples:
    • Button loadFile;
    • int localAreaCode;
    • boolean quitGame;
• page 041 avoid using undercores and dollar signs even though they are allowed
  • one exception, when using all uppercase to name a variable name, use the underscore to separate words
  • example: static int DAYS_IN_WEEK = 7;

Variables Types

• Top
• page 041 besides the name of a variable, the type must also be declared
  • three types of types
    • one of the primitive data types, such as int or boolean
    • the name of a class or interface
    • an array

Data Types

• Top
• page 042 Java has 8 basic data types that store integers, floating-point numbers, characters, and Boolean values.
  • These are often called primitive data types because they are built-in parts of the language rather than objects, which make them easier to create & use.

• Top
• page 042 all these types are signed, which means values can be positive or negative values
  • the type used depends on the range of values it might need to hold
  • none of the integer variables can reliably store a value that is either too large or too small for its designated variable type
  • so take care when designating a type
• page 042 Floating-Point numbers can be designated as float or double.
  • Floating-Point numbers are numbers with a decimal point
  • double is preferred because its more precision
• reserve

• Top
• page 042 the char type is used for individual characters, such as letters, numbers, punctuation, and other symbols
• page 042 boolean holds either true or false
• page 042 all these variable types appear in lowercase
  • some class names have the same names as these data types, but with different capitalization, such as Boolean or Double
  • these are created and referenced differently in a Java program
  • so you cannot use them interchangeably in most circumstances
• page 043 there is a ninth primitive type in Java named void which indicates nothing
  • it's used in methods to indicate that they do not return a value

Class Types

• Top
• page 043 besides primitive data types, a variable can have a class as its type
  • examples
    • String lastName = "Hopper";
      Color hair;
      MarsRobot robbie;
• page 043 when a variable has a class type
  • the variable refers to an object of that class or one of its subclasses
• page 043 for the line: MarsRobot robbie;
  • creates a variable named robbie that is reserved for a MarsRobot object

Assigning Values to Variables

• Top
• page 043 After a variable has been declared, a value can be assigned to it with the assignment operator =
  • examples:
    • idCode = 8675309;
      accountOverdrawn = false;

Constants

• Top
• page 043 Constant - a variable who's value never changes as a program runs
  • Constants are useful in defining shared values for the use of all methods of an object.
  • in Java you can create constants for all kinds of variables, ie: instance, class, and local.
• page 044 to declare a constant, use the final keyword before the variable declaration and include an initial value for that variable
  • examples:
    • final double PI = 3.141592;
      final boolean DEBUG = false;
      final int PENALTY = 25;
• page 044 Constants can be used for naming various states of an object and then testing for those states
  • example: you have a program that takes directional input from the numeric keypad on the keyboard
    • press 8 to go up, 4 to go left, 6 to go right, and 2 to go down
    • you can define those values as constant integers
    • final int LEFT = 4;
      final int RIGHT = 6;
      final int UP = 8;
      final int DOWN = 2;
• page 044 Constants makes a program easier to understand
  • in this example the second statement is easier to understand
  • guide.direction = 4;
    guide.direction = LEFT;
• page 044 Java programmers usually use a convention that all contant variables are words in uppercase, such as LEFT or DEBUG
• page 044 when the name consist of many words spelled in caps, use the underscore to separate the words, ie: ESCAPE_CODE
  • final int ESCAPE_CODE = 27;
• reserve

Chapter 2 First Project

• Top
• page 044 this project is a Java application that creates several variables, assign them initial values, and displays two of them as output.
  • run NetBeans and create a new Java program by taking these steps
    1. Choose the menu command File, New File. The "New File" dialog box opens.
    2. In the Categories pane, choose Java
    3. In the "File Types" pane, choose "Empty Java File" and click the "Next" button. The "Empty Java File" dialog box opens.
    4. In the "Class Name" text field, enter Variables, which will give the source code file the name Variables.java
    5. In the "Package Name" text field, enter com.java21days.
    6. Click the "Finish" button.

• page 045 On this project, you specify a class name and a package name.
  • Packages are a way to organize related Java programs together.
  • They serve a similar purpose to file folders in a file system.
  • Enter the following code into the source code editor.
  • 
    package com.java21days;
    
    public class Variables {
    
        public static void main(String[] arguments) {
            final char UP = 'U';
            byte initialLevel = 12;
            short location = 13250;
            int score = 3500100;
            boolean newGame = true;
    
            System.out.println("Level: " + initialLevel);
            System.out.println("Up: " + UP);
        }
    }
    
    
• page 045 Save the file by choosing File, Save
  • NetBeans automatically compiles the application if it contains no errors.
  • Run the program by choosing Run, Run File.
  • This program produces the output shown below.

Screen Shot of the Output Pane

• Top
• page 046 The package name of the class is established by the package statement, which must be the first line of a Java program when it is used:
  package com.java21days;

• page 046 This class uses four local variables and one constant, making use of the System.out.println() in lines 12 - 13 to produce output.
  • System.out.println() is a method called to display strings and other information to the standard output device, which is usually the monitor.
  • This method takes a single argument within its parentheses: a string.
  • To present more than one variable or literal as the argument to println(), the + operator combines the elements into a single string.
• page 046 Java also has a System.out.print() method that displays a string without terminating it with a newline character.
  • You can call print() instead of println() to display several strings on the same line.

Screen shots of the project

• the New Empty Java File | the Code | Run File | the Output pane

Comments

• Top
• page 046 Comments - text in a program describing what is happening in the code.
• page 046 There are three types of comments
  • single-line comments
  • multi-line comments
  • Javadoc comments

Single-line Comments

• Top
• page 046 a single-line comment is preceded by two slash characters //
  • everything from the slashes to the end of the line is considered a comment and disregarded by the compiler
  • example: int creditHours = 3; // set up credit hours for course

Multi-line Comments

• Top
• page 046 a multi-line comment begins with /* and ends with */
  • everything between these two delimiters is considered a comment, even over multiple lines
  • example:
  • /* This program occasionally deletes all files on
    your hard drive and renders it unusable
    forever when you click the Save button. */

Javadoc Comments

• Top
• page 047 A Javadoc comment begins with /** and ends with */.
  • Everything between those delimiters is considered to be official documentation on how the class and its methods work.
• page 047 Javadoc comments are designed to be read by utilities such as javadoc, a command-line tool that's part of the Java Development Kit (JDK).
  • This tool uses official comments to create a set of web pages that document the functionality of a Java class
  • show its place in relationship to its superclass and subclasses
  • and describe each of its methods.
• page 047 TIP - All the official documentation on each class in the Java Class Library is generated from Javadoc comments
  • You can view current Java documentation at http://docs.oracle.com/javase/8/docs/api
  • You learn how to use the javadoc tool in Appendix E, "Programming with the Java Development Kit."

Literals

• Top
• page 047 in addition to variables, you can work with values as literals in a Java statement
  • a literal is any number, text, or other information that directly represents a value.
  • the following assignment statement uses a literal:
  • int year = 2017;
  • the literal 2017 represents the integer value 2017
  • Numbers, characters, and strings are all examples of literals
  • Java has types of literals that represent different kinds of numbers, characters, strings, and Boolean values

Number Literals

• Top
• page 047 Java has several integer literals.
  • the number 4 is an integer literal of the int variable type
  • it can also be assigned to byte and short variables
    • because the number is small enough to fit into those integer types
  • an integer literal larger than an int can hold automatically
    • is considered to be of the type long
  • you also can indicate that a literal should be a long integer
    • by adding the letter L right after the number, no spaces between number and L
    • the L can be in either upper or lower case
• page 048 continues with an explanation of the example
• example:
  • pennyTotal = pennyTotal + 4L;
  • this statement adds the value 4, formatted as a long, to the current value of the pennyTotal variable
• page 048 to represent negative number as a literal
  • precede it with a minus sign (-) as in -45
• page 048 Floating-point literals use a period character . for the decimal point
  • the following statement uses a literal to set up a double variable
  • double gpa = 3.55;
  • all floating-point literals are considered to be of the double variable type instead of float
  • to specify a literal of float, add the letter F to the end of the literal, upper or lower case
  • example
    • float piValue = 3.1415927F;
  • you can use exponents in floating-point literals by using the letter e or E followed by the exponent
    • which could be a negative number
  • examples: the following statements use exponential notation
    • double x = 12e22;
    • double y = 19E-95;
  • a large integer literal can use the underscore character in place of a comma
  • example
    • int jackpot = 3_500_000;
    • the java compiler ignors the underscores
• page 048 Java also supports numeric literals that use binary, octal, and hexadecimal numbering
  • Binary numbers are a base-2 numbering system, only values 0 and 1 are used
    • example: 0, 1, 10, 11, 100, 101, 110, 111, 1000
    • each digit in the number is called a bit
    • the combination of eight numbers is a byte
    • a binary literal is specified by proceding it with 0b, as in 0b101 which equates to 5 in our base-10 numbering system
  • Octal numbers are a base-8 numbering system, only values 0 though 7 are used as a single digit, the eith number is 10
    • example: 0, 1, 2, 3, 4, 5, 6, 7, 10(8), 11(9) 12(10)
    • octal literals begin with a 0, so 010 is 8, 011 is 9, 012 is 10, 013 is 11, 014 is 12, 015 is 13, 016 is 14, 017 is 15, 020 is 16
  • Hexadecimal numbers are a base-16 numbering system, that can represent 16 numbers as a sinle digit
    • example: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F which represents 1 through 15 in decimal , 10 is 16, 11 is 17
    • hexadecimal literals begin with a 0x, therefore 0x12 is 18 and 0xFF is 255
• 049 examples of using octal or hexadecimal systems are better suited for other tasks, ie: using hex to change colors
  • green (0x001100), blue (0x000011), butterscotch (0xFFCC99)

Boolean Literals

• Top
• 049 when assigning a value to a Boolean Literals only teo values can be used, true or false.
  • example: boolean chosen = true;
  • note: that the literal true does not have quotation marks around it
  • if it did the java compiler would interpret the literal as a string of characters

Character Literals

• Top
• 049 Character Literals are expressed by a single character surrounded by single quotation marks, such as 'a', '#' ,and '3'.
  • the ASCII character set includes 128 characters, including letters, numbers, punctuation, and other characters useful in computing.
  • Java supports ASCII along with thousands of additional characters from the Unicode character standard
• 049 some character literals represents characters that are not readily printable or accessible from a keyboard
  • Table 2.2 from page 050 lists the codes that can represent these special characters as well as characters from the Unicode character set
  • the letter d in the octal, hex, and Unicode escape codes represents a number or a hexadecimal digit (a through F or A through F).

String Literals

• Top
• 050 String Literals represents strings of characters
  • a string in Java is an object
    • rather than a primitive data type
• 050 because string objects are real objects in Java,
  • methods are available to combine strings, modify strings, and determine whether two strings have the same value, (compare strings)
• 050 String Literals consist of a series of characters inside double quotation marks
  • examples
    • String quitMsg = "Are you sure you want to quit?";
    • String password = "drowssap";
  • Strings can include the character escape codes listed in Table 2.2
  • examples
    • String example = "Socrates asked, \"Hemlock is poison?\"";
    • System.out.println("Sincerely, \nMillard Fillmore\n");
    • String title = "Sams Teach Yourself Node in the John\u2122";
      • in this example, the Unicode code sequence \u2122 produces a TM symbol on systems that have been configured to support Unicodeffff
• 051 Caution: Although Java supports the transmission of Unicode characters
  • a computer also must support it for the characters to be displayed when the program is run
• 051 Although string literals are used in a manner similar to other literals in a program
  • they are handled differently behind the scenes.
• 051 with a string literal, Java stores that value as a String object.
  • you don't have to explicitly create a new object, as you must when working with other objects, so they are an easy to work with as primitive data types
  • Strings are unsual in this respect - none of the basic types are stored as an object when used

Expressions and Operators

• Top
• 051 An expression is a statement that can convey a value, some of the most common expressions are mathematical
• examples
  • int x = 3;
  • int y = x;
  • int z = x * y;
• 051 these three statements can be considered expressions
  • they convey values that can be stores as variables
    • the first assigns the literal 3 to the variable x
    • the second assigns the value x to the variable y
    • in the third expression, the multiplication operator * is used to multiply the x and y integers
      • and the result is stored in the z integer.
• 051 Expressions can be any combination of variables, literals, and operators.
  • They also can be method calls because methods send back a value to the object or class that called the method.
• 052 The value conveyed by an expression is called a return value.
  • This value can be assigned to a variable and used in many other ways in your Java program.

• 052 Most of the expressions in Java use operators such as *.
  • Operators are special symbols used for:
    • mathematical functions
    • assignment statements
    • logical comparisons

Arithmetic

• Top
• 052 Five operators are used to accomplish basic arithmetic in Java
  • as shown in Table 2.3

• Top
• 052 Each operator takes two operands
  • one on each side of the operator

• 052 The subtraction operator also can be used to negate a single operand
  • which is equivalent to multiplying that operand by -1.

• 052 One thing to be mindful of when performing division is the type of numbers being used.
• 052 If you store a division operation in an integer, the result is truncated to the next-lower whole number,
  • because the int data type can't handle floating-point numbers.
  • example: 31 / 9 results in 3 if stored in an integer - int data type

• 052 Modulus division, which uses the % operator, produces the remainder of a division operation
  • The expression 31 % 9 results in 4 because 31 divided by 9, with the whole number result of 3, leaves a remainder of 4

• Top
• 052 Note that many arithmetic operations involving integers produce an int regardless of the original type of operands
  • If you're working with other numbers, such as floating-point numbers or long integers,
  • you should make sure that the operands have the same type you're trying to end up with.

The next project

• Top
• 052 The next project is a Java class that demonstrates how to perform simple aritemetic in the language.
  • Create a new empty Java file in NetBeans called Weather in the com.java21days package
  • and enter the code shown in Listing 2.2 into the source code editor.
  • Save the file with the command File, Save when your done.
• from page 044: this project is a Java application that creates several variables, assign them initial values, and displays two of them as output.
  • run NetBeans and create a new Java program by taking these steps
    1. Choose the menu command File, New File. The "New File" dialog box opens.
    2. In the Categories pane, choose Java
    3. In the "File Types" pane, choose "Empty Java File" and click the "Next" button. The "Empty Java File" dialog box opens.
    4. In the "Class Name" text field, enter Weather, which will give the source code file the name Weather.java
    5. In the "Package Name" text field, enter com.java21days.
    6. Click the "Finish" button.
• Enter the following code into the source code editor.
• from: page 045 Save the file by choosing File, Save
  • NetBeans automatically compiles the application if it contains no errors.

Listing 2.2

• page 053
  
  package com.java21days;
  
  public class Weather {
      public static void main(String[] arguments) {
          float fah = 86;
          System.out.println(fah + " degrees Fahrenheit is ...");
          // To convert Fahrenheit into Celsius
          // begin by subtracting 32
          fah = fah - 32;
          // Divide the answer by 9
          fah = fah / 9;
          // Multiply that answer by 5
          fah = fah * 5;
          System.out.println(fah + " degrees Celsius\n");
  
          float cel = 33;
          System.out.println(cel + " degrees Celsius is ...");
          // To convert Celsius into Fahrenheit
          // begin by multiplying by 9
          cel = cel * 9;
          // Divide the answer by 5
          cel = cel / 5;
          // Add 32 to the answer
          cel = cel + 32;
          System.out.println(cel + " degrees Fahrenheit");
      }
  }
  
  

Listing 2.2 (from NetBeans) displayed below

• Top
• 053 Run the program by selecting Run, Run File.
  • It produces the output shown in Figure 2.2
• reserve

Figure 2.2 goes here

• Top
• 053 In lines 5 - 14 of this Java application
  • a temperature in Fahrenheit is converted to Celsius using arithmetic operators:
  • Line 5 - The floating-point variable fah is created with a value of 86
  • Line 6 - The current value of fah is displayed
• 054
  • Line 7 - The first of several comments explains what the program is doing. The Java compiler ignores these comments
  • Line 9 - fah is set to its current value minus 32
  • Line 11 - fah is set to its current value divided by 9
  • Line 13 - fah is set to its current value multiplied by 5
  • Line 14- Now that fah has been converted to a Celsius value, fah is displayed again

• 054 A similar thing happens in lines 16 - 25, but in the reverse direction
  • A temperature in Celsius is converted to Fahrenheit
• reserve

More About Assignment

• Top
• 054 Assigning a value to a variable is an expression because it produces a value
  • Because of this feature, you can combine assignment statements in this unusual way
  • x = y = z = 7;
  • In this statement, all three vaiables x, y, and z end up with the value of 7
  • The right side of an assignment expression always is calculated before the assignment takes place
  • this makes it possible to use an expression statement as in the following code:
  • int x = 5;
  • x = x + 2;
  • In the expression x = x + 2, the first thing that happens is that x + 2 is calculated
    • The result of this calculation, 7, is then assigned to x
  • Using an expression to change a variable's value is a common task in programming
    • Several operators are used strictly in these cases.
  • reserve
• 054 Table 2.4 shows these assignment operators and the expressions they are functionally equivalent to

• Top
• 055 Caution
  • These shorthand assignments operators are functionally equivalent to the longer assignment statements for which they substitute. If either side of your assignment statement is part of a complex expression, however, there are cases where the operators are not equivalant. For example, if x equals 20 and y equals 5, the following two statements do not produce the same value:
  • x = x / y + 5;
  • x /= y + 5;
  • The first statement produces an x value of 9 and the second an x value of 2. When in doublt about what an expression is doing, simplify it by using multiple assignment statements and don't use the shorthand operators.
• reserve

Incrementing and Decrementing

• Top
• 055 Another common task required in programming is to add or subtract 1 from an integer variable.
  • These expressions have special operators, which are called incrementand decrement operators.
  • Incrementing a variable means adding 1 to its value
  • and decrementing a variable means subtracting 1 from its value.
• 055 The increment operator is ++
  • The decrement operator is --
• 055 These operators are placed immediately after or before a variable name, as in the following code
  • int x = 7;
  • x++;
  • In this example, the statement x++ increments the x variable from 7 to 8
• 055 These increment and decrement operators can be placed before or after a variable name
  • This affects the value of expressions that involve these operators
• 055 increment and decrement operators are called prefix operators if listed before a variable name and postfix operators if listed after a name.
• 055 In a simple expression such as count--;,
  • using a prefix or postfix operator produces the same result,
  • making the operators interchangeable.
  • When increment and decrement operators are part of a larger expression, however, the choice between prefix and postfix operators is important
• 055 consider the following code:
  • int x, y, z;
  • x = 42;
  • y = x++;
  • z = ++x;
• 056 The three expressions in this code yield different results because of the difference between prefix and postfix operations
• 056 When you use postfix operators on a variable in an expression,
  • the variable's value is evaluated in the expression before it is incremented or decremented
  • So in y = x++; y receives the value of x before it is incremented by 1
  • reserve
• 056 When you use prefix operators on a variable in an expression,
  • the variable is incremented or decremented before its value is evaluated in that expression.
  • Therefore, in z = ++x, x is incremented by 1 before the value is assigned to z
• 056 The end result of the preceding codes examples is that y equals 42, z equals 44 and x equals 44

• Top
• If you're still having some trouble figuring this out, here's the example again with comments describing each step
  • int x, y, z; // x, y, and z are declared
  • x = 42;      // x is given the value 42
  • y = x++;     // y is given x's value (42) before it is incremented
  •              // and x is then incremented to 43
  • z = ++x;     // x is incremented to 44, and z is given x's value

• Top
• 056 Caution ... Using increment and decrement operators in complex expressions can produce results you might not expect
  • The concept of "assigning x to y before x is incremented" isn't precisely right, because Java evaluates everything on the right side of an expression before assigning its value to the left side.
  • Java stores some values before handing an expression to make postfix work the way it has been described in this section.
  • If you're not getting the results you expect from a complex expression that includes prefix and postfix operators, try breaking the expression into multiple statements to simplify it.

Comparisons

• Top
• 056 Java has several operators for making comparisons among variables, variables and literals, and literals, or other types of information in a program.
• 056 These operators are used in expressions that return Boolean values of true or false
  • depending on whether the compararison being made is true or not.
  • Table 2.5 shows the comparison operators.

• Top
• 057 The following example shows a comparison operator in use:
  • boolean isHip;
  • int age = 37;
  • isHip = age < 25;
• 057 The expression age < 25 prodeces a result of either true or false
  • depending on the value of the integer age
  • because age is 37 in this example (which is not less than 25), isHip is given the Boolean value false.
• reserve

Logical Operators

• Top
• 057 Expressions that result in Boolean values, such as comparison operations, can be combined to form more complex expressions
  • This is handled through logical operators
    • which are used for the logical combinations AND, OR, XOR, and logical NOT
  • For AND combinations,the & or && logical operator is used
  • When two Boolean expressions are linked by these operators, the combined expression returns a true value only if both Boolean expressions are true
  • Consider this example
    • boolean extralife = (score > 75000 & (playerLives < 10);
    • this expression combines two comparison expressions: score > 75000 and playerLives < 10
      • If both expressions are tru, the Boolean value true is assigned to the variable extraLife
      • in any other circumstance, the false is assigned to the variable
    • reserve
  • the difference between & and && lies in how much work Java does on the combined expression
    • if &is used, the expressions on both sides of the & are evaluated no matter what
    • if && is used and the left side of the && is false, the expression on the right side of the && never is evaluated.
  • 058 this makes && more efficient because no unneccessary work is performed
    • In the preceding example if score is not ggreater than 75000, there's no need to consider whether playerLives is less than 10

• Top
• 058 For OR combinations, the | or || logical operator is used
  • These combined expressions return a true value if either Boolean expresion is true.
  • consider this example:
    • boolean extraLife = (score > 75000) || (playerLevel == 0);
    • This expression combines two comparison expressions score > 75000 and playerLevel == 0.
    • if either of these expressions is true, the Boolean value true is assigned to the variable extraLife
    • Only if both of these expressions are false is the value false assigned to extraLife
  • Note the use of || instead of |
    • Because of this usage, if score > 75000 is true
      • extraLife is set to true
      • and the second expression never is evaluated.
• 058 the XOR combination has one logical operator, ^
  • This results in a true value only if the Boolean expressions it combines have opposite values.
  • If both are true or both are false,
    • the ^ operator produces a false value.
• 058 the NOT combination uses the ! logical operator followed by a single expression
  • It reverses the value of a Boolean expression in the same way that a minus sign reverses the positive or negative sign on a number.
  • For example, if age < 25 returns a true value,
    • ! (age < 25) returns a false value
• 058 the logical operators may seem illogical when you first encounter them
  • you get plenty of opportunities to work with them during the rest of this week, especially on Day 5, "Creating Classes and Methods."

Operator Precedence

• Top
• 058 when more than one operator is used in an expression, Java has an established precedence hierarchy to determine the order in which operators are evaluated
  • in many cases, this precedence determines the expression's overall value
  • For example: consider the following expression:
    • y = 6 + 4 / 2;
  • The y variable will equal the value 5 or the value 8, depending on which arithmetic operation is handled first.
  • If the 6 + 4 expression comes first, y has the value of 5.
  • Otherwise, y equals 8.

• 059 In general, the order of evaluation from first to last is as follows
  1. Increment and decrement operations
  2. Arithmetic operations
  3. Comparisons
  4. Logical operations
  5. Assignment expressions
• 059 If two operations have the same precedence, the one on the left in the expression is handled before the one on the right.
  • Table 2.6 shows the specific precedence of the various operators in Java.
  • Operators higher up in the table are evaluated first.

• Top
• 060 several of the operators listed in Table 2.6 are covered later this week
• 060 Returning to the expression y = 6 + 4 / 2, Table 2.6 shows that division is evaluated before addition, so the value y equals 8
• 060 To change the order in which expressions are evaluated
  • place parentheses around the expressions that should be evaluated first.
  • You can nest one set of parentheses inside another to make sure that expressions are evaluated in the desired order
  • the innermost parenthetic expression is evaluated first
• 060 The following expression results in a value of 5
  • y = (6 + 4) / 2
• 060 The value of 5 is the result because 6 + 4 is calculated first, and then the result, 10 is divided by 2
• 060 Parentheses also can improve an expression's readability.
  • If an expression's precedence isn't immediately clear to you
  • adding parentheses to impose the desired precedence can make the statement easier to understand.

String Arithmetic

• Top
• 060 As stated before, the + operator has a double life outside the world of mathematics.
  • It can concatenate two or more strings.
• 060 The + operator combines strings, other objects, and variables to form a single string.
• 060 Working with the concatenation operator is made easier in Java by the fact that the operator can handle any variable type and object value as if it were a string.
  • If any part of a concatenation operation is a String or a string literal, all elements of the operation are treated as if they were strings:
  • System.out.println(4 + "score and " + 7 + " years ago");
  • This produces the output text "4 score and 7 years ago", as if the integer literals 4 and 7 were strings.
• 061 There also is a += shorthand operator to append something to the end od a string.
  • For example, consider the following expression:
  • myName += " Jr.";
  • This expression is equivalent to the following:
  • myName = myName + " Jr.";
  • In this example, += changes the value of myName, which might be something like "Robert Downey," by adding "Jr." at the end to form the string "Robert Downey Jr."
  • To summarize today's material, Table 2.7 lists the operators you have learned about.

Summary

• Top
• Anyone who pops open a set of matryoshka dolls has to be a bit disappointed upon reaching the smallest doll in the group.
• Today you reached Java's smallest nesting doll. Using statements and expressions enables you to begin building effective methods, which make effective objects and classes possible.
• Today you learned about creating variables and assigning values to them. You also used literals to represent numeric, character, and string values and worked with operators. Tomorrow, you'll put these skills to use developing classes.

Q & A

• Top
• Q What happens if I assign an integer value to a variable that is too large for that variable to hold?
• A Logically, you might think that the variable is converted to the next-larger type, but this isn't what happens. Instead, an overflow occurs - a situation in which the number wraps around from one size extreme to the other. An example of overflow would be a byte variable that goes from 127 (an acceptable value) to 128 (unacceptable). It would wrap around to the lowest acceptable value, which is -128, and start counting upward from there. Overflow isn't something you can readily detect in a program, so be sure to give numeric variables plenty of living space in their chosen data type.
• Small data types like byte were more necessary when computers had much less memory than they do today and every byte counted. Today, with plentiful memory and hard disk space measured in terrabytes, it is better to use larger data tyoes like int to ensure that you have enough space to store all possible values in a particular variable

• Q Why does Java have all these shorthand operators for arithmetic and assignment? It's really hard to read that way.
• A Java's syntax is based on C++, which is based on C. C is an expert language that values programming power over readability, and the shorthand operators are one of the legacies of that design priority. Using them in a program isn't required because effective substitutes are available, so you can avoid them in your own programming if you prefer.

• Q The MarsRobot and MarsApplication programs on Day 1 didn't contain a package statement. Does that mean they're not in a package?
• A All Java programs belong to a package. When the package statement appears in a program, the program is part of that named package. The programs you created during this day are all in the com.java21days package.
• A program that does not have a package statement is put into the default package, which does not have a name. Although programs can be created in this unnamed package, it's good practice to always specify a package with each program you create in Java.

Quiz

• Top

1. Which of the following is a valid value for a boolean variable?
   1. "false"
   2. false
   3. 10
2. Which of these is NOT a convention for naming variables in Java"
   1. After the first word in the variable name, each successive word begins with a capital letter.
   2. The first letter of the variable name is lowercase.
   3. All letters are capitalized
3. Which of these data types holds numbers from -32,768 to 32, 767
   1. char
   2. byte
   3. short

Answers

• Top

1. B. In Java, a boolean can only be true or false. If you put quotation marks around the value, it is treated like a String rather than one of the two boolean values.
2. C. Constant names are capitalized to make them stand out from other variables.
3. C. The short primitive data type has that range of values.

Certification Practice

• Top
• The following question is the kind of thing you could expect to be asked on a Java programming certification test. Answer it without looking at today's material.
• The answer is available on the book's website at www.java21days.com

1. Which of the following data types can hold the number 3,000,000,000 (3 billion)?
   1. short, int, long, float
   2. int, long, float
   3. long, float
   4. byte

Exercise

• Top
• To extend your knowledge of the subjects covered today, try the following exercises:
  1. Create a program that calculates how much a $14,000 investment would be worth if it increased in value by 40% during the first year, lost $1,500 in value the second year, and increased 12% in the third year.
  2. Write a program that displays two numbers and uses the / and % operators to display the result and remainder after they are divided. Use the \t character escape code to make a tab character separate the result and remainder in your output.
• Exercise solutions are offered on the book's website at www.java21days.com

End of Day 2

• Below are screenshots that I captured for this chapter.

Screenshots from running the first project in Chapter 2

The "New Empty Java File" dialog box

• Top | back to First Project | back to "Screen shots of the project"
• Screen shot displays the dialog box with Variables in the "Class Name" & com.java21days in the "Package" field.

The code from the book

• Top | back to First Project | back to "Screen shots of the project"
• view of inside the source code pane, note the tab is named Variables.java

Getting ready to run the file

• Top | back to First Project | back to "Screen shots of the project"
• the code has already been saved

The Output Pane

• Top | back to First Project | back to "Screen shots of the project" | go to Comments
• looks like a successful run

Reserve

• reserve