Lecture 2&3
Primitive Data Types and Operations



Introduce Programming with an Example
Identifiers, Variables, and Constants
Primitive Data Types
– byte, short, int, long, float, double, char, boolean





Expressions
Operators, Precedence, Associativity, Operand
Evaluation Order: ++, --, *, /, %, +=, -=, *=, /=, %=,
^, &, |, +, -,
Getting Input from Input Dialog
Boxes
Style and Documentation Guidelines
Syntax Errors, Runtime Errors, and Logic Errors
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 1
Introducing Programming with an
Example
 Example
2.1 Computing the Area of a
Circle
This program computes the area of the
circle.
ComputeArea
S.W.Ma/CIM/LWL
Run
41211/2 Prog. IIA
Page 2
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.
 An identifier cannot be true, false, or
null.
 An identifier can be of any length.
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 3
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);
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 4
Declaring Variables

int x;

double radius; // Declare radius to
// be a double variable;

char a;
S.W.Ma/CIM/LWL
// Declare x to be an
// integer variable;
// Declare a to be a
// character variable;
41211/2 Prog. IIA
Page 5
Assignment Statements

x = 1;
// Assign 1 to x;

radius = 1.0;
// Assign 1.0 to radius;

a = 'A';
// Assign 'A' to a;
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 6
Declaring and Initializing
in One Step
 int
x = 1;
 double
 float
d = 1.4;
f = 1.4;
Is this statement correct?
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 7
Constants

final datatype CONSTANTNAME = VALUE;

final double PI = 3.14159;
final int SIZE = 3;

S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 8
Numerical Data Types
 byte
8 bits
 short
16 bits
 int
32 bits
 long
64 bits
 float
32 bits
 double
64 bits
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 9
Operators
 +,
-, *, /, and %
 5/2
yields an integer 2, due to integer
division.
 5.0/2
yields a double value 2.5
5
% 2 yields 1 (the remainder of the
division)
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 10
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.

Calculations with integers yield a precise integer
result, but watch out for overflows.
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 11
Number Literals


A literal is a constant value that appears directly in the
program.
Examples:
– int i = 34;
– long l = 1000000;
– double d = 5.0;
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 12
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.

An integer literal is assumed to be of
the int type, whose value is between 231
(-2147483648)
to
231–1
(2147483647).
 S.W.Ma/CIM/LWL
To denote
an integer literal of the
41211/2 Prog. IIA
Page 13
Floating-Point Literals

Floating-point literals
with a decimal point.

By default, a floating-point literal
is treated as a double type value.

For example, 5.0 is considered
double value, not a float value.

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, 100.2f or 100.2F is a
float number, and 100.2d or 100.2D is
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
are
written
Page 14
a
Scientific Notation

Floating-point literals can also
specified in scientific notation.

1.23456e+2 is same as 1.23456e2, is
equivalent to 123.456, and 1.23456e-2
is equivalent to 0.0123456.

E (or e) represents an exponent.
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
be
Page 15
Arithmetic Expressions
3  4 x 10( y  5)( a  b  c)
4 9 x

 9( 
)
5
x
x
y
is translated to
(3+4*x)/5 – 10*(y-5)*(a+b+c)/x +
9*(4/x + (9+x)/y)
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 16
Shortcut Assignment Operators
S.W.Ma/CIM/LWL
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
41211/2 Prog. IIA
Page 17
Increment and
Decrement Operators
suffix
x++; // Same as x = x + 1;
prefix
++x; // Same as x = x + 1;
suffix
x––; // Same as x = x - 1;
prefix
––x; // Same as x = x - 1;
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 18
Increment and
Decrement Operators, cont.
int i=10;
int newNum = 10*i++;
Equivalent to
int i=10;
int newNum = 10*(++i);
S.W.Ma/CIM/LWL
Equivalent to
41211/2 Prog. IIA
int newNum = 10*i;
i = i + 1;
i = i + 1;
int newNum = 10*i;
Page 19
Increment and
Decrement Operators, cont.


Using increment and decrement
operators makes expressions short, but
it may also make 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.
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 20
Assignment Expressions and
Assignment Statements

Prior to Java 2, all expressions
can 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--;
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 21
Numeric Type Conversion

Consider the following statements:
 byte i = 100;
 long k = i*3+4;
 double d = i*3.1+k/2;
 int x = k; //(Wrong)
 long k = x; //(fine,implicit casting)
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 22
Type Casting






S.W.Ma/CIM/LWL
(double)
(float)
(long)
(int)
(short)
(byte )
41211/2 Prog. IIA
Page 23
Type Casting, cont.
 Implicit
