core

Webprogramming

Basic Java Syntax

1 © 2001-2003 Marty Hall, Larry Brown: [Link]

Agenda
• Creating, compiling, and executing simple
Java programs
• Accessing arrays
• Looping
• Using if statements
• Comparing strings
• Building arrays
– One-step process
– Two-step process
• Using multidimensional arrays
• Manipulating data structures
2
• Handling errors
Basic Java Syntax [Link]
 Getting Started
• Name of file must match name of class
– It is case sensitive, even on Windows
• Processing starts in main
– public static void main(String[] args)
– Routines usually called “methods,” not “functions.”
• Printing is done with [Link]
– [Link], [Link]
• Compile with “javac”
– Open DOS window; work from there
– Supply full case-sensitive file name (with file extension)
• Execute with “java”
– Supply base class name (no file extension)
3 Basic Java Syntax [Link]

Example
• File: [Link]
public class HelloWorld {
public static void main(String[] args) {
[Link]("Hello, world.");
}
}
• Compiling
DOS> javac [Link]
• Executing
DOS> java HelloWorld
Hello, world.

4 Basic Java Syntax [Link]

2
 More Basics
• Use + for string concatenation
• Arrays are accessed with []
– Array indices are zero-based
– The argument to main is an array of strings that
correspond to the command line arguments
• args[0] returns first command-line argument
• args[1] returns second command-line argument
• Etc.
• The length field gives the number of
elements in an array
– Thus, [Link] gives the number of command-
line arguments
– Unlike in C/C++, the name of the program is not inserted
into the command-line arguments
5 Basic Java Syntax [Link]

Example
• File: [Link]
public class ShowTwoArgs {
public static void main(String[] args) {
[Link]("First arg: " +
args[0]);
[Link]("Second arg: " +
args[1]);
}
}

6 Basic Java Syntax [Link]

3
 Example (Continued)
• Compiling
DOS> javac [Link]
• Executing
DOS> java ShowTwoArgs Hello World
First args Hello
Second arg: Class

DOS> java ShowTwoArgs

[Error message]

7 Basic Java Syntax [Link]

Looping Constructs
• while
while (continueTest) {
body;
}
• do
do {
body;
} while (continueTest);
• for
for(init; continueTest; updateOp) {
body;
}

8 Basic Java Syntax [Link]

4
 While Loops

public static void listNums1(int max) {

int i = 0;
while (i <= max) {
[Link]("Number: " + i);
i++; // "++" means "add one"
}
}

9 Basic Java Syntax [Link]

Do Loops

public static void listNums2(int max) {

int i = 0;
do {
[Link]("Number: " + i);
i++;
} while (i <= max);
// ^ Don’t forget semicolon
}

10 Basic Java Syntax [Link]

5
 For Loops

public static void listNums3(int max) {

for(int i=0; i<max; i++) {
[Link]("Number: " + i);
}
}

11 Basic Java Syntax [Link]

Aside: Defining Multiple

Methods in Single Class
public class LoopTest {
public static void main(String[] args) {
listNums1(5);
listNums2(6);
listNums3(7);
}

public static void listNums1(int max) {…}

public static void listNums2(int max) {…}
public static void listNums3(int max) {…}
}

12 Basic Java Syntax [Link]

6
 Loop Example
• File [Link]:
public class ShowArgs {
public static void main(String[] args) {
for(int i=0; i<[Link]; i++) {
[Link]("Arg " + i +
" is " +
args[i]);
}
}
}

13 Basic Java Syntax [Link]

If Statements
• Single Option
if (boolean-expression) {
statement;
}
• Multiple Options
if (boolean-expression) {
statement1;
} else {
statement2;
}

14 Basic Java Syntax [Link]

7
 Boolean Operators
• ==, !=
– Equality, inequality. In addition to comparing primitive
types, == tests if two objects are identical (the same
object), not just if they appear equal (have the same
fields). More details when we introduce objects.
• <, <=, >, >=
– Numeric less than, less than or equal to, greater than,
greater than or equal to.
• &&, ||
– Logical AND, OR. Both use short-circuit evaluation to
more efficiently compute the results of complicated
expressions.
• !
– Logical negation.
15 Basic Java Syntax [Link]

Example: If Statements

public static int max2(int n1, int n2) {

if (n1 >= n2)
return(n1);
else
return(n2);
}

16 Basic Java Syntax [Link]

8
 Strings
• String is a real class in Java, not an array of
characters as in C and C++.
• The String class has a shortcut method to
create a new object: just use double quotes
– This differs from normal objects, where you use the new
construct to build an object
• Use equals to compare strings
– Never use ==

17 Basic Java Syntax [Link]

Strings: Common Error

