Lecture 5
Java Introduction
CPE 401 / 601
Computer Network Systems
slides are modified from Ricky Sethi
So what the heck is Java (besides
coffee, that is)?
 A programming language.

Syntax and constructs are very similar to C++
 A virtual platform



Java Virtual Machine is a software “machine” or
“hypothetical chip”
Since it’s “virtual”, it can be implemented on any hardware
Cross-platform distribution achieved via .class binary file
of bytecodes (instead of machine-dependent machine code)
 Write Once, Run Anywhere
 A class library

Standard APIs for GUI, data storage, processing, I/O, and
networking.
Java Introduction
2
Getting Java Brewing…
1. Download the latest Java SDK from
http://java.sun.com

The SDK is a command-line based set of tools
2. A Text Editor
3. Web-browser that’s java-enabled (optional)
4. Some introductory links/guides/tutorials:



http://developer.java.sun.com/developer/onlineTraining/Programming/Basic
Java1/compile.html
http://www.horstmann.com/ccc/c_to_java.pdf
http://www.csd.uu.se/datalogi/cmtrl/oopj/vt-2000/slides/OOPJ-1-04.pdf
Java Introduction
3
Mechanics of Writing Java Programs
 Create a Java source file.
 Must have the .java extension and contain only one public class.
 Compile the source file into a bytecode file.
 The Java compiler, javac, takes your source file and translates
its text into instructions that the Java Virtual Machine (Java VM)
can understand. The compiler puts these instructions into a .class
bytecode file.
 Run the program contained in the bytecode file.
 The Java VM is implemented by a Java interpreter, java. This
interpreter takes your bytecode file and carries out the
instructions by translating them into instructions that your
computer can understand.
Java Introduction
4
Putting it all together
public class Hello {
public static void main(String args[]) {
System.out.println(“Hello, world!”);
}
}
1. Put in: Hello.java
2. Compile with: javac Hello.java
 Creates Hello.class
3. Run with: java Hello
Java Introduction
5
Applications vs. Applets
 A Java application:



Is a standalone program
Is interpreted by the Java Virtual Machine and run using the
java command
Contains a main() method.
 A Java applet:



Runs within a Java-enabled Web browser
extends the Applet or JApplet class (Inheritance)
Contains an init() or a paint() method (or both).
 To create an applet, you'll perform the same basic steps:
1.
Create a Java source file (NameOfProgram.java) and an HTML
file (NameOfHTMLFile.html)
2. Compile the source file (NameOfProgram.class)
3. Run the program (either using java NameOfProgram or
appletviewer NameOfHTMLFile.html)
Java Introduction
6
Java notes for C++ programmers
 Everything’s an object

Every object inherits from java.lang.Object
 No code outside of the class definition!
 No global variables (use static variables instead)
 Single inheritance only
 Instead, implement interfaces
 All classes are defined in .java files

One top level public class per file
• The file has to have the same name as the public class!
 Syntax is similar (control structures are very similar).



Primitive data types are similar
But a bool is not an int
To print to stdout, use System.out.println()
Java Introduction
7
Why Java?
 Network Programming in Java is very different than
in C/C++

much more language support
• Networking is at the core of the language

well defined error handling

no global variables

no struct, union types, goto’s, enums, bitfields, typedefs

no pointers! (garbage collection)

Threads are part of the language.

some support for common application level protocols (HTTP).
Java Introduction
8
Requisite First Program
(Application Version)
Put in HelloWorld.java:
public class HelloWorld {
public static void main(String args[]) {
System.out.println("Hello World");
}
}
Java Introduction
9
Compiling and Running
compile
HelloWorld.java
javac HelloWorld.java
source code
run
java HelloWorld
HelloWorld.class
bytecode
Java Introduction
10
So what’s going on?
The Java bytecode and interpreter at work!
 Bytecode is an intermediate representation of the
program (the class file)

Think of it as the machine-code for the Java Virtual Machine
 The Java interpreter (java) starts up a new “Virtual
Machine”
 The VM starts executing the user’s class by running its
