outline

Variables in java

• primitive types
• Object types

Boolean

• name	boolean
  length	1 byte
  legal values	true or false (no caps)
  default value	false
  operations	Can be used ONLY in boolean operations (=, ==, !=, !, &, &&, |, ||, ^, ?:)

Boolean example

• 
  boolean continue = true;
  while (continue){
    //code goes here...
    if(continue){
       //code goes here...
      continue = false
    }// end if
  } // end while
  

Boolean comments

• booleans are NOT integers, they only take up one byte
• You cannot combine integer and boolean operations
• EG if (intVar = 10){} is NOT legal in java (thank goodness)

Characters (char)

• name	char
  length	16 bit (only ONE character)
  legal values	unicode (ASCII + extensions)
  default value	\u0000 (null character)
  operations	any of the typical operations assignment boolean including if , while, for, switch it can be cast into other primative types (although it might lose some information)

Char Examples

• char myChar = 'C'
• myChar = 'a'

Char Notes

• notice that you must refer to a char literal inside single quotes
• Uppercase and lowercase letters are different
• If you cast a char to a numeric type, the new value will reflect the unicode value of the character

byte

• name	byte
  length	8 bits
  legal values	-128 to 127
  default value	0
  operations	Any operations, but boolean operations ALWAYS produce a boolean result

int

• name	int
  length	32 bits
  legal values	-2,147,483,648 to 2,147,483,647
  default value	0
  operations	Any operations, but boolean operations ALWAYS produce a boolean result

long

• name	long
  length	64 bits
  legal values	-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
  default value	0
  operations	Any operations, but boolean operations ALWAYS produce a boolean result

Examples of integer types

• int num1;
• int num2 = 3;
• int ans;
• long myLong = 3L;
• long myLong = (long)num2;
• ans = num1 + num2;

Notes on integer types

• You cannot always be sure what type your answer will be when you compare different types. You may need to cast an answer
• to be sure
• Remember that integer values can be positive or negative, but cannot contain decimal values

More on integers

• when dealing with long values, either cast explicitly to a long or use the long postfix (L)
• java interprets this value as an int : 5
• java interprets this value as a long: 5L
• (note that the L is capitalized, unlike other postfixes. Lowercase 'l' looks too much like '1' (The one character)

Float

• name	float
  length	4 bytes
  legal values	@ 2 to +/- 38
  default value	0.0f
  operations	Can be used for assignment, comparison. Can be cast to other primitive types, but may lose value

double

• name	double
  length	8 bytes
  legal values	@ 2 to +/- 300
  default value	0.0d
  operations	Can be used for assignment, comparison. Can be cast to other primitive types, but may lose value

Casting primitives

• Conversion between primitive types
• The next line will cause an error!!
• int answer = 54.2 + 21.7;
• The next line will be OK
• int answer = (int)(54.2 + 21.7);
• of course, some detail will have been lost
• This is different than
• int answer = (int)54.2 + (int)21.7;

postfix identifiers

• used for literal values
• 2i, 3d, 7L
• Casting will work just as well, might be more clear

Strings

• ...are OBJECTS, not primitive types!!
• cannot be cast
• cannot be compared using math operators
• (..at least and get the result you might expect)

Wrapper objects

• classes defined to encapsulate primitives
• start with a capital letter
• Float is an object, float is a primitive
• Wrappers exist for all primitive types

Wrapper examples

• float fltPrim = 3.6f;
• float result;
• Float fltClass = new Float(fltPrim);
• result = fltClass.toFloat();

Converting primitives to String

• String.valueOf(anything);
• Concatenation to a string will automatically call this method
• Wrappers also contain a toString method

primitive to string examples

• String myString = String.valueOf(5);
• Integer myInteger = new Integer(4);
• myString = myInteger.toString();
• myString = Integer.toString(4);

Strings to primitives

• Most of the wrapper objects can take a String value as their initial value, and will automatically attempt to create the proper
• value of the appropriate type.
• EG
• Float myVal = new Float (txtInput.getText());
• lblOut.setText myVal.toString();

More on String to Primitive conversion

• There is also a .valueOf method in the wrappers to do this:
• EG
• Float myVal = Float.valueOf (txtInput.getText());
• In these cases, however, there has not been a primitive defined (!)
• The value has NEVER stood alone as a primitive. It has always been part of some kind of object.

Warning about Wrapper objects!!!

• They cannot be used in mathematical operations
• convert to a primitive first (floatValue(), doubleValue(), etc) first

Pass by reference, pass by value

• All objects are passed by reference
• All primitives are passed by value
• To pass a primitive by value, encase it in a wrapper first

Circle 1