The Basic Parts of Java

Data Types

Primitive Composite

array (will also be covered in the lecture on Collections)

Lexical Rules Expressions and operators Methods

Parameter list Argument parsing An example an overview, very much C like

Control structures

OOP: Basic Parts of Java

Primitive Data Types

boolean byte short int long float double char {true, false} 8-bit 16-bit 32-bit 64-bit 32-bit 64-bit 16-bit uni-code

Natural numbers

Floating points

Also called built-in types All numbers are signed Have fixed size on all platforms
OOP: Basic Parts of Java 2

Declarations
A declaration is the introduction of a new name in a program. All variables must declared in advance. The is no dedicated variable declaration part of a Java
program. General forms type variableName1, variableName2, variableName3; type variableName1 = value1, variableName2 = value2, variableName3 = value3;

Variables of primitive type are initialized with default values.

0 (binary) what ever that means for the specific data type Constants are declared as final static variables

OOP: Basic Parts of Java

Primitive Data Types, Example

// create some integers int x, y, z; x = 1234; y = 3; z = Integer.MAX_VALUE; // or similar for doubles double v = 3.14e-23, w = 5.5, vv = Double.NEGATIVE_INFINITY; // create som chars char c1 = 'a'; Character c2; // use a wrapper class c2 = new Character ('b'); // read only // A well-known constant final static double PI = 3.14;
OOP: Basic Parts of Java 4

Array: A Composite Data Type

An array is an indexed sequence of values of the same type. Arrays are defined as classes in Java. Example:
boolean[] boolTable = new boolean[MAXSIZE]

Elements are all of type boolean The index type is always integer Index limits from 0 to MAXSIZE-1

Bound-check at run-time. Arrays are first class objects (not pointers like in C) There are no struct/record or enumaration types in Java.
structs/records are replaced by classes Type safe enumeration will be added in Java 1.5 (2005)

OOP: Basic Parts of Java

Lexical Rules
A name in Java consists of [0-9][a-z][A-Z][_$]

cannot start with a number national language letters can be used, e.g., , , and . no maximum length thisIsAVeryLongVariableName

All resevered word in Java are lower case, e.g., if. Case matters myVariable, myvariable

OOP: Basic Parts of Java

Naming Conventions
Words run together, no underscore Intermediate words capitalized.

Okay: Not okay

noOfDays, capacity, noInSequence no_of_days, noofdays

Name of classes: first letter upper case

Okay: Not okay:

Person, Pet, Car, SiteMap vehicle, site_map, siteMap

Name of method or variable: first letter lower case Name of constants: all upper case, separated by underscore,
e.g., java.math.E and java.math.PI Part of JavaSoft programming standard Java's Naming convention (link)
OOP: Basic Parts of Java

Commands in Java
Very similar to the C programming language Assignment

variable = <expression>

Method call

call by value call by reference (almost)

Control Structures

sequential (follow the flow) branching (selective) looping (iterative)

OOP: Basic Parts of Java

Block Statement
Several statements can be grouped together into a block
statement. A block is delimited by braces { <statement list> } Variables can be declared in a block. A block statement can be used wherever a statement is called for in the Java syntax.

For example, in an if-else statement, the if portion, or the else portion, or both, could be block statements

OOP: Basic Parts of Java

Expresions and Operators

An expression is a program fragment that evaluates to a single
value.

double d = v + 9 * getSalary() % Math.PI; e = e + 1; (here e is used both as an rvalue and a lvalue)

Arithmetic operators

Additive +, -, ++, -Multicative *, /, % (mod operator)

i = i + 1, i++, --i 9%2 = 1, 7%4 = 3

Relational Operators

Equality == (two '=' symbols) Inequality != Greater-than >, >= Less-than <, <=

i i i i

== j vs i = j != j > j, i >= j < j, i <= j

10

OOP: Basic Parts of Java

Expresions and Operators, cont.

Logical operators

and && or || not ! All are short-circuit

bool1 && bool2 bool1 || bool2 || bool3 !(bool1)

Bitwise operators

and & or | xor ^ shift left << shift right >>

255 & 255 | 3 ^ 16 << 16 >>

5 5 8 2 2

= = = = =

5 255 11 64 4

15 & 8 | 16 ^ 7 << 7 >>

128 = 0 2 = 10 31 = 15 3 = 56 2 = 1

OOP: Basic Parts of Java

11

Expresions and Operators, cont.

Assignement Operators

can be combined with other binary operators +=, -=, *=, /=, %=, >>=, <<=, &=, ^=, !=

Conditional Operator

Ternary operator ?: int max = n > m ? n : m;

