What is your goal?
void is reserved for functions. Making an array of nothingness doesn't make much sense.
You can make an empty array, but it must have some type.

There is the type Void

err.....

void is used with a function.

It means empty / return no value.

e.g. print Hello:

1. void printHello () {
2.      println ("Hello");
3. }

This function does something but it returns nothing.
You call it with

1. printHello ();

You can also give values to a function

1. void printNumber ( int a ) {
2.      println ( a );
3. }

you call it by

1. printNumber (9 );

It returns nothing (void).
9 is called a parameter in the function and it gets into the var a within the function. a is the parameter.
You can give different parameters like 9, 10, 11 etc.
You can write functions that get more than one parameter.


now when you have a function that adds 5 to any given number you return a number:

1. int addValue5 ( int x ) {
2.     return x + 5;
3. }

you call it by using the return value, e.g.

1. println (addValue5 ( 6 ) );

This is a function more in a mathematical sense: you give a value and you get a value back.
Note that void is replaced by int a the beginning of the line int addValue5 (....  above

Now maybe you confuse array and function?

You can call a function with all different parameters


see
http://www.processing.org/reference/void.html

http://www.processing.org/learning/basics/functions.html

Hi,

here you can have different values for waiting

(only one alarm)

1. int alarmCounter;
2. void setup() {
3.   setAlarm (160);
4. }
5. void draw() {
6.   if (alarmCounter > 0 )
7.   {
8.     alarmCounter--;
9.   }
10.   else if (alarmCounter == 0 ) {
11.     println ("Alarm");
12.     alarmCounter = -1;
13.   }
14. }
15. void setAlarm ( int a) {
16.   alarmCounter = a;
17. }
18. //

this has many alarms

• and each alarm can have a different duration and
• a different function what to do (denoted by an int you have to pass through "executeEvent")

Note that we have :

• one function to set an alarm and
• one function to execute the alarm and
• two arrays of type int (not void) to save the alarms (later we could have a class Alarm)

1. int[] alarmCounter = new int [100];
2. int[] alarmCounterEvents = new int [100];
3. int whichCounter = 0;
4. //
5. void setup() {
6.   size ( 700, 700);
7.   setAlarm ( 160, 0 );
8.   setAlarm ( 110, 1 );
9.   fill(0);
10. }
11. //
12. void draw() {
13.   for (int i = 0; i < whichCounter; i++) {
14.     if (alarmCounter[i] > 0 )
15.     {
16.       // still running
    
17.       alarmCounter[i]--;
18.     }
19.     else if (alarmCounter[i] == 0 )
    
20.     {
21.       // over
    
22.       println ("Alarm");
23.       executeEvent ( alarmCounterEvents[i] );  // excute
    
24.       alarmCounter[i] = -1;    // set to dead
    
25.     }
26.   } // for
27. } // func
    
28. //
29. void executeEvent ( int eventNumber ) {
30.   switch ( eventNumber ) {
31.   case 0:
32.     text("K", 30, 300);
33.     break;
34.   case 1:
35.     text("J", 330, 300);
36.     break;
37.   default:
38.     println ("Unknown event");
39.     break;
40.   } // switch
41. } // func
42. //
43. void setAlarm ( int a, int event ) {
44.   //
45.   alarmCounter[whichCounter] = a;
46.   alarmCounterEvents[whichCounter] = event ;
47.   whichCounter++;
48. }
49. //

You have to make an Alarm class which you can derive in specialized classes, each having the task to execute, in the form of a method to override.
Thus, you can store the instances of this class in an array, loop over the array to decrease the counter, and when the counter of a given alarm instance reaches zero, you can run the function it has.

Quick illustration of the above:

1. abstract class Alarm
2. {
3.   int count;
4.   Alarm(int count)
5.   {
6.     this.count = count;
7.   }
8.   abstract void run(); // To override
9.   void tick()
10.   {
11.     if (--count < 0)
12.       return;
13.     println("tick " + count);
14.     if (count == 0)
15.     {
16.       run();
17.     }
18.   }
19. }
20. 
    
21. Alarm[] alarms =
22. {
23.   new Alarm(5) { void run() { println("I do stuff"); } },
24.   new Alarm(10) { void run() { println("I do other stuff"); } },
25. };
26. 
    
27. void draw()
28. {
29.   for (Alarm alarm : alarms)
30.   {
31.     alarm.tick();
32.   }
33. }

You can add refinement like restarting the count, etc.

In short, in Java, you don't store directly functions, but rather instances of objects wrapping the functions.
This will change in Java 8, but so far, that's the way Java works.

Sorry for the late reply, but thanks everyone for helping out... I'll see what I can do!