Chapter 2
This presentation is the property of its rightful owner.
Sponsored Links
1 / 97

Spring 2013 PowerPoint PPT Presentation


  • 182 Views
  • Uploaded on
  • Presentation posted in: General

Chapter 2 Elementary Programming. Spring 2013. Motivations.

Download Presentation

Spring 2013

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Spring 2013

Chapter 2

Elementary Programming

Spring 2013


Motivations

Motivations

In the preceding chapter, you learned how to create, compile, and run a Java program. Starting from this chapter, you will learn how to solve practical problems programmatically. Through these problems, you will learn Java primitive data types and related subjects, such as variables, constants, data types, operators, expressions, and input and output.


Objectives

Objectives

  • To write Java programs to perform simple calculations (§2.2).

  • To obtain input from the console using the Scanner class (§2.3).

  • To use identifiers to name variables, constants, methods, and classes (§2.4).

  • To use variables to store data (§§2.5-2.6).

  • To program with assignment statements and assignment expressions (§2.6).

  • To use constants to store permanent data (§2.7).

  • To declare Java primitive data types: byte, short, int, long, float, double, and char (§§2.8.1).

  • To use Java operators to write numeric expressions (§§2.8.2–2.8.3).

  • To display current time (§2.9).

  • To use short hand operators (§2.10).

  • To cast value of one type to another type (§2.11).

  • To compute loan payment (§2.12).

  • To represent characters using the char type (§2.13).

  • To compute monetary changes (§2.14).

  • To represent a string using the String type (§2.15).

  • To become familiar with Java documentation, programming style, and naming conventions (§2.16).

  • To distinguish syntax errors, runtime errors, and logic errors and debug errors (§2.17).

  • (GUI) To obtain input using the JOptionPane input dialog boxes (§2.18).


Introducing programming with an example

Introducing Programming with an Example

Listing 2.1 Computing the Area of a Circle

This program computes the area of the circle.

IMPORTANT NOTE: To enable the buttons, you must download the entire slide file slide.zip and unzip the files into a directory (e.g., c:\slide) .

ComputeArea

Run


Trace a program execution

animation

Trace a Program Execution

allocate memory for radius

public class ComputeArea {

/** Main method */

public static void main(String[] args) {

double radius;

double area;

// Assign a radius

radius = 20;

// Compute area

area = radius * radius * 3.14159;

// Display results

System.out.println("The area for the circle of radius " +

radius + " is " + area);

}

}

radius

no value


Trace a program execution1

animation

Trace a Program Execution

memory

public class ComputeArea {

/** Main method */

public static void main(String[] args) {

double radius;

double area;

// Assign a radius

radius = 20;

// Compute area

area = radius * radius * 3.14159;

// Display results

System.out.println("The area for the circle of radius " +

radius + " is " + area);

}

}

radius

no value

area

no value

allocate memory for area


Trace a program execution2

animation

Trace a Program Execution

assign 20 to radius

public class ComputeArea {

/** Main method */

public static void main(String[] args) {

double radius;

double area;

// Assign a radius

radius = 20;

// Compute area

area = radius * radius * 3.14159;

// Display results

System.out.println("The area for the circle of radius " +

radius + " is " + area);

}

}

radius

20

area

no value


Trace a program execution3

animation

Trace a Program Execution

memory

public class ComputeArea {

/** Main method */

public static void main(String[] args) {

double radius;

double area;

// Assign a radius

radius = 20;

// Compute area

area = radius * radius * 3.14159;

// Display results

System.out.println("The area for the circle of radius " +

radius + " is " + area);

}

}

radius

20

area

1256.636

compute area and assign it to variable area


Trace a program execution4

animation

Trace a Program Execution

memory

public class ComputeArea {

/** Main method */

public static void main(String[] args) {

double radius;

double area;

// Assign a radius

radius = 20;

// Compute area

area = radius * radius * 3.14159;

// Display results

System.out.println("The area for the circle of radius " +

radius + " is " + area);

}

}

radius

20

area

1256.636

print a message to the console


Reading input from the console

Reading Input from the Console

  • 1. Create a Scanner object

    • Scanner input = new Scanner(System.in);

  • 2. Use the methods next(), nextByte(), nextShort(), nextInt(), nextLong(), nextFloat(), nextDouble(), or nextBoolean() to obtain to a string, byte, short, int, long, float, double, or boolean value. For example,

    • System.out.print("Enter a double value: ");

    • Scanner input = new Scanner(System.in);

    • double d = input.nextDouble();

