Woodger Computing Inc. - Java Language Introduction

Java Language Introduction

This language overview is aimed at experienced developers, new to the Java Language. Java has taken much of the C/C++ syntax, making simplifications and revisions to suit to its own philosophy.

The Java Language is introduced under the following headings:

Major Operators
Variables Rules
Data Types
Simple Input and Output
Major Constructs
Methods (functions)
Classes

1. Major Operators

Operator	Description	Comment / Example
/* */ //	encloses multi-line comment indicates rest of line is a comment
=	assignment
;	terminates a line	x = x + y;
== !=	checks for equality, e.g. if (x==1) check for inequality	If you accidentally use if (x=1), the compiler flags the mistake. For string comparion, always use the equals method: str1.equals(str2)
> >= < <=	greater than, gr. than or equal less than, less than or equal
!	NOT (negates a boolean expression)
+= -= *=	shorthand operator to add/subtract/multiple two numbers and assign to first	x += s (is like x = x + s, doing addition or string concat. depending on whether these are numbers or strings)
++ --	quick increment (decrement)	x++ is like x = x + 1
&& \|\|	Logical and, Logical or respectively.	(a && b) if a is false, b is not evaluated (or executed) (a \|\| b) if a is true, b is not evaluated (or executed)
a ? b : c	Conditional operator	if boolean expr. "a" is true, use expr. "b", otherwise use expr. "c"

2. Variables Rules

variable must be declared before use

conversion (casting) between data types generally needs to be explicit (except where there is no risk of loss of data). For example, casting is required for float-to-integer or when moving from longer data types to shorter ones (e.g. long to int).

boolean variables cannot be directly converted to a numeric variable type.

instead of a supporting structures, Java requires that a class be defined to "group" data elements

Variable Access:

Class variables or properties (or fields, as Java calls them) have the following access levels:

public: accessible by any class (example: public int i;)

protected: accessible by subclasses or within the same package, but not outside package unless it is a subclass (example: protected int j;)

default: accessible within package but not outside package, not even a subclass (example: default int index;)
private: only accessible within the class, not by a subclass and not outside the class (example: private int k;)

3. Data Types

NUMERIC (all numbers are signed)

short integer (16 bit number) --> i.e. +/- 32,768
int integer (32 bit number) --> i.e. +/- 2 billion or 2 x 10⁹
long integer (64 bit number) --> i.e. +/- 9 x 10¹⁸
float real (32 bit decimal) --> i.e. +/- 1.4 x 10^-45to +/- 3.4 x 10³⁸
double real (64 bit decimal) --> i.e. +/- 4.9 x 10^-324to +/- 1.7 x 10³⁰⁸

CHARACTER/STRING

char a unicode (2-byte) char
the String class handles multi-character strings (strings are unicode, as well). Strings are said to be immutable: updates to a String cause the new string to be created in memory (and pointed to by the String class). However the old string is not actually "updated", rather, its reference is lost (and it becomes available for garbage collection).

BOOLEAN

boolean (with values true, false)

DATE

the Date class measures the milliseconds since Jan 1, 1970 and provides supporting functions to interpret and manipulate date/times

ARRAYS

arrays hold multiple instances of a data type or object
arrays can be declared but still need to be explicitly initialized
int [] dataPoints; // declares the array of integer
dataPoints = new int[10] ; // allocates array size (now usable)
dataPoints = new int[numPoints]; // allocates array size with size specified by a run-time variable
an array can be re-initialized (with the same data type) at runtime, at which point old array entries are discarded
Java standard arrays cannot are not dynamically resizable like arrays in Visual Basic or PowerBuilder (i.e. where the language can dynamically extend the array, if needed). Java throws an exception if an out-of-bounds array index is referenced. Java.util's Vector class provides dynamic array-like capability (a Vector can store a collection of any type of object). The standard Vector class does not, however, limit data to a specific data type (data type limitation capability has to be built in a Vector extension).

4. Simple Output and Input Statement in Java

4.1 Simple Output

Println and Print can be used to produce simple output, as shown below:

System.out.println("Hours worked: " + hours + "Payrate: " + pay);

System.out.print("Important Note: ")

Println ends the output with a newline character.

4.2 Viewing Simple Output from an Applet

When running an applet, the println output will no longer be immediately viewable in a browser. There are two simple approaches to viewing the println output (e.g. for rudimentary debugging):

use the JDK appletviewer and println output will show on the "console" (i.e. DOS sessions where the viewer was launched)
use the console in your browser. For Navigator, choose Window-Java Console to see what has been written to the console. For IE, first check the Java console option in the Internet Options-Advanced Tools tab. Once set, you can see future console output in "View-Java Console".

4.3 Simple Input from User

Simple data input (typed directly from the keyboard) requires that an array of bytes be read and moved to a string. For direct keyboard input, the possibility of an exception must be handled.

byte buffer[] = new byte[50];

String name;
System.out.println("Input your name:");

try{
  System.in.read(buffer);
}

catch (java.io.IOException e) {System.out.println("Exception reading input");}

// move user input into a string
name = new String(buffer,0,buffer.length); // could also trim to remove trailing CR/LF

If the desired user input was a number, the input value could then be moved from the string to a number with the appropriate functions (along with error-checking, in case the user entered a non-numeric).

4.4 Formatting Numbers for Output

The following code formats decimal values to common North American formats.

import java.text.*; // import this before class definition (DecimalFormat belongs)