main() method
Java Introduction
11
Requisite First Program
(Applet Version)
Put in HelloWorld.java:
import java.awt.Graphics;
public class HelloWorld extends java.applet.Applet {
public void paint(Graphics g) {
g.drawString("Hello World“, 35, 15);
}
}
Put in test.html:
<html>
<title>Test the applet</title>
<body>
<h3>Test the applet</h3>
<applet code=“HelloWorld.class” height=“200” width=“300”>
</applet>
</body></html>
Java Introduction
12
Java Language Basics
 Data types same as in C++ (except bool)
 bool,char,byte,short,int,long,float,
double,string, etc.
 Operators (same as C++)
 Assignment: =, +=, -=, *=, …
 Numeric: +, -, *, /, %, ++, --, …
 Relational: ==. !=, <, >, <=, >=, …
 Boolean: &&, ||, !
 Bitwise: &, |, ^, ~, <<, >>, …
 Control Structures  more of what you expect:
1. conditional: if, if else, switch
2. loop: while, for, do
3. break and continue
Java Introduction
13
Classes, References, & Packages
 Classes and Objects
 “All Java statements appear within methods, and all methods are
defined within classes”.
 Java classes are very similar to C++ classes (same concepts).
 Instead of a “standard library”, Java provides a lot of Class
implementations or packages
 What are packages?
 You can organize a bunch of classes and interfaces into a
package (or library of classes)
• defines a namespace that contains all the classes.

Use the import keyword to include the packages you need
• import java.applet.*;

You need to use some java packages in your programs
• java.io (for Files, etc.), java.util (for Vectors, etc.)
 References
 No pointers  everything’s a reference!
 classes, arrays
Java Introduction
14
Exceptions
 When a program carries out an illegal action, an
exception is generated.
 Terminology:



throw an exception: signal (in the method header) that some
condition or error has occurred but we want to pass the buck
and not deal with it.
catch an exception: deal with the error (or whatever) ourselves
inside the function/method.
Catch it using a try/catch block (next slide).
 In Java, exception handling is necessary


forced by the compiler  compilation errors!
Except for RunTimeExceptions
Java Introduction
15
Try/Catch/Finally
try {
// code that can throw an exception
} catch (ExceptionType1 e1) {
// code to handle the exception
} catch (ExceptionType2 e2) {
// code to handle the exception
} catch (Exception e) {
// code to handle other exceptions
} finally {
// code to run after try or any catch
}
This block is always run
Java Introduction
16
Exception Handling
 Exceptions take care of handling errors
 instead of returning an error, some method calls will throw an
exception.
 Can be dealt with at any point in the method invocation
stack.

But if no method in the hierarchy handles it, results in an
unchecked exception which generates a compiler error (unless
it’s a RunTimeException)
 Forces the programmer to be aware of what errors can
occur and to deal with them.
Java Introduction
17
Defining a Class
 One top level public class per .java file.

Typically end up with many .java files for a single program with at
least one containing a static public main() method (if they’re
applications).
 Class name must match the file name!

The compiler/interpreter use class names to figure out what the
file name is.
 Classes have these three features:



A constructor that’s used to allocate memory for the object,
initiailize its elements, and return a reference to the object
Methods (function members)
Fields (data members)
Java Introduction
18
A Sample Class
public class Point {
public Point(double x, double y) {
this.x = x; this.y=y;
}
public double distanceFromOrigin(){
return Math.sqrt(x*x+y*y);
}
private double x,y;
}
Java Introduction
19
Objects and new
 You can declare a variable that can hold an object:
Point p;
 But this doesn’t create the object! You have to use new:
Point p = new Point(3.1,2.4);
 new allocates memory and the garbage collector reclaims
unused memory
Java Introduction
20
Using Java objects
 Just like C++:
 object.method() or object.field
 BUT, never like this (no pointers!)
 object->method() or object->field
 Event driven model:
 Objects “register” to receive (and respond to) certain messages
like button presses, mouse clicks, etc. (e.g., mouseUp(),
mouseDown(), keyUp(), keyDown())
Java Introduction
21
Strings are special
 You can initialize Strings like this:
String blah = "I am a literal ";
 Or this ( + String operator):
String foo = "I love " + “CET375";
 Or this ( new operator):
String foo = new String(“Yummy FooBars!”);
Java Introduction
22
Arrays
 Arrays are supported as a second kind of reference type
(objects are the other reference type).
 Although the way the language supports arrays is
different than with C++, much of the syntax is compatible.

however, creating an array requires new
 Index starts at 0.
 Arrays can’t shrink or grow.

e.g., use Vector instead.
 Each element is initialized.
 Array bounds checking (no overflow!)

ArrayIndexOutOfBoundsException
 Arrays have a .length
 You can use array literals like C/C++ (no need for new
keyword):
Java Introduction
23
Array Examples
int x[] = new int[1000];
byte[] buff = new byte[256];
float[][] mvals = new float[10][10];
int[] values;
int total=0;
for (int i=0;i<value.length;i++) {
total += values[i];
}
String[] names = {“Joe”, “Sam”};
Java Introduction
24
Reference Types
 Objects and Arrays are reference types
 Primitive types are stored as values
 Reference type variables are stored as references
(pointers that we can’t mess with)
int x=3;
int y=x;
There are two copies of the
value 3 in memory
Point p = new Point(2.3,4.2);
There is only one Point
Point t = p;
object in memory!
Java Introduction
25
Passing arguments to methods
 Primitive types: the method gets a copy of the value.
Changes won’t show up in the caller
 Pass by value
 Reference types: the method gets a copy of the
reference, the method accesses the same object
 Pass by reference
 There is no pass by pointers!
Java Introduction
26
Comparing Reference Types
 Comparison using == means:
 “Are the references the same?”
• Do they refer to the same object?
 Sometimes you just want to know if two objects/arrays
are identical copies.

Use the .equals() method
• You need to write this for your own classes!
 All objects and arrays are references!
Java Introduction
27
Inheritance
 Use the extends keyword to inherit from a super
(or parent) class
 No multiple inheritance
 Use implements to implement multiple interfaces (abstract,
virtual classes)
 Use import instead of #include (not exactly the
same but pretty close) to include packages (libraries)
Java Introduction
28
Concurrent Multi-threaded Programming
 Java is multithreaded!

