Htydjtk

Is it possible to do something like this in Java

private ? /* (I dont know what Class to use) */ shortcutToMethod = redundantMethod(game.getGraphics());

So instead of calling redundantMethod(game.getGraphics().doThisMethod());

I could just do shortCutToMethod.doThisMethod();

Is this possible?

In Java, there are various ways. If you take a look at java.util.function package, you can see

• 
  Function: Takes one argument, produces one result


• 
  Consumer: Takes one argument, produces nothing.


• 
  BiConsumer: Takes two arguments, produces nothing.


• 
  Supplier: Takes no argument, produces one result.


• 
  Predicate: Boolean value function of one argument

You can used them as inputs for your method and execute it within.

Java 8 has introduced the idea of a Functional Interface, which allows you to essentially assign methods to variables. It includes a number of commonly-used interfaces as well.

Common examples:

• 
  Consumer<T> - a method that takes in T and returns void
  


• 
  Function<T, R> - a method that takes in T and returns R
  


• 
  Supplier<T> - a method that takes no arguments and returns R
  


• 
  Runnable - a method that takes no arguments and returns void
  


• 
  Predicate<T> - a method that takes in T and returns boolean
  

In your case, you appear to be after a Runnable:

Runnable shortcutToMethod = () -> redundantMethod(game.getGraphics());

shortcutToMethod.run();

You can use functional interfaces. A functional interface allows one to adapt an abstract method to a lambda expression that can in turn be stored in a variable, and that's close to storing a method in a variable.

There are a number of functional interfaces available in Java (you can design others yourself). For example, if your redundantMethod returns nothing, you can use a functional interface appropriate for that:

private Consumer<Graphics> shortcutToMethod = 

           graphics -> redundantMethod(game.getGraphics());

It can even go with a method reference:

private Consumer<Graphics> shortcutToMethod = this::redundantMethod; //some rules apply

And that can be called with:

shortcutToMethod.accept(game.getGraphics());

Consumer is one of the functional interfaces that come with Java, and it declares the abstract method accept that is called above. There are others that you can find in the java.util.function package, and you choose or write a particular functional interface based on what signature your particular method has. See java.util.function package for more information.

Well in addition to what the others already wrote. Assuming the returntype is "Graphics".

//You need some kind of forward declaration, name don't matter:

public static interface FunctionDeclaration{

    public Graphics doThisMethod();

}



//here you go and assing your variable

private FunctionDeclaration shortCutToMethod = game.getGraphics()::doThisMethod;

//or you want this - not sure?

// private FunctionDeclaration shortCutToMethod = game::getGraphics;

// and then you just call it:

shortCutToMethod.doThisMethod();

and if you want to pass the graphics

//You need some kind of forward declaration, name don't matter:

public static interface FunctionDeclaration{

    public Graphics doThisMethod(Graphics g);

}

//assign your variable

private FunctionDeclaration shortCutToMethod = param -> param.doThisMethod();

//and call it - calls game.getGraphics().doThisMethod()

shortCutToMethod.doThisMethod(game.getGraphics());

And if your "redundant" method does something:

//You need some kind of forward declaration, name don't matter:

public static interface FunctionDeclaration{

    public Graphics doThisMethod(Graphics g);

}

//assign your variable

private FunctionDeclaration shortCutToMethod = param -> redundantMethod(param.doThisMethod());

//and call it - calls redundantMethod(game.getGraphics().doThisMethod())

shortCutToMethod.doThisMethod(game.getGraphics());

Or same principle:

//You need some kind of forward declaration, name don't matter:

public static interface FunctionDeclaration{

    public Graphics doThisMethod();

}

//assign your variable

private FunctionDeclaration shortCutToMethod = () -> redundantMethod(game.getGraphics().doThisMethod());

//and call it - calls redundantMethod(game.getGraphics().doThisMethod())

shortCutToMethod.doThisMethod();

And so on ...
Sure enough for the forward declaration you can use any existing interface like the predefined ones Joe and others mentioned(eg. Supplier).