Your Federal Quarterly Tax Payments are due April 15th Get Help Now >>

Heap Printable Applications by qtz11798

VIEWS: 6 PAGES: 31

Heap Printable Applications document sample

More Info
									                    Java Examples
                  Java Language Constructs




CS 884 (Prasad)              Java Examples   1
                  Java Program Organization

     • Compilation Unit = File
     • Package = Directory
           – A Java program is a set of compilation
             units organized using a package
             hierarchy (that is, as a forest of trees).
           – A compilation unit is a set of class and
             interface declarations.
           – Every compilation unit belongs to a
             unique (possibly unnamed) Java package.

CS 884 (Prasad)            Java Examples                  2
    • Every file (compilation unit) can have at
      most one public class.
    • The definition of public class PC must be
      in a file named PC.java.
          – Set environment variables CLASSPATH and PATH appropriately.

    • To compile:     > javac PC.java
    • To run:         > java PC
    • To run applets: > netscape PC.html
                      > appletviewer PC.html




CS 884 (Prasad)                 Java Examples                             3
                           Class Declaration
         – Fields / Instance Variables (Holds state)
                  • x, y
         – Constructors (Initializes state)
                  • Point
         – Methods (Proc/Func) (State Transformer/Observer)
                  • move
         – Class Variables (Global to all instances)
                  • count
         – Local Variables / Formal Parameters
CS 884 (Prasad)                 Java Examples                 4
                  Interface Declaration
interface Table {
    boolean isEmpty();
    void insert(Object x, int key);
    Object lookUp(int key);
}
      – An interface specifies constants and signatures
        of the methods.
      – An interface can extend several super-
        interfaces.
CS 884 (Prasad)           Java Examples               5
           Class implements Interface
  import java.util.Hashtable;
  class Index implements Table {
      HashTable v = new Hashtable();
      public boolean isEmpty() {
           return v.isEmpty(); }
      public void insert(Object x, int key) {
           v.put(new Integer (key) , x); }
      public Object lookUp(int key) {
           return v.get(new Integer ( key ) ); }
  }

CS 884 (Prasad)           Java Examples            6
                  Abstract Classes
• Classes must implement all methods.
• Interfaces must specify only the signatures
  of the methods.
• Abstract classes can implement some
  methods, leaving the rest to subclasses.
• Interfaces and abstract classes cannot be
  instantiated (to create objects).

CS 884 (Prasad)        Java Examples            7
                       Arrays
 • Index Range: 0 to (length - 1).
 • Each array object is of fixed size, permitting
   index checking at run-time.

 •    int [] [] twoD = new int [8] [];
 •    Point [] points = {new Point(5, 5), null };
 •    twoD[1] = new int [2];
 •    twoD[1][0] = points[0].x;
CS 884 (Prasad)       Java Examples                 8
• Declaration
      – int[]       intArray;
      – field     intArray   initialized to null, by default.
• Creation
      – intArray = new int[5];
      – intArray = { 0, 2, 4, 3*2, 4+4 };

• Multi-dimensional array
      – double [][] iA = { { 1, 0 }, null };

• Java runtime verifies that array indices are
  in the correct range.

CS 884 (Prasad)                 Java Examples                   9
                  Traditional First Program
        public class HelloWorld {
          public static void main(String [] args) {
              System.out.println(“Hello World”);
          }
        }
              – javac HelloWorld.java
              – java HelloWorld a b c

CS 884 (Prasad)           Java Examples          10
                  Another Example Program
class EchoArgs {
 public static void main(String[] args){
    for (int i = 0; i < args.length; i++)
        System.out.print( args[i] );
    System.out.println( “ ”);
 };
}
  – javac   EchoArgs.java
  – java    EchoArgs a 23 c abc
  – java    EchoArgs


CS 884 (Prasad)           Java Examples     11
                                  4            “a”

                                               “23”
            args
                                               “c”

                                               “abc”
     (local variable
         on stack)     (array object
                                                 (string objects
                           on heap)
                                                     on heap)




