Question

Ok, assume I have a class, X and X is something which has an aggregate relationship with other objects. Lets pretend X is a soccer stadium.

X is full of class spectators. However, the behaviour of each spectator for a particular activity differs. Instead of IF statements, I want the different behaviour to be within the spectator class, so that I can use dynamic binding.

However, the problem is that the behaviour the spectator performs affects the “soccer stadium” class. So I was thinking of passing “this” from the soccer stadium class, through a method, to the Spectator class, so that the spectator class can do something to the Soccer Stadium class?

public class SoccerStadium{
    SpecatorInterface s = new Spectator();

    public void SpectatorBehaviour(){
        s.doSomething(this);
    }

    public void doSomethingthingBySpecator(){
    }
}

public class Spectator implements SpecatorInterface{
    public void doSomething(SoccerStadium s){
        s.doSomethingthingBySpecator();
    }
}

I only want to do this so that I can use dynamic binding and alter the behaviour in Specator.doSomething() so that I can have lots of different types of SpectatorSuperClass as an attribute passed to SoccerStadium and then have the different behaviour.

EDIT: What if I passed the reference of the Stadium to the Specator through the Spectator constructor, instead of passing this?

Answer 1

Your implementation is absolutely fine, I have seen that kind of thing before. Yes you can hold on to the Stadium reference, by passing it through the Spectator constructor, that would probably be cleaner than sending through the reference every time you need it.

However, I don’t like it very much; I prefer inner classes. It’s not completely clear what you’re trying to do, but something like this is possible:

public class Outer {

private int someVariable=0;

public void someMethod(){
    ExtendsInner ei = new ExtendsInner();
    ei.innerMethod();
    System.out.println(someVariable);
}

private void anotherMethod(){
    someVariable++;
}

public abstract class Inner {
    public abstract void innerMethod();
}

public class ExtendsInner extends Inner{
    public void innerMethod(){
        anotherMethod();
        someVariable++;
    }
}

public static void main(String[] args){
    Outer o = new Outer();
    o.someMethod();
}
}

Unfortunately, you would then have to have all of your “spectator” classes inside your other class, which could lead to one really long file, and thus, ugly code.

However, I think you should definitely avoid doing both things, as it will most definitely make your code overly complicated.