最简单的Java框架-java.util.function.*

在最简单的Java框架中，简化了框架概念：

★框架/framework是需要上层模块提供代码的低层骨架式方案。

换言之，我们说的框架，不要求它如applet或GUI框架那样，有太多底层细节或控制逻辑需要处理。因此，最简单的框架MyFramework的函数方法(functionalmethod)为

double op(double m,double n) ，对两个double操作后返回一个double值。

那么，更一般化，函数方法可以设计为double op(M m,N n) ，或者

package principle.callback.lower;
@FunctionalInterface
public interface DoubleOP<T,U>{
    double applyAsDouble(T t, U u);
}

为什么取这样的函数名applyAsDouble呢？因为我喜欢。非也，我不喜欢。而是因为JDK中有这样的东西，它的方法名就是applyAsDouble。

java.util.function.*

该包中，有一系列的函数接口，为了通用使用了泛型，但是，Java中你又不能够定义不同个数参数的泛型类，如DoubleOP<T,U>、DoubleOP<T,U,V>/DoubleOP<T,U,V,W>，必须为它们取不同的名字，函数也取了一些不同的名字，真是醉了。

    public static void testFunction(){
        principle.callback.lower.DoubleOP<Double,String> f = ( x, y)->{return x +y.length() ;};
        double d = f.applyAsDouble(1.0,"yqj2065");
        pln(d);
        
        ToDoubleBiFunction<Double,Double> f1 = ( m, n)->{return m +2*n ;};
        d = f1.applyAsDouble(1.0,3.0);        pln(d);
        
        Function<String,Double> f2 = x->(double)x.length();
        d = f2.apply("yqj2065"); pln(d);
        BiFunction<String,String,Double>  f3 = (x,y)->x.length()+y.length()*1.0;
        d = f3.apply("yqj","2065"); pln(d);
        BinaryOperator<Double> f4 = (x,y)->x+y;
        d = f4.apply(1.0,3.0); pln(d);
        DoubleBinaryOperator f5 = (x,y)->x+y;
        d = f5.applyAsDouble(1.0,3.0); pln(d);
        
    }

都是类型擦除惹的祸。单就double op(double m,double n) 而言，最匹配的函数接口是DoubleBinaryOperator。

• R foo(...) 形式：                 Function<T,R> ，类型签名 T→R；           主要方法名apply；      25个接口
• void foo(...)形式：            Consumer<T>，类型签名 T→void ；      主要方法名accept；   8个接口
  
• boolean foo(...)形式：      Predicate<T>，类型签名 T→boolean；主要方法名test；        5个接口
  
• T foo()形式：                     Supplier<T>，类型签名 ()→T；            主要方法名get；         5个接口
  

R foo(...) 形式，参数个数，支持到2个，基本类型支持int、double和long；有更多的要求，自己写，如char。