Try making Object5 an interface rather than a class - see code below it works.

1. class Object1 {
2.     int type;
3.     Object5 obj2;
4.     Object1 (int typein) {
5.         type = typein;
6.         switch (type) {
7.             case 0:
8.             obj2 = new Object3();
9.             break;
10.             case 1:
11.             obj2 = new Object4();
12.             break;
13.         }
14.     }
15.     void put(){
16.         obj2.put();
17.     }
18. }
19.  
20. interface Object5 {
21.    void put();
22. }
23.  
24. class Object3 implements Object5 {
25.     int foo;
26.     Object3 () {
27.         foo = floor(random(10));
28.     }
29.     void put(){
30.         text(foo,10,10);
31.     }
32. }
33.  
34. class Object4 implements Object5 {
35.     float bar;
36.     Object4 () {
37.         bar = random(10);
38.     }
39.     void put(){
40.         text(round(bar),10,10);
41.     }
42. }

Thanks!  To move on from the abstract a little, I'm having an issue when obj2 contains ArrayLists of varying types, as below.  The error I receive is "things cannot be resolved or is not a field".  As before, if there is a better way to do this I'd love to hear it.  Thanks again.

You seem to be sticking to your original idea of using inheritence/polymorphism so lets discuss that

obj2 is a reference to a class called Object5
a reference can refer to any object of that class (Object5) or any class that inherits from it (Object3 & Object4)

so as you have discovered both these are valid statements
obj2 = new Object3();
obj2 = new Object4();
and so is this
obj2 = new Object5();

BUT you cannot use obj2 to access methods in child classes (Object3 & Object4) unless they override a method in the parent (Object5) class so to execute statements such as
obj2.put();
you need to modify the parent class like this.

1. class Object5 {
2.       Object5(){
3.       }
4. 
   
5.       void put(){
6.       }
7. }

Now when you do

obj2.put();

it will use polymorphism to execute the put() method in the right class (Object3 or Object4)

The fact that you now want arraylist of different types of object in the 2 child classes is a cause for concern. Inheritance is more than just a way of organising code it defines a relationship between the classes, in this case 'a kind of' relationship.

For instance we might have a class called Animal and it has an attribute called hunger. Now when hunger gets high there is a method called eat() which reduces hunger. Now we could have 2 more classes called Horse and Lion they are both types of Animal and they can both get hungry and both can eat, but they eat different things.

Since Horse and Lion are types of Animal they can inherit from (extend) the Animal class, The child classes do not need an attribute called hunger beccause they inherit it from Animal but they need there own eat method. In Java this would look like.

1. class Animal {
2.       int hunger = 100; // max humgry
3. 
   
4.       void eat(){}
5. }
6. 
   
7. class Horse extends Animal {
8.       void eat(){
9.             println("Some nice grass here!");
10.             hunger -= 12;
11.       }
12. }
13. 
    
14. class Lion extends Animal {
15.       void eat(){
16.             println("No horse shame will have to make do with rabbit");
17.             hunger-= 6;
18.       }
19. }

Then this will work

1. void setup(){
2.   Animal a = new Horse();
3.   a.eat();
4.   ArrayList<Animal> animals = new ArrayList<Animal>();
5.   animals.add(a);
6. }

Your description is too abstract and I suspect there is no kind of relationship between class Object3 and Object4 with Object5.

 

Whoops, no, I just copied my code instead of yours... I am doing it this way:

In reality, they are different display functions depending on the type of Object1

In that case the interface approach is the more appropriate way to go. Unlike C++ the developers of Java decided on having just single inheritance (i.e. a class can only extend from one other class). To get round this they introduced the interface and allowed a class to implement multiple intefaces.

Unlike inheritance an interface does not always represent a relationship between classes but rather identifies common behaviour. In your example Object3 and Object4 do the same kind of thing i.e. they draw to the screen.

The interface can only hold constant values (those marked as final) and method signatures (methods without the implementation) so in this code Object5 is an interface with just one method signature.

1. interface Object5 {
2.     void put();
3. }

Any class that implements Object5 must provide fthe implementation for this method.

Using an interface means that you cannot directly access the arraylists inside the classes, you can only access the methods specified in the inteface.

To add something to your Arralist modify the classes likes this

1. interface Object5 {
2.     void put();
3.          void addObject(Object obj);
   
4. }
5.  
6. class Object3 implements Object5 {
7.     int foo;
8.     ArrayList<Thing> things;
9. 
   
10.     Object3 () {
11.         things = new ArrayList<Thing>();
12.         foo = floor(random(10));
13.     }
14. 
    
15.     void put(){
16.         text(foo,10,10);
17.     }
18. 
    
19.     void addObject(Object obj){
20.          things.add( (Thing)obj );
21.     }
    
22. }
23.  
24. class Object4 implements Object5 {
25.     ArrayList<Stuff> stuffs;
26.     float bar;
27. 
    
28.     Object4 () {
29.         stuffs= new ArrayList<Stuff>();
30.         bar = random(10);
31.     }
32. 
    
33.     void put(){
34.         text(round(bar),10,10);
35.     }
36. 
    
37.     void addObject(Object obj){
38.          stuffs.add( (Stuff)obj );
39.     }
    
40. }
    

There would be a simpler way of doing it depending on the realtionship between Thing and Stuff.

More info on interfaces can be found here.

Thanks quarks, I suspected the way to go was custom add() methods but I was hoping not to have to go that route. :D

As a follow-up, I think I'm just going to implement an ArrayList of the interface rather than have separate objects with internal ArrayLists.

As a follow-up, I think I'm just going to implement an ArrayList of the interface rather than have separate objects with internal ArrayLists.

That sounds like a good direction to go in.