CSCI A201/A597 Lecture Notes 29 Spring 2000

If we have a mathematical function f from the set of positive integers N to the set of positive integers N and with the following definition:

f(x) = 3x + 1 

int f(int n) {
  return 3x + 1; 
} 

Functions are encapsulating computations. In Java functions are called methods. Let's suppose we now want to implement a (still simple) but more complicated function, that computes the sum of the first n positive numbers.

We can do it in several ways:

a) iterative approach

int sum (int n) {
  int sum; 
  for (int i = 0; i <= n; i++) {
    sum += 1; 
  } 
  return sum; 
} 

int sum(int n) {
  return n * (n + 1) / 2; 
} 

int sum(int n) {
  if (n == 1) return 1; 
  else return n + sum(n - 1); 
} 

The closed form is OK as long as we can prove that the formula we use does indeed compute the sum of the first n positive integers. To prove that the formula is correct we can use mathematical induction. To come up with a formula it's a different story however.

Exercise: write a function that computes the sum of the squares of the first n positive integers. Write another that computes the sum of the cubes of the first n integer numbers.

The recursive approach is an elegant approach.

Functions can also be mutually recursive, for example consider this definition of when a given positive integer number n is odd or even:

boolean odd(int n) {
  if (n == 0) return false; 
  else return even(n - 1); 
} 

boolean even(int n) {
  if (n == 0) return true; 
  else return odd(n - 1); 
}

In Java there are eight primitive types:

1. boolean

2. byte
3. short
4. int
5. long
6. char

7. float
8. double

Now we know how to write functions, but where do we put them. Functions can't exist on their own in Java. They must be located either inside objects or classes. We'll first put them in an object. But for this we need to create an object, so we need to talk about objects and classes.

We create a type of object Abacus and put the methods in it.

class Abacus {
  int sum(int n) {
    if (n == 1) return 1; 
    else return n + sum(n - 1); 
  } 
  boolean odd(int n) { 
    ... 
  }
  boolean (even int n) {
    ...
  } 
}

• objects - instances of classes
• classes - blueprints of objects

class Point {
  double x; 
  double y; 
} 

Objects are being created with new.

An invocation of new activates a constructor.

Every class gets a default no-args constructor by default if no constructor is specified. If at least one constructor is specified then there is no default constructor whatsoever.

So to create a Point object with the current definition:

new Point(); 

Reference types

To store a reference to a newly created Point one needs to use a variable of type Point.

Point p = new Point(); 

The instance variables x, and y are initialized to 0.0 by default. That's different from the local variables used by methods.

If we add a new constructor to class Point like that

class Point { 
  double x, y;
  Point (double initialX, double initialY) {
    x = initialX;
    y = initialY; 
  } 
  // no default no-args constructor now! 
} 

Point p = new Point(); // this doesn't compile now. 

Point p = new Point(-1.0, -3.5); 

class Point { 
  double x, y;
  Point (double initialX, double initialY) {
    x = initialX;
    y = initialY; 
  } 
  // explicit no-args constructor 
  Point() {
    x = 0.0; 
    y = 0.0; 
  } 
} 

Data members (fields) are accessed like this:

objectReference.fieldName

objectReference.methodName()

Java programs are organized as sets of packages. To start with we will be working with the default package, essentially "the current directory". The default visibility for instance variables is public within the current package.

We look at the following examples:

Point p = new Point(); 
p.x = 3.0; 
p.y = 5.0; 

p = new Point(); 
p.x = -1.0;
p.y = -2.0; 

Instance members are of two kinds: (data) fields, and methods (that encapsulate behaviour).

Let's give an example of an instance method for objects of type Point():

double squareOfDistanceToOrigin() {
  return x * x + y * y; 
} 

double squareOfDistanceToPoint(Point p) {
  return (x - p.x) * (x - p.x) + (y - p.y) * (y - p.y); 
} 

double squareOfDistanceToPoint(Point p) {
  return this.x * p.x + this.y * p.y; 
} 

So we have discussed about instance variables (fields) and about instance methods. We now need the bigger picture so we have the following classification:

Members are:

• instance members
  • fields (variables)
  • methods
  These are one per object.

• class members
  • fields (variables)
  • methods
  They are one per class (or static).

class Point {
  ...
  static int howMany; 
  static void count() {
    howMany += 1; 
  } 
  ...
}

Point.count(); 

Point howMany(); 

We could use count() in the constructors and keep track of how many Points have been generated in our program. The main point though is to remember that access of class members has a similar syntax to those of instance members.

To write a full-blown Java program you need at least a class. To run it you need at least one of your classes to implement a method called main with the following look:

class One { 
  public static void main(String[] args) {
    ...
  } 
} 

In class Point the following definition

class Point {
  ...
  static Point origin = new Point(); 
  ...
}

We could define some more:

class Point {
  ...
  static Point bearsPlace = new Point(-2.0, -1.5); 
  static Point lindleyHall = new Point(-1.0, 10.5); 
  ...
}

1. Assume the following lines of code:

Point p = new Point(3.2, 5.1); 
double val = Point.origin.squareDistanceToPoint(p); 

2. Same question for

Point q = new Point(3.2, 5.1); 
double val = Point.bearsPlace.squareDistanceToPoint(lindleyHall); 

Point.origin.squareDistanceToPoint(p)

System.out.println("Hello, world!")

1. first a class name is mentioned (System, Point)
2. then a static member of that class is accessed (out, origin)
3. an instance method of the resulting object is invoked
   (println(...), squareDistanceToPoint(...))

(Note: the java.lang is imported by default).

So now we can write a full-blown Java program, compile it, and run it.

(We can also use Math.sqrt() in the instance methods of class Point that compute distances).

To illustrate a full-blown program let's compile and run this program:

class Puzzle {
  public static void main(String[] args) {
    Puzzle p = new Puzzle(); 
    System.out.println("Final result: " + p.fun(6)); 
  }   
  int fun(int n) { 
    int result; 
    if (n == 0) return 0; 
    else {
      // [1] 
      result = n + fun(n - 1); 
      // [2] 
      return result; 
    } 
  } 
} 

Exercises

1. Add a line

   System.out.println(n); 
   

   in place of the first comment. Explain the change in output.

2. Move the line

   System.out.println(n); 
   

   in place of the second comment, thus leaving the first comment unchanged.
   Explain the change in output.

Draw a diagram for the objects of type Pair defined below.

 
class Pair {
  int value; 
  Pair nextPair; 

  Pair(int initialValue, Pair initialNext) {
    value = initialValue; 
    nextPair = initialNext; 
  } 
}

class LisP {
  Pair myList; 
  // define your constructors

  public static void main(String[] args) {
    // define your main function here 
  }

  // define your method length here 
}

Last modified: Apr 25, 2000 for A201 by Adrian German