Lecture Notes 05: More Numeric Variable Types And Casting

Objectives

• Create variable declarations for variables.
• Assign values to variables by simple assignment, and print them out.
• Demonstrate ability to perform operations for a desired output.
• Evaluate expressions with variables in them.
• Convert values by using Casting
• Convert English descriptions of operations into expressions.
• Mentally trace execution with expressions and calculations.
• Identify new syntactic elements related to the above.
• Demonstrate how to read values entered by the user into the terminal

And, once we've worked with integers, we'll also do some "number crunching".

Before Starting

• Read Sections 5.01 to 5.04 in the Codio Course

If you do not have your Codio course ready, use any text editor or simple IDE. Some possibilities are:

• Write using Sublime; Compile and run in the Terminal
• Use IDEs like: IntelliJ, DrJava, or JGrasp

Catching Up

Before we move forward, let's catch up (complete any remaining work from the previous module)
In this case, make sure we've got:

1. Integers: Decclaring, assignming and use in operations

Real-valued variables

About real numbers:

• We typically think of real numbers as numbers "with something after the decimal point" like 3.14159 or 2.718.

• But 3, an integer, is also a real number.

• The "reals" are a much larger set, and include the integers.

• Some tidbits about the reals:
  • Some are rational meaning they can be expressed as a fraction of integers like 4/3.
  • Others are irrational and cannot be expressed as such, such as √2.
  • Some are algebraic, meaning they are the solution to an equation like 3x² + 5 = 11.
  • Those that aren't algebraic go by the lovely name of transcendental, such as π.
  • The reals are a fun group that like to party on weekdays.

• So, is every number a real number?
         ⇒ No, there are numbers like √-1 that are imaginary.

Just like we did with integers, we can declare variables and assign values to them, using the reserved word double

Another example:

• You might be wondering ... why is it called double?

• The short form int corresponds nicely with the English word integer. But double?

• There is an explanation.

• One can also use the Java reserved word float as a substitute for double, as in:

    float x = 3.14159;
      

• Here, float means English term floating point number.

• Think about this:
  • A number like π has an infinite number of digits after the decimal (as do all irrationals and transendentals).
  • Because a computer's internal storage is finite, we can only store a fixed number of digits.
  • Now, observe that 3.14159 = 0.314159 × 10 = 0.314159 × 10¹
  • The standard internal representation (in a computer) is to store the digits "314159" and the exponent "1" (the power of 10 here), all of which takes less space.
  • This is called a floating point representation because we can adjust the exponent to make the decimal point "float"
  • Another example: 42.93 = 0.4293 × 10², which implies the digits "4293" and exponent "2".

• Back to double:
  • The float format reserves a fixed number of spaces for digits.
  • This limits accuracy.
  • When you perform mathematical calculations with numbers represented in the float format, you can run into accuracy issues quickly.
  • This is why Java allows the accuracy to be doubled using double.

• Hardly anyone uses float. anymore. We'll use double.

Again, as with integers, the standard operators apply:

Activity 1: Complete the program called AreaExample.java to print out the area of a circle whose radius is specified in the code. The template is in Codio, Mod 5 [in-Lecture]: More numeric Types and Casting

Activity 2: Do the increment and decrement operators work with real numbers? Write a program called TestIncrement.java to find out. In this program, declare variables x and y of type double, setting them to x=1.1 and y=1.2; then apply the increment (++) and decrement (--) operators to x and y respectively.

Now consider this simple example:

Activity 3: Change the assignment to:

and see what prints. Explain the result.

Casting

Consider the following program:

Activity 4: What you suppose will be printed? Try it. Then, change the program to try the assignment the other way around: initially assign the value of 1 to i and then assign i to x.

An assignment from an int to a double works fine:

About casting:

• The assignment from int to double works because every int is a valid double value.

• However, a double need not be a valid int.
         ⇒ Which is why the compiler complains.

• Recall: we faced the same issue in going from int to char.

• However, as we did in that case, we can force an assignment using an explicit cast

  

• The result: the largest integer less than the real.
         ⇒ The result is 1 above.

• An explicit cast is need even if the double's value happens to be an integer like 1.0.

• As we'll see later, casting is a general operation that can be applied to different variable types.

When things go wrong

look at the code below and identify all the syntax (spelling) and semantic(logical) errors.

Activity 6: If the objective is to calculate the average grade of a student, find all the errors and bugs in the following program:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

  public class CalcMyGrade
  {
    public static void main(String args[]) 
    {
      // This is a very naive way of doing this
      // We'll do this in a cooler way very soon

      int grade1 = 86;
      int grade 2 = 60;
      int 3grade = 98;
      int grade_four = 76;
      int grade5 = 0;

      int sum = grade1 + grade 2 + 3grade + grade_four;
      System.out.print ("sum is: ");
      System.out.println ( sum );

      int total = 5;
      double averageGrade = sum/total;
      System.out.print ("averageGrade is: ");
      System.out.println ( averageGrade );

      // Applying a +1 point bonus AND THEN a 10% curve 
      double finalGrade = (averageGrade*1.1)+1;
      System.out.println(finalGrade);
  }
  

Reading values from the terminal

One very useful feature is to be able to "read in" vallues from the terminal. The way we'll do this is to use a predefined block of code that we will not explain in detail for now. The block of code is between the comments:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

  import java.util.Scanner;

  public class ScannerTest
  {
    public static void main(String args[])     
    {
      System.out.println ("Give me a number and then press Enter: ");

      // Scanning code starts here
      Scanner myScanner = new Scanner (System.in);
      String s = myScanner.nextLine ();
      // Scanning code ends here

      System.out.println (s);

    }
  }  
  

Activity 7: Try the scanner code in Codio.

Using Fancy operations

Sometimes, we need to do operations that are a bit more complex, like elevating a number to a power, or obtaining the square root.

Later, we'll look a t this more closely, but for now, look at the following code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

  public class PowAndSqrtTest
  {
    public static void main(String args[])     
    {
      double side = 2;

      // Easy squaring of a value
      double square = side*side;
      System.out.println (square);

      // Squaring with pow
      square = Math.pow(side,2);
      System.out.println (square);

      // Other powers with pow
      double cube = Math.pow(side,3);
      System.out.println (cube);

      // Square root with sqrt
      double root = Math.sqrt(square);
      System.out.println (root);

    }
  }  
  

Activity 8: we will open a new file in Codio, and complete this example.