Method references

• Concept: A method reference allows you to reference a method without executing it.

• Relationship with lambda expressions: Both require a target type context composed of a compatible functional interface.

• Functional instance: A method reference creates an instance of a functional interface when evaluated.

References to Static Methods

• The class name and method are separated by a double colon (::), inserted in JDK 8.

• Can be used wherever compatible with the target type.

Example of Reference to Static Methods

• Functional interface:
  Name: IntPredicate
  Method: test(int value)
  Parameters: an integer.
  Return: a boolean (tests conditions on integer values).

• Auxiliary class:
  Name: MyIntPredicates
  Implemented static methods:
  isPrime(): checks if the number is prime.
  isEven(): checks if the number is even.
  isPositive(): checks if the number is positive.

• Main method:
  Name: numTest()
  Parameters:
  A reference to the IntPredicate.
  interface An integer being tested.

• Execution:
  In the main() method, three tests are performed with numTest().
  For each test, a specific method reference (isPrime, isEven, isPositive) is passed as an argument for execution.

// Demonstrates a reference to a static method.
// Functional interface for numeric predicates that operates with
// integer values.
interface IntPredicate {
boolean test(int n);
}
// This class defines three static methods that check an integer
// in relation to some condition.
class MyIntPredicates {
// A static method that returns true when a number is prime.
static boolean isPrime(int n) {
if(n < 2) return false;
for(int i=2; i <= n/i; i ) {
if((n % i) == 0)
return false;
}
return true;
}
// A static method that returns true when a number is even.
static boolean isEven(int n) {
return (n % 2) == 0;
}
// A static method that returns true when a number is positive.
static boolean isPositive(int n) {
return n > 0;
}
}
class MethodRefDemo {
// This method has a functional interface as its type
// first parameter. Therefore, you may receive a reference to
// any instance of this interface, including a created one
// by a method reference.
static boolean numTest(IntPredicate p, int v) {
return p.test(v);
}
public static void main(String args[])
{
boolean result;
// Here, a reference to the isPrime method is passed to numTest().
result = numTest(MyIntPredicates::isPrime, 17);
if(result) System.out.println("17 is prime.");
// Then a reference to the isEven method is used.
result = numTest(MyIntPredicates::isEven, 12);
if(result) System.out.println("12 is even.");
// Now a reference to the isPositive method is passed.
result = numTest(MyIntPredicates::isPositive, 11);
if(result) System.out.println("11 is positive.");
}
}

• The reference to the static method isPrime() is passed as an argument to the numTest() method.

• The isPrime() method is compatible with the IntPredicate functional interface.

• The expression MyIntPredicates::isPrime creates a reference where isPrime() implements the test() method of IntPredicate.

• The other calls to numTest() follow the same compatibility and operating principle.

• Any method that has the boolean signature test(int n) can be used as a reference for the IntPredicate interface.

The above is the detailed content of Method references. For more information, please follow other related articles on the PHP Chinese website!