Java Intro

Download as ppt, pdf, or txt
Download as ppt, pdf, or txt
You are on page 1of 41

Netprog 2002 Java Intro 1

Crash Course in Java




Based on notes from D. Hollinger
Based in part on notes from J.J. Johns

also: Java in a Nutshell
Java Network Programming and
Distributed Computing
Netprog 2002 Java Intro 2
What is Java?
A programming language.
As defined by Gosling, Joy, and Steele in the Java
Language Specification
A platform
A virtual machine (JVM) definition.
Runtime environments in diverse hardware.
A class library
Standard APIs for GUI, data storage, processing,
I/O, and networking.
Netprog 2002 Java Intro 3
Why Java?
Network Programming in Java is very
different than in C/C++
much more language support
error handling
no pointers! (garbage collection)
threads are part of the language.
some support for common application level
protocols (HTTP).
dynamic class loading and secure sandbox
execution for remote code.
source code and bytecode-level portability.
Netprog 2002 Java Intro 4
Java notes for C++
programmers
Everything is an object.
Every object inherits from java.lang.Object
No code outside of class definition!
No global variables.
Single inheritance
an additional kind of inheritance: interfaces
All classes are defined in .java files
one top level public class per file

Netprog 2002 Java Intro 5
More for C++ folks
Syntax is similar (control structures are
very similar).
Primitive data types similar
bool is not an int.
To print to stdout:
System.out.println();
Netprog 2002 Java Intro 6
First Program

public class HelloWorld {
public static void main(String args[])
{
System.out.println("Hello World");
}
}

Netprog 2002 Java Intro 7
Compiling and Running

HelloWorld.java


javac HelloWorld.java


java HelloWorld

HelloWorld.class

compile
run
bytecode
source code
Netprog 2002 Java Intro 8
Java bytecode and interpreter
bytecode is an intermediate
representation of the program (class).

The Java interpreter starts up a new
Virtual Machine.

The VM starts executing the users class
by running its main() method.
Netprog 2002 Java Intro 9
PATH and CLASSPATH
The java_home/bin directory is in your
$PATH

If you are using any classes outside the
java or javax package, their locations
are included in your $CLASSPATH
Netprog 2002 Java Intro 10
The Language
Data types
Operators
Control Structures
Classes and Objects
Packages
Netprog 2002 Java Intro 11
Java Data Types
Primitive Data Types:
boolean true or false
char unicode! (16 bits)
byte signed 8 bit integer
short signed 16 bit integer
int signed 32 bit integer
long signed 64 bit integer
float,double IEEE 754 floating point
Netprog 2002 Java Intro 12
Other Data Types
Reference types (composite)
classes
arrays

strings are supported by a built-in class
named String
string literals are supported by the
language (as a special case).
Netprog 2002 Java Intro 13
Type Conversions
conversion between integer types and
floating point types.
this includes char
No automatic conversion from or to the
type boolean!
You can force conversions with a cast
same syntax as C/C++.
int i = (int) 1.345;

Netprog 2002 Java Intro 14
Operators
Assignment: =, +=, -=, *=,
Numeric: +, -, *, /, %, ++, --,
Relational: ==. !=, <, >, <=, >=,
Boolean: &&, ||, !
Bitwise: &, |, ^, ~, <<, >>,

Just like C/C++!
Netprog 2002 Java Intro 15
Control Structures
More of what you expect:
conditional: if, if else, switch
loop: while, for, do
break and continue (but a little different
than with C/C++).


Netprog 2002 Java Intro 16
Exceptions
Terminology:
throw an exception: signal that some
condition (possibly an error) has occurred.
catch an exception: deal with the error (or
whatever).

In Java, exception handling is
necessary (forced by the compiler)!
Netprog 2002 Java Intro 17
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
}

Netprog 2002 Java Intro 18
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.
Forces the programmer to be aware of
what errors can occur and to deal with
them.
Netprog 2002 Java Intro 19
Concurrent Programming
Java is multithreaded!
threads are easy to use.
Two ways to create new threads:
Extend java.lang.Thread
Overwrite run() method.
Implement Runnable interface
Include a run() method in your class.
Starting a thread
new MyThread().start();
new Thread(runnable).start();
Netprog 2002 Java Intro 20
The synchronized Statement
Java is multithreaded!
threads are easy to use.
Instead of mutex, use synchronized:

