|
1
|
- 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
|
|
2
|
- 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.
|
|
3
|
- 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.
|
|
4
|
- Everything is an object.
- Every object inherits from java.lang.Object
- No code outside of class definition!
- Single inheritance
- an additional kind of inheritance: interfaces
- All classes are defined in .java files
- one top level public class per file
|
|
5
|
- Syntax is similar (control structures are very similar).
- Primitive data types similar
- To print to stdout:
|
|
6
|
- public class HelloWorld {
- public static void main(String
args[]) {
- System.out.println("Hello
World");
- }
- }
|
|
7
|
|
|
8
|
- 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 it’s main() method.
|
|
9
|
- 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
|
|
10
|
- Data types
- Operators
- Control Structures
- Classes and Objects
- Packages
|
|
11
|
- 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
|
|
12
|
- Reference types (composite)
- strings are supported by a built-in class named String
- string literals are supported by the language (as a special case).
|
|
13
|
- conversion between integer types and floating point types.
- No automatic conversion from or to the type boolean!
- You can force conversions with a cast – same syntax as C/C++.
|
|
14
|
- Assignment: =, +=, -=, *=, …
- Numeric: +, -, *, /, %, ++, --, …
- Relational: ==. !=, <, >, <=, >=, …
- Boolean: &&, ||, !
- Bitwise: &, |, ^, ~, <<, >>, …
- Just like C/C++!
|
|
15
|
- 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++).
|
|
16
|
- 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)!
|
|
17
|
- 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
- }
|
|
18
|
- 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.
|
|
19
|
- Java is multithreaded!
- 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();
|
|
20
|
- Java is multithreaded!
- Instead of mutex, use synchronized:
- synchronized ( object ) {
- // critical code here
- }
|
|
21
|
- You can also declare a method as synchronized:
- synchronized int blah(String x) {
- // blah blah blah
- }
|
|
22
|
- “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.
|
|
23
|
- 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.
|
|
24
|
- 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);
- }
- }
|
|
25
|
- You can declare a variable that can hold an object:
- but this doesn’t create the object! You have to use new:
- Point p = new Point(3.1,2.4);
- there are other ways to create
objects…
|
|
26
|
- Just like C++:
- object.method()
- object.field
- BUT, never like this (no pointers!)
- object->method()
- object->field
|
|
27
|
- You can initialize Strings like this:
- String blah = "I am a literal ";
- Or this ( + String operator):
- String foo = "I love " + "RPI";
|
|
28
|
- 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
|
|
29
|
- int x[] = new int[1000];
- byte[] buff = new byte[256];
- float[][] mvals = new float[10][10];
|
|
30
|
- 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
|
|
31
|
- int[] values;
- int total=0;
- for (int i=0;i<value.length;i++) {
- total += values[i];
- }
|
|
32
|
- You can use array literals like C/C++:
- int[] foo = {1,2,3,4,5};
- String[] names = {“Joe”, “Sam”};
|
|
33
|
- 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).
- There are significant differences!
|
|
34
|
- 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);
|
|
35
|
- Primitive types: the method gets a copy of the value. Changes won’t show
up in the caller.
- Reference types: the method gets a copy of the reference, the method
accesses the same object!
|
|
36
|
- 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]++;
- }
- }
|
|
37
|
- 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!
|
|
38
|
- 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
|
|
39
|
- Instead of #include, you use import
- You don’t 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.
|
|
40
|
- 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).
|
|
41
|
- 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
|