You can use arrays - or ArrayLists - to store your objects.

1. ArrayList points, segments, triangles;
2. ArrayList  objects;
3. 
   
4. void mouseClicked() {
5.   Point p = new Point(mouseX, mouseY);
6.   points.add(p);
7.   objects.add(p);
8.   println("There are " + points.size() + " points.");
9.   println("There are " + objects.size() + " objects.");
10. }

Your code doesn't make a great deal of sense to me.  It looks like your main class contains variables that are actually specific to the subclasses?  What you should do is define shared properties and methods in the main class and then specify specific properties and methods in the subclasses.  Then you can properly enjoy the benefits of extending a class...  and it will make your code much more readable.

If your motivation for doing this was to manage multiple objects then, as antiplastik suggests, using a container to store them is a much more standard approach.  Here's a quick example with a main class and one sub-class and using an ArrayList to manage multiple objects:

1. ArrayList points;
2. 
   
3. void setup() {
4.  size(400,400);
5.  points = new ArrayList();
6.  smooth();
7. }
8. 
   
9. void draw() {
10.   background(0);
11.  
12.   for(int i=0; i<points.size(); i++){
13.     // Getting a reference to an Object in an ArrayList is a little more tricky than when using an array:
14.     Point2d thisPoint = (Point2d) points.get(i);
15.     thisPoint.display();
16.   }
17. }
18. 
    
19. void mousePressed() {
20.   // create a new point and add it to the ArrayList:
    
21.   points.add(new Point2d(255, 3, mouseX, mouseY));
22. }
23. 
    
24. // - - main class - - //
25. class MainObject {
26.  // properties that belong to all sub-classes
    
27.  int colour;
28.  int weight;
29.  
30.  // constructor
31.  MainObject(int colour, int weight) {
32.   this.colour = colour;
33.   this.weight = weight;
34.  }
35.  
36.   // add common methods
37.   void setWeight(int weight){
38.     this.weight = weight;
    
39.   }
40.   // etc...
    
41. }
42. 
    
43. // - - sub class - - //
44. class Point2d extends MainObject {
45.   // subclass specific properties
    
46.   int x;
47.   int y;
48.  
49.   // constructor
50.   Point2d(int colour, int weight, int x, int y) {
51.     // When extending a main class you can just call its constructor with super()
52.     super(colour,weight);
53.     // Then you can set the properties of the subclass
54.     this.x = x;
55.     this.y = y;
56.    
57.     println("Point2d: " + x + "/" + y);
58.   }
59.  
    
60.   // subclass specific methods...
    
61.   void display() {
62.     fill(colour);
63.     noStroke();
64.     ellipseMode(CENTER);
65.     ellipse(x,y,weight,weight);
66.   }
67. }
68. 
    

Just in case you're wondering, using:  this.property = property;  is a convention that I prefer over property = mangledProperty; though this is just a matter of taste ;)

Might be a bit hard if you begin... you'll need to iterate over every object to check whether the mouse is over or out, so you know exactly which objects are under the cursor and then you can launch appropriate events.

Your classes need something like a contains(float x, float y) method to check if the mouse if inside or outside of the shape.

Some libraries (like the picking library) might help, though.

Well - you have to think about which class should be handling each step of the process.  Since drawing of your subclass depends very much on what it represents, and the shape of the object determines when the mouse is over it, both these tasks should be handled in the subclass.  But the actual changing of colour might be considered 'generic' and could be handled in the parent class.

I made a few quick changes to my previous example to demonstrate this:

1. ArrayList points;
2. 
   
3. void setup() {
4.  size(400,400);
5.  points = new ArrayList();
6.  smooth();
7. }
8. 
   
9. void draw() {
10.   background(0);
11.  
12.   for(int i=0; i<points.size(); i++){
13.     // Getting a reference to an Object in an ArrayList is a little more tricky than when using an array:
14.     Point2d thisPoint = (Point2d) points.get(i);
15.     thisPoint.display();
16.   }
17. }
18. 
    
19. void mousePressed() {
20.   // create a new point and add it to the ArrayList:
21.   points.add(new Point2d(255, 10, mouseX, mouseY));
22. }
23. 
    
