you cant pass functions as parameters in processing or in Java in general i dont think. But in processing all of your code in all of your classes get compiled into 1 big jumble so you can call variables and functions in the main applet file from any class.

Ex

1. //main Applet
2. void setup(){
3. }
4. void draw(){
5. }
6. void functionInMain(){
7.       println("function in main applet");
8. }
9. //class fine
10. class MyClass{
11.       MyClass(){
12.             functionInMain();//this will call that function from the main applet
13.       }
14. }

so in your code in the processing IDE you should be able to do something like this :

1. //g function in some the main applet
2. void g(){
3.       println("calling g from the main applet");
4. }
5. void timer(){
6.   static long prev = 0;
7.   if (millis() - prev >= interval){
8.     g();
9.     prev = millis();
10.   }
11. }

hope this helps

Yes, in Java, you cannot pass a function or a reference to a function. Usually, you make a class (or an interface) to wrap the function. That's the case of the Comparator interface, to name only one commonly used here. A bit verbose / heavy, but it works.

Is there a reason why you cant just create it as a global variable and access it every time you run the function?

1. final long prev = 0;
   
2. void setup(){
3. }
4. 
   
5. void draw(){
6. }
7. 
   
8. void timer(){
9.   prev = 0;
10.   if (millis() - prev >= interval){
11.     g();
12.     prev = millis();
13.   }
14. }

that way its accessible from anywhere and you can choose only to let the timer function use it in your code if you want.

An example illustrating the common pattern used in Java. Usage of reflection is actually quite rare...

interface TimerCallback
{
  int getPrev();
  void reset();
  void execute();
}

abstract class BaseTimerCallback implements TimerCallback
{
  private int prev;
  
  int getPrev() { return prev; }
  void reset() { prev = millis(); }
  // execute must be defined by sub-classes
}

TimerCallback tcb1 = new BaseTimerCallback()
{
  void execute() { println("T1"); }
};
TimerCallback tcb2 = new BaseTimerCallback()
{
  void execute() { println("T2"); }
};

final int INTERVAL = 1000;

void setup()
{
}

void draw()
{
  timer(tcb1);
  timer(tcb2);
}

void timer(TimerCallback callback)
{
  if (millis() - callback.getPrev() >= INTERVAL)
  {
    callback.execute();
    callback.reset();
  }
}

The interface defines what methods are available in such classes. The abstract class defines the functions (and some fields) common to all theses classes. We create specialized classes with the treatment specific to each one. Then we can invoke each class.
We can put a specific interval to each class, but I was trying to illustrate a simple callback scheme. Actually, we could even move timer() in the abstract class, it would be more the OO way.

1. 
   /** Millis
   By dkl65 on Arduino Forum
   This code delays a println statement in the draw by an array of
   time to "wait". You can do other random things while the println
   is "waiting" to run again. The loop println the number of ms
   elapsed. This code is for Processing.
   */
   //Array of ms intervals to "wait"
   int interval[] = {5000, 2000, 800, 1000};
   long mill; //store the current millis
   long prev = 0; //store the previous millis
   byte index = 0; //the index number of intervals
   //store the number of times to println(mill-prev); in draw
   byte counter = 0;
   void setup(){
     println(mill-prev+"!!!"); //BEGIN!!!
   }
   void draw(){
     mill = millis(); //initiate the current millis
     //if interval[index] ms has passed, and ran less than 9 times
     if (mill - prev >= interval[index] && counter < 8){
       println(mill-prev);
       prev = mill;
       index++;
       //go back to the beginning of the array
       if (index > 3) index = 0;
       //you will see 8 ms elapsed lines in the console
       counter++;
     }
     if (counter == 8){
       println("DONE!!!");
       counter = 9; //Never run this function again!
     }
   }

This is my original sketch. I wanted to make it more compact, so I can easily copy it, and use it in other sketches. What I'm doing here is executing a function (i.e. println(mill-prev);) every interval, without delay(). Here, I am "waiting" for an array on intervals! I will probably have to use it in other sketches. It is easier in Arduino. I have more experience with Arduino, but less with Processing.