CS 884 (Prasad)                Java Examples                       12
class PascalTriangle {
  public static void main( String[] args ) {
    n = Integer.parseInt( args[0] );
    int [] [] pT = new int [n + 1] [];
    pT[0] = new int[1];           // first row
   pT[0][0] = 1;
    for (int i = 1; i <= n; i++) {// rows 2 to n+1
          pT[i] = new int [i + 1];
          pT[i][0] = 1;
          pT[i][i] = 1;
          for (int j = 1; j < i ; j++ ) {
            pT[i][j] = pT[i-1][j-1] + pT[i-1][j];
    }
  }
}

CS 884 (Prasad)      Java Examples               13
                                               1
                                  3
                                               1
                                               2


            pT                                 1
                                               1   (int array objects
                                               3
                                                       on heap)
                                               1
     (local variable
                                               2
         on stack)     (array object
                           on heap)            1




CS 884 (Prasad)                Java Examples                            14
      Array type : “unconstrained”
• Define matrix operations in terms of structure of
  the array (dimensionality); size is implicit.
      • Vector dot-product that works for two equal length
        single-dimension array with same type elements.
      • Matrix multiplication : Dimension compatibility
        checked at run-time.
• length field of an array object used :
     – to control loops.
     – to allocate storage for local variables.
• Type is unconstrained, but each object/instance has a
  fixed size. (E.g., String type vs String object )
• Cf. Ada Unconstrained array types.

CS 884 (Prasad)           Java Examples                   15
                   Exceptions
• Abnormal condition may be signaled by throw-ing
  an exception. (Cf. Returning error (status) code that
  can be ignored by caller.)
• To deal with abnormal situation, the caller can
  provide an appropriate handler using try-catch
  construct.
• In Java, Checked Exceptions must be handled
  explicitly or propagated explicitly. (Errors and
  Unchecked Exceptions are propagated implicitly, if
  not handled explicitly.)

CS 884 (Prasad)       Java Examples                 16
                  Visibility of names
• Private:
      • class
• Default:
      • package (not just compilation unit)
• Protected:
      • package and subclasses (in other packages).
• Public:
      • where-ever the package is visible.

CS 884 (Prasad)         Java Examples                 17
                  Java Development Kit
        •   java.lang (contains Threads)
        •   java.io (contains StreamTokenizer)
        •   java.awt (Abstract Windowing ToolKit)
        •   java.net (Support for TCP/IP, HTTP)
        •   java.applet (To run code via Browser)
        •   java.util (Standard Utilities)
        •   javac, java, javadoc

CS 884 (Prasad)          Java Examples          18
                                      Tokens
     • Whitespace                            • Keywords (reserved)
                  • blank                    • Identifiers
                  • tab
                  • newline                  • Literals
                                                       • 25, 2.5 (int/float)
     • Comment                                             – 09 is not an integer.
                  • // ...                             • true, false (boolean)
                  • /* ... */                          • „a‟, \u0061, \n (char)
                  • /** ... */
                                             • Operators
     • Separators                                      • +, >, &&, etc
                  • (, ), [, ], etc


CS 884 (Prasad)                        Java Examples                                 19
                   Character Strings
                         class String
                      class StringBuffer
                     (Cf. array of characters)

                  Based on 2-byte Unicode characters


CS 884 (Prasad)                Java Examples           20
  class String          vs     class StringBuffer

• immutable                       • mutable
     – contents of String                 – contents of
       instance unchangeable                StringBuffer instance

