You definitely don't want multiple classes for these objects -- a single class is perfect when you have many objects which share functionality but differ in certain areas.

I think you will want a class that has a "charName" variable to store the character it represents.  When you generate the list of objects of that class, each instance should be given its own character.  This leads to the question: "how does the computer know the alphabet?"  It doesn't, unless there's a special Java function I'm unaware of, so you'll have to teach it:

char[] alphabet=new char{'a','b','c','d' ......etc.};
// now alphabet[0] == 'a',  and alphabet[25] == 'z'.

keyObject[] myObjects = new keyObject[26];

void setup(){
  for (int i = 0; i < myObjects.length; i++){
     myObject[i] = new keyObject(alphabet[i]);
     // translation: running from 0 to 25, create each keyObject with the corresponding letter from the alphabet[] list.
  }
}

class keyObject{
  char charName;
  int pressNum;
  keyObject(char passChar){
     charName = passChar;
     // this allows setup() to pass characters to each object.
  }
}

Once you have your 26 objects, you can trap keyPresses simply, like this:

void keyPressed(){
  for (int i = 0; i < alphabet.length; i++){
     if (Char.toLowerCase(key) == alphabet[i]){
        myObjects[i].pressNum ++;
     }
  }
}

the Char.toLowerCase('x') is a Java function that will help avoid problems with the shift key or caps lock.  "key" in this case is a character equal to whatever just got pressed, for instance you can add: println (key); to see the output reported unmodified.

There are a lot of other puzzles left in this project, but this should get you started.

--Ben

Ok.  The "if objects of id xxx are touching objects of id yy" suggests you might want to look into a hashmap...but to start, you can use a Vector or ArrayList -- both are arrays of flexible size.  E.g.:

Vector mythings = new Vector();
mythings.add(new thing(thingvariables));
for (int i=0;i<things.size();i++){
  ((thing)things.get(i)).update();
}
other useful commands:
things.remove(this);
things.clear();
...
and to check to see whether objects of id xxx are touching objects of id yy, run through them in a double loop.  (This is where hashmaps are more efficient.)  But in this example:
for (int i=0;i<mythings.size();i++){
 for (int j=i;j<mythings.size();j++){
   if (j is touching i) (tell object j and i about it);
 }
}
the 'j=i' is a simple optimization: don't check the inner loop against objects that were already checked in the outer loop.
--Ben

No problem --
a class is mostly useful for the creation of multiple instances with slight variations.  So your structure might look like:

Vector myobjects = new Vector(); // declare an (empty) vector to hold your objects

[setup stuff]

draw{
 update all your objects
}

keyPressed / mousePressed / whanot{
 add a new object with the appropriate variables
}

class object{
 declare class-owned variables
 object( accept passed variables here){
    put passed vars into appropriate class-owned variables
 }
 void update(){
    this is how each object updates itself
 }
}

You can make separate groups of multiple "circle" objects using separate Vectors:

Vector redCircles = new Vector();
Vector blueCircles = new Vector();
Vector yellowCircles = new Vector();

but you aren't going to escape the nested loop structure I mentioned in the post before last.  In this case:

for (all redCircles)
 check against blue and yellow circles

for (all blueCircles)
  check against yellow circles

I hope it is clear that this is the same structure as the double loop example with the "i" and "j" variables.  This a relatively inefficient way to deal with large numbers of objects, but it shouldn't slow you down, and it's relatively easy to code.  So, in the "i" and "j" example, the only part you need to add is a conditional: if these objects are not the same color, check their distances and see if they are colliding.  That way you could keep everything in a single Vector.

for (int i=0;i<mythings.size();i++){
  for (int j=i;j<mythings.size();j++){
     if ((j.color != i.color) && (j is touching i)) (tell object j and i about it);
   }
}