4. Thursday(12/03): Review of Java Classes and Methods. Writing the

FindMaxValue class. Prog7_01 Maximum Value of a Function in a Given

Interval. Here is the code that uses the FindMaxValue class.

HW: Finish Prog7_01 from class and turn-in tomorrow.

5. Friday(12/04): Prog7_02 Analysis of the Path of a Projectile.

HW: Finish Prog7_02 from class and turn-in tomorrow.

6. Monday(12/07): Writing Classes for Statistical Applications. The

MeanFinder, Median Finder, and ModeFinder classes. Prog7_03 Finding

the Mean, Median, and Mode. HW: Finish Prog7_03 from class and turn-in

tomorrow.

7. Tuesday(12/08): Writing the Variance class. Prog7_04 Finding the

Variance and Standard Deviation from a data set. HW: Finish Prog7_04

from class and turn-in tomorrow.

8. Wednesday(12/09): Writing the Permutation and Combination

classes. Prog7_05 Permutations and Combinations. HW: Finish Prog7_05

from class and turn-in tomorrow.

9. Thursday(12/10): Writing the Poisson Probability class.

Prog7_06 Calculating Poisson Probabilities. HW: Finish Prog7_06 from

class and turn-in tomorrow.

10. Friday(12/11): Writing the Hypergeometric Random Variable class.

Prog7_07 The Hypergeometric Random Variable. HW: Finish Prog7_07 from

class and turn-in Monday.

4. MONDAY(12/14): Review I for Semester Exam. All assigned

Homework Programs due, NO Exceptions. HW: Complete Review

Handout. Semester Folder check (50 pts.) due, NO Exceptions, during

your Semester Exam. 

5. TUESDAY(12/15): Period 1 Semester Exam. Shortened classes for

Periods 2-7. Review II for Semester Exam. HW: Study for Semester Exams.

6. WEDNESDAY(12/16): Late Start (10:30). Period 2 & 3 Semester

Exams. HW: Study for Semester Exams.

7. THURSDAY(12/17): Late Start (10:30). Period 4 & 5 Semester

Exams. HW: Study for Semester Exams.

8. FRIDAY(12/18): Late Start (10:30). Period 6 & 7 Semester Exams.

class Sphere {
static final double PI = 3.14;
static int count = 0;

double radius;

double xCenter, yCenter, zCenter;

Sphere(double theRadius, double x, double y, double z) {
radius = theRadius;

xCenter = x; yCenter = y; zCenter = z;
count++;
}

static int getCount() {
return count;
}

double volume() {
return 4.0 / 3.0 * PI * Math.pow(radius, 3);
}
}

Which is accessed by the program CreateSpheres:

public class CreateSpheres
{
public static void main (String[]args)
 {
    System.out.println("Number of Objects: " + Sphere.getCount());

    Sphere ball = new Sphere(4.0,0.0,0.0,0.0);
    System.out.println("Number of Objects: " + Sphere.getCount());

    Sphere globe = new Sphere(12.0,1.0,1.0,1.0);
    System.out.println("Number of Objects: " + Sphere.getCount());

//Volume
    System.out.println("Ball volume: " + ball.volume());
    System.out.println("Globe volume: " + globe.volume());
    }
}

Types of methods.

There are two types of methods.

(1) Instance methods are associated with an object and use the instance

variables of that object. This is the default.

(2) Static methods use no instance variables of any object of the class they

are defined in. If you define a method to be static, you will be given a rude

message by the compiler if you try to access any instance variables. You can

access static variables, but except for constants, this is unusual. Static

methods typically take all they data from parameters and compute something

from those parameters, with no reference to variables. This is typical of

methods which do some kind of generic calculation. A good example of this

are the many utility methods in the predefined Math class.

(See Math and java.util.Random).

Below is the program that finds the maximum value of a function in an interval.

From outside the defining class, an instance method is called by prefixing it

with an object, which is then passed as an implicit parameter to the instance

method,  inputTF.setText("");

A static method is called by prefixing it with a class name,  Math.max(i,j);.

Curiously, it can also be qualified with an object, which will be ignored, but

the class of the object will be used.

Example

Here is a typical static method.

class MyUtils {
    . . .
    //================================================= mean
    public static double mean(int[] p) {
        int sum = 0;  // sum of all the elements
        for (int i=0; i<p.length; i++) {
            sum += p[i];
        }
        return ((double)sum) / p.length;
    }//endmethod mean
    . . .
}

The only data this method uses or changes is from parameters (or local

variables of course).

Why declare a method static

The above mean() method would work just as well if it wasn't declared static,

as long as it was called from within the same class. If called from outside the

class and it wasn't declared static, it would have to be qualified (uselessly)

with an object. Even when used within the class, there are good reasons to

define a method as static when it could be.

(1) Documentation. Anyone seeing that a method is static will know how to

call it (see below). Similarly, any programmer looking at the code will know

that a static method can't interact with instance variables, which makes

reading and debugging easier.

(2) Efficiency. A compiler will usually produce slightly more efficient code

because no implicit object parameter has to be passed to the method.

Here is an example:

public class IndexFinder {

public static int find(int[] b, int num) {
     for (int j=0; j < b.length; j++) {
        if (b[j] == num) return j;
        }
        return -1;
        }

public static void main(String[] args) {
int index;
int a[] = {1, 3, 5, 7, 4, 5, 6, 9, 2, 0};
        for (int k=0; k < a.length; k++) {
            index = find(a, k);
            System.out.println("For " + k + " index is " + index);
            }
        }
}