About this course?

EE2E1 (MS)
Introduction to Java programming

Basic ideas about objects and classes

We will also look at more advanced features

of Java
Graphics
Files and streams
Multi-threading
Networks

EE2E2 (DP)
Object Oriented Software Design
 Assessment
EE2E1 and EE2E2 are assessed jointly
(making up the EE2E module)
EE2E1 is assessed through a classtest and
programming exercises and a major
programming assignment
15% through a 1 hour class test

2 x 22.5% through 2 programming

exercises
40% through a major programming
assignment carried out in semester 2
Java resources
Suns Java home page
http://java.sun.com/

Java online tutorial

http://java.sun.com/docs/books/tutorial/

Comparing C++and Java

http://www.compapp.dcu.ie/~renaat/projects/cvjava.ht
ml
Textbook
Core Java 2. Volume 1-Fundamentals

C.S.Horstmann, G. Cornell

Amazon Link

My web page
http://www.eee.bham.ac.uk/spannm/Courses/ee2e.h
tm
Why should I learn Java?
Main reason, Java is object oriented
What is OOP good for?
Modelling asynchronously interacting objects

GUIs
Event simulation
Ray tracing visualisation
CAD simulation
Real-time control/embedded systems
Robotics
Image/Video processing
Client/Server systems
etc
OK, so whats good about Java?
Java is free to download and is easy to learn
Java has powerful (and free!) development tools
e.g. Eclipse , Netbeans
Excellent documentation support Javadocs
Great community support
Rich collection of open source libraries
Can develop Android apps in Java supported by
Eclipse and Netbeans
Android is a good platform for mobile apps
because of ease of release, wide range of
devices and its an open platform
EE2E1. JAVA Programming

Lecture 1

From C to Java
Contents
A simple Java program
Data types
Variables
Assignment/initialization
Operators
Control Flow
Strings
Arrays
Simple example Java program
public class firstProgram
{
public static void main(String[] args)
{
System.out.println(Java is fun!);
}
}
Main points
Everything in a Java program is a class
Keyword public is an access modifier
Program starts execution from the main method
We will worry about what static void means later
The program prints the string Java is fun!
System.out.println() means call the println()
method of the object System.out (which is part of
the class System)
Data types
Like C, Java is strongly typed
Java has 8 primitive data types
Machine independent storage requirements
Primitive data types
Type Storage requirement Range
int 4 bytes -2,147,483,648 ..
2,147,483,647
short 2 bytes -32768 .. 32767
18
long 8 bytes Approx 9x10
byte 1 byte -128 .. 127
38
float 4 bytes Approx 3.4x10
308
double 8 bytes Approx 1.8x10
char 2 bytes (Unicode)
boolean false, true
The char datatype
char represented by a 2-byte Unicode value
Designed to represent all characters in the written
world
Allows 65536 characters (35000 are in use)
whereas ascii only allows 255
Expressed as hexidecimal \u0000 to \uFFFF
(\u0000 to \u00FF is the ascii set)
\u indicates a Unicode value

Check out www.unicode.org for more details

Variables
Variables must be declared before use
Variable names must begin with a letter but
can contain letters and digits
Variable names are case sensitive
Assignment/initialization
Assignment and initialization are identical
to C

int myVariable=20; // initialization

int anotherVariable;
anotherVariable=myVariable; // assignment

char yes=y; // initialization

char cc;
cc=yes; // assignment
Constant variables
In Java, the keyword final denotes a
constant
Constant variables cannot be assigned to

final double electronicCharge=1.6E-19;

