Primitive Types

• Java supports two kinds of types of values– objects, and– values of primitive data types

• variables store– either references to objects (address in memory)– or directly primitive values (bit patterns)• bit patterns is interpreted according to the primitive type

• primitive types– int, byte, short, long• integer numbers only different precision (32, 8, 16, 64 bits)

– double, float• floating point numbers only different precision (64, 32 bits)

– char • characters (letters, digits, special characters)

– boolean • logical values true or false

Operators

• primitive types support operators– typically binary, but also unary and even ternary– used in expressions

• arithmetic operators– numeric operands, result is the more precise number type

– byte, short, int, long, float, double• +, -, *, /, % (modulo)• +, - (sign change, unary)

• relational operators– primitive types operands, boolean result• == (=), != (≠); (works also with objects!) • <, >, <= (≤), >= (≥)

• logical operators– boolean operands, boolean result• & (and), | (or) ), ^ (xor) • && (and), || (or)

– short circuit, i.e. second operand is evaluated only if necessary• ! (not, unary)

Other Operators

• + (String concatenation)

• instanceof (tests whether an object has certain type)

• <<, >>, >>>, ~, &, |, ^ – (bit pattern operations with numeric operands)

• there are overloaded operators– e.g., +: unary sign, binary addition, String concatenation– operand type or usage decide meaning

• ternary operator <op1> ? <op2> : <op3>• <op1> must be boolean• result is <op2> if <op1> is true • result is <op3> if <op1> is false

– e.g., int minimum = i < j ? i : j;

Assignment Operators

• increment and decrement operators• x++; means x = x + 1; • x--; means x = x - 1 ;

– there is also ++x and --x; don't use it!

• most operators can be combined with an assignment– meaning: x <op>= y; means x = x <op> y • x += y; means x = x + y; • x -= y; means x = x - y; • x *= y; means x = x * y;• x /= y; means x = x / y;• x %= y; means x = x % y;

• don't ever use assignment operators within an expression– Java allows is, but it's only source of errors• x++ + y; if different from ++x + y• x += y -= z; what the heck does it?

Operator Precedence

• precedence = the order in which operators are evaluated:• ()• +, -, ! (unary)• *, /, %• +, -• <, >, <=, >=• ==, !=• &• | • ^ • &&• ||

• on the same level, operators are evaluated left to right

Numeric Types

• integer types• byte (8 bits)• short (16 bits)• int (32 bits)• long (64 bits)

– result of division by zero is an error– overflow is not an error!– byte, short stored in one 32-bit word– long stored in two 32-bit words– long constants have L suffix, e.g., long m = 1000L;– hex constants start with 0x prefix, e.g., byte hex = 0x2f3a;

• floating point types• float (32 bits; 24 bits mantissa, 8 bits exponent)• double (48 bits mantissa, 16 bits exponent)

– special value NaN (undefined)• result of division by zero is NaN

– overflow is an error– float constants have F suffix, e.g., float x = 1000F;

• Additional support in package java.lang– classes Byte, Short, Integer, Long, Float, Double

Type char

• represents characters– constants are enclosed in single quotes, e.g., char digit = '9';– constants can be defined numerically with C suffix, e.g., char ch = 0C;– is ordered, but the order is crazy

• first some special characters• then lowercase 'a'..'z'• then more special characters• then uppercase 'A'..'Z'• then other special characters..• then digits '0'..'9'• then other characters

• Unicode standard– 16 bits, but stored in one 32-bit word– supports most at languages– Chinese, Kanji, Hiragana, Katakana, Korean, Thai, Arabic, …

• compatible with integer types– e.g., int lowercase = 'q';– char uppercase = (char) (lowercase + 'A' - 'a');

• Additional support in class Character in package java.lang

Type boolean

• two values true and false

• operand ! (not)• ! true is true • ! false is false

• operands &, && (and)– are both operands true?• true & true is true • true & false is false• false & true is false• false & false is false

– also: only true & true is true – also: both operands must be true so that result is true – also: if one of the operands is false the result is false • &: evaluate both operands then compare • &&: evaluate first operand, if it's false then don't evaluate second

– only if it's true evaluate second operand and compare

Type boolean

• operands |, || (or)– is at least one operand true?• true | true is true • true | false is true • false | true is true • false | false is false

– also: only false | false is false– also: both operands must be false so that result is false– also: if one of the operands is true the result is true • |: evaluate both operands then compare • ||: evaluate first operand, if it's true then don't evaluate second

– only if it's false evaluate second operand and compare

• operands ^ (xor)– are both operands different?• true ^ true is false • true ^ false is true • false ^ true is true • false ^ false is false

– also: both operands must have the same value so that result is false– also: operands must have different values so that result is true

Use of boolean

• computation with logical values– variables of type boolean– e.g. boolean done = false;

• to return result from a method– asking existence, e.g., hasOutline()– asking for truth of a property isVisible()

• conditional decisions– if a condition is true do something• otherwise do something else

– repeat doing something while a condition is true

• special branching and looping statements– if statement– if-else statement– switch statement– while statement– for statement