casting
– double d = 3; (type widening)
 Explicit
casting
– int i = (int)3.0; (type narrowing)
 What
S.W.Ma/CIM/LWL
is wrong?
int x = 5/2.0;
41211/2 Prog. IIA
Page 24
Character Data Type

char letter = 'A'; (ASCII)
char numChar = '4'; (ASCII)

char letter = '\u0041'; (Unicode)

char numChar = '\u0034';(Unicode)

Special characters

– char tab = ‘\t’;
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 25
Unicode Format
Description
Escape Sequence
Unicode
Backspace
\b
\u0008
Tab
\t
\u0009
Linefeed
\n
\u000a
Carriage return \r
\u000d
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 26
Casting between char and
Numeric Types
 int i = 'a';
// Same as int i = (int)'a';
 char c = 97;
// Same as char c = (char)97;
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 27
The boolean Type and Operators

boolean lightsOn = true;
boolean lightsOn = false;
boolean b = (1 > 2);

&& (and) :


(1 < x) && (x < 100)

|| (or) :
(lightsOn) || (isDayTime)

! (not) :
!(isStopped)
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 28
Comparison Operators
Operator Name
<
less than
<=
less than or equal to
>
greater than
>=
greater than or equal to
==
equal to
!=
not equal to
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 29
Boolean Operators
Operator Name
S.W.Ma/CIM/LWL
!
not
&&
and
||
or
^
exclusive or
41211/2 Prog. IIA
Page 30
Truth Table for Operator !
Truth Table for Operator !
S.W.Ma/CIM/LWL
Operand
!Operand
true
false
false
true
41211/2 Prog. IIA
Page 31
Truth Table for Operator &&
Operand1 Operand2 Operand1 &&
Operand2
false
false
false
false
true
false
true
false
false
true
true
true
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 32
Truth Table for Operator ||
Operand1 Operand2 Operand1 ||
Operand2
false
false
false
false
true
true
true
false
true
true
true
true
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 33
Truth Table for Operator ^
Operand1 Operand2 Operand1 ^
Operand2
false
false
false
false
true
true
true
false
true
true
true
false
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 34
The & and | Operators





&&: conditional AND operator
&: unconditional AND operator
||: conditional OR operator
|: unconditional OR operator
Examples :
 exp1 && exp2, such as
(1 < x) && (x < 100)
 exp1 || exp2, such as
(1 < x) & (x < 100)
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 35
The & and | Operators

If x is 1, what is x after this expression?
– (x > 1) & (x++ < 10)

If x is 1, what is x after this expression?
– (1 > x) && ( 1 > x++)

How about (1 == x) | (10 > x++)?
– (1 == x) || (10 > x++)?
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 36
Operator Precedence

How to evaluate
3 + 4 * 4
S.W.Ma/CIM/LWL
>
5 * (4 + 3) - ++i
41211/2 Prog. IIA
Page 37
Operator Precedence














var++, var-+, - (Unary plus and minus), ++var,--var
(type) Casting
! (Not)
*, /, % (Multiplication, division, and modulus)
+, - (Binary addition and subtraction)
<, <=, >, >= (Comparison)
==, !=; (Equality)
& (Unconditional AND)
^ (Exclusive OR)
| (Unconditional OR)
&& (Conditional AND) Short-circuit AND
|| (Conditional OR) Short-circuit OR
=, +=, -=, *=, /=, %= (Assignment operator)
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 38
Operator Associativity


When two operators with the same
precedence
are
evaluated,
the
associativity of the operators
determines
the
order
of
evaluation.
All
binary
operators
except
assignment operators are leftassociative.
 a – b + c – d is
to ((a – b) + c) – d

equivalent
Assignment operators are rightassociative.
Therefore,
the
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 39
Operand Evaluation Order


Operands are evaluated from
left to right in Java.
The left-hand operand of a
binary operator is evaluated
before any part of the
right-hand operand is
evaluated.
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 40
Operand Evaluation Order, cont.


If no operands have side
effects that change the value
of a variable, the order of
operand evaluation is
irrelevant.
Beware when operands do have a
side effect. For example, x
becomes 1 in the following
code.
 int a = 0;
int x = a + (++a);

But x becomes 2 in the
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 41
Getting Input from Input
Dialog Boxes

String string = JOptionPane.showInputDialog(
null, “Prompt Message”, “Dialog Title”,
JOptionPane.QUESTION_MESSAGE));
where the second parameter is a string for the prompting
message and the fourth parameter is a string for the title of the
input dialog box.
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 42
Getting Input from Input Dialog Boxes (Cont’d)

