An Introduction to Java

An Introduction to Java
for FORTRAN 90 Programmers

Prof. David Bernstein
James Madison University

Computer Science Department

bernstdh@jmu.edu

Basic Style Issues

FORTRAN:
- Is line oriented (with a maximum of 132 characters per line); lines can be extended using an & character
- "Formatting" is important in some versions of FORTRAN
- Everything on a line after a ! is a comment (i.e., is ignored)
Java:
- Is statement-oriented and every statement ends with a ;
- "Formatting" tends to be ignored (e.g., extra spaces, tabs)
- Everything on a line after a // is a comment as is everything betweem a /* and */
- Block statements are contained between a { and a }

Basic Language Issues

FORTRAN:
- Is procedural and has derived types
- Is modular
- Supports operator overloading
- Supports POINTERs and TARGETs
Java:
- Is object-oriented
- Is modular
- Doesn't support operator overloading
- Objects are reference types; primitives are value types

Naming Conventions

FORTRAN:
- Names (i.e., identifiers) must start with a letter
- Names can contain letters, digits and '_'
- Names are not case-sensitive
Java:
- Names (i.e., identifiers) must start with a letter
- Names can contain letters, digits and '_'
- Names are case-sensitive

Primitive Types

FORTRAN

Type

INTEGER

REAL

CHARACTER

LOGICAL

Java

Type	Memory	Range
`byte`	1 byte	-128 to 127
`short`	2 bytes	-32,768 to 32,767
`int`	4 bytes	-2,147,483,648 to 2,147,483,647
`float`	4 bytes
`double`	8 bytes
`char`	2 bytes	Unicode
`boolean`	1 bit	true or false

Declarations

FORTRAN
- Syntax:
  type [,attribute] :: variable[=value] [, variable[=value]]...
- Examples:
  REAL :: temperature, pressure
  INTEGER :: month=1, year=2007
- Supports implicit declarations (e.g., variables that start with i,j,k,l,m,n are implicitly integers)
Java:
- Syntax:
  type variable[=value] [, variable[=value]]...
- Examples:
  double temperature, pressure;
  int month=1, year=2007;
- All variables must be explicitly declared

"Constants"

FORTRAN:
- Can be specified using the PARAMETER attribute
- Examples:
  REAL, PARAMETER :: pi=3.1415926
Java:
- Can be specified using the final qualifier
- Examples:
  final double pi=3.1415926;

Arithmetic Operators

FORTRAN:
- Addition (+)
  Subtraction (-)
  Multiplcation (*)
  Division (/)
  Exponentiation (**)
Java:
- Addition (+)
  Subtraction (-)
  Multiplcation (*)
  Division (/)
  Integer Division (/)
  Modulo (%)
  Increment (++)
  Decrement (--)

Arithmetic Operators (cont.)

FORTRAN:
- Precedence:
  Parentheses play the "usual role"
  Highest: **
  Next Highest: * /
  Lowest: + -
- Operators have left-to-right associativity
Java:
- Precedence:
  Parentheses play the "usual role"
  Highest: ++ --
  Next Highest: * / %
  Lowest: + -
- Binary operators have left-to-right associativity whereas unary operators have right-to-left associativity

Logicals/Booleans

FORTRAN:
- Values of .TRUE. and .FALSE.
- Unary Operators: .NOT.
- Binary Operators: .AND., .OR., .EQV., .NEQV.
Java:
- Values of true and false
- Unary Operators: !
- Binary Operators: &&, ||, ==, !=

Relational Operators

FORTRAN:
- Binary Operators: <, <=, >, >=, ==, //=
Java:
- Binary Operators: <, <=, >, >=, ==, !=

Characters

FORTRAN:
- Literals can be enclosed in single or double quotes
- Declared using the CHARACTER type
- Example:
  CHARACTER :: gender='F'
Java:
- Literals must be enclosed in single quotes
- Declared using the char type
- Example:
  char gender='F';

Strings

FORTRAN:
- Literals can be enclosed in single or double quotes
- Declared using the CHARACTER type with an additional len
- Example:
  CHARACTER(len=10) :: title='Prof.'
Java:
- Literals must be enclosed in double quotes
- Declared using the String type
- Example:
  String title="Prof.";

Strings (cont.)

FORTRAN:
- Can be concatenated using the //// operator
- Substrings can be accessed using
  name( [start]:[stop] )
  which is 1-based (e.g., title(1:2) returns 'P')
- Can be manipulated with the intrinsic functions LEN(string), INDEX(substring, string) and TRIM(string) (e.g., LEN(title) returns 10)
Java:
- Can be concatenated using the + operator
- Substrings can be accessed using
  name.substring(start,end)
  which is 0-based (e.g., title.substring(0,1); returns "P")
- Can be manipulated with a variety of methods including length(), indexOf(substring) and trim() (e.g., title.length() returns 5)

Arrays