String displayNum;
Decimal myNum;
DecimalFormat dec0 = new DecimalFormat("#,##0;(#,##0)");
DecimalFormat curr2 = new DecimalFormat("$#,##0.00;($#,##0.00)");
DecimalFormat dec2 = new DecimalFormat("#,##0.0#;(#,##0.0#)");
DecimalFormat perc2 = new DecimalFormat("#.00%");

myNum = 43.497;
displayNum = curr2.format(winRatio); // result: "$43.50" (rounds to two decimals)

myNum = 3001;
displayNum = dec2.format(winRatio); // result: "3,001.0" (shows at least one decimal)

myNum = 0.17299;
displayNum = perc2.format(winRatio); // result: "17.30%" (rounds to two decimals)

Note: Java also supports more general formatting mechanisms which will display numbers in local format, e.g. it will show decimals as periods in North America, commas in Europe, etc.

5. Major Constructs

Statements blocks are delimited with { }. Brace brackets are optional there is a single level statement in the scope. However, it is good style to always include brace brackets. Note that the syntax of the listed constructs is like C's.

IF STMT

if ((a==b) && (b<c)) {
  statements
} else {
  statements
}

SWITCH STMT (limited to char, byte, short, int data types)

switch (age) {
  case 1:
     ...
     break;

  case 2:
     ...
     break;

default:
   ...
}

FOR LOOP

for(i=0; i<10; i++) {
   statements
}

WHILE LOOP

i=0
while (i<10) {
   ...
   i++
}

6. Methods (functions)

6.1 Standard Method (function) Declaration Flavours

Like other object-oriented languages, Java provides different "access" methods for method declaration. A number of examples follow.

Public method access with float Return Value

public float computePay(float HoursWorked, float RatePaid) {
  return (HoursWorked * RatePaid);
}

Protected method access with no Return Value

protected void paint(Graphics g) {
  ...
}

Note: protected access allows access within the package and by any descendants.

Default method access, returning a byte array

byte[] getKeyboardInput() {
  ...
  return buffer;
}

Note: default access allows access within the package only, but not by objects (even descendants) outside the package.

Private-Protected method access with Return Value

private protected int locate(String s) {
  ...
  return location;
}

Note: private protected access allows within the class and its descendants.

Private method with Return Value

private String make(String s) {
  ...
  return result;
}

Note: private access allows access only from within the class.

6.2 Method Parameters

In Java terminology, a parameter is a name that appears in the parameter list in the method declaration where an argument is the a value passed when the method is executed.

Java passes its primitive data types such as int, char, double, etc. by value while it passes arrays and Java objects by reference. For parameter passing purposes, String is best considered passed-by-value since a String cannot have its value updated, with the new value returned to the caller.

If it is necessary to have an primitive data variable returned from a method (other than as the return value), then the primitive variable should be placed within a class and passed as a object or an array.

In other languages you might use a return code to indicate the method's success/failure and then have the desired primitive value returned as reference parameter. To achieve a comparable result in Java, you would return the primitive as the return value and then raise a user-defined exception if the method failed. The calling method would use a try/catch block to determine if the method succeeded.

Comparison of a function with an primitive variable returning and a success/failure indicator.

Visual Basic Sample

Java Sample

Defining the function:

Public Function manip_string(
  ByVal inString As String,
  ByRef outString As String)
  As Boolean

 boolean ret_code = true

 .. some logic
 If(.. bad condition ..)Then
   ret_code = false
 End if
 ..
 Return ret_code
End Function

NOTE: First parm is input, second parm is the result (if OK) while the return code indicates the operation's success or failure.

public String manipString (inString)
  throws BadInputStringException{

 .. some logic

 If (.. bad condition ..) {
   throw new BadInputStringException(
   "Invalid Input");
 }
..
}

NOTE: inString is input while output is returned as a String. Method success/failure is indicated by throwing an exception.

Calling the function:

If (manip_string(x, y)) Then
  .. normal processing
Else
  .. when its fails
End If

try {
  y = manipString(x);
  .. normal processing
}
catch(BadInputStringException e) {
  .. when its fails
}

7. Classes

Each Java classes is generally placed into it own source file (there can be at most one public class per source file). A class has a series of methods and properties.

7.1 Declaring a Class

// this class is public (i.e. accessible outside its package)
public class Customer {

String custName; // class-level variable

  // Constructor: can declare zero, one or many constructors (which take different parms)
  public Customer (string name) {
    this.custName = name; // "this" is optional here but refers to current object
  }

  // as many methods can be defined as needed
  public printName(string name) {
    System.out.println("Customer Name is " + name);
  }
}

7.2 Class Inheritance

To inherit from an existing class, the extends keyword is used. Inheritance works the same as other object-oriented languages (e.g. start with Base Class methods/properties, can override or extend methods, etc.).

public class RetailCust extends Customer {
  ...
}

7.3 Variable Declaration (to create class instance)

Customer myCust; // declares class but does not create instance
Customer myOtherCust = new Customer; // declares and creates an instance of Customer

7.4 Class Variable Assignment and Comparison

Customer myCust1 = new Customer("ABC Mfg");
Customer myCust2 = new Customer("Carpets Unlimited");
Customer myCust3;

myCust3 = myCust1; // points myCust3 to the same instance as myCust1;
myCust2 = myCust1; // points myCust2 to the same instance and frees up other object for garbage collection
if (myCust3 == myCust2) // checks if both variables point at the same object instance

... back to Java Topics