     – cannot insert or                     modifiable
       append characters          • growable
• fixed length                       – grows automatically
                                       when characters added
• s.length()                      • sb.length()
   – number of characters in      • sb.capacity()
     the string                      – total allocated capacity

CS 884 (Prasad)           Java Examples                             21
   String literals and concatenation
      • String s = “abc”;
      • System.out.println( s + “def” );
            – “+” stands for string concatenation.
            – Built-in operator overload.
      • Left associativity of “+”
            (s +   3 + 5) evaluates to “abc35”.
            (s + (3 + 5)) evaluates to “abc8”.
            (5 + 3 + s)   evaluates to “8abc”.
      • Assignment
            s += 25;
CS 884 (Prasad)             Java Examples            22
                  String conversions
 • class Object      supports toString()-method
      to convert a class instance into a printable
      string form: classname@hashcode
 •    toString() can be overridden.
             public String toString() { ... };
 • println/print       methods in System.out, the
      “+”-expressions, and the “+= ”-statements
      invoke toString() implicitly, to coerce an
      instance to a string.
CS 884 (Prasad)         Java Examples            23
CS 884 (Prasad)   Java Examples   24
                  Comparison
• “abc”.equals(“abc”)               is   true.
• “abc”.equalsIgnoreCase(“ABC”)                   is   true.
• (s == s)        is   true.
• (“abc” + s ==         “abc” + s)         is    false.
• s1.compareTo(s2)
     • negative: s1 lexicographically precedes          s2
     • zero:     s1          is equal                   s2
     • positive: s1 lexicographically follows           s2


CS 884 (Prasad)          Java Examples                         25
                                 Interning
package testPackage;
class Test {
   public static void main(String[] args) {
        String hello = "Hello", lo = "lo";
        System.out.print((hello == "Hello") + " ");
        System.out.print((Other.hello == hello) + " ");
        System.out.print((ext.Other.hello == hello)+" ");
        System.out.print((hello == ("Hel"+"lo")) + " ");
        System.out.print((hello == ("Hel"+lo)) + " ");
        System.out.println(hello == ("Hel"+lo).intern());
   }
}
class Other { static String hello = "Hello"; }
package ext;
public class Other { static String hello = "Hello"; }

Result of execution:
true true true true false true



CS 884 (Prasad)                   Java Examples             26
                           Assignment
                        String s = “abc”;
                              s += 2+3+5;
                   s.equals(“abc10”) == true
                  s.equals(“abc235”) == false
                     (Recall that “+” is left-associative.)


                       Type E1;
                      E1 += E2;
              E1 = (Type) ((E1) + (E2))

CS 884 (Prasad)                  Java Examples                27
                  Useful Methods
      – String t = “abca”;
      – String s = new String(t);
• s.charAt(2)                  is       „c‟.
• s.indexOf(„a‟)               is        0.
• s.indexOf(“bc”)              is        1.
• s.indexOf(„a‟,2)             is        3.
• s.lastIndexOf(„a‟)           is        3.
• regionMatches, startsWith, endsWith, etc.
      – Pure ASCII applications can be inefficient
        because Java uses 16-bit Unicode characters.
CS 884 (Prasad)         Java Examples                  28
     Motivation for Strong Typing
      • Type declarations provide extra information
        associated with an identifier. This redundant
        info. enables mechanical detection of errors.
      • In practice, a number of logical and
        typographical errors manifest themselves as
        type errors. Thus, strongly typed languages
        allow construction of reliable programs.
      • In OOPLs, the type tags associated with
        objects aid in the impl. of dynamic binding,
        polymorphism, and safe conversions.

CS 884 (Prasad)          Java Examples                  29
                              Typing

 variable        reference                            object
  (text)         (pointer)                          (memory)
 • Static Typing (e.g., Ada)
             • type(variable) = type(object)
             • compile-time checking : efficient
 • Dynamic Typing (e.g., Scheme)
             • variables type-less; objects carry type tags
             • run-time type-checking : flexible

CS 884 (Prasad)                Java Examples                   30
• Typing in OOPL (E.g., Java, Eiffel, C++, …)
           • type(object/reference) is-a-subtype-of
             type(variable).
           • In Java, a variable of class C, can hold a reference to
             an instance (object) of a subclass of C.
     – Type correctness guaranteed at compile-time.
           • Efficient and secure.
     – Dynamic binding dispatches each call to the
       appropriate code, at run-time.
           • Flexible handling of heterogeneous data.


CS 884 (Prasad)                Java Examples                      31

								
To top