FORTRAN:
- Index bounds can be specified
- Supports multi-dimensional arrays
- Array literals are contained within (// and //) and are delimited by ,
- Example Literal:
  (//1,5,9//)
Java:
- 0-based
- Supports arrays of arrays
- Array literals are contained within { and } and are delimited by ,
- Example Literal:
  {1,5,9}

Arrays (cont.)

FORTRAN:
- Declaration Syntaxes:
  type, DIMENSION(bound)[, attr] :: variable[, variable]...
  type [, attr] :: variable(bound) [,variable(bound)]...
- Examples:
  INTEGER, DIMENSION(6) :: a
  INTEGER, DIMENSION(4,2) :: b
  REAL :: c(4:9)
Java:
- Declaration Syntax:
  type[] variable [,variable]...;
- Initialization Syntax:
  variable = new type[size];
- Example:
  int[] a;
  a = new int[6];
  int[][] b;
  b = new int[4][2];

Arrays (cont.)

FORTRAN:
- Access Syntax:
  variable(index[,index...])
- Examples:
  a(5)
  b(1,1)
Java:
- Access Syntax:
  variable[index]
- Examples:
  a[5]
  b[1][1]

Derived/User-Defined Types

FORTRAN:

Syntax:
TYPE :: name
statement
[statement]...
END TYPE [name]

Example:

        TYPE rectangle

            REAL :: height, width

        END TYPE rectangle

Java:
- Syntax:
  public class name
  {
  public type variable [,variable>...;
  [public type variable [,variable>...;]...
  }
- Example:
```
        public class rectangle
        {
            public double  height, width;
        }
        
```
- Classes can be used in this way but can also be used in much more interesting ways (since Java is object-oriented)

Derived/User-Defined Types (cont.)

FORTRAN:

Components are accessed using the % operator

Example:

	TYPE(rectangle) ::   cage

	cage%height = 5
        cage%width  = 10

Java:

Components are accessed using the . operator

Example:

	Rectangle    cage;

        cage = new Rectangle();

	cage.height = 5;
        cage.width  = 10;

Control Structures

FORTRAN:

Statement Syntax:
IF (logical_expression) statement
Construct Syntax:
[name: IF (logical_expression) THEN
block
[ELSEIF (logical_expression) THEN [name]
block]
[ELSE [name] block]
ENDIF [name]

Example:

              IF ( n==1 ) THEN
	          discount = 0.0
	      ELSEIF ( n<=5 ) THEN
	          discount = 0.1
	      ELSEIF ( n>5 .AND. n<=10) THEN
	          discount = 0.15
	      ELSE
	          discount = 0.25
	      ENDIF

Java:

Syntax:
if (logical_expression) statement; [else statement;]

Example:

              if ( n==1 )
              {
	          discount = 0.0;
              }
	      else if ( n<=5 )
              {
	          discount = 0.1;
              }
	      else if ( n>5 .AND. n<=10)
              {
	          discount = 0.15;
              }
	      else
	      {
	          discount = 0.25;
	      }

Control Structures (cont.)

FORTRAN:
- Syntax:
  [name:] DO counter=start,stop [, step
  block
  END DO [name]
- Example:
```
        DO i=1,10,1
            total = total + sales(i)
        END DO
	
```
- CYCLE can be used to begin another iteration and EXIT can be used to "break out"
Java:
- Syntax:
  for (initialization; boolean; update) statement;
- Example:
```
        for (i=0; i<10; i++)
        {
            total = total + sales[i];
        }
	
```
- exit can be used to "break out"
- A for loop can be used like a DO loop but can be used in many other ways as well

Control Structures (cont.)

FORTRAN:

Java:

Syntax:
while (boolean) statement;

Example:

        while (tolerance > 0.001)
        {
            approximation = approximation + 0.01;
            tolerance = target - approximation;
        }

Syntax:
do statement while (boolean);

Example:

        i = 0;
        do
        {
            total = total + sales[i];
            i = i + 1;
        }
        while (i < 10);

Functions/Subroutines/Methods

FORTRAN:

Supports two types of procedures, functions and subroutines
Syntax:
procedure name [(argument [,argument]...)]
declarations
statements
END procedure [name]

Example:

              FUNCTION line(m, x, b)

                  REAL :: line
                  REAL :: m, x, b

                  line = m*x + const

              END FUNCTION line

Java:

Methods can either return a value or not (in which case they have a type of void)
Syntax:
accessibility [static] type name([type parameter]...)

Example:

	      public double line(double m, double x, double b)
              {
                  double result;

                  result = m*x + b;

                  return result;
              }

Functions/Subroutines/Methods (cont.)

FORTRAN:

All arguments are passed copy-in, copy-out

The following will work:

              SUBROUTINE swap(a, b)

                  REAL :: a, b, temp

                  temp = a
                  a    = b
                  b    = temp

              END SUBROUTINE swap

Java:

All arguments are passed by value

The following will NOT work:

	      public void swap(double a, double b)
              {
                  double temp;

                  temp = a;
                  a    = b;
                  b    = temp;
              }

Input/Output

FORTRAN:
- Involves READ and WRITE statements
- Involves the FORMAT statement (and edit descriptors including I,F,E,ES,EN,D,G,L,A,H,T,TL,TR,X,P,BN,BZ,SP,SS,S,/,:,')
- Example:
```
        READ(*,FMT=200) x,y

        WRITE(*,200) a,b

        100 FORMAT(2I)

        200 FORMAT(2F10.6)
	
```
Java:
- Involves "streams" for byte-based I/O
- Involves "readers" for character-based I/O