Data Types and Control Statements

I Career Craft

[email protected]

Data Types

Built-in Data Types

Java primitives (whole numbers) byte short int long Java primitives (real numbers) float double

Built-in Data Types

Java primitives (text) char (character, use single quotes: b) String * Java primitives (True/False) boolean

* String is not a primitive

Variable Declarations
Simple form <datatype> Example int total; Optional initialization at declaration <data type> <identifier> = <init value>; Example int total = 0;

<identifier>;

Examples
int counter; int numStudents = 583; float gpa; double batAvg = .406; char gender; char gender = f; boolean isSafe; boolean isEmpty = true; String personName; String streetName = North Avenue;

Primitive Type Facts

Type boolean Size Min 1bit false* Max true* Default false

char byte
short int long float double void

2 1
2 4 8 4 8

'\u0000' (null) -128

-32,768
-2,147,483,648
-9,223,372,036,854,775,808

127
32,767
2,147,483,647
9,223,372,036,854,775,807

(byte) 0
(short) 0 0 0L 0.0F 0.0D

Approx Approx

3.4E+38 with 7 significant digits 1.7E+308 with 15 significant digits

* Not truly min and max.

Note: Size is in Bytes

Conditionals & Iteration

Decision Statements
if statement omitting else branch: if (condition) statement1;

if statement omitting else branch: if (condition) { statements; } // if

Decision Statements
if statement - single statement bodies: if (condition) statement1; else statement2; if statement - multiple statement blocks: if (condition) { statements; } else { statements; } // if

Multiple Selections via switch

1. Use if construct for single selection. 2. Use if/else construct for double selection. 3. Use switch construct for multiple selection. Notes about switch:

Useful when making a selection among multiple values of the same variable.
Not useful when selecting among values of different variables.