JOptionPane.showInputDialog(parentComponent,
objectExpression, boxTitleString, messageType);
Parameter
parentComponent
objectExpression
boxTitleString
messageType
Description
An object that represents the parent of the dialog box.
Default is null causing the dialog box to appear in the
middle of the screen.
This expression is usually the string that appears in the
dialog box.
This is the title of the dialog box.
An int value controlling the type of icon that will appear
in the dialog box. You can use the JOptionPane options.
messageType
JOptionPane.ERROR_MESSAGE
JOptionPane.INFORMATION_MESSAGE
JOptionPane.PLAIN_MESSAGE
JOptionPane.QUESTION_MESSAGE
JOptionPane.WARNING_MESSAGE
S.W.Ma/CIM/LWL
Description
The error icon is displayed in the dialog box.
The information icon is displayed in the dialog box.
No icon appears in the dialog box.
The question mark icon is displayed in the dialog box.
The exclamation icon is displayed in the dialog box.
41211/2 Prog. IIA
Page 43
Convertting 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 =
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 44
Convertting 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”.
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 45
Example 2.2
Entering Input from
Dialog Boxes
 This program first prompts the
user to enter a year as an
int value and checks if it
is a leap year, it then
prompts you to enter a
double value and checks if
it is positive.
 A year is a leap year if it