electronicCharge=1.6E-18; // illegal assignment!
Operators
Usual arithmetic operators + - * / are used
in Java as in C
Integer divide / and modulus % as in C
Increment ++ and decrement --
Exponentiation uses pow() function which
is part of the Math class
a
double y=Math.pow(x,a); // y=x
Relational and boolean operators
Java uses the same relational operators as C
== (equal to)
!= (not equal to)
<, >, <=, >= (less, greater, less or equal, greater or equal)
Java uses the same bitwise operators as C
& (and)
| (or)
^ (xor)
~ (not)
Boolean expressions
In Java the result of a boolean expression is a
boolean type (true or false)
This cant be converted to an int (as in C)
if (x == y) {} // Result is a boolean
Java eliminates a common C programming bug
if (x = y) {} // Ok in C, wont compile in
// Java
Control flow
Java uses the same control structures as in C
Selection (conditional) statements
if (..) {}
if (..) {} else if (..) {} . else {}
switch (..) { case 1: break; default: break; }
Iteration statements
for (..) {}
while (..) {}
do {} while (..);
Example a square root calculator
public class SquareRoot
{
public static void main(String[] args)
{
double a,root;
do
{
a=Console.readDouble("Enter a positive number : ");
if (a<0)
{
System.out.println(Please enter a positive number!);
.
}
} while (a<0);
root=a/2;
double root_old;
do
{
root_old=root;
root=(root_old+a/root_old)/2;
} while (Math.abs(root_old-root)>1.0E-6);
 Computes the square root of an inputted
number using a simple algorithm
Same control structure as in C
Note the use of indentation to indicate

control
In Java, keyboard input is not
straightforward
Done by the readDouble() method in
class Console
Strings
Strings are sequences of characters as in C
The standard Java library has a predefined
class String
String name = Mike;

Strings are immutable (unlike in C)

individual characters in the string cannot be
changed
name[0] = m; // Not allowed!
 Strings can be concatenated using the +
operator
String name1 = Mike;
String name2 = Spann;
String myName=name1+name2;

In Java, every object, even literals, can be

automatically converted to a string
String postcode = B+15+ +2+TT;
 The println(.) function makes use of string
concatentation
int age = 25;
System.out.println(I am + age + years old!);

This works with any data type

final double pi = 3.14159;
System.out.println(The value of PI = + pi);
Other string facilities
A substring(.) method is provided to access
a substring of a larger string
String java=Java;
String s = java.substring(0,3); // Jav

A charAt(int n) method returns the

character at position n in the string
String java=Java;
char c= java.charAt(2) // v
 An equals(.) method tests for string equality
if (s.equals(Hello))
{}

The == operator should not be used it tests

to see if the strings are stored in the same
location!
int length() returns the length of the string

There are more than 50 methods in the Java

String class! (java.lang.String)
Arrays
Arrays created with the new operator
int[] intArray = new int[20]; // 20 int array

Arrays can be created and initialized as in C

int[] evenNumbers = {2,4,6,8};

The array length can be determined using

name.length
for (int j=0; j<evenNumbers.length; j++)
System.out.println(evenNumbers[j]);
 Array variable is effectively a pointer to an
array allocated on the heap (hence arrays
passed by reference)
BUT
Cant do pointer arithmetic (as in C)

int[] intArray = new int[20]; // creates a 20 int array

intArray++; // NOT ALLOWED!
 Multi-dimensional arrays are defined as
follows :

int[][] a = new int[5][4]; // 5 x 4 int array

Its effectively a 1D array of pointers :

a[][] a[0]
a[1] a[3][0]
a[2] a[3][1]
a[3]
a[4] a[3][2]
a[3][3]
Copying arrays
Copying 1 array variable to another is
equivalent (in C) to copying pointers

int[] newArray = evenNumbers;

2
evenNumbers
4
6
newArray
8
 The method System.arraycopy() should
be used to copy the array contents
System.arraycopy(from, fromIndex, to,
toIndex,n)
int[] newArray = {0,0,0,0}
System.arraycopy(evenNumbers,0,newArray,0,4);

2 2
evenNumbers
4 4
6 6
8 8
newArray
 Class java.util.Arrays has a number of
convenience utility functions for arrays
Arrays.sort(a) - sorts array a into

ascending order
Arrays.fill(a,val) fills array a with value
val
Arrays.binarySearch(a, key) searches

for a value key in array a

Arrays.equals(a1,a2) test for
equivalence of arrays a1 and a2
And finally
Basic Java programming is less error prone
than C
No pointers to worry about

There is a genuine boolean type

We have yet to think about object oriented

concepts
Classes are the subject of the next lecture
Introduction to the Java lab
All the Java programming assignments for this semester
will be available on the course web site and Canvas
http://www.eee.bham.ac.uk/spannm/Courses/ee2e.htm
Lab structure
Semester 1 (weeks 4-6, 9-10) Tuesday 2-5pm N122

Lab intro. (1 week), non-assessed

Classes (2 weeks), assessed

Inheritance (2 weeks), assessed

Semester 2
Major programming assignment, assessed
 Organisation of the lab
You will work in pairs

The programming assignments cover

material already done in lectures
Please carry out the preparatory work

before the lab with your partner

You will need to put in some time outside
the lab slots to finish each exercise
 Assessment :
Makes up 85% of the 2E1 mark

There will be 2 programming assignments this

semester
Assessed by submission of code + program
outputs per lab group
More details will follow and submission will

be at the end of the semester

There will be 1 major programming assignment

next semester
Assessed by a formal lab report per lab

group