public static void main(String[] args) {
String match = "Test";
if ([Link] == 0) {
[Link]("No args");
} else if (args[0] == match) {
[Link]("Match");
} else {
[Link]("No match");
}
}
• Prints "No match" for all inputs
– Fix:
if (args[0].equals(match))
18 Basic Java Syntax [Link]

9
 Building Arrays:
One-Step Process
• Declare and allocate array in one fell swoop
type[] var = { val1, val2, ... , valN };
• Examples:
int[] values = { 10, 100, 1000 };
Point[] points = { new Point(0, 0),
new Point(1, 2),
... };

19 Basic Java Syntax [Link]

Building Arrays:
Two-Step Process
• Step 1: allocate an array of references:
type[] var = new type[size];
• Eg:
int[] values = new int[7];
Point[] points = new Point[[Link]];
• Step 2: populate the array
points[0] = new Point(...);
points[1] = new Point(...);
...
Points[6] = new Point(…);
• If you fail to populate an entry
– Default value is 0 for numeric arrays
– Default value is null for object arrays
20 Basic Java Syntax [Link]

10
 Multidimensional Arrays
• Multidimensional arrays are implemented as
arrays of arrays
int[][] twoD = new int[64][32];

String[][] cats = { { "Caesar", "blue-point" },

{ "Heather", "seal-point" },
{ "Ted", "red-point" } };

• Note: the number of elements in each row (dimension)

need not be equal
int[][] irregular = { { 1 },
{ 2, 3, 4},
{ 5 },
{ 6, 7 } };

21 Basic Java Syntax [Link]

TriangleArray: Example
public class TriangleArray {
public static void main(String[] args) {

int[][] triangle = new int[10][];

for(int i=0; i<[Link]; i++) {

triangle[i] = new int[i+1];
}

for (int i=0; i<[Link]; i++) {

for(int j=0; j<triangle[i].length; j++) {
[Link](triangle[i][j]);
}
[Link]();
}
}
}
22 Basic Java Syntax [Link]

11
 TriangleArray: Result
> java TriangleArray

0
00
000
0000
00000
000000
0000000
00000000
000000000
0000000000

23 Basic Java Syntax [Link]

Data Structures
• Java 1.0 introduced two synchronized data
structures in the [Link] package
– Vector
• A strechable (resizeable) array of Objects
• Time to access an element is constant regardless of
position
• Time to insert element is proportional to the size of the
vector
• In Java 2 (eg JDK 1.2 and later), use ArrayList
– Hashtable
• Stores key-value pairs as Objects
• Neither the keys or values can be null
• Time to access/insert is constant
• In Java 2, use HashMap
24 Basic Java Syntax [Link]

12
 Useful Vector Methods
• addElement/insertElementAt/setElementAt
– Add elements to the vector
• removeElement/removeElementAt
– Removes an element from the vector
• firstElement/lastElement
– Returns a reference to the first and last element, respectively
(without removing)
• elementAt
– Returns the element at the specified index
• indexOf
– Returns the index of an element that equals the object specified
• contains
– Determines if the vector contains an object

25 Basic Java Syntax [Link]

Useful Vector Methods

• elements
– Returns an Enumeration of objects in the vector
Enumeration elements = [Link]();
while([Link]()) {
[Link]([Link]());
}
• size
– The number of elements in the vector
• capacity
– The number of elements the vector can hold before
becoming resized

26 Basic Java Syntax [Link]

13
 Useful Hashtable Methods
• put/get
– Stores or retrieves a value in the hashtable
• remove/clear
– Removes a particular entry or all entries from the hashtable
• containsKey/contains
– Determines if the hashtable contains a particular key or element
• keys/elements
– Returns an enumeration of all keys or elements, respectively
• size
– Returns the number of elements in the hashtable
• rehash
– Increases the capacity of the hashtable and reorganizes it

27 Basic Java Syntax [Link]

Collections Framework
• Additional data structures added by Java 2
Platform
Collection Map
HashMap
Hashtable†
Set List
HashSet
ArrayList SortedMap
LinkedList
Vector† TreeMap
SortedSet
TreeSet

Interface Concrete class †Synchronized Access

28 Basic Java Syntax [Link]

14
 Collection Interfaces
• Collection
– Abstract class for holding groups of objects
• Set
– Group of objects containing no duplicates
• SortedSet
– Set of objects (no duplicates) stored in ascending order
– Order is determined by a Comparator
• List
– Physically (versus logically) ordered sequence of objects
• Map
– Stores objects (unordered) identified by unique keys
• SortedMap
– Objects stored in ascending order based on their key value
– Neither duplicate or null keys are permitted
29 Basic Java Syntax [Link]

