© 2006 Pearson Education Arithmetic1 of 21 Working With Base Types (or built-in types) –not objects or references: Java has special syntax to deal with

© 2006 Pearson EducationArithmetic 1 of 21

• Working With Base Types (or built-in types)– not objects or references: Java has special syntax

to deal with them– easy to learn and work with!

• Arithmetic– integers– fractional numbers– arithmetic operations

• Constants

EXPRESSIONS AND ARITHMETIC


Number Crunching (chomp, chomp)

• Why do we have to learn about arithmetic? We’ve done fine without it so far...

• Numbers are very useful– do obvious things that involve arithmetic such as

allowing user to keep electronic checkbook or use ATM

– keep track of what’s going on inside program (e.g., loop counters — stay tuned)

– drive peripherals, like graphic displays and printers

• We use integers to position and size shapes on screen. Entire screen or any subscreen defines bounded coordinate system that is a Cartesian plane.

(0, 0)

(MAX_X, 0)

(0, MAX_Y)

(MAX_X, MAX_Y)


Numbers in Java

• Before we learn about arithmetic, we need to learn about numbers in Java

• Until now, our variables have only been references to objects

• Now we learn to use primitive data types predefined by Java, called base types

• There are six different numerical base types:– bytes– shorts– ints– longs– floats– doubles


Integers

• An integer is any whole number, negative or positive, including 0

• In Java we can have integers of different sizes– bytes (8 bits) can store values from -128 to 127

(-27 to 27 - 1)– shorts (16 bits) can store values from -32,768 to

32,767 ( -215 to 215 - 1)– ints (32 bits) can store values from -

2,147,483,648 to 2,147,483,647 (-231 to 231 - 1)– longs (64 bits) can store values -9,223,372,...808

to 9,223,372,...807 (-263 to 263 -1)

• When using integers, we usually use ints


Declaring Base Types

• Java recognizes int and other numbers as “base types,” but they are not objects or references!

• Base types do not have constructors, instance variables, or methods– hence, we do not “new” them, we just assign

values to them!– example on next slide

• But they are declared just like other variables:

public class HockeyPlayer{ private int _numTeeth;}

• all types in procedural languages are base types


Integer Assignment

• Integer variables can be used in arithmetic expressions, sent as parameters, and assigned values, just like other variables

• References to objects are assigned a default value of null; integers are assigned a default value of 0

• However, it is good coding style to assign a value to everything before using it– we write code for _numTeeth, assigning it an

initial value:

