Readings

• On the course Web page look at:
  • Errors in the text
  • Spring CSC108 page
  • Course announcements
    - about the Midterm
  • How to print Print Java
    Assignment.
  • Assignment 2 is on the course web page! It is also available on the Bulletin board outside of SF 2304.
• In the text read
  • Chapters 6, Appendix 'O'.
  • Suggested Text exercises:All ``Self-Review Questions'' and ``Exercises'' chapters 1-5,
    ``Programming Projects'' 3.17-19,21-24,
    4.18-20

More Programming Constructs

• Storage formats
• Type Conversion
• More Java operators
• More program constructs (switch, do, for)

Representing integers

two's complement

• represents positive numbers normally
• represents negative numbers by
  toggling and adding 1
• signed byte (two's complement) makes computer arithmetic easier
• but causes incorrect results if your calculation causes overflow or underflow.

}

Type

Storage   Min Value   Max Value

byte

8  bits   -128           127

short

16 bits  -32,768         32,767

int

32 bits  -2,147,483,648  2,147,483,647

long

64 bits  < -9 x 10 18    > 9 x 10 18

Representing Floating Point

                           exponent
     sign * mantissa * base

We use decimal (base 10) the computer uses binary (base 2)

Type

Storage Mantissa   Exponent

float

32 bits    23      8

double

64 bits    52      11

In floating point, half the represented
numbers are between -1 and 1.

Representing Characters

Unicode is the mapping from keyboard
characters to a binary representation.

Unicode is a superset of ascii code

Unicode is an unsigned 16 bit integer
allowing representation of 65,536
characters (many languages characters)

'A' is 65 decimal or 1000001 binary

A-Z is earlier than a-z and both are adjacent
in Unicode so you can shift from upper to lower
case by adding 32 which is equivalent to
adding: (int)'A' - (int)'a'

The digits represented are adjacent.

'0' is 48 (decimal) so character digits can be made integers by subtracting 48.

Type Conversion Categories

• widening possible loss of precision int to
  float or long to double because fewer
  digits represent the mantissa in the
  respective floating point type than the
  integer type.

    int i = 2147483647; // largest int
    float f = i;    // f = .2147483e10

• narrowing possible catastrophic loss of
  magnitude as well as precision because the
  type may not be able to represent the
  number at all. i.e. too large or too small
  in magnitude.

    float f = 1.e10f; // or 1.e-10f
    int i = (int)f; // i = ???

Performing Conversions

• Assignment conversion - widening only
• Arithmetic promotion - float / integer the denominator becomes a float first.
• Casting - forces conversion
  (could be dangerous)

  double d = 10.5;
  int i = (int)d; // 10

Operators and Short Forms

• integer
  • increment i++ means i = i + 1
  • decrement i- means i = i - 1
  • prefix (operation then return value)
    ++i or -i
  • postfix (return value then operation)

Operators and Short Forms

• logical ! NOT, && AND, || OR
• assignment = += -= *= |= and more syntactic sugar
  • short forms are not necessary
  • x += expression; // x + expression;
  • byte b |= a; // b | a; // bitwise OR
• conditional operator returns a value
• x = (condition) ? exp1 : exp2;

  if (condition)
     x = exp1;
  else
     x = exp2;

Operator Precedence

1 L-R

dot, parameter evaluation,
postfix operators

2 R-L

prefix operators

3    

new object and casting

4 L-R

arithmetic

5 L-R

relational comparison i.e. >=

6 L-R

logical connectors i.e. ||

7 R-L

? :

8 R-L

assignment

boolean b = true;
i = 3;
boolean c;
c = b = 0 < new Double("3" + ".0").doubleValue() - i++ && b;
  |   |   |  |             |      |              |  |   |
  9   8   6  2             1      3              5  4   7

Selection

switch (integral_expression) {
  case value1: statement1;
  case value2: statement2;
  case value3: statement3;
  default: statementd;
}

Not the same as if-then-else-if unless you use a break after each case

Iteration statements

do
  statement;
while (condition);

for (initialization; condition; increment) 
  statement;

initialization is a list of comma separated
assignments or empty list

condition evaluates to boolean (true or false) or empty

increment is a list of assignments or empty

break and continue in loops

To exit from the middle of a do, for, or while loop use break

while (true) {
  statements;
  if (condition) break;
  statements;
}

To continue at the top of the loop

while (condition) {
  statements;
  if (condition) continue;
  statements;
}

Strings

The String class allows literal assignment
without the new operator

Methods

char charAt(int)
int indexOf(char)
int lastIndexOf(char)
boolean endsWith(String suffix)
boolean startsWith(String)
boolean equals(Object)
boolean equalsIgnoreCase(String)
int compareTo(String)
String toLowerCase()
String toUpperCase()
int length()

StringTokenizer

Constructors

StringTokenizer(String)
StringTokenizer(String, String delimiters)
StringTokenizer(String, String delimiters,
                boolean returnDelimitors)

Methods

boolean hasMoreTokens() // returns boolean
String nextToken()     // default last delimiters
String nextToken(String delimiters) // persistent
int countTokens()

See Voltaire and URL_Tokens

StringBuffer Class

StringBuffer size can change dynamically

Does the Basic String operations and more

Constructors

StringBuffer(), default 16
StringBuffer(int)
StringBuffer(String)

Methods

String append(char)
String insert(int, char)
char charAt(int)
void setLength(int)
String reverse()
int length()

• Lecture 6 ...