Collections Class
• Use to create synchronized data structures
List list = [Link](new ArrayList());
Map map = [Link](new HashMap());

• Provides useful (static) utility methods

– sort
• Sorts (ascending) the elements in the list
– max, min
• Returns the maximum or minimum element in the
collection
– reverse
• Reverses the order of the elements in the list
– shuffle
• Randomly permutes the order of the elements
30 Basic Java Syntax [Link]

15
 Wrapper Classes
• Each primitive data type has a
corresponding object (wrapper class)
Primitive Corresponding
Data Type Object Class
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

– The data is stored as an immutable field of the object

31 Basic Java Syntax [Link]

Wrapper Uses
• Defines useful constants for each data type
– For example,

Integer.MAX_VALUE
Float.NEGATIVE_INFINITY

• Convert between data types

– Use parseXxx method to convert a String to the
corresponding primitive data type
try {
String value = "3.14e6";
Double d = [Link](value);
} catch (NumberFormatException nfe) {
[Link]("Can't convert: " + value);
}

32 Basic Java Syntax [Link]

16
 Wrappers: Converting Strings

Data Type Convert String using either …

byte [Link](string )
new Byte(string ).byteValue()
short [Link](string )
new Short(string ).shortValue()
int [Link](string )
new Integer(string ).intValue()
long [Link](string )
new Long(string ).longValue()
float [Link](string )
new Float(string ).floatValue()
double [Link](string )
new Double(string ).doubleValue()

33 Basic Java Syntax [Link]

Error Handling: Exceptions

• In Java, the error-handling system is based
on exceptions
– Exceptions must be handed in a try/catch block
– When an exception occurs, process flow is immediately
transferred to the catch block
• Basic Form
try {
statement1;
statement2;
...
} catch(SomeException someVar) {
handleTheException(someVar);
}

34 Basic Java Syntax [Link]

17
 Exception Hierarchy
• Simplified Diagram of Exception Hierarchy

Throwable

Exception Error

…
IOException RuntimeException

35 Basic Java Syntax [Link]

Throwable Types
• Error
– A non-recoverable problem that should not be caught
(OutOfMemoryError, StackOverflowError, …)
• Exception
– An abnormal condition that should be caught and handled
by the programmer
• RuntimeException
– Special case; does not have to be caught
– Usually the result of a poorly written program (integer
division by zero, array out-of-bounds, etc.)
• A RuntimeException is considered a bug

36 Basic Java Syntax [Link]

18
 Multiple Catch Clauses
• A single try can have more that one catch
clause
try {
...
} catch (ExceptionType1 var1) {
// Do something
} catch (ExceptionType2 var2) {
// Do something else
}

– If multiple catch clauses are used, order them from the

most specific to the most general
– If no appropriate catch is found, the exception is
handed to any outer try blocks
• If no catch clause is found within the method, then the
exception is thrown by the method

37 Basic Java Syntax [Link]

Try-Catch, Example
...
BufferedReader in = null;
String lineIn;
try {
in = new BufferedReader(new FileReader("[Link]"));
while((lineIn = [Link]()) != null) {
[Link](lineIn);
}
[Link]();
} catch (FileNotFoundException fnfe ) {
[Link]("File not found.");
} catch (EOFException eofe) {
[Link]("Unexpected End of File.");
} catch (IOException ioe) {
[Link]("IOError reading input: " + ioe);
[Link](); // Show stack dump
}

38 Basic Java Syntax [Link]

19
 The finally Clause
• After the final catch clause, an optional
finally clause may be defined
• The finally clause is always executed,
even if the try or catch blocks are exited
through a break, continue, or return
try {
...
} catch (SomeException someVar) {
// Do something
} finally {
// Always executed
}

39 Basic Java Syntax [Link]

Thrown Exceptions
• If a potential exception is not handled in the
method, then the method must declare that
the exception can be thrown
public SomeType someMethod(...) throws SomeException {
// Unhandled potential exception
...
}
– Note: Multiple exception types (comma separated) can be
declared in the throws clause

• Explicitly generating an exception

throw new IOException("Blocked by firewall.");

throw new MalformedURLException("Invalid protocol");

40 Basic Java Syntax [Link]

20
 Summary
• Loops, conditional statements, and array
access is the same as in C and C++
• String is a real class in Java
• Use equals, not ==, to compare strings
• You can allocate arrays in one step or in two
steps
• Vector or ArrayList is a useful data
structure
– Can hold an arbitrary number of elements
• Handle exceptions with try/catch blocks

41 Basic Java Syntax [Link]

core

Webprogramming

Questions?

42 © 2001-2003 Marty Hall, Larry Brown: [Link]

21