Java Methods
Object-Oriented Programming
and Data Structures
3rd AP edition
Maria Litvin ● Gary Litvin
int chapter = 5;
Data Types, Variables,
and Arithmetic
Copyright © 2015 by Maria Litvin, Gary Litvin, and Skylight Publishing. All rights reserved.
Objectives:
• Discuss primitive data types
• Learn how to declare fields and local
variables
• Learn about arithmetic operators, compound
assignment operators, and increment /
decrement operators
• Discuss common mistakes in arithmetic
5-2
Variables
• A variable is a “named container”
•
that holds a value.
q = 100 - q;
5
count
means:



1. Read the current value of q
2. Subtract it from 100
3. Move the result back into q
mov ax,q
mov bx,100
sub bx,ax
mov q,bx
5-3
Variables (cont’d)
• Variables can be of different data types: int,
char, double, boolean, etc.
• Variables can hold objects; then the type is
the class of the object.
• The programmer gives names to variables.
• Names of variables usually start with a
lowercase letter.
5-4
Variables (cont’d)
• A variable must be declared before it can
be used:
int
Type
count;
double
x, y;
JButton
go;
Name(s)
Balloon b;
String firstName;
5-5
Variables (cont’d)
• The assignment operator = sets the
variable’s value:
count = 5;
x = 0;
go = new JButton("Go");
firstName = args[0];
5-6
Variables (cont’d)
• A variable can be initialized in its
declaration:
int count = 5;
JButton go = new JButton("Go");
String firstName = args[0];
5-7
Variables: Scope
• Each variable has a scope —
the area in the source code
where it is “visible.”
• If you use a variable outside its
scope, the compiler reports a
syntax error.
• Variables can have the same
name when their scopes do not
overlap.
{
int k = ...;
...
}
for (int k = ...)
{
...
}
5-8
Fields
• Fields are declared outside all
constructors and methods.
• Fields are usually grouped together,
either at the top or at the bottom of the
class.
• The scope of a field is the whole class.
5-9
Fields (cont’d)
Scope
public class SomeClass
{
Fields
}
Constructors
and methods
Or:
Scope
public class SomeClass
{
Constructors
and methods
Fields
}
5-10
Local Variables
• Local variables are declared inside a
constructor or a method.
• Local variables lose their values and are
destroyed once the constructor or the method
is exited.
• The scope of a local variable is from its
declaration down to the closing brace of the
block in which it is declared.
5-11
Local Variables (cont’d)
public class SomeClass
{
...
public SomeType SomeMethod (...)
{
Local variable declared
{
Scope
Local variable declared
}
}
...
}
5-12
Variables (cont’d)
• Use local variables whenever appropriate;
never use fields where local variables should
be used.
• Give prominent names to fields, so that they
are different from local variables.
• Use the same name for local variables that
are used in similar ways in different methods
(for example, x, y for coordinates, count for a
counter, i, j, k for indices and loop control
variables, etc.).
5-13
Variables (cont’d)
• Common mistakes:
public void someMethod (...)
{
int x = 0;
...
int x = 5; // should be: x = 5;
...
Variable declared twice
within the same scope —
syntax error
5-14
Variables (cont’d)
• Common mistakes:
private double radius;
...
public Circle (...)
// constructor
{
double radius = 5;
...
Declares a local variable
radius; the value of the field
radius remains 0.0
5-15
Primitive Data Types
•
•
•
•
int
double
char
boolean
•
•
•
•
byte
short
long
float
Used in
Java Methods
5-16
Strings
• String is not a primitive data type
• Strings work like any other objects, with two
exceptions:


strings in double quotes are recognized as literal
constants
+ and += concatenate strings (or a string and a
number or an object, which is converted into a
string)
"Catch " + 22
"Catch 22"
5-17
Literal Constants
new line
tab
'A', '+', '\n', '\t'
char
-99, 2010, 0
int
0.75, -12.3, 8., .5
double
“coin.gif", "1776", "y", "\n"
String
5-18
Symbolic Constants
• Symbolic constants are initialized final
variables:
private final int sideLength = 8;
private static final int BUFFER_SIZE = 1024;
public static final int PIXELS_PER_INCH = 6;
5-19
Why Symbolic Constants?
• Easy to change the value throughout the
program, if necessary
• Easy to change into a variable
• More readable, self-documenting code
• Additional data type checking by the
compiler
5-20
Arithmetic
• Operators: +, -, /, * , %
• The precedence of operators and
parentheses is the same as in algebra.
• m % n means the remainder when m is
divided by n (for example, 17 % 5 is 2;
2 % 8 is 2).
% has the same rank as / and *.
•
• Same-rank binary operators are performed in
order from left to right.
5-21
Arithmetic (cont’d)
• The type of the result is determined by the
types of the operands, not their values; this
rule applies to all intermediate results in
expressions.
• If one operand is an int and another is a
double, the result is a double; if both
operands are ints, the result is an int.
5-22
Arithmetic (cont’d)
• Caution: if a and b are ints, then a / b is
truncated to an int…
17 / 5 gives 3
3 / 4 gives 0
• …even if you assign the result to a double:
double ratio = 2 / 3;
The double type of
the result doesn’t
help: ratio still gets
the value 0.0.
5-23
Arithmetic (cont’d)
• To get the correct double result, use double
constants or the cast operator:
double ratio = 2.0 / 3;
double ratio = 2 / 3.0;
int m = ..., n = ...;
double ratio = (double) m / (double) n;
double ratio = (double) m / n;
Casts
double r2 = n / 2.0;
5-24
Arithmetic (cont’d)
• A cast to int can be useful:
Returns a
double
int ptsOnDie = (int)(Math.random() * 6) + 1;
int miles = (int)(km * 1.61 + 0.5);
Converts kilometers to
miles, rounded to the
nearest integer
5-25
Arithmetic (cont’d)
• Caution: the range for ints is from
-231 to 231-1 (about -2·109 to 2·109)
• Overflow is not detected by the Java
compiler or interpreter:
n
n
n
n
n
n
n
=
=
=
=
=
=
=
8
9
10
11
12
13
14
10^n
10^n
10^n
10^n
10^n
10^n
10^n
=
=
=
=
=
=
=
100000000
1000000000
1410065408
1215752192
-727379968
1316134912
276447232
n!
n!
n!
n!
n!
n!
n!
=
40320
=
362880
=
3628800
=
39916800
= 479001600
= 1932053504
= 1278945280
5-26
Arithmetic (cont’d)
• Compound assignment
operators:
• Increment and
decrement operators:
a = a + b;
a = a - b;
a += b;
a -= b;
a = a * b;
a *= b;
a = a / b;
a /= b;
a = a % b;
a %= b;
a = a + 1;
a = a - 1;
a++;
a--;
Do not use these in
larger expressions
5-27
From Numbers to Strings
• The easiest way to convert x into a string is to
concatenate x with an empty string:
String s = x + "";
Empty string
'A'
123
-1
"A"
"123"
"-1"
.1
3.14
Math.PI
"0.1"
"3.14"
"3.141592653589793"
• The same rules apply to System.out.print(x)
5-28
From Objects to Strings
• The toString method is called:
public class Fraction
{
private int num, denom;
...
public String toString ()
{
return num + "/" + denom;
}
}
Fraction f = new Fraction (2, 3);
System.out. println (f) ;
Output: 2/3
f.toString() is called
automatically
5-29
The Math class
• Has methods for common math functions:








Math.abs(x)  |x|, absolute value of x
Math.round(x)  x rounded to an integer
Math.pow(x, e)  xe
Math.sqrt(x)  square root of x
Math.max(x, y)  the greater of x, y
Math.min(x, y)  the smaller of x, y
Math.random()  a random number 0  x < 1
Other math functions: trig, log, etc.
5-30
Review:
• What is a variable?
• What is the type of a variable that holds an
object?
• What is meant by the scope of a variable?
• What is the scope of a field?
• What is the scope of a local variable?
5-31
Review (cont’d):
• Is it OK to give the same name to variables in
different methods?
• Is it OK to give the same name to a field and
to a local variable of the same class?
• What is the range for ints?
• When is a cast to double used?
5-32
Review (cont’d):
• Given
double dF = 68.0;
double dC = 5 / 9 * (dF - 32);
what is the value of dC?
• When is a cast to int used?
• Should compound assignment operators
be avoided?
• Name a few methods of Math.
5-33