1 / 22

EXPRESSIONS AND ARITHMETIC

EXPRESSIONS AND ARITHMETIC. Working With Base (or Built-In) Types Arithmetic Constants. Number Crunching (crunch, crunch). Why do we have to learn about arithmetic? We’ve done fine without it so far... With numbers we can…

lowri
Télécharger la présentation

EXPRESSIONS AND ARITHMETIC

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. EXPRESSIONS AND ARITHMETIC • Working With Base (or Built-In) Types • Arithmetic • Constants

  2. Number Crunching (crunch, crunch) • Why do we have to learn about arithmetic? We’ve done fine without it so far... • With numbers we can… • do obvious things that involve arithmetic such as allowing the user to keep an electronic check book or use an ATM • keep track of what’s going on inside the program (e.g. loop counters — stay tuned) • drive peripherals, like graphic displays and printers • We use integers to position and size shapes on screen. The entire screen or any subscreen defines a bounded coordinate system that is a Cartesian plane. Imagine trying to measure something without numbers! (0, 0) (MAX_X, 0) (0, MAX_Y) (MAX_X, MAX_Y)

  3. 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: • byte • short • int • long • float • double

  4. Integers • An integer is a whole number, positive or negative, including 0 • In Java, we can have integers of different sizes • byte (8 bits) can store values from -128 to 127 (-27 to 27 - 1) • short (16 bits) can store values from -32,768 to 32,767 ( -215 to 215 - 1) • int (32 bits) can store values from -2,147,483,648 to 2,147,483,647 (-231 to 231 - 1) • long (64 bits) can store values from -9,223,372,...,808 to 9,223,372,...,807 (-263 to 263 -1) • When using integers, we usually use int

  5. 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 non-object-oriented procedural languages are base types

  6. 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 • code using _numTeeth, declaring it and assigning it an initial value as with an instance public class HockeyPlayer { private int _numTeeth; public HockeyPlayer() { _numTeeth = 8; } public void playHockey() { // we can reassign it! _numTeeth = 4; } } • = means “gets” just as it does when assigning references to variables

  7. Arithmetic Operators Operator Meaning • For integers, division truncates (chops off the decimals, rounds down) • Arithmetic expressions can be constants, numeric variables, functions (i.e., methods that return a value), 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? multiplication division remainder * / % + - addition subtraction

  8. More Operators • To change sign, use - operator on single expression val = -val; // negates val • Since = represents assignment, not a statement of equality, we can operate on and assign to the 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 += 1; a--; a = a - 1; a -= 1;

  9. Variable Increment Operators • Variable increment operators: • i++ usesi, then adds 1 to it (post-increment) • ++i adds 1 to i, then uses it (pre-increment) • What does order mean? • first case, postfix: assign to j, then increment variable inti = 10; int j = i++; // j is 10, i becomes 11 • second case, prefix: increment variable, then assign to j inti = 10; int j = ++i; // j is 11, so is i • same for decrement operators

  10. Evaluation: Follow Rules from High School 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: 2 2 * 3 2 + 4 * 3 - 7 4 / 2 10 % 3 (2 + 3) * (11 / 12) (6 + 4) * 3 + (2 - (6 / 3)) 0 % 9 9 % 9

  11. Fractional Numbers • What if we want to represent fractional numbers? • In Java, we can use float (floating point) or double (double precision floating point) • floating point refers to where the decimal point is assumed to be (an internal implementation detail you don’t have to worry about) • use double for most computation because they a have larger range and are more precise • We declare and assign these the same way • can declare and initialize in same statement double myRadius = 2.427; r

  12. Mixing Integers and Fractional #s • Can use different types of numbers together, but be careful! • Can go from less to more precise, notthe other way around! • Java will not let you lose precision implicitly public class MyMathClass { public void reassign() { intmyInt = 4; double myDouble = 2.64; myInt = myDouble; // can’t assign a double to an int } } • You can change above assignment to: myDouble = myInt; // myDouble is now 4.0 • We can force Java to convert double to int • called casting or coercion • loss of precision myInt = (int)myDouble; // myInt is now 2

  13. Java Math Class • Provides all kinds of cool methods Math.sin(x); Math.cos(x); Math.tan(x); Math.pow(x,y); — raises x to the power of y Math.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 Math’s methods are static!

  14. static Class Methods • static methods, or class methods, are invoked on behalf of the entire class, not on a specific instance of the class – no instance variables needed (nor are you allowed to access any!) • In the 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); • You’ll never need to write a static method in CS15, although you will use Math in future assignments

  15. static Class Variables • Each instance of a class has different copies of instance variables. What if we want all instances of a class to have the same value for a variable? • Use reserved word static to make all instances of a class use the same variable • Each time any method of any instance changes the value of a static variable, all instances have access to that new value. public class SimpleExample { // We initialize outside of constructor // because the variable is static private staticint _numberOfInstances = 0; public SimpleExample() { // We want to keep a tally of all the // SimpleExamples that we create _numberOfInstances++; } public getNumInstances() { return _numberOfInstances; } // Anyone can call getNumInstances to see // how many SimpleExamples have been created }

  16. 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 • Constants should be: • static, so there is exactly one value for the 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; // constructor elided public double getDistanceTraveled( double numSeconds) { // distance = velocity * time return (LIGHT_SPEED * numSeconds); } } • Note: our convention is to capitalize constants and put underscores between words

  17. 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 compile • this is because of the final keyword • Constants have descriptive names; literal numbers (such as 42) don’t • LIGHT_SPEED is called a symbolic constant • 42is called a literal constant • 42 is also a literary constant • Always use constants whenpossible — literal numbersshould rarely appear in yourprograms (except 0,1) • makes your program easier tomaintain and tweak • makes your code easier to read

  18. Using Constants in Multiple Classes • What if many classes use the same constants? • Can put constants in their own utility class public abstract class PhysicsConstants { // speed of light (hundred-million meters // per second) double static final LIGHT_SPEED = 2.998; // more constants, if we want . . . } • To access this constant from another class just use the class name followed by the constant name. Note the use of the dot (.) , much like the use of dot in package hierarchy public double massToEnergy(double mass) { return mass*PhysicsConstants.LIGHT_SPEED* PhysicsConstants.LIGHT_SPEED; } • Constants classes never need to be instantiated and should be declared abstract

  19. 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 a 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 abstract class CowConstants { // initial weight of cow in pounds double static final COW_START_WEIGHT = 587.45; // weight of one blade of grass in pounds double static final BLADE_WEIGHT = 0.0118; // cow must be under this weight to fly double static final MAX_FLYING_WEIGHT = 603.76; } // end of CowConstants

  20. Flying Cow (2 of 2) • Now we can have our cow calculate its weight • Since the cow doesn’t gain the full weight of the grass, we need an equation to determine how much weight the cow gains after grazing • Let’s say the cow will gain 5 times the square root of the total grass’ weight: public class Cow extends FarmAnimal { private double _weight; // constructor elided /** * This method changes the cow’s weight * based on how many blades of grass it ate. */ public void eatGrass(intnumBlades) { double grassWeight = numBlades * CowConstants.BLADE_WEIGHT; // What can we use to calculate square // root? } }

  21. eatGrass(...) • We can use java.lang.Math! public void eatGrass(intnumBlades) { double grassWeight = numBlades * CowConstants.BLADE_WEIGHT; _weight += 5 * Math.sqrt(grassWeight); } • But how can we check to see if the flying conditions are met …?

  22. Announcements • Lab 3 (Interfaces and Polymorphism) is this week! • TASafeHouse is due Friday at 10pm! • Early deadline: Wednesday at 11:59pm • Late deadline: Sunday at 11:59pm • GFX goes out on Thursday. Inheritance and Interfaces 22 of 29

More Related