24. // - - main class - - //
25. abstract class MainObject {
26.  // properties that belong to all sub-classes
27.  int colour;
28.  int weight;
29.  int colourOver = #ff9900;
30.  
31.  // constructor
32.  MainObject(int colour, int weight) {
33.   this.colour = colour;
34.   this.weight = weight;
35.  }
36.  
37.   // add common methods
38.   void setWeight(int weight){
39.     this.weight = weight;
40.   }
41.  
42.   void display() {
43.     if(mouseOver()){
44.       fill(colourOver);
45.     }
46.     else {
47.       fill(colour);
48.     }
49.     drawObject();
50.   }
51. 
    
52.   // abstract methods must be defined in the subclass  
53.   // so in this case you know you need something to return true when the mouse
54.   // is over your subclass object, but since you don't know what shape a subclass might be
55.   // the implementation has to be handled in the subclass
56.   abstract boolean mouseOver();
57.   // as must the drawing of the object
58.   abstract void drawObject(); 
59. }
60. 
    
61. // - - sub class - - //
62. class Point2d extends MainObject {
63.   // subclass specific properties
64.   int x;
65.   int y;
66.  
67.   // constructor
68.   Point2d(int colour, int weight, int x, int y) {
69.     // When extending a main class you can just call its constructor with super()
70.     super(colour,weight);
71.     // Then you can set the properties of the subclass
72.     this.x = x;
73.     this.y = y;
74.    
75.     println("Point2d: " + x + "/" + y);
76.   }
77.  
78.   // implementation of abstract methods
79.   boolean mouseOver(){
80.     float dx = x-mouseX;
81.     float dy = y-mouseY;
82.     float deltaSquared = dx*dx + dy*dy;
83.     return (deltaSquared < weight*weight);
84.   }
85. 
    
86.   void drawObject() {  
87.     noStroke();
88.     ellipseMode(RADIUS);
89.     ellipse(x,y,weight,weight);
90.   }
91.  
92.   // subclass specific methods... 
93.  
94. }

You'll see that I've declared the main class as 'abstract'.  I'm assuming that you'll never want to create an instance of the main class and it's just being used to define common properties and methods of the subclasses.  Declaring methods as abstract means that they must be implemented in the sub-class or you'll get a compile error.  That means you can't forget to implement them ;)

Ah - well I was answering the question in terms of the class structure; so keeping things relatively simple.  Checking mouseOver with 3D objects is non-trivial as you have to calculate whether the mouse is over the 2D rendered position; so no it's not a simple matter of comparing 3d coordinates!

This is however a question that's been addressed in the old forums (search them ) and I believe may be handled by some of the libraries.  Once you find a solution you can drop it into the mouseOver() method of your subclass...

The colour parameter in the main class is set up to a default value. It's just in case in won't be set up later.

Notice that the Point2D's constructor overrides this colour parameter :

1. Point2d(int colour, ...) {
2.   super(colour, weight);
3.   ...
4. }

So you need to change the colour at the moment you are instanciating your new object :

1. points.add(new Point2d(255, 3, mouseX, mouseY));

My code works fine; you just don't understand it

MainClass has a constructor that takes two arguments: colour and weight.  The subclass calls this constructor using super(colour, weight).  Your changes set a default value for colour in the main class, but these are immediately overridden when you instantiate an object as colour is passed to and set by the constructor.

The whole point of doing that is to allow you to change the colour when you instantiate the object.  So you could replace the current mousePressed() code with the following:

1. void mousePressed() {
2.   // generate a new random colour:
3.   int r = 100 + (int) random(155);
4.   int g = 100 + (int) random(155);
5.   int b = 100 + (int) random(155);
6.   color newColour = color(r,g,b);
7.   // you can get away with passing a variable of type 'color' to the constructor because 'color' resolves to an int
8.   points.add(new Point2d(newColour, 10, mouseX, mouseY));
9. }

If you wanted to set the colour in the main class then you'd need to remove the colour argument from the constructor, or create a separate constructor that doesn't take a colour argument (Java allows you to define multiple constructors for a class).