Home > Chapter 2: Primitive Data Types and Operations

Chapter 2: Primitive Data Types and Operations


Chapter 2: Primitive Data Types and Operations

 

Writing Simple Programs 

  • Computing an area of a circle.  The algorithm for this program is as follows:
  • Read in the Radius
  • Compute the area using the following formula
  • Area = radius * radius * ∏
  • Display the area.
  • Java provides data types for representing integers, floating-point numbers, characters, and Boolean types.  These types are known as primitive data types.
  • When you code, you translate an algorithm into a programming language understood by the computer.
  • The outline of the program is:
 

    // ComputeArea.Java: compute the area of a circle Comment 
     
    public class ComputeArea// Class Name 

      public static void main(String[] args)// Main Method signature 
      {  
        double radius;// Data type & variable 
        double area; 
        // Assign a radius 
        radius = 20; 
       // Compute area 
       area = radius * radius * 3.14159;// Expression 
       // Display results 
       System.out.println("The area for the circle of radius "

           + radius + " is " + area); 
      }


     

no value

radius

allocate memory for radius

no value

radius

memory

no value

area

allocate memory for area

 
 
 
 

20

radius

no value

area

assign 20 to radius

20

radius

memory

1256.636

area

compute area and assign it to variable area

 
 

print a message to the console

  • The program needs to declare a symbol called a variable that will represent the radius.  Variables are used to store data and computational results in the program. 
     
  • Use descriptive names rather than x and y.  Use radius for radius, and area for area.  Specify their data types to let the compiler know what radius and area, indicating whether they are integer, float, or something else. 
  • The program declares radius and area as double variables.  The reserved word double indicates that radius and area are double-precision floating-point values stored in the computer. 
  • For the time being, we will assign a fixed number to radius in the program.  Then, we will compute the area by assigning the expression radius * radius * 3.14159 to area. 
  • The program’s output is: 

   The area for the circle of radius 20.0 is 1256.636 

  • A string constant should not cross lines in the source code.  Use the concatenation operator (+) to overcome such problem.
 
 