Switch syntax
switch (<variable>) { case <value>: // whatever code you want break; // usually need this case <value>: // whatever code you want break; // usually need this default: // whatever code you want break; // optional }

Multiple Selections via switch

Note the "optional" default case at the end of the switch statement. It is technically optional only in terms of syntax.

switch (number) { case 1: System.out.println ("One"); break; case 2: System.out.println ("Two"); break; case 3: System.out.println ("Three"); break; default: System.out.println("Not 1, 2, or 3"); break; // Needed??? } // switch

This might work without the default case, but would be poor technique

For safety and good programming practice, always include a 'default' case.

How many days?

if (month == 4 || month == 6 || month == 9 || month == 11) numdays = 30; else if (month = 2) { numdays = 28; if (leap) numdays = 29; } else numdays = 31;

Switch
switch (month) { case 4: case 6: case 9: case 11: numdays = 30; break; case 2: numdays = 28; if(leap) numdays = 29; break; default: /* Good idea? */ numdays = 31; }

Java Iteration Constructs: "While Loops"

Java example:
<get first value> while (condition) { <process value> <get next value> }
Note: Check is made before entering loop thus it is possible that loop may not execute

Java Iteration Constructs: "Do While Loops"

Java example: do { statement 1; ... statement N; } while (condition);

Test Last Loop: Body of loop is guaranteed to be executed at least once. Useful when termination condition is developed inside loop.

Java Iteration Constructs: For Loop

Java syntax: for (<initialization>; <continue if>;<increment>)

Java example: int count; for (count = 1; count <= 50; count ++) { <loop-body> }

Secret!
A for Loop can always be converted to a while loop i = 0; while (i < 10) { System.out.println(i); i++; } for(i = 0; i < 10; i++) { System.out.println(i); }

This will help you understand the sequence of operations of a for loop

Operators

Operators based on the number of operators:

Unary Operators

Binary Operators

Ternary Operators

Arithmetic Operators
Sign Unary Operators + Increment and Decrement Operators ++ - Basic Arithmetic Operators + * / %

Relational Operators
Greater than (>) Less than (<) Greater than or equal to (>=) Less than or equal to (<=) Equal to (==) Not equal to (!=)

Logical Operators

Bitwise Operators Short-circuit operators

Bitwise Logical Operators

AND (&) OR (|) XOR (^)

Bitwise Inversion (~)`

Short-Circuit Logical Operators

Short-circuit Logical AND (&&) Short-circuit Logical OR OR (||) Boolean Inversion-NOT (!)

Assignment Operators
= += -= *= /= %= &= |= ^=

Advanced Operators
Shortcut if-else statement (?:) Dot operator (.) Cast operator (<type>) new

instanceof

Equality

Equality of primitives (==) Equality of references (==) Equality of object (equals)

Arrays

A problem with simple variables

One variable holds one value
The value may change over time, but at any given time, a variable holds a single value

If you want to keep track of many values, you need many variables All of these variables need to have names What if you need to keep track of hundreds or thousands of values?

Multiple values
An array lets you associate one name with a fixed (but possibly large) number of values All values must have the same type

The values are distinguished by a numerical index between 0 and array size minus 1
0 1 2 3 4 5 6 7 8 9

myArray 12 43

83 14 -57 109 12

Indexing into arrays

To reference a single array element, use array-name [ index ] Indexed elements can be used just like simple variables You can access their values You can modify their values An array index is sometimes called a subscript 0 1 2 3 4 5 6 7 8 9

myArray 12 43 myArray[0]

83 14 -57 109 12 myArray[5]

myArray[9]

Using array elements

0 1 2 3 4 5 6 7 8 9

myArray 12 43

83 14 -57 109 12

Examples: x = myArray[1]; // sets x to 43 myArray[4] = 99; // replaces 14 with 99 m = 5; y = myArray[m]; // sets y to -57 z = myArray[myArray[9]];// sets z to 109

Array values
An array may hold any type of value

All values in an array must be the same type For example, you can have: An array of integers An array of Strings An array of Person An array of arrays of Strings An array of Object

Two ways to declare arrays

You can declare more than one variable in the same declaration: int a[ ], b, c[ ], d; // notice position of brackets a and c are int arrays b and d are just ints Another syntax: int [ ] a, b, c, d; // notice position of brackets a, b, c and d are int arrays When the brackets come before the first variable, they apply to all variables in the list

Different ways of Creating the array

int myarray [ ]= {1,2,3}; int myarray [ ]= new int[3]; myarray[0]=1; myarray[1]=2; myarray[2]=3; Only Values Only size of array

int myarray [ ]= new int[] {1,2,3};

No size, only values

How to retrieve the values

To retrieve the values from an array for (int i=0; i < myarray.length; i++) { System.out.println(Value is: + myarray[i]); } Here length indicates the size of an array

Arrays of objects
Suppose you declare and define an array of objects:
Person[ ] people = new Person[20];

There is nothing wrong with this array, but

it has 20 references to Persons in it all of these references are initially null you have not yet defined 20 Persons For example, people[12].name will give you a nullPointerException

Arrays of arrays
The elements of an array can be arrays Once again, there is a special syntax Declaration: int[ ][ ] table; (or int table[ ][ ];) Definition: table = new int[10][15]; Combined: int[ ][ ] table = new int[10][15]; The first index (10) is usually called the row index; the second index (15) is the column index An array like this is called a two-dimensional array

Different ways of creating array of arrays

int[ ][ ] table = { {1, 2}, {3, 6}, {7, 8} }; int[ ][ ] table = new int[3][2]; Int[ ][ ] table = new int[ ][ ] { {1, 2}, {3, 6}, {7, 8} };

0 1
1 3 2 7

2
6 8

For example, table[1][1] contains 6 table[2][1] contains 8, and table[1][2] is array out of bounds To retrieve the values: for (int i = 0; i < 3; i++) { for (int j = 0; j < 2; j++) { System.out.println ( table[i][j] ); } }

Size of these arrays

0
0 1

2 1 3 6 2 7 8

int[ ][ ] table = new int[3][2]; The length of this array is the number of rows: table.length is 3 Each row contains an array To get the number of columns, pick a row and ask for its length: table[0].length is 2 But remember, rows may not all be the same length