synchronized ( object ) {
// critical code here
}
Netprog 2002 Java Intro 21
synchronized as a modifier
You can also declare a method as
synchronized:

synchronized int blah(String x) {
// blah blah blah
}
Netprog 2002 Java Intro 22
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.
Netprog 2002 Java Intro 23
Defining a Class
One top level public class per .java file.
typically end up with many .java files for a
single program.
One (at least) has a static public main()
method.
Class name must match the file name!
compiler/interpreter use class names to
figure out what file name is.
Netprog 2002 Java Intro 24
Sample Class
(from Java in a Nutshell)
public class Point {
public double x,y;
public Point(double x, double y) {
this.x = x; this.y=y;
}
public double distanceFromOrigin(){
return Math.sqrt(x*x+y*y);
}
}
Netprog 2002 Java Intro 25
Objects and new
You can declare a variable that can hold
an object:
Point p;
but this doesnt create the object! You
have to use new:
Point p = new Point(3.1,2.4);
there are other ways to create objects
Netprog 2002 Java Intro 26
Using objects
Just like C++:
object.method()
object.field

BUT, never like this (no pointers!)
object->method()
object->field
Netprog 2002 Java Intro 27
Strings are special
You can initialize Strings like this:

String blah = "I am a literal ";

Or this ( + String operator):

String foo = "I love " + "RPI";

Netprog 2002 Java Intro 28
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
Netprog 2002 Java Intro 29
Array Examples
int x[] = new int[1000];

byte[] buff = new byte[256];

float[][] mvals = new float[10][10];


Netprog 2002 Java Intro 30
Notes on Arrays
index starts at 0.
arrays cant shrink or grow.
e.g., use Vector instead.
each element is initialized.
array bounds checking (no overflow!)
ArrayIndexOutOfBoundsException
Arrays have a .length
Netprog 2002 Java Intro 31
Array Example Code
int[] values;

int total=0;

for (int i=0;i<value.length;i++) {
total += values[i];
}

Netprog 2002 Java Intro 32
Array Literals
You can use array literals like C/C++:

int[] foo = {1,2,3,4,5};

String[] names = {Joe, Sam};
Netprog 2002 Java Intro 33
Reference Types
Objects and Arrays are reference types
Primitive types are stored as values.
Reference type variables are stored as
references (pointers that we cant mess
with).
There are significant differences!

Netprog 2002 Java Intro 34
Primitive vs. Reference Types
int x=3;
int y=x;

Point p = new Point(2.3,4.2);
Point t = p;

Point p = new Point(2.3,4.2);
Point t = new Point(2.3,4.2);
There are two copies of
the value 3 in memory
There is only one Point
object in memory!
Netprog 2002 Java Intro 35
Passing arguments to methods
Primitive types: the method gets a copy
of the value. Changes wont show up in
the caller.

Reference types: the method gets a
copy of the reference, the method
accesses the same object!
Netprog 2002 Java Intro 36
Example
int sum(int x, int y) {
x=x+y;
return x;
}

void increment(int[] a) {
for (int i=0;i<a.length;i++) {
a[i]++;
}
}

Netprog 2002 Java Intro 37
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!
Netprog 2002 Java Intro 38
Packages
You can organize a bunch of classes
and interfaces into a package.
defines a namespace that contains all the
classes.
You need to use some java packages in
your programs
java.lang java.io, java.util
Netprog 2002 Java Intro 39
Importing classes and packages
Instead of #include, you use import
You dont have to import anything, but
then you need to know the complete
name (not just the class, the package).
if you import java.io.File you can
use File objects.
If not you need to use java.io.File
objects.
Netprog 2002 Java Intro 40
Sample Code
Sum.java: reads command line args,
converts to integer, sums them up and
prints the result.

Sum1.java: Same idea, this one creates
a Sum1 object, the constructor then
does the work (instead of main).
Netprog 2002 Java Intro 41
More Samples
Multiple Public classes:
need a file for each class.
Tell the compiler to compile the class with
main().
automatically finds and compiles needed
classes.
Circle.java, CircleTest.java, Point.java,
Threads.java, ExceptionTest.java

You might also like