is InputDialogDemo
divisible by 4Run
but not by
100, or it is divisible by
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 46
// InputDialogDemo.java: Entering input from input dialog boxes
import javax.swing.JOptionPane;
public class InputDialogDemo {
public static void main(String args[]) {
// Prompt the user to enter a year
String yearString = JOptionPane.showInputDialog(null, "Enter a year:",
"Example 2.2 Input (int)", JOptionPane.QUESTION_MESSAGE);
// Convert the string into an int value
int year = Integer.parseInt(yearString);
// Check if the year is a leap year
boolean isLeapYear =
((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
// Display the result in a message dialog box
JOptionPane.showMessageDialog(null,
year + " is a leap year? " + isLeapYear,
"Example 2.2 Output (int)", JOptionPane.INFORMATION_MESSAGE);
// Prompt the user to enter a double value
String doubleString = JOptionPane.showInputDialog(null, "Enter a double value:",
"Example 2.2 Input (double)", JOptionPane.QUESTION_MESSAGE);
// Convert the string into a double value
double doubleValue = Double.parseDouble(doubleString);
// Check if the number is positive
JOptionPane.showMessageDialog(null, doubleValue + " is positive? " + (doubleValue >
0),
Example 2.2 Output (double)", JOptionPane.INFORMATION_MESSAGE);
System.exit(0);
}
}
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 47
Example 2.3
Computing Mortgages
 This program lets the user enter the
interest rate, number of years, and loan
amount and computes monthly payment
and total payment.
loanAmount  monthlyInterestRate
1
1
(1  monthlyInterestRate) numOfYears12
ComputeMortgage
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Run
Page 48
// ComputeMortgage.java: Compute mortgage payments
import javax.swing.JOptionPane;
public class ComputeMortgage {
/** Main method */
public static void main(String[] args) {
double annualInterestRate;
int numOfYears;
double loanAmount;
// Enter yearly interest rate
String annualInterestRateString = JOptionPane.showInputDialog(null, "Enter yearly interest rate,
for example 8.25:","Example 2.3 Input", JOptionPane.QUESTION_MESSAGE);
// Convert string to double
annualInterestRate =
Double.parseDouble(annualInterestRateString);
// Obtain monthly interest rate
double monthlyInterestRate = annualInterestRate/1200;
// Enter number of years
String numOfYearsString = JOptionPane.showInputDialog(null,
"Enter number of years as an integer,\nfor eg 5:", "EG 2.3 Input", JOptionPane.QUESTION_MESSAGE);
// Convert string to int
numOfYears = Integer.parseInt(numOfYearsString);
// Enter loan amount
String loanString = JOptionPane.showInputDialog(null,
"Enter loan amount, for example 120000.95:",
"Example 2.3 Input", JOptionPane.QUESTION_MESSAGE);
// Convert string to double
loanAmount = Double.parseDouble(loanString);
// Calculate payment
double monthlyPayment=loanAmount*monthlyInterestRate/1 - 1/Math.pow(1+monthlyInterestRate,
numOfYears*12));
double totalPayment = monthlyPayment * numOfYears * 12;
// Format to keep two digits after the decimal point
monthlyPayment = (int)(monthlyPayment * 100) / 100.0;
totalPayment = (int)(totalPayment * 100) / 100.0;
// Display results
String output = "The monthly payment is " + monthlyPayment + "\nThe total payment is " + totalPayment;
JOptionPane.showMessageDialog(null, output, "EG 2.3 Output", JOptionPane.INFORMATION_MESSAGE);
System.exit(0);
}
}
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 49
Example 2.4
Computing Changes
 This program lets the user enter the amount in
decimal representing dollars and cents and output a
report listing the monetary equivalent in 10 dollar
coins, 5 dollar coins, 2 dollar coins , 1 dollar coins,
50 cent coins, 20 cent coins and 10 cent coins. Your
program should report maximum number of 10
dollar coins, then the maximum number of 5 dollar
coins, and so on, in this order.
ComputeChange
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Run
Page 50
// ComputeChange.java: Break down an amount into smaller units
import javax.swing.JOptionPane;
public class ComputeChange {
public static void main(String[] args) {
double amount; // Amount entered from the keyboard
// Receive the amount entered from the keyboard and convert to double
String amountString = JOptionPane.showInputDialog(null,"Enter an amount in double, for eg 11.50",
"Example 2.4 Input", JOptionPane.QUESTION_MESSAGE);
amount = Double.parseDouble(amountString);
int remainingAmount = (int)(amount * 100);
// Find the number of 10 dollar coins
int numOf10Dollars = remainingAmount / 1000;
remainingAmount = remainingAmount % 1000;
// Find the number of 5 dollar coins
int numOf5Dollars = remainingAmount / 500;
remainingAmount = remainingAmount % 500;
// Find the number of 2 dollar coins
int numOf2Dollars = remainingAmount / 200;
remainingAmount = remainingAmount % 200;
// Find the number of one dollars
int numOf1Dollars = remainingAmount / 100;
remainingAmount = remainingAmount % 100;
// Find the number of 50 cent coins the remaining amount
int numOf50Cents = remainingAmount / 50;
remainingAmount = remainingAmount % 50;
// Find the number of 20 cent coins in the remaining amount
int numOf20Cents = remainingAmount / 20;
remainingAmount = remainingAmount % 20;
// Find the number of 10 cents coins in the remaining amount
int numOf10Cents = remainingAmount / 10;
// Display results, ignoring remaining cents
String output = "Your amount " + amount + " consists of \n" + numOf10Dollars + " 10 dollars\n" +
numOf5Dollars + " 5-dollars\n" + numOf2Dollars + " 2-dollars\n" + numOf1Dollars +
" 1-dollars\n" + numOf50Cents + " 50-cents\n" + numOf20Cents + " 20-cents\n" + numOf10Cents +
" 10-cents\n" + "Remaining cents ignored";
JOptionPane.showMessageDialog(null, output, "EG 2.4 Output", JOptionPane.INFORMATION_MESSAGE);
System.exit(0);
}
}
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 51
Programming Style and
Documentation




Appropriate Comments
Naming Conventions
Proper Indentation and Spacing Lines
Block Styles
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 52
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,
instruction, date, and a brief
description at the beginning of
the program.
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 53
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.
 Examples :
Radius;
 area, and
 the method computeArea.

S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 54
Naming Conventions, cont.

Class names:
 Capitalize the first letter of each word in
the name.
 Example : ComputeArea.

Constants:
 Capitalize all letters in constants.
 Example : the constant PI.
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 55
Proper Indentation and Spacing

Indentation
 Indent two spaces.

Spacing
 Use blank line to separate segments of the
code.
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 56
Block Styles

Use end-of-line style for braces.
Next-line
style
public class Test
{
public static void main(String[] args)
{
System.out.println("Block Styles");
}
}
public class Test {
public static void main(String[] args) {
System.out.println("Block Styles");
}
}
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
End-of-line
style
Page 57
Programming Errors

Syntax Errors
 Detected by the compiler

Runtime Errors
 Causes the program to abort

Logic Errors
 Produces incorrect result
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 58
Compilation Errors
public class ShowSyntaxErrors
{
public
static
void
main(String[] args) {
i = 30;
System.out.println(i+4);
}
}
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 59
Runtime Errors
public class ShowRuntimeErrors
{
public
static
void
main(String[] args) {
int i = 1 / 0;
}
}
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 60
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)));
S.W.Ma/CIM/LWL
41211/2 Prog. IIA
Page 61