Identifiers 

  • Programming languages use special symbols called identifiers to name such programming entities as variables, constants, methods, classes, and packages.

    • The following are the rules for naming identifiers:
      1. An identifier is a sequence of characters that consist of letters, digits, underscores (_), and dollar signs ($).
      1. An identifier must start with a letter, an underscore (_), or a dollar sign ($). It cannot start with a digit.
      2. An identifier cannot be a reserved word. (See Appendix A, “Java Keywords,” for a list of reserved words).
      3. An identifier cannot be true, false, or null.
      4. An identifier can be of any length.
    • Legal identifiers are for example: $2, ComputeArea, area, radius, and showMessageDialog.
    • Illegal identifiers are for example: 2A, d+4.
    • Since Java is case-sensitive, X and x are different identifiers.
     

    Variables 

  • Variables are used to store data input, data output, or intermediate data.
  • You can write the code shown below to compute the area for different radii:
 

    // Compute the first area

    radius = 1.0;

    area = radius*radius*3.14159;

    System.out.println("The area is “ + area + " for radius "+radius); 

    // Compute the second area

    radius = 2.0;

    area = radius*radius*3.14159;

    System.out.println("The area is “ + area + " for radius "+radius); 

Declaring Variables 

  • Variables are used for representing data of a certain type.

    • To use a variable, you declare it by telling the compiler the name of the variable as well as what type of data it represents.  This is called variable declaration.
    • Declaring a variable tells the compiler to allocate appropriate memory space for the variable based on its data type.  The following are examples of variable declarations:
     

         int x;         // Declare x to be an integer variable;

         double radius; // Declare radius to be a double variable;

         char a;        // Declare a to be a character variable;

     

    • If variables are of the same type, they can be declared together using short-hand form:
     

      Datatype var1, var2, …, varn;   variables are separated by commas 

      Assignment Statements and Assignments Expressions 

    • After a variable is declared, you can assign a value to it by using an assignment statement.  The syntax for assignment statement is:
     

      variable = expression; 

          x = 1;          // Assign 1 to x;  Thus 1 = x is wrong

          radius = 1.0;   // Assign 1.0 to radius;

          a = 'A';        // Assign 'A' to a; 

          The variable can also be used in the expression. 

    x = x + 1; 

    • In Java, an assignment statement can also be treated as an expression that evaluates to the value being assigned to the variable on the left-hand side of the assignment operator.  For this reason, an assignment statement is also known as an assignment expression, and the symbol = is referred to as the assignment operator.
     

      System.out.println(x = 1);  ⇔ x = 1; System.out.println(x); 

      i = j = k = 1;   ⇔ k = 1; j = k; i = j; 

    • In an assignment statement, the data type of the variable on the left must be compatible with the data type of the value on the right.
     

          int x = 1.0; // is illegal because the data type of x is int 

    Declaring and Initializing Variables in One Step 

    • You can declare a variable and initialize it in one step.
     

       int x = 1;

       double d = 1.4;

       float f = 1.4; 

    • A variable must be declared before it can be assigned a value.
     

     

    Constants 

  • The value of a variable may change during the execution of the program, but a constant represents permanent data that never change.
  • The syntax for declaring a constant:
 

       final datatype CONSTANTNAME = VALUE;    

    final double PI = 3.14159;   // Declare a constant

    final int SIZE = 3; 

  • A constant must be declared and initialized before it can be used.  You can’t change a constant’s value once it is declared.  By convention, constants are named in uppercase.
  • There are three benefits of using constants: 
    1. You don’t have to repeatedly type the same value. 
    2. The value can be changed in a single location.
    3. The program is easy to read.
 

Numerical Data Types 

  • Every data type has a range of values.  The compiler allocates memory space to store each variable or constant according to its data type.
  • Java has six numeric types: four for integers and two for floating-point numbers.
 

    Name  Storage Size Range 

    byte            8 bits  -27 (-128)   to 27 – 1 (127)

    short          16 bits  -215 (-32768)  to 215 – 1 (32767)

    int            32 bits  -232 (-2147483648) to 215 – 1 (2147483647)

    long           64 bits  -263 to 263 - 1

    float          32 bits  6 – 7 significant digits of accuracy

    double         64 bits  14 – 15 significant digits of accuracy 

    Numeric Operators 

          +, -, *, /, and % 

          5/2 yields an integer 2.

          5.0/2 yields a double value 2.5.

          5 % 2 yields 1 (the remainder of the division.)  

    • A unary operator has only one operand.  A binary operator has two operands.
     

    NOTE

    • Calculations involving floating-point numbers are approximated because these numbers are not stored with complete accuracy. For example:
     

         System.out.println(1 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1); 

       displays 0.5000000000000001, not 0.5, and  

          System.out.println(1.0 - 0.9); 

    displays 0.09999999999999998, not 0.1.  

  • Integers are stored precisely. Therefore, calculations with integers yield a precise integer result.
 

    import javax.swing.JOptionPane; 
     
    public class DisplayTime { 
      public static void main(String [ ] args) { 
        int seconds = 500; 
        int minutes = seconds / 60; 
        int remainingSeconds = seconds % 60; 
        JOptionPane.showMessageDialog(null, 
        seconds + " seconds is " + minutes + 
        " minutes and " + remainingSeconds

        + " seconds"); 
      } 
    }

 


Numeric Literals 

  • A literal is a constant value that appears directly in the program. For example, 34, 1,000,000, and 5.0 are literals in the following statements:
  

      

int i = 34;

      

long l = 1000000;

      

double d = 5.0;  

Integer Literals 

  • An integer literal can be assigned to an integer variable as long as it can fit into the variable. A compilation error would occur if the literal were too large for the variable to hold.
  • For example, the statement byte b = 1000 would cause a compilation error, because 1000 cannot be stored in a variable of the byte type.
  • An integer literal is assumed to be of the int type, whose value is between -231 (-2147483648) to 231–1 (2147483647). To denote an integer literal of the long type, append it with the letter L or l. L is preferred because l (lowercase L) can easily be confused with 1 (the digit one).
 

Floating-Point Literals 

  • Floating-point literals are written with a decimal point. By default, a floating-point literal is treated as a double type value.
  • For example, 5.0 is considered a double value, not a float value.
  • You can make a number a float by appending the letter f or F, and make a number a double by appending the letter d or D.
  • For example, you can use 100.2f or 100.2F for a float number, and 100.2d or 100.2D for a double number.
 

Scientific Notations 

  • Floating-point literals can also be specified in scientific notation, for example, 1.23456e+2, same as 1.23456e2, is equivalent to 123.456, and 1.23456e-2 is equivalent to 0.0123456. E (or e) represents an exponent and it can be either in lowercase or uppercase.

     

    Arithmetic Expressions 

     

     
     
     

          Is translated to: 

    (3 + 4 * x)/5 – 10 * (y - 5)*(a + b + c)/x + 9 *(4 / x + (9 + x)/y) 

    • Operators contained within pairs of parentheses are evaluated first. Multiplication, division, and remainder operators are applied next.  Order of operation is applied from left to right.  Addition and subtraction are applied last.
     

       public class FahrenheitToCelsius { 
         public static void main(String [ ] args) { 
           double fahrenheit = 100; 
           double celsius = (5.0 / 9) * (fahrenheit -32); 
           System.out.println("Fahrenheit " + fahrenheit + " is " + 
             celsius + " in Celsius"); 
         } 
       } 

    • Result is: Fahrenheit 100.0 is 37.77777777777778 in Celsius
     

    Shorthand Operators 

    • The following statement adds the current value of i with 8 and assigns the result back to i.         i = i + 8;
    • Java allows you to combine assignment and addition operators using a shorthand operator. The preceding statement can be written as:   i += 8;
     

    Operator Example Equivalent

    +=  i+=8  i = i+8

    -=  f-=8.0 f = f-8.0

    *=  i*=8  i = i*8

    /=  i/=8  i = i/8

    %=  i%=8  i = i%8 

    • There are two more shortcut operators for incrementing and decrementing a variable by 1. These two operators are ++, and --.  They can be used in prefix or suffix notations.

     

    Increment and Decrement Operators

    Operator Name  Description 

    ++var  preincrement The expression (++var) increments var by 1 and evaluates

                            to the new value in var after the increment.

    var++  postincrement The expression (var++) evaluates to the original value

                            in var and increments var by 1.

    --var  predecrement The expression (--var) decrements var by 1 and evaluates

                            to the new value in var after the decrement.

    var--  postdecrement The expression (var--) evaluates to the original value

                            in var and decrements var by 1.

    Same effect as

     

    int newNum = 10 * i;

    i = i + 1;

     

    int i = 10;

    int newNum = 10 * i++;

     

     
     
     
     

    newNum = 100

    int i = 10;

    int newNum = 10 * (++i);

     

    i = i + 1;

    int newNum = 10 * i;

     

     

    Same effect as

     

     
     
     

    newNum = 110

     

    Ex:

     

      double x = 1.0;

      double y = 5.0;

      double z = x-- + (++y);

    • After execution, y = 6.0, z = 7.0, and x = 0.0; 
    • Using increment and decrement operators make expressions short; it also makes them complex and difficult to read. Avoid using these operators in expressions that modify multiple variables or the same variable for multiple times such as this:  

       int k = ++i + i.

     

    Numeric Type Conversions

    • Consider the following statements: 
     

      byte i = 100;

       long k = i*3+4;

       double d = i*3.1+k/2;

    • Are these statements correct? 
    • When performing a binary operation involving two operands of different types, Java automatically converts the operand based on the following rules:
     

         1.    If one of the operands is double, the other is converted into double.

         2.    Otherwise, if one of the operands is float, the other is converted into float.

         3.    Otherwise, if one of the operands is long, the other is converted into long.

         4.    Otherwise, both operands are converted into int.

    • Thus the result of 1 / 2 is 0, b/c both operands int values and the result of 1.0 / 2 is 0.5, b/c 1.0 is double and 2 is converted to 2.0
    • The range of numeric types increase in this order.

     

    • Type Casting is an operation that converts a value of one data type into a value of another data type.   
       
       
    • Casting a variable of a type with a small range to variable with a larger range is known as widening a typeWidening a type can be performed automatically without explicit casting.
    • Casting a variable of a type with a large range to variable with a smaller range is known as narrowing a typeNarrowing a type must be performed explicitly.
     

       float f = (float) 10.1;

       int i = (int) f;

     

      double d = 4.5; 
      int i =(int)d; 
      System.out.println("d " + d + " i " + i); // answer is d 4.5 i 4

     

    Implicit casting

     

          double d = 3; // type widening

     

    Explicit casting

     

          int i = (int)3.0; // type narrowing

     

    What is wrong? 

     

          int x = 5 / 2.0; // loss of precision

     

    Ex: A program that displays the sales tax with 2 digits after the decimal point.

     

    public class SalesTax { 
      public static void main(String [ ] args) { 
        double purchaseAmount = 197.55; 
        double tax           = purchaseAmount * 0.06; 
        System.out.println((int)(tax * 100) / 100.0); 
      } 
    }

     

    Answer is: 11.85

    Character Data Type and Operations

    • The character data type, char, is used to represent a single character. 
     

      char letter = 'A'; // Assigns A to char variable letter (ASCII)      

      char numChar = '4'; // Assigns digit character 4 to numChar (ASCII)

      char letter = '\u0041'; (Unicode  16-bit encoding scheme)

       char numChar = '\u0034'; (Unicode)

     

    Unicode and ASCII Code

    • Computers use binary numbers internally.  A character is stored as a sequence of 0s and 1s in a computer. 
    • The process of converting a character to its binary representation is called encoding.
    • There are different ways to encode a character.  How characters are encoded is defined by an encoding shceme.
    • Java supports Unicode, an endocing scheme established by the Unicode Consortium to support the interchange, processing, and diplay of written texts in the world’s diverse languages.
    • Unicode takes two bytes, preceded by \u, expressed in four hexadecimal numbers that run from '\u0000' to '\uFFFF'. So, Unicode can represent 65535 + 1 characters.
     

      char ch = ‘a’;

      System.out.println(++ch);  // displays b

     

    Escape Sequences for Special Characters

     

      Description       Escape Sequence  Unicode

      Backspace         \b    \u0008

      Tab                    \t    \u0009

      Linefeed            \n    \u000A

      Carriage return  \r    \u000D

      Backslash          \\    \u005C

      Single Quote      \'     \u0027

      Double Quote     \"    \u0022

    • Suppose you want to print the quoted message shown below: 

      He said “Java is fun”

    • The statement to print should be: 
     

      public class JavaFun { 
        public static void main(String [ ] args) { 
          System.out.println("He said \"Java is fun\""); 
        } 
      }

     

      Answer: He said "Java is fun"

     

     

     

    Casting between char and Numeric Types

    • A char can be cast into any numeric type, and vice versa.  When an int is cast into a char, only its lower 16 bits of data are used; the other part is ignored. 
     

      char c = (char)0XAB0041; //the lower 16 bits hex code 0041 is

            //assigned to c

      System.out.println(c); //c is character A

    • When a floating-point value is cast into a char, the integral part of the floating-point value is cast into a char
     

      char c = (char)65.25; //decimal 65 is assigned to c

      System.out.println(c); //c is character A

    • When a char is cast into a numeric type, the integral character’s Unicode is cast into the specified numeric type. 
     

      int i = (int) 'A';  // Same as int i = (int)'a';

      System.out.println(i); //i is character 65

    • The following casting is incorrect, b/c the Unicode \uFFF4 cannot fit into a byte: 
     

      byte b = ‘\uFFF4’;  byte b = (byte)‘\uFFF4’;

     
     

      int i = '1' + '2';// (int) 1 is 49 and (int) 2 is 50 
      System.out.println("i is " + i);

     

      int j = 1 + 'a'; // (int) a is 97 
      System.out.println("j is " + 98); 
      System.out.println(j + " is the Unicode for character " + (char) j); 
      System.out.println("Chapter " + 2);

     

       Output is:

     

         i is 99

         j is 98

         98 is the Unicode for character b

         Chapter 2

     

    The String Type

    • The char type only represents one character. To represent a string of characters, use the data type called String. For example,  

            String message = "Welcome to Java";

     

     

    •  
    • String is actually a predefined class in the Java library just like the System class and JOptionPane class. The String type is not a primitive type. It is known as a reference type. Any Java class can be used as a reference type for a variable.
    • Reference data types will be thoroughly discussed in Chapter 7, “Classes and Objects.” For the time being, you just need to know how to declare a String variable, how to assign a string to the variable, and how to concatenate strings.

    String Concatenation

    • The plus sign (+) is the concatenation operator if one of the operands is a string. 
    • If one of the operands is a non-string (e.g. a number), the non-string value is converted into a string and concatenated with the other string.
     

      // Three strings are concatenated

      String message = "Welcome " + "to " + "Java";

     

      message += “ and Java is fun”; // message = Welcome to Java and Java is fun

       

     // String Chapter is concatenated with number 2

      String s = "Chapter" + 2; // s becomes Chapter2

      

     // String Supplement is concatenated with character B

      String s1 = "Supplement" + 'B'; // s becomes SupplementB

     

      i = 1; j = 3; 
      System.out.println("i + j is " + i + j);   i + j is 13

      System.out.println("i + j is " + (i + j)); i + j is 4

     

    Getting Input from Input Dialog Boxes

     

      String string = JOptionPane.showInputDialog(

         null, “Prompt Message”, “Dialog Title”,   

         JOptionPane.QUESTION_MESSAGE));

     

      String string = JOptionPane.showInputDialog(

         null, x, y, JOptionPane.QUESTION_MESSAGE));

     

      where x is a string for the prompting message and y is a string for the title of the input dialog box.

     
    • There are several ways to use the showInputDialog method. For the time being, you only need to know two ways to invoke it.
    • One is to use a statement as shown in the example:
     

      String string = JOptionPane.showInputDialog(null, x,

        y, JOptionPane.QUESTION_MESSAGE));

    • where x is a string for the prompting message, and y is a string for the title of the input dialog box. 
    • The other is to use a statement like this: 
     
     
     

          JOptionPane.showMessageDialog(x);

     

          where x is a string for the prompting message.

     

    Converting Strings to Numbers

    • The input returned from the input dialog box is a string. If you enter a numeric value such as 123, it returns “123”. To obtain the input as a number, you have to convert a string into a number.  
    • The Integer and Double classes are both included in the java.lang package, and these are automatically imported.
     

     

    • To convert a string into an int value, you can use the static parseInt method in the Integer class as follows:
     

     

      int intValue = Integer.parseInt(intString);

     

     

      where intString is a numeric string such as “123”.

    • To convert a string into a double value, you can use the static parseDouble method in the Double class as follows: 
     

     

       double doubleValue = Double.parseDouble(doubleString);

     

     

       where doubleString is a numeric string such as “123.45”.

    • This program lets the user enter the amount in decimal representing dollars and cents and output a report listing the monetary equivalent in single dollars, quarters, dimes, nickels, and pennies. Your program should report maximum number of dollars, then the maximum number of quarters, and so on, in this order.  
     
     

     

      import javax.swing.JOptionPane; 
       
      public class ComputeChange { 
        /** Main method */ 
        public static void main(String[] args) { 
          // Receive the amount entered from the keyboard 
          String amountString = JOptionPane.showInputDialog(null, 
            "Enter an amount in double, for example 11.56", 
            "Example 2.3 Input", JOptionPane.QUESTION_MESSAGE); 
       
          // Convert string to double 
          double amount = Double.parseDouble(amountString); 
       
          int remainingAmount = (int)(amount * 100); 
       
          // Find the number of one dollars 
          int numberOfOneDollars = remainingAmount / 100; 
          remainingAmount = remainingAmount % 100; 
       
          // Find the number of quarters in the remaining amount 
          int numberOfQuarters = remainingAmount / 25; 
          remainingAmount = remainingAmount % 25; 
       
          // Find the number of dimes in the remaining amount 
          int numberOfDimes = remainingAmount / 10; 
          remainingAmount = remainingAmount % 10; 
       
          // Find the number of nickels in the remaining amount 
          int numberOfNickels = remainingAmount / 5; 
          remainingAmount = remainingAmount % 5; 
       
          // Find the number of pennies in the remaining amount 
          int numberOfPennies = remainingAmount; 
       
          // Display results 
          String output = "Your amount " + amount + " consists of \n" + 
            numberOfOneDollars + " dollars\n" + 
            numberOfQuarters + " quarters\n" + 
            numberOfDimes + " dimes\n" + 
            numberOfNickels + " nickels\n" + 
            numberOfPennies + " pennies"; 
          JOptionPane.showMessageDialog(null, output, 
            "Example 2.3 Output", JOptionPane.INFORMATION_MESSAGE); 
        } 
      }

     
     
     
     
     

      Displaying the current time

     

      import javax.swing.JOptionPane; 
       
      public class ShowCurrentTime { 
        /** Main method */ 
        public static void main(String[] args) { 
          // Obtain the total milliseconds since the midnight, Jan 1, 1970 
          long totalMilliseconds = System.currentTimeMillis(); 
       
          // Obtain the total seconds since the midnight, Jan 1, 1970 
          long totalSeconds = totalMilliseconds / 1000;

       
          // Compute the current second in the minute in the hour 
          int currentSecond = (int) (totalSeconds % 60); 
       
          // Obtain the total minutes 
          long totalMinutes = totalSeconds / 60; 
       
          // Compute the current minute in the hour 
          int currentMinute = (int) (totalMinutes % 60); 
       
          // Obtain the total hours 
          long totalHours = totalMinutes / 60; 
       
          // Compute the current hour 
          int currentHour = (int) (totalHours % 24); 
       
          // Display Results 
          String output = "Curent time is " + currentHour + ":" 
            + currentMinute + ":" + currentSecond + "GMT"; 
       
          JOptionPane.showMessageDialog(null, output); 
        } 

     

     

    Getting Input from the Console (optional)

    • You may obtain input from the console.  Java uses System.out to refer to the standard output device, and System.in to the standard input device. 
    • By default the output device is the console, and the input device is the keyboard.
    • To perform the console output, you simply use the println method to display a primitive value or a string to the console.
    • Console input is not directly supported in Java but you can use the Scanner class to create an object to read input from System.in as follows:
     

      Scanner scanner = new Scanner(System.in);

    • Scanner is a new class in JDK 1.5.  The syntax new Scanner(System.in) creates an object of the Scanner type. 
    • The whole line Scanner scanner = new Scanner(System.in) creates a Scanner object and assigns its reference to the variable Scanner.

      A Scanner object contains the following methods for reading an input:

     

      next() reading a string.  A string is delimited by spaces.

      nextByte() reading an integer of the byte type.

      nextShort()  reading an integer of the short type.

      nextInt() reading an integer of the int type.

      nextLong() reading an integer of the long type.

      nextFloat() reading an integer of the float type.

      nextDouble() reading an integer of the double type.

    • The following prompts the user to enter a double value from the console: 
     

      System.out.print(“Enter a double value:”);

      Scanner scanner = new Scanner(System.in);

      double d = scanner.nextDouble();

     

    Ex:

     

    import java.util.Scanner; //Scanner is in java.util 
     
    public class TestScanner { 
      /** Main method */ 
      public static void main(String[] args) { 
        // Create a scanner 
        Scanner scanner = new Scanner(System.in); 
     
        // Prompt the user to enter an int 
        System.out.print("Enter an Integer: "); 
        int intValue = scanner.nextInt(); 
        System.out.println("You entered the Integer: " + intValue); 
     
        // Prompt the user to enter a double value 
        System.out.print("Enter a double value: "); 
        double doubleValue = scanner.nextDouble(); 
        System.out.println("You entered the double value: " + doubleValue); 
     
        // Prompt the user to enter a string 
        System.out.print("Enter a string without a space: "); 
        String string = scanner.next(); 
        System.out.println("You entered string: " + string); 
     
      } 
    }

     

        Answer is: Enter an Integer: 25 
        You entered the Integer: 25 
        Enter a double value: 9.9 
        You entered the double value: 9.9 
        Enter a string without a space: saints 
        You entered string: saints

     

        Pedagogical Note

    • You can use JOptionPane or Scanner for obtaining input, whichever is convenient. 
     

    Ex:

     

    import java.util.Scanner; 
     
    public class ComputeLoanAlternative { 
      /** Main method */ 
      public static void main(String[] args) { 
        // Create a scanner for input 
        Scanner input = new Scanner(System.in);   
         
        // Enter yearly interest rate 
        System.out.print("Enter yearly interest rate, for example 8.25: "); 
     
        double annualInterestRate = input.nextDouble(); 
         
        // Obtain monthly interest rate 
        double monthlyInterestRate = annualInterestRate/1200; 
         
        // Enter number of years 
     
        System.out.print( 
        "Enter number of years as an integer, \nfor example 5: "); 
        int numberOfYears = input.nextInt(); 
         
        // Enter loan amount 
        System.out.print("Enter loan amount, for example 120000.95: "); 
        double loanAmount = input.nextDouble(); 
     
        // Calculate payment 
        double monthlyPayment = loanAmount * monthlyInterestRate / 
          (1 - 1 / Math.pow(1 + monthlyInterestRate, numberOfYears * 12)); 
        double totalPayment = monthlyPayment * numberOfYears * 12; 
         
        // Format to keep two digits after the decimal point 
        monthlyPayment = (int)(monthlyPayment * 100) / 100.0; 
        totalPayment = (int)(totalPayment * 100) / 100.0; 
         
        // Display results 
        System.out.println("The monthly payment is " + monthlyPayment); 
        System.out.println("The total payment is " + totalPayment); 
      } 

    Answer is:

    Enter yearly interest rate, for example 8.25: 8.25 
    Enter number of years as an integer,  
    for example 5: 5 
    Enter loan amount, for example 120000.95: 120000 
    The monthly payment is 2447.55 
    The total payment is 146853.01

     

    Programming Style and Documentation

    • Programming Style deals with what programs look like. 
    • Documentation is the body of explanatory remarks and comments pertaining to a program.
    • Programming style and documentation are as important as coding.  They make the programs easy to read.
     

    Appropriate Comments and Comments Style

    • Include a summary at the beginning of the program to explain what the program does, its key features, its supporting data structures, and unique techniques it uses. 
    • In a long program, you should also include comments that introduce each major step and explain anything that is difficult to read.
    • Make your comments concise so that they do not crowd the program or make it difficult to read.
    • Include your name, class section, instruction, date, and a brief description at the beginning of the program.
    • Use javadoc comments (/**… */ for commenting on an entire class or an entire method.
    • For commenting on steps inside a method, use line comments (/ /).
     

    Naming Conventions

    • Use lowercase for variables and methods. If a name consists of several words, concatenate all in one, use lowercase for the first word, and capitalize the first letter of each subsequent word in the name. Ex: showInputDialog. 
    • Choose meaningful and descriptive names.
    • For example, the variables radius and area, and the method computeArea. 
    • Capitalize the first letter of each word in the class name.  For example, the class name ComputeArea.
    • Capitalize all letters in constants.  For example, the constant PI and MAX_VALUE.
    • Do not use class names that are already used in Java library.
     

    Proper Indentation and Spacing Lines

    • Indentation is used to illustrate the structural relationships between a program’s components or statements. 
    • Indent two spaces in each subcomponent more than the structure which it is nested.
    • Use a single space on both sides of a binary operator.
     

      boolean b = 3 + 4 * 4 > 5 * (4 + 3)

    • Use a blank line to separate segments of the code. 
     

    Block Styles

    • A block is a group of statements surrounded by braces.  Use end-of-line style for braces or next-line style. 

     

     

    Programming Errors

     

    Syntax Errors “Compilation Error”

    • Detected by the compiler during compilation.  They result from errors in code construction, such as mistyping a keyword, omitting some necessary punctuation, or using an opening brace without a corresponding closing brace. 
    • These errors are easily detected, because the compiler tells you where they are and the reasons for them.
    • The following program compilation results in a syntax error:
     

       public class ShowSyntaxErrors {

       public static void main(String[] args) {

           i = 30;

           System.out.println(i + 4);

        }

       }

     

    Runtime Errors

    • Causes the program to terminate abnormally.  They occur while an application is running where the environment detects an operation that is impossible to carry out. 
    • An input error, for example, occurs when the user enters an unexpected input value that the program can’t handle.
    • If the program expects to read in a number, but instead the user enters a string, this causes data-type errors to occur in the program.
    • To prevent input errors, the program should prompt the user to enter the correct type of values.
    • Another example of a run time error is division by zero, for example:
     

       public class ShowRuntimeErrors {

       public static void main(String[] args) {

           int i = 1 / 0;

        }

       }

     

    Logic Errors

    • Occurs when a program doesn’t perform the way it was intended to. 
     

      public class ShowLogicErrors { 
        public static void main(String[] args) { 
            // Add number1 to number2 
            int number1 = 3; int number2 = 3; 
            number2 += number1 + number2; 
            System.out.println("number2 is " + number2); 
        } 
      }

    Answer is: number2 is 9

    The program doesn’t print the correct result for number2.

     

    Debugging

    • Finding logic errors “bugs” is challenging and the process of finding and correcting errors is called debugging
    • You can hand-trace the program or you can insert print statements in order to show the values of the variables or the execution flow of the program.
    • For a large, complex program, the most effective approach for debugging is to use a debugger utility.

Set Home | Add to Favorites

All Rights Reserved Powered by Free Document Search and Download

Copyright © 2011
This site does not host pdf,doc,ppt,xls,rtf,txt files all document are the property of their respective owners. complaint#downhi.com
TOP