Lecture 5 Socket Programming
Download
Report
Transcript Lecture 5 Socket Programming
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