C SC 160 Chapter 3: Numerical Data
major resource: An Introduction to Object-Oriented Programming with Java, fourth edition, Wu, McGraw Hill, 2006

[ previous | schedule | next ]

Java Language "model"

• Java and other mainstream languages based on "machine model"
• Recall Turing machines? They are not based on the machine model, but instead on a mathematical model (Turing developed them several years before electronic computers were developed).
• The Machine Model is the von Neumann computer architecture
• Memory holds instructions and data
• Instruction cycle to process data and instructions
• Remember MIPS assembly? Didn't you use it in CSC 150?
• MIPS program to add two integers together

  # MIPS assembly program to add two integers # Pete Sanderson # .data first: .word 13 second: .word 25 result: .word 0 .text lw $t0, first # load value from memory into register $t0 lw $t1, second # load value from memory into register $t1 add $t2, $t0, $t1 # add $t0 value to $t1 value, result into register $t2 sw $t2, result # store value from register $t2 into memory

• Key statement is: add   $t2, $t0, $t1
• At the time of addition, the values are in registers, disassociated from their memory source!
• The result is placed into a register, and only later written to memory.
• Consider the (non-OO) Java equivalent program.
• Key statement is the assignment statement

Assignment Statement

• Format: variable = value;
• a.k.a. LHS = RHS;
• LHS is Left Hand Side, RHS is Right Hand Side
• Focus on numeric types, initially RHS then LHS

Numeric Types

• Operations and operands
• Operation precedence
• Primitive types (not OO)
• Range and Precision
• Integer types: byte, short, int, long (different range, same precision)
• Real types: float, double (different range, different precision)
• Determining type of resulting RHS value? Widest range of any RHS operand
• Do some experiments
• Implicit promotion ("widening")
• Can override using typecast
• NOTE: neither implicit promotion nor typcasting affects the variables themselves

Wrapper classes

• All primitive types have class equivalent
• Integer for int
• Double for double
• etc...
• "auto-boxing" implicitly converts primitive to equivalent object when necessary
• "auto-unboxing" does opposite
• Unboxing then boxing example:
  int wirth;
  Integer first = new Integer(11);
  wirth = first + 3; // Unbox; equivalent to: wirth = first.intValue() + 3;
  first = wirth * 7; // Box; equivalent to: first = new Integer(wirth * 7);

Assignment LHS

• Consider assignment symbol as binary operator
• lowest precedence
• associates right-to-left (e.g. a=b=c=d evaluated right to left)
• LHS is variable, representing memory cell to receive RHS result
• result is value assigned
• Has "side effect" : writing to the memory cell
• LHS is subject to type determination (see above) with one huge difference: it cannot be promoted!
• Cannot be promoted because it represents storage, not value. Data type associated with storage cannot be changed.

Primitive, non-numeric types

• char (16 bit Unicode), boolean (true or false)

Constants

• Constant means the value cannot be changed.
• This is obvious for literal constants, such as 457 or 3.1415926
  • Note that 457 is an int constant. If you need long, append an "L" as in 457L
  • Note that 3.1415926 is a double constant. If you need float, append an "F" as in 3.1415926F
• This may not be immediate obvious for named constants, which are identifiers
  • By tradition, the identifier provides visual clue by containing only upper case and underscore ( _ )
  • The compiler expectation, however, is that the identifier is declared final
  • Examples:
       final int MAXIMUM_OCCUPANTS = 245;
       final String PROMPT = "Please enter your age ";
  • It can only be assigned a value one time

Assignment with Objects

• Format: variable = value;
• The variable on LHS is an identifier declared to be of an object (non-primitive) type
• The value on RHS is normally a constructor call, method call, another object variable, or null
• Constructor returns reference to (address of) newly-created object
• Method with object (non-primitive) return type returns reference to (address of) an object
• The value of an object variable is the reference to (address of) the object it represents
• In all three cases, the value assigned is a reference. We normally draw this as an arrow to the object.
• If the value is keyword null (or a null reference), it is a reference to no object
• The memory view really helps here.
• Another object assignment issue is aliasing
• Consider primitives. If I write:
     int time = 10;
     int more = time;
  then more gets its own copy of the value 10. It is separate from and independent of the value 10 held by time. No worries, mate.
• Consider objects. If I write:
     Employee dave = new Employee();
     Employee emil = dave;
  then emil gets its own copy of the reference, but both dave and emil now refer to the same object!
• The dave/emil situation is aliasing. Multiple names for the same thing. Not independent.
• Object aliasing is not a problem if the object is immutable (can't be changed), like String objects.
• Object aliasing can be a big problem is the object is mutable. Analogy: Both you and your father's name are on your savings account and he withdraws $500 without telling you. He did it, you are affected too.

Several Useful Library Classes

• Math : provides a number of static (class) methods for common mathematical functions and constants.
• Scanner : provides methods for getting input. Mainly from the keyboard, a.k.a. System.in, a.k.a. "standard input"
• DecimalFormat : provides methods for producting formatted strings from numerical values
• GregorianCalendar : provides methods for working with dates and times