Sequential and multiple method calls? (Command/Runnable/Enums)

Newbie & Debugging Questions
#1

So I was watching someone else program in actionscript. And I have never really had a desire or great use to use function pointers( pass a method as an argument) and they were using an array to pass special effects to some graphic/text things, the special effects were usually simple 2-5 line function/methods and it just seemed so easy, without my typical method of having a ton of boolean statements everywhere.

However after seeing them do some things quite conveniently, I was hoping to find an alternative.
In my case I just wanted to be able to do it to handle certain ‘effects’ that I can add/remove from an update/scripts list

Here is just a random limited example.

logo


scripts.add(new fade());		
}

ArrayList<functionPointer> scripts = new ArrayList<functionPointer>();
public float alpha;
	
public class fadeOut implements functionPointer{
	@Override
	public void execute() {
		alpha=-.01f;
	}
}
public class fade implements functionPointer{
	@Override
	public void execute() {
		alpha+=.01f;
		if(alpha >= 1){
			scripts.remove(this);
			scripts.add(new fadeOut());
		}
	}
}

public void someUpdateFunction(){
	for(functionPointer fp : scripts){
		fp.execute();
	}
}

Then of course
functionPointer.java



public interface functionPointer {
	public void execute();
}

Would there be a better way of doing this?

Essentially whats a good way to embed possibly sequential and/or concurrent methods to be utilized by the same class in several areas that need to come and go.
Alternatively, I could have a lot of embedded if/else and boolean statements and other conditionals all over the place.

Maybe there is something out there that would work a lot better that I just don’t know about? (Some sort of event/script/callback manager) thingy?

#2

Java 8 will have built-in support for passing methods as arguments. :wink:

#3

Your method is appropriate, it is called the Command Pattern.

Really?

#4

Aha! Brilliant thanks!

Command is a better name the functionPointer :smiley:

#5

Yup. They are calling them Lambda Expressions.

Java Dzone article
Oracle tutorial.

#6

Well Lambda Expressions are nothing new, although incorporating them into Java will be interesting.

#7

Use enums. Enums can have abstract methods, in which case you define one method per enum value. Or you can use enums in a switch statement (inside an enum method or outside the enum class.)

Your work will be much easier with enums because you can name your effects. (Glow, Fade, Sparkle, Shrink, Explode, etc.) If you want to modify an effect you change it in one place instead of half a dozen. Your IDE will also support enums better. You can use autocompletion, usage searches, and refactoring tools. The IDE will warn your of missing case statements. And you can configure it to automatically create a full switch, case, break, default block.

Edit: Unlike interface instances they can be compared using ==, do not create garbage, and can be used with the singleton pattern. The only downside is they cannot be created dynamically and everything has to appear in the same file. (Unless they call a static function in another class.) The latter could be addressed using a tool that merges several text files. The former is not often useful but maybe could be done using a class loading hack, but the dynamic part defeats the benefits of non-dynamic IDE features.

Edit 2: Enums can implement interfaces. I think that means you could create separate class files, do dynamic class loading, and treat them like Objects. If you wanted to use it in a switch you would have to cast it. (Or use int constants)

#8

Your “functionpointer” interface already exists in the forms of Runnable and Callable, both of which will benefit from some syntax sugar in 1.8. But if you have a fixed set of commands, you’re better off using an Enum. There’s nothing stopping you from making your enum implement an interface itself if you think you might need custom implementations, which is how I did BlendMode in JCOD

#9

So I have been trying to use enums, however I am having issues with variable access

When I make the enum and trying to access the classes variable, lets say alpha, x, or y. IT wants it to be a static access, however I can’t do that given how I want to set the things up. Since there might be multiple instances of the class.

Any suggestions? Because I like the style/appearance enums has, especially with the reduction of garbage.

edit: or how do I force the enum inside my class to not be static?

#10

I’ve never seen the error you are talking about. Are you using enums as a singleton with a state? You want the enum to represent the method to perform on the data and not to store data itself. Pass the data as a parameter. It should work, otherwise you would not be able to use enum’s equals method. Enum has very strange syntax, it’s possible you made a mistake. Post the code if you want.

Edit:

Did you make the enum an inner class of something else? You won’t be able to use it with other classes if you make it non-static and if you make it static it will give you the same error that a static inner class accessing an outer class. (There is no OuterClass.this reference for static classes while there is for non-static inner classes. Static inner classes require a reference since it is not implicit.)

I don’t recommend using innner classes for this purpose.

#11

I was taking a look at this earlier actually Im not sure but I think you can do it with the .getClass().getMethods(); function aswell.

#12

You could, but it creates more than one object (which is more than zero), there is no parameter type checking on invoke, it’s slower, and method.invoke() is less clear than interface.method().

#13

So while this isn’t exactly the use case I wnat. I think its a good enough example and fully functioning one.

main GdxGame file
http://pastebin.com/8H0ewZnj

Logo.java
http://pastebin.com/AZTgzWbD
First I have it run 2 things pseudo-concurrently, then they are both removed, and 1 is called at the end of one of them to run indefinitely until that object is removed.

The only other solution I can think of is creating a whole other set of classes and an entire system which depends upon Logo extending or implementing certain interfaces or a base class(Entity) that has things such as alpha and position in them.
Then set up a whole system with variable input and output to handle it.
Or for the 3-4 places I want it, I just throw in a short quick semi hardcoded solution.

Either way I was trying to not have a whole other class to handle this 1 class.
I also didn’t want to create an entire dynamic tween/manipulator set of classes to handle a more ‘robust’ system (which although would be great longer term) I am just looking to apply it to a few small areas.

If there is a better/simpler way of setting this up, then my provided example. Please let me know.

#14

Hmm… Computer programs consist of two basic units; data and code. Data is accessed statically via named variables and named functions and dynamically through pointers and function pointers. In object oriented programming, the things called objects are bundles of data with operations associated with them. Objects combine data and code into one variable or pointer.

If you have N objects and 1 effect but the effect require extra state data which is not stored in the original objects, you still need N places to store the extra state data even though there is only 1 effect. Function pointers are stateless.
There are three ways to fix it.

  1. Take the state data out of the effect and put it into the object it affects. (Use one object and one function pointer.)
  2. Leave the effect state data in the Effect object. Reference the affected object int the effect object and vica versa. (Use one additional object per effect/entity pair.)
  3. Merge the state data for all effects into the super class of the class it affects. (Use one object and bad design practices.)

To simplify the following definitions, assume that static variables are not used. (Mutable global variables are bad practice anyways.)
Data variables store values and do nothing on their own.
Functions represent code. They do nothing without data to work on.
Objects store both of the above.

Objects have an implicit this reference. If you rely on having that reference as your code does, you are using your class as an object not a “function pointer”.

public enum Effect implements Whatever
{
// public abstract void doEffect(); // Wrong
public abstract void doEffect(Object affectedObject); // Right
}

public class Thing
{
public abstract void doEffects(); // Right
public abstract void doEffect(EffectType effect); // Right
}
#15

I wouldn’t say it’s always as strict as that, since an object also represents a static closure, which is something you can and do determine dynamically. In that case, affectedObject would be passed in via the constructor. Of course if your Effects are enums, then yes. you are going to have to pass affectedObject in as a parameter, since your instances of Effect are all statically defined (enumerated) beforehand.