public class HockeyPlayer { private int _numTeeth; public HockeyPlayer() { _numTeeth = 8; } public void playHockey() { // we can reassign it! _numTeeth = 4; }}

• = means “gets” just like it does when assigning references to variables


Arithmetic Operators

• For integers, division truncates (rounds) toward zero

• Arithmetic expressions can be constants, numeric variables, functions, two sub-expressions joined by an operator, or expressions surrounded in parentheses

• Examples– (((10.4))) evaluates to 10.4– 7 % 5 evaluates to 2– 9 / 2 evaluates to 4– numOne + numOne evaluates to twice the value

of numOne (assuming numOne is a numeric variable type)

– 2 (3 + 4) is not a valid expression — why?

Operator Meaning

*

/

%

multiplication

division

mod (remainder of integer div.)+

-

addition

subtraction


More Operators

• To change sign, use - operator on single expression

val = -val; // negates val

• Since = represents assignment, not statement of equality, can operate on and assign to same variable– e.g., a = a + 5;

• We can also do this using shorthand <op>=a += 5; a = a + 5;a -= 5; a = a - 5;a *= 5; a = a * 5;a /= 5; a = a / 5;a %= 5; a = a % 5;

• Even more shorthand!a++; a = a + 1;a--; a = a - 1;


Variable Increment operators

• Variable increment operators:– i++ use i, then add 1 to it– ++i add 1 to i, then use it

• What does order mean?– first case, prefix: increment variable, then use int i = 10; int j = ++i; // j is 11, so is i

– second case, postfix: use, then increment variable int i = 10; int j = i++; // j is 10, i becomes 11

– same for decrement operators


Evaluation: Follow Rules from 9th Grade Algebra

• Three rules for evaluation– evaluation takes place from left to right, except

that– expressions in parentheses are evaluated first,

starting at the innermost level, and– operators are evaluated in order of precedence

*, /, and % have precedence over + and -

• Sample expressions:22 * 32 + 4 * 3 - 74 / 210 % 3(2 + 3) * (11 / 12)(6 + 4) * 3 + (2 - (6 / 3))0 % 99 % 9


Fractional Numbers

• What if we want to represent fractional numbers?

• In Java we can use floats (floating point) or doubles (double precision floating point)– floating point refers to where the decimal point is

assumed to be – internal implementation detail– use doubles for scientific computation because

they have larger range

• We declare and assign these in same way

rdouble myRadius = 2.427;


Mixing Integers and Fractional #s

• Can use different types of numbers together, but be careful!

• Can go from less to more precise, not the other way around!– Java will not let you lose precision implicitly

public class MyMathClass { public void reassign() { int myInt = 4; double myDouble = 2.64; myInt = myDouble; // can’t assign a double to an int }}

• Change above assignment to: myDouble = myInt;

• We can force Java to convert double to int– called casting or coercion– loss of precision myInt = (int) myDouble; // myInt is now 2


Digression: static Class Variables

• Each instance of a class has different copies of instance variables. What if we want entire class to have same value for variable?

• Can use reserved word static to make class variables, of which there is only one copy for entire class.

• Each time any method of any instance changes the value of a static variable, all instances have access to that new value.

public class ContrivedExample {

private static int _numberOfInstances;

public ContrivedExample() { // we want to keep a tally of all the // ContrivedExamples that we create _numberOfInstances++; } // now every instance of ContrivedExample // can access _numberOfInstances to see how // many contrived examples have been // created}


Constants (1 of 2)

• Constants are used to represent values which never change in a program (like Planck’s constant, speed of light, etc.)– we’ve seen constants before: the red, blue, green, etc., values of the java.awt.Color class

• They should be:– static, so there is exactly one value for entire

class– final, so their values can’t be changed– and probably public, so they are widely available

public class Physics { // Speed of Light // (hundred-million meters per second) public static final double LIGHT_SPEED =

2.998; public double getDistanceTraveled(

double numSeconds) {

// distance = velocity * time return (LIGHT_SPEED * numSeconds); }}

• Note: our convention is to capitalize constants and put underscores between words


Constants (2 of 2)

• If a new value for LIGHT_SPEED is discovered, we can change our entire program very easily, by changing the value of our constant and recompiling– extendable to different universes

• Constants never change after declaration– <constant> = <expr> in a method won’t work

• Constants have descriptive names; literal numbers (such as 42) don’t– LIGHT_SPEED is called a symbolic constant– 42 is called a literal constant

• 42 is also a literary constant– (in Memoriam, Douglas Adams)

• Always use constants when possible — literal numbers should never (well, hardly ever) appear in programs. 0, 1 are common exceptions– makes your program easier to change– makes your code easier to read


Using Interfaces with Constants

• So far we have only used interfaces to declare methods — we can also use them to declare constants

• What if many classes use same constants?

• Can put constants in an interface and have classes implement it!– then public, static, and final are implicit

public interface PhysicsConstants { // speed of light (hundred-million meters // per second double LIGHT_SPEED = 2.998; // more constants, if we want . . .}

• Now all classes that implement the PhysicsConstants interface have access to LIGHT_SPEED


A Fun Example: Flying Cow (1 of 2)

• We want to model a cow that can fly, but only if the moon is full and if the cow is under a certain weight

• When cow grazes, its weight changes. We need to calculate its new mass after grazing. But how?

• First, we’ll need some constants to help us.

public interface CowConstants { // initial weight of cow in pounds double COW_START_WEIGHT = 587.45; // weight of one blade of grass in pounds double BLADE_WEIGHT = 0.0118; // cow must be under this weight to fly double MAX_FLYING_WEIGHT = 603.76;}


Flying Cow (2 of 2)

• Now we can have our cow calculate its weight

• Since cow doesn’t gain full weight of grass, we need equation to determine how much weight cow gains after grazing

• Let’s say cow will gain 5 times square root of grass’ weight:

public class Cow extends FarmAnimal implements CowConstants {

private double _weight;

/** * This method changes the cow’s weight * based on how many blades of grass it ate. */ public void eatGrass(int numBlades) { double grassWeight = numBlades *

BLADE_WEIGHT;

// Uh-oh... how to calculate square root? }}


Java Math Class

• We can use Math class which is predefined by Java!

• Provides all kinds of cool methodsMath.sin(x);Math.cos(x);Math.tan(x);Math.pow(x,y); — raises x to the power of yMath.log(x);Math.sqrt(x); — square root of x

... and more!

• Math also defines two symbolic constants:E = 2.71...PI = 3.14...

• Why can we call methods on Math without instantiating it?

• Because its methods are static!


static Class Methods

• static methods, or class methods, are invoked on behalf of entire class, not on specific instance of class – no instance variables needed (nor are you allowed to access any)!

• In Math class, methods are declared:

public static double sin(double a) {...

}

• When calling static method, don’t have to instantiate class, just send message to class

_side = Math.sin(x);

• This is just so you know, you’ll never need to write a static method in this course, although you will use Math in future assignments.


eatGrass

• Now we can finish writing eatGrass method:

public void eatGrass(int numBlades) { double grassWeight = numBlades *

BLADE_WEIGHT;

_weight += 5 * Math.sqrt(grassWeight);}

• But how do we know if flying conditions are met?

Documents

© 2006 Pearson Education Arithmetic1 of 21 Working With Base Types (or built-in types) –not objects or references: Java has special syntax to deal with