将方法传递给方法的解决方法？

Question

I am looking for a way to pass a method as a parameter into another method.

I am currently trying to simulate the Newton's-method ( http://en.wikipedia.org/wiki/Newton%27s_method ) in Java with the following code:

public class Newton {


// Iterationmethod
public void newtonCalc(double x0) {
    double x;

    // counter
    int i = 0;

    //Newton-Iteration for x0
    x = x0 - (y2(x0) / y2Deriv(x0));

    while (Math.sqrt(y2(x)*y2(x)) >= Math.pow(10, -10)){
        //Newton-Iteration x(n+1)
        x = x - (y2(x))/ y2Deriv(x);
        i++;
        System.out.printf("%d. %.11f\n",i,y2(x));
    }

    System.out.printf("%d steps were necessary for a resolution of 10^-10", i);
}

// Function for (2)
public static double y2(double x) {
    return Math.sin(x) / (1 - Math.tan(x));
}

// Derivative for (2)
public static double y2Deriv(double x) {
    return (Math.cos(x) + Math.sin(x) * Math.tan(x) * Math.tan(x))
            / ((Math.tan(x) - 1) * (Math.tan(x) - 1));
}

// Function for (4)
public static double y4(double x) {
    return Math.exp(-1/Math.sqrt(x));
}

// Derivative for (4)
public static double y4Deriv(double x) {
    return Math.exp(-1/Math.sqrt(x))/(2*Math.pow(x, 3d/2));
}



public static void main(String[] args) {
    Newton newton = new Newton();
    newton.newtonCalc(1);
}

}

newtonCalc(x0) gets an x0 at wich the iteration should be started. But the function (y2) now is hardcoded into this method. I want it to be flexible. For example newtonCalc(double x0, Method y) to run the iteration for y starting at x0. I have 2 different functions (y2 and y4 which are both functions from a excercise sheet from my lecture plus its derivatives y2Deriv and y4Deriv which are used in the Iterationmethod).

I know passing a method is not possible but i dont get any easy workaround.

Forgive me if this is unclear or i have missed any necessary information!

Regards,

Tak3r07

Answer 1

从Java 8开始，完全有可能使用lambda表达式

Answer 2

If you want to stay with pre-Java-8 methods, make an interface Function with member functions eval and deriv and pass (possibly anonymous) instances of derived classes to the Newton class invocation.

---

This could look like (I'm not sure that all details are correct, these are just code fragments to illustrate the idea)

interface Function {
     public double eval(double x);
     public double deriv(double);
}

class Example1 implements Function {
     @override
     public double eval(double x) { return x*(x+3)+1; }
     @override
     public double deriv(double) { return 2*x+3; }
}

....

Solver solver1 = new Newton(new Example1(),x0);
....
Solver solver2 = new Newton(new Function(){
     @override
     public double eval(double x) { return cos(x); }
     @override
     public double deriv(double) { return -sin(x); }
}, x0);