Java2 eg

CS 884 (Prasad) Java Examples 1

Java Examples

Java Language Constructs


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.


• 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


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


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.


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 ) ); }

}


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).


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;


• 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.


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


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


4 “a”

“c”

“23”

“abc”

args

(local variable on stack)

(array object on heap)

(string objects on heap)


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];

}

}

}


31

1

1

1

pT

(local variable on stack)

(array object on heap)

(int array objects on heap)

1

2

3

2

1


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.


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.)


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.


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


Tokens

• Whitespace• blank

• tab

• newline

• Comment• // ...

• /* ... */

• /** ... */

• Separators• (, ), [, ], etc

• Keywords (reserved)• Identifiers• Literals

• 25, 2.5 (int/float)– 09 is not an integer.

• true, false (boolean)

• ‘a’, \u0061, \n (char)

• Operators• +, >, &&, etc


Character Strings

class Stringclass StringBuffer

(Cf. array of characters)

Based on 2-byte Unicode characters


class String vs class StringBuffer

• immutable– contents of String

instance unchangeable

– cannot insert or append characters

• fixed length

• s.length()– number of characters

in the string

• mutable– contents of

StringBuffer instance modifiable

• growable– grows automatically

when characters added

• sb.length()• sb.capacity()

– total allocated capacity


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”.

• Assignments += 25;


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.


TYPE TO STRI NG FROM STRI NG

bool ean Stri ng. val ueOf (bool ean)new Bool ean(Stri ng).bool eanVal ue()

i nt Stri ng. val ueOf ( i nt) I nteger. parseI nt(Stri ng)

l ong Stri ng. val ueOf ( l ong) Long. parseI nt(Stri ng)

fl oat Stri ng. val ueOf (fl oat)new Fl oat(Stri ng).fl oatVal ue()

doubl e Stri ng. val ueOf (doubl e)new Doubl e(Stri ng).doubl eVal ue()


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


Interningpackage 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


AssignmentString 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))


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.


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.


variable reference object

(text) (pointer) (memory)

• Static Typing (e.g., Ada)• typetype(variable) = typetype(object)

• compile-time checking : efficient

• Dynamic Typing (e.g., Scheme)• variables type-less; objects carry type tags

• run-time type-checking : flexible

Typing


• Typing in OOPL (E.g., Java, Eiffel, C++, …)• typetype(object/reference) is-a-subtype-of

typetype(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.

Java2 eg

Documents

java examplestraditional

java pcto

java runtime

unnamed java package

interface import java

directorya java program

java examplesarraysindex

new int n