Precendence rules similar to C for Java operators Associtivity rules similar to C for Java operators

OOP: Basic Parts of Java

12

Methods in Java
All procedures and functions in Java are methods on classes. The difference between a procedure and a function is the
return type

void myProcedure() int myFunction() MyClass myFunction1()

Methods cannot be nested! Returning

Implicit: When the last command is executed (for procedures). Explicit: By using the return command.

Good design: only to have one return command each method

OOP: Basic Parts of Java

13

Methods in Java, cont.

General format
ReturnType methodName (/* <argument list> */){ // <method body> return stuff; }

Examples calling methods

double y = getAverageSalary(); double z = getAverageSalary; boolean b = exists(/*args*/); exists(/*args*/); Person p = getPerson(/*args*/); // // // // // returns double an error! returns boolean ignore return val. returns Person

Methods can be overloaded

double set(int i), double set(int i, int j) Cannot overload on return value!
14

OOP: Basic Parts of Java

Class IPAddress Example

public class IPAddress{ public static final String DOT = "."; private int[] n; // example 127.0.0.1 private String logical; // example localhost /* Constructor */ public IPAddress(){n = new int[4]; logical = null;} /* Sets the logical name */ public void setName(String name){logical = name;} /* Gets the logical name */ public String getName(){ return logical; } /* Sets numerical name */ public void setNum(int one, int two, int three, int four){ n[0] = one; n[1] = two; n[2] = three; n[3] = four;} /* Sets numerical name */ public void setNum(int[] num){ for (int i = 0; i < 4; i++){n[i] = num[i];} } /* Gets the numerical name as a string */ public String getNum(){
OOP: Basic Parts of Java

return "" + n[0] + DOT + n[1] + DOT + n[2] + DOT + n[3];

}
15

Class IPAddress Example, cont.

public class IPAddress{ // create a new IPAddress IPAddress luke = new IPAddress(); luke.setName("luke.cs.auc.dk"); System.out.println(luke.getName()); luke.setNum(130, 225, 194, 177); String no = luke.getNum(); System.out.println(no); // create another IPAddress IPAddress localHost = new IPAddress(); localHost.setName("localhost"); int[] lNum = {127, 0, 0, 1}; // array initialization localHost.setNum(lNum); System.out.print(localHost.getName()); System.out.print(" "); System.out.println(localHost.getNum()); }
OOP: Basic Parts of Java 16

Class IPAddress, Ugly Stuff

public class IPAddress{ /* <snip> as previous class*/ /* What is ugly here? */ public void setName1(String name){ logical = name; return; } /* What is ugly here? */ public void setName2(String name, int i){ logical = name; } /* What is ugly here? */ public int setName3(String name){ logical = name; return 1; }
OOP: Basic Parts of Java 17

Parameter Mechanism
All parameters in Java are pass-by-value.

The value of the actual parameter is copied to the formal parameter. public static void main (String[] args) Will be supported in Java 1.5

A variable number of arguments in not supported

Passing Objects

Objects are accessed via a reference. References are pass-by-value.

The refernce is copied The object itself is not copied

Via a formal parameter it is possible to modify the object directly. The reference to the object cannot be modified.

OOP: Basic Parts of Java

18

Actual and Formal Parameters

Each time a method is called, the actual parameters in the
invocation are copied into the formal parameters.
String s = obj.calc(25, 44, "The sum is ");

String calc(int num1, int num2, String message){ int sum = num1 + num2; String result = message + sum return result; }

OOP: Basic Parts of Java

19

Class IPAddress Example, cont.

public class IPAddress{ /* Call by value */ public int callByValue(int i){ i += 100; return i; } /* Call by value */ public String callByValue(String s){s = "modified string"; return s; } /* Call by reference like method */ public int callByRefLike(int[] a){ int sum = 0; for(int j = 0; j < a.length; j++){ sum += a[j]; a[j] = 255;} return sum; } // in main IPAddress random = new IPAddress() int dummy = 2; random.callByValue(dummy); // dummy unchanged String str = "not using new"; random.callByValue(str); // str unchanged, also if called with new int[] ranIPNum = new int[4]; random.setNum(ranIPNum); // ranIPNUM changed to 255.255.255.255 OOP: Basic Parts of Java 20

The static Keyword

For data elements

Are shared between all the instances of a class public static int i; public static ArrayList = new ArrayList(); public static final char DOT = '.';

For methods

Can be access without using an object public static void main(String args[]){} public static int getCount(){}

OOP: Basic Parts of Java

21

Class IPAddress Example, cont.

public static void main (String[] args){ private static int count = 0; public static final String DOT = "."; <snip> /* Constructor */ public IPAddress(){ n = new int[4]; logical = null; count++;} /* Get the number of objects created */ public static int getCount() { return count;} <snip> /* Handy helper method */ public static void show(IPAddress ip){ System.out.print(ip.getName()); System.out.print(" "); System.out.println(ip.getNum()); } }
OOP: Basic Parts of Java 22

Control Structures
Basic parts of the programs Borrowed from C programming language Branching

if-else switch (case statement) break, continue, goto while-do do-while for

Looping

OOP: Basic Parts of Java

23

The if Statement
The if statement has the following syntax:
The condition must be a boolean expression. It must evaluate to either true or false. if (condition){ statement; }

if is a Java reserved word

If the condition is true, the statement is executed. If it is false, the statement is skipped.

OOP: Basic Parts of Java

24

Logic of an if Statement
// example 1 if (weight < 20000) doStuffMethod(); // same thing if (weight < 20000){ doStuffMethod(); } // example 2 if (weight < 20000) doStuffMethod(); doMoreStuff(); false // NOT the same thing if (weight < 20000){ doStuffMethod(); doMoreStuff(); } // What is ugly here? boolean b = getChoice(); if (b == true){ // do stuff }

condition

true statement

next statement

OOP: Basic Parts of Java

25

The if-else Statement

An else clause can be added to an if statement to make it an ifelse statement
if (condition){ statement1; } else{ statement2; }

If the condition is true, statement1 is executed; if the

condition is false, statement2 is executed One or the other will be executed, but not both An else clause is matched to the last unmatched if (no matter what the indentation implies)

OOP: Basic Parts of Java

26

Logic of an if-else Statement

if (income < 20000) System.out.println ("poor"); else if (income < 40000) System.out.println ("not so poor") else if (income < 60000) System.out.println ("rich") else System.out.println ("really rich") // what is wrong here? char c = getChoice(); if (c == 'A') doStuffA(); if (c == 'B') doStuffB(); if (c == 'C') doStuffC();

condition false statement2

true statement1

next statement

OOP: Basic Parts of Java

27

The switch Statement

The general syntax of a switch statement is
switch (expression) { case value1 : statement-list1 case value2 : statement-list2 case value3 : statement-list3 } enumerable

switch and case are reserved words

If expression matches value2, control jumps to here

enumerables can appear in any order enumerables do not need to be consecutive several case constant may select the same substatement enumerables must be distinct enumerable cannot use case 1..9

OOP: Basic Parts of Java

28

The switch Statement, cont.

Often a break statement is used as the last statement in each
case's statement list A break statement causes control to transfer to the end of the switch statement If a break statement is not used, the flow of control will continue into the next case
switch (expression) { case value1 : statement1 break; case value2 : statement2 break; case value3 : statement3 break; }
29

break exits the innermost enclosing loop or switch

OOP: Basic Parts of Java

Logic of an switch Statement

switch (expression){ case value1 : statement-list1 break; case value2 : statement-list2 break; case value3 : statement-list3 break; } // next statement

expression

value1

value 2

value3

statement-list1

statement-list2

statement-list3

next statement

other values

OOP: Basic Parts of Java

30

The switch Statement, cont.

A switch statement can have an optional default case. The default case has no associated value and simply uses the
reserved word default. If the default case is present, control will transfer to it if no other case value matches. The default case can be positioned anywhere in the switch, it is usually placed at the end.

Control falls through to the statement after the switch if there

is no other value matches and there is no default case.

OOP: Basic Parts of Java

31

The switch Statement, cont.

The expression of a switch statement must result in an integral
data type, like an integer or character, e.g., it cannot be a floating point value or a string. Note that the implicit boolean condition in a switch statement is equality - it tries to match the expression with a value. You cannot perform relational checks with a switch statement, e.g.,
not integral type checking switch (i < 7) { case true : statement1 break; case Hello : statement2 break; } illegal, relational checking

OOP: Basic Parts of Java

32

The switch Statement, Example

int salary = getSalary(); // gets a salary

switch(salary/20000) { case 0: System.out.println("poor"); break; case 1: System.out.println("not so poor"); break; case 2: System.out.println("rich"); break; case 3: System.out.println("really rich"); break; default: System.out.println("Hi, Bill Gates"); }
OOP: Basic Parts of Java

33

The while Statement

The while statement has the following syntax
If the condition is true, the statement is executed. Then the condition is evaluated again. while is a reserved word while (condition) statement;

The statement is executed repetitively until the condition becomes false.

Note, if the condition of a while statement is false initially, the

statement is never executed

Therefore, the body of a while loop will execute zero or more times
34

OOP: Basic Parts of Java

Logic of the while Statement

// Count from 1 to 10 int n = 10; int i = 1; while (i <= n) { System.out.println(i); i = i + 1; } // next statement

condition

true false statement

next statement

// what is wrong here? int i = 0; while(i < 10){ System.out.println(i); // do stuff }

OOP: Basic Parts of Java

35

The while Statement, cont.

The body of a while loop must eventually make the condition
false. If not, it is an infinite loop, which will execute until the user interrupts the program.

This is a common type of logical error. You should always double check to ensure that your loops will terminate normally. That is, the body of a while could contain another loop Each time through the outer while, the inner while will go through its entire set of iterations

The while statement can be nested

OOP: Basic Parts of Java

36

The do Statement
The do statement has the following syntax
Uses both the do and while reserved words do { statement; } while (condition)

The statement is executed once initially, then the condition is evaluated. The statement is executed until the condition becomes false.

A do loop is similar to a while loop, except that the

condition is evaluated after the body of the loop is executed.

Therefore the body of a do loop will execute at least one time.

37

OOP: Basic Parts of Java

Logic of the do Statement

// Count from 1 to 10 int n = 10; int i = 1; do { System.out.println(i) i = i + 1; } while (i <= 10); // next statement

statement true condition false next statement

OOP: Basic Parts of Java

38

The for Statement

The for statement has the following syntax
Reserved word The initialization portion is executed once before the loop begins The condition is checked before each iteration

for (initialization ; condition ; increment) statement; The statement is executed until the condition becomes false The increment portion is executed at the end of each iteration

OOP: Basic Parts of Java

// equvivalent while statement initialization while (condition){ statement; increment; }

39

Logic of the for Statement

// Count from 1 to 10 int n = 10; for (int i = 1; i <= n; i++) System.out.println (i); // next statement // what is wrong here? for (int i=0; i < 10; i++){ System.out.println(i); i--; } false // what is wrong here? for (int i = 0; i < 10;){ i++; // do stuff } // what is wrong here? int i; for (i = 0; i < 10; i++){ // do stuff }

initialization

condition true statement increment

next statement

OOP: Basic Parts of Java

40

The for Statement, cont

Like a while loop, the condition of a for statement is tested
prior to executing the loop body. Therefore, the body of a for loop will execute zero or more times. It is well-suited for executing a specific number of times that can be determined in advance. Each expression in the header of a for loop is optional

Both semi-colons are always required in the for loop header.

OOP: Basic Parts of Java

41

Branching
break

Can be used in any control structure Exits from the innermost enclosing loop break <label> Cycles a loop, e.g., jump to the condition checking Only from methods Jumps out of the current method an returns to where the method was called from return <expression> Reserved word, not implemented

continue

return

goto

OOP: Basic Parts of Java

42

Logic of the break Statement

condition1 true stmt1 while (condition1) { stmt1; if (condition2) break; stmt2; } // next statement false

condition2 false stmt2 true

next statement
OOP: Basic Parts of Java 43

Logic of the break Statement, cont

condition1 true stmt1 while (condition1) { stmt1; while (true){ break; } stmt2; } // next statement false

condition2 (true) break stmt2

next statement
OOP: Basic Parts of Java 44

Logic of the continue Statement

condition1 true true stmt1 while (condition1) { stmt1; if (condition2) continue; stmt2; } // next statement

condition2 false stmt2

false

next statement
OOP: Basic Parts of Java

// what is wrong here? while (condition){ // many more statements continue; }

45

continue Example
public void skipPrinting(int x, int y){ for(int num = 1; num <= 100; num++){ if((num % x) == 0){ continue; } if((num % y) == 0){ continue; } // This num is not divisible by x or y System.out.println(num); } }

OOP: Basic Parts of Java

46

break and continue Example

for (int i = 3; i <= max; i++) { // skip even numbers if (i % 2 == 0) continue; // check uneven numbers boolean isPrime = true; for (int j = 2; j < i - 1; j++) { // is i diviseable with any number in [2..i-i] // then it is not a prime number so we break // of efficiency reasons if (i % j == 0) { isPrime = false; break; } } if (isPrime) System.out.println(i + " is a prime number");
OOP: Basic Parts of Java

47

Summary
Set of built-in data types Array are supported

No support records or enumarated type Procedure Functions Always by-value in Java Actual and formal parameters. if, if-else, if-else-if-else, if-else-if-else-if-else, etc. while-do, do-while for switch
48

Methods

Argument passing

Control structures

OOP: Basic Parts of Java