Threads are easy to use.
 Two ways to create new threads:

Extend java.lang.Thread
• Override “run()” method.

Implement Runnable interface
• Include a “run()” method in your class.

Usually, you’ll implement the Runnable interface
 How to implement the Runnable interface:
 Add a public void start() function:
• This is where you’ll initialize the thread and start() it

Add a public void stop() function:
• This is where you’ll set the boolean stopFlag to true

Add a public void run() function:
• This is where you’ll call repaint() to paint each new frame and
handle any synchronized variables or methods
29
The synchronized Statement
 Instead of mutex (a binary semaphore), use
synchronized:
synchronized ( object ) {
// critical code here
}
 Also, declare a method as synchronized:
synchronized int blah(String x) {
// blah blah blah
}
 Can also use wait() and notify() to put threads on
hold and wake them up again (e.g., to implement a pause
or suspend feature)

Must be called within a synchronized block
Java Introduction
30
Using Documentation Comments
 Documentation comments are delimited by /** and */
 javadoc automatically generates documentation

Copies the first sentence of each documentation comment to a
summary table
• Write the first sentence with some care!
 For each method/class, supply:

@param followed by the parameter name and a short explanation

@return followed by a description of the return value

@author for author info, etc.
• Need to use “javadoc –author” for this…
Java Introduction
31
javadoc
Must come immediately
before the class, method, etc.
 The Java Standard calls for every class, every method,
every parameter, and every return value to have a
comment
 Write the method comments first!

If you can’t explain what a class or method does, you aren’t ready
to implement it!
 How to create HTML documentation:



Type: javadoc *.java in the directory containing your source
code
This produces one HTML file for each class and an index.html
file
Documenation is together with code!
Java Introduction
32