ComputeAreaWithConsoleInput

ComputeAverage

Run

Run


Identifiers

Identifiers

  • An identifier is a sequence of characters that consist of letters, digits, underscores (_), and dollar signs ($).

  • An identifier must start with a letter, an underscore (_), or a dollar sign ($). It cannot start with a digit.

    • An identifier cannot be a reserved word. (See Appendix A, “Java Keywords,” for a list of reserved words).

  • An identifier cannot betrue, false, ornull.

  • An identifier can be of any length.

  • Java is case sensitive

    • Upper case letters are not the same as lower case letters

    • Examples

      • Name is not the same as name


Java reserved words

Java Reserved Words


Example identifiers

Example Identifiers

  • yes√

  • Iam √

  • I’mx

  • good jobx

  • good_job √

  • goodJob √

  • $id √

  • _id √

  • A1 √

  • 1ax


Variables

Variables

  • Used to store values to be used later in the program

  • Values can be changed

  • Variables are used to represent data of certain type

  • Must declare a variable before you use it

    • Tell the compiler its name

    • Tell the compiler its type

  • Declaring the data type tells the compiler to allocate the appropriate memory space for the variable


Variables1

Variables

// 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

Declaring Variables

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;


Declaring variables1

Declaring Variables

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;

  • Declarations are used to

    • tell the compiler how much memory space is needed for the value that will be assigned to the variable

    • tell the compiler the type of data that will be referenced by that variable


Variables2

Variables

publicclass DisplayRadius {

publicstaticvoid main(String[]args) {

double radius; //Declare variable radius

double area; //Declare variable area

// Compute the first area

radius = 1.0; //assign value to variable radius

area = radius * radius * 3.14159; //compute value of area

System.out.println("The area is " + area +

" for radius " + radius);

// Compute the second area

radius = 2.0; //assign value to variable radius

area = radius * radius * 3.14159; //compute value of area

System.out.println("The area is " + area +

" for radius "+radius);

}

}

The area is 3.14159 for radius 1.0

The area is 12.56636 for radius 2.0


Variables3

Variables

publicclass DisplayRadius {

publicstaticvoid main(String[]args) {

double radius; //Declare variable radius

double area; //Declare variable area

// Compute the first area

radius = 1.0; //assign value to variable radius

area = radius * radius * 3.14159; //compute value of area

System.out.println("The area is " + area +

" for radius " + radius);

// Compute the second area

radius = 2.0; //assign value to variable radius

area = radius * radius * 3.14159; //compute value of area

System.out.println("The area is " + area +

" for radius "+radius);

}

}

The area is 3.14159 for radius 1.0

The area is 12.56636 for radius 2.0


Assignment statements

Assignment Statements

x = 1; // Assign 1 to x;

radius = 1.0; // Assign 1.0 to radius;

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


Assignment statements1

Assignment Statements

x = 1; // Assign 1 to x;

radius = 1.0; // Assign 1.0 to radius;

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

  • Assignment statements

    • Assign a value to the variable

    • That value is stored in the memory location associated with that variable


Declaring and initializing in one step

Declaring and Initializingin One Step

  • int x = 1;

  • double d = 1.4;

  • In Jave, you can declare a variable and store a value in that variable in one statement

  • It is usually a good idea to initialize the variable when it is declared


Constants

Constants

  • Constant

    • Once a value is assigned it cannot be changed

  • final is the keyword used to declare a variable a constant

  • Format

    • final datatype CONSTANTNAME = VALUE;

  • Examples

    • final double PI = 3.14159;

    • final int SIZE = 3;

  • Note

    • Convention is to use all upper case letters for the name of the constant variable


Spring 2013

TIP

An excellent tool to demonstrate how numbers are stored in a computer was developed by Richard Rasala. You can access it at

http://www.ccs.neu.edu/jpt/jpt_2_3/bitdisplay/applet.htm


Numerical data types

Numerical Data Types


Numeric operators

Numeric Operators


Integer division

Integer Division

+, -, *, /, 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)


Remainder operator

Remainder Operator

  • Remainder is very useful in programming.

  • For example

    • an even number % 2 is always 0

    • an odd number % 2 is always 1.

  • So you can use this property to determine whether a number is even or odd.

  • Suppose today is Saturday and you and your friends are going to meet in 10 days. What day is in 10 days? You can find that day is Tuesday using the following expression:


Problem displaying time

Problem: Displaying Time

Write a program that obtains hours and minutes from seconds.

publicclass DisplayTime {

publicstaticvoid main(String[] args) {

int seconds = 500;

int minutes = seconds / 60;

int remainingSeconds = seconds % 60;

System.out.println(seconds + " seconds is " + minutes +

" minutes and " + remainingSeconds + " seconds");

}

}

Run

DisplayTime

500 seconds is 8 minutes and 20 seconds


Spring 2013

NOTE

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

System.out.println(1.0 - 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.


Number literals

Number 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 x = 1000000;

      double d = 5.0;


Integer literals

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

  • 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

  • You 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 notation

Scientific Notation

  • 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

Arithmetic Expressions

is translated to

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


How to evaluate an expression

How to Evaluate an Expression

Though Java has its own way to evaluate an expression behind the scene, the result of a Java expression and its corresponding arithmetic expression are the same. Therefore, you can safely apply the arithmetic rule for evaluating a Java expression.

Appendix C, page 690, has a chart of operator precedence. We will cover this in detail in Chapter 3.


Problem converting temperatures

Problem: Converting Temperatures

Write a program that converts a Fahrenheit degree to Celsius using the formula:

publicclass FahrenheitToCelsius {

publicstaticvoid main(String[] args) {

double fahrenheit = 435; // Say 100;

double celsius = (5.0 / 9) * (fahrenheit - 32);

System.out.println("Fahrenheit " + fahrenheit +

" is " + celsius + " in Celsius");

}

}

Fahrenheit 435.0 is 223.88888888888889 in Celsius


Problem displaying current time

Problem: Displaying Current Time

Write a program that displays current time in GMT in the format hour:minute:second such as 1:45:19.

The currentTimeMillis method in the System class returns the current time in milliseconds since the midnight, January 1, 1970 GMT. (1970 was the year when the Unix operating system was formally introduced.) You can use this method to obtain the current time, and then compute the current second, minute, and hour as follows.

ShowCurrentTime

Run


Chapter 2

Chapter 2

Lesson 2


Shortcut assignment operators

Shortcut Assignment Operators

OperatorExampleEquivalent

+=i += 8i = i + 8

-=f -= 8.0f = f - 8.0

*=i *= 8i = i * 8

/=i /= 8i = i / 8

%=i %= 8i = i % 8


Increment and decrement operators

Increment and Decrement Operators

OperatorNameDescription

++varpreincrementThe expression (++var) increments var by 1 and evaluates

to the new value in varafter the increment.

var++postincrementThe expression (var++) evaluates to the original value

in var and increments var by 1.

--varpredecrementThe expression (--var) decrements var by 1 and evaluates

to the new value in varafter the decrement.

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

in var and decrements var by 1.

++var and --var: performs the arithmetic operation first than uses the value.

var++ and var– uses the value first than performs the arithmetic operation.


Increment and decrement operators cont

Increment andDecrement Operators, cont.

newNum will have the value 100, i will have the value 11

newNum will have the value 110, i will have the value 11


Increment and decrement operators cont1

Increment and Decrement Operators, cont.

  • Using increment and decrement operators makes expressions short, but 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.


Assignment expressions and assignment statements

Assignment Expressions and Assignment Statements

  • Expressions perform operations on data and move data around.

  • All statements except blocks are terminated by a semicolon. Blocks are denoted by open and close curly braces.

Prior to Java 2, all the expressions could be used as statements. Since Java 2, only the following types of expressions can be statements:

variable op= expression; // Where op is +, -, *, /, or %

++variable;

variable++;

--variable;

variable--;


Numeric type conversion

Numeric Type Conversion

Consider the following statements:

byte i = 100;

long k = i * 3 + 4;

double d = i * 3.1 + k / 2;

byte type

long type

  • Some of the statements have mixed types

    • byte types are mixed with long types

    • byte and long types are mixed with double type


Conversion rules

Conversion Rules

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.

The value must fit into the available bits, otherwise must do explicit casting


Type casting

8-bits

16-bits

32-bits

64-bits

32-bits

64-bits

Type Casting

Implicit casting

double d = 3; (type widening)

Explicit casting

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

int i = (int)3.9; (Fraction part is truncated)

What is wrong?int x = 5 / 2.0;

converts the 5 to 5.0, performs division to get 2.5 then tries to store a double in an int, but it won’t fit. You will get a compile error.

Will store 3.000000000

Will store 3


Problem keeping two digits after decimal points

Problem: Keeping Two Digits After Decimal Points

Write a program that displays the sales tax with two digits after the decimal point.

publicclass SalesTax {

publicstaticvoid main(String[] args) {

double purchaseAmount = 197.55;

double tax = purchaseAmount * 0.06;

System.out.println("Sales tax is $" + tax);

System.out.println("Sales tax is $" +

(int)(tax * 100) / 100.0);

}

}

Sales tax is $11.853

Sales tax is $11.85


Problem computing loan payments

Problem: Computing Loan Payments

This program lets the user enter the interest rate, number of years, and loan amount and computes monthly payment and total payment.

ComputeLoan

Run


Computeloan

ComputeLoan

import java.util.Scanner;

public class ComputeLoan {

public static void main(String[] args) {

// Create a Scanner

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, for example 5: ");

int numberOfYears = input.nextInt();


Computeloan1

ComputeLoan

// 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;

// Display results

System.out.println("The monthly payment is " +

(int)(monthlyPayment * 100) / 100.0);

System.out.println("The total payment is " +

(int)(totalPayment * 100) / 100.0);

}

}


Character data type

Character Data Type

Four hexadecimal digits.

char letter = 'A'; //(ASCII)

char numChar = '4'; //(ASCII)

char letter = '\u0041'; //(Unicode)

char numChar = '\u0034'; //(Unicode)

NOTE: The increment and decrement operators can also be used on char variables to get the next or preceding Unicode character. For example, the following statements display character b.

char ch = 'a';

System.out.println(++ch);


Unicode format

Unicode Format

Java characters use Unicode, a 16-bit encoding scheme established by the Unicode Consortium to support the interchange, processing, and display 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.

Unicode \u03b1 \u03b2 \u03b3 for three Greek letters


Problem displaying unicodes

Problem: Displaying Unicodes

Write a program that displays two Chinese characters and three Greek letters.

import javax.swing.JOptionPane;

public class DisplayUnicode {

public static void main(String[] args) { JOptionPane.showMessageDialog(null,

"\u6B22\u8FCE \u03b1 \u03b2 \u03b3",

"\u6B22\u8FCE Welcome",

JOptionPane.INFORMATION_MESSAGE);

}

}


Unicode representation of greek alphabet

Unicode Representation of Greek Alphabet

Unicode representation of Greek alphabet can be found at the following sites:

  • http://unicode.org/charts/PDF/U0370.pdf

  • http://www.bible-researcher.com/greek-unicode.html

  • http://tlt.its.psu.edu/suggestions/international/bylanguage/greekchart.html


Escape sequences for special characters

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


Escape sequence

Escape Sequence

First design how the output will look::First

Character Escape Sequence

\t

Then the next column::

Character Escape Sequence Name

\t Tab

Then the last column::

Character Escape Sequence Name Unicode Code

\t Tab \u008

Now put the first line in an output statement

System.out.println(“Character Escape Sequence\t\tName\t\tUnicode CodeUnicode”);

The next line in an output statement

System.out.println(“Character Escape Sequence\t\tName\t\tUnicode CodeUnicode”);

System.out.println(“\t\t\\t\t\tTab\t\t\\u008”);


Escape sequence1

Escape Sequence

  • Add the other lines in the table

  • Note the use of \ in the code

    • \t will print 8 spaces (tab in java)

    • \\ will cause the backslash to appear

  • Since you will have to display the “ as well as the ‘, and those two characters are used to indicate String and char types in Java, you have to use \” and \’ to actually print “ and ‘

    • This could get confusing, so keep track of where you are in your output.


Appendix b ascii character set

Appendix B: ASCII Character Set

ASCII Character Set is a subset of the Unicode from \u0000 to \u007f


Ascii character set cont

ASCII Character Set, cont.

ASCII Character Set is a subset of the Unicode from \u0000 to \u007f


Casting between char and numeric types

Casting between char and Numeric Types

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

char c = 97; // Same as char c = (char)97;


Problem monetary units

Problem: Monetary Units

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.

ComputeChange

Run


Trace computechange

Trace ComputeChange

Suppose amount is 11.56

remainingAmount

1156

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;

remainingAmount initialized


Trace computechange1

animation

Trace ComputeChange

Suppose amount is 11.56

remainingAmount

1156

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;

11

numberOfOneDollars

numberOfOneDollars assigned


Trace computechange2

animation

Trace ComputeChange

Suppose amount is 11.56

remainingAmount

56

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;

11

numberOfOneDollars

remainingAmount updated


Trace computechange3

animation

Trace ComputeChange

Suppose amount is 11.56

remainingAmount

56

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;

11

numberOfOneDollars

numberOfOneQuarters

2

numberOfOneQuarters assigned


Trace computechange4

animation

Trace ComputeChange

Suppose amount is 11.56

remainingAmount

6

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;

11

numberOfOneDollars

numberOfQuarters

2

remainingAmount updated


The string type

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, “Objects and Classes.” 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

String Concatenation

// Three strings are concatenated

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

// 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

Create a String type named message and store “Welcome to Java” at that location

Create a String type named s and store “Chapter2” at that location

Create a String type named s1 and store “SupplementB” at that location


String concatenation cont

String Concatenation (cont.)

// add to message

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

Message = message + “! Good luck!!”

Create a String type named message and store “Welcome to Java” at that location.

Then add “! Good luck!!” to message and now “Welcome to Jave! Good luck!!”

is stored at location message.


Programming style and documentation

Programming Style and Documentation

  • Appropriate Comments

  • Naming Conventions

  • Proper Indentation and Spacing Lines

  • Block Styles


Appropriate comments

Appropriate Comments

Include a summary at the beginning of the program to explain what the program does, its key features, its supporting data structures, and any unique techniques it uses.

Include your name, class section, instructor, date, and a brief description at the beginning of the program.


Homework identifiers

Homework Identifiers

/***********************************************************

*

* Student Name:

* Date Due: 8/26/2011

* Date Submitted:

* Program Name: HW713Write the following method that returns the

* location of the largest element in a two-dimensional array.

*

* public static int[] locateLargest(double[][] a)

*

* The return value is a one-dimensional array that contains two elements.

* These two elements indicate the row and column indices of the largest

* element in the two dimensional array. Write a test program that prompts

* the user to enter a two-dimensional array and displays the location of the

* largest element in the array.

* Program Description: Write a program that prompts the user to enter a

* social security number in the format DDD-DD-DDDD, where D is a

* digit. The program displays "valid SSN" for a correct social security

* number and "invalid SSN" otherwise.

*

**********************************************************/

  • Each program must have a comment at the very beginning with the following information


Naming conventions

Naming Conventions

  • Choose meaningful and descriptive names.

  • Variables and method names:

    • Use lowercase. If the 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. For example, the variables radius and area, and the method computeArea.


Naming conventions cont

Naming Conventions, cont.

  • Class names:

    • Capitalize the first letter of each word in the name. For example, the class name ComputeArea.

  • Constants:

    • Capitalize all letters in constants, and use underscores to connect words. For example, the constant PI and MAX_VALUE


Proper indentation and spacing

Proper Indentation and Spacing

  • Indentation

    • Indent two spaces.

  • Spacing

    • Use blank line to separate segments of the code.


Block styles

Block Styles

Use end-of-line style for braces.


Grading standards

Grading Standards

  • Each program is graded using the following standard:

    • Program compiles without any compile errors or warnings: 25%

    • Program executes without any runtime errors: 25%

    • Program produces correct results: 25%

    • Program contains correct header information: 15%

    • Program uses coding standards: 10%


Programming errors

Programming Errors

  • Syntax Errors

    • Detected by the compiler

  • Runtime Errors

    • Causes the program to abort

  • Logic Errors

    • Produces incorrect result


Syntax errors

Syntax Errors

public class ShowSyntaxErrors {

public static void main(String[] args) {

i = 30;

System.out.println(i + 4);

}

}

i not declared before assigning a value to it


Runtime errors

Runtime Errors

public class ShowRuntimeErrors {

public static void main(String[] args) {

int i = 1 / 0;

}

}

Divide by 0


Logic errors

Logic Errors

public class ShowLogicErrors {

// Determine if a number is between 1 and 100 inclusively

public static void main(String[] args) {

// Prompt the user to enter a number

String input = JOptionPane.showInputDialog(null,

"Please enter an integer:",

"ShowLogicErrors", JOptionPane.QUESTION_MESSAGE);

int number = Integer.parseInt(input);

// Display the result

System.out.println("The number is between 1 and 100, " +

"inclusively? " + ((1 < number) && (number < 100)));

System.exit(0);

}

}

Incorrect answer: what if input is 1 or 100?


Debugging

Debugging

Logic errors are called bugs. The process of finding and correcting errors is called debugging. A common approach to debugging is to use a combination of methods to narrow down to the part of the program where the bug is located. You can hand-trace the program (i.e., catch errors by reading the program), or you can insert print statements in order to show the values of the variables or the execution flow of the program. This approach might work for a short, simple program. But for a large, complex program, the most effective approach for debugging is to use a debugger utility.


Debugger

Debugger

Debugger is a program that facilitates debugging. You can use a debugger to

  • Execute a single statement at a time.

  • Trace into or stepping over a method.

  • Set breakpoints.

  • Display variables.

  • Display call stack.

  • Modify variables.


Obtaining input

Obtaining Input

This book provides two ways of obtaining input.

  • Using the JDK 1.5 Scanner class (§2.16)

    • Inputs from DOS window or lower pane in Eclipse workspace.

  • Using JOptionPane input dialogs (§2.11)

    • Inputs from a GUI window.


Getting input using scanner

Getting Input Using Scanner

  • Need to import Scanner

  • importjava.util.Scanner;

  • 2. Create a Scanner object

    • Scanner scanner = new Scanner(System.in);

  • 3. Use the methods nextLine(), next(), nextByte(), nextShort(), nextInt(), nextLong(), nextFloat(), nextDouble(), or nextBoolean() to obtain a line of characters (ending with a line separator), String, byte, short, int, long, float, double, or boolean value.

  • Reads an item separated by whitespace: ‘ ’, ‘\t’, ‘\f’, ‘\r’, ‘\n’

Note: To avoid input error, do not use nextLine() after nextByte(), nextShort(), nextInt(), nextLong(), nextFloat(), nextDouble(), and next().


Using scanner input

Using Scanner Input

  • For example,

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

    Scanner scanner = new Scanner(System.in);

    double d = scanner.nextDouble();

    System.out.println(“The value you entered is: “ + d);

    Enter a double value:

    The value you entered is: 25.5

25.5 [Enter Key]


Testscanner

TestScanner

import java.util.Scanner; // Scanner is in java.util

public class TestScanner {

public static void main(String args[]) {

// Create a Scanner

Scanner input = new Scanner(System.in);

// Prompt the user to enter an integer

System.out.print("Enter a line of text: ");

String line = input.nextLine();

System.out.println("You entered the line: " + line);

System.out.print("Enter an integer: ");

int intValue = input.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 = input.nextDouble();

System.out.println("You entered the double value " + doubleValue);

// Prompt the user to enter a string

System.out.print("Enter a string without space: ");

String string = input.next();

System.out.println("You entered the string " + string);

// Prompt the user to enter a line

System.out.print("Enter a line of text: ");

String line2 = input.nextLine();

System.out.println("You entered the line: " + line2);

}

}

  • TestScanner.java


Getting input from input dialog boxes

Getting Input from Input Dialog Boxes

String input = JOptionPane.showInputDialog(

"Enter an input");


Getting input from input dialog boxes1

Getting Input from Input Dialog Boxes

String string = JOptionPane.showInputDialog(

null, “Prompting Message”, “Dialog Title”,

JOptionPane.QUESTION_MESSAGE);


Two ways to invoke the method

Two Ways to Invoke the Method

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.showInputDialog(x);

where x is a string for the prompting message.


Converting strings to integers

Converting Strings to Integers

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.

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”.


Converting strings to doubles

Converting Strings to Doubles

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”.


Other conversions

Other Conversions

  • Boolean.parseBoolean (String s)

  • Byte.parseByte (String s)

  • Double.parseDouble (String s)

  • Float.parseFloat (String s)

  • Integer.parseInt (String s)

  • Long.parseLong (String s)

  • Short.parseShort (String s)

  • Don’t need a String.parseString because the input from JOptionPane is a type String.


Problem computing loan payments using input dialogs

Problem: Computing Loan Payments Using Input Dialogs

Same as the preceding program for computing loan payments, except that the input is entered from the input dialogs and the output is displayed in an output dialog.

ComputeLoanUsingInputDialog

Run


Debugging in netbeans

Companion Website

Debugging in NetBeans

Supplement II.E, Learning Java Effectively with NetBeans


Debugging in eclipse

Companion Website

Debugging in Eclipse

Supplement II.G, Learning Java Effectively with NetBeans


  • Login