Docstoc

Lecture 5 Socket Programming

Document Sample
Lecture 5 Socket Programming Powered By Docstoc
					          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      HelloWorld.class


    java HelloWorld         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;                 There are two copies of the
   int y=x;                 value 3 in memory


   Point p = new Point(2.3,4.2);
   Point t = p;      There is only one Point
                            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)
                                                    Java Introduction   30
      Must be called within a synchronized block
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

				
DOCUMENT INFO