Java 一类函数

因此，我们有一个名为Func.java的接口，看起来像这样：

public interface Func<A,B> {
    public B apply(A x);
}

public class mainClass{
    public static void main(String[] args) {
    }

    public static <A,B,C> Func<A,C> compose(final Func<A,B> f, final Func<B,C> g){
        return new Func<A,C>(){
            public C apply(A x){
                return g.apply(f.apply(x));
            }
        };
    }
}

公共接口函数{
公共B应用（A x）；
}

然后我们有一个名为mainClass.java的主类，它如下所示：

public interface Func<A,B> {
    public B apply(A x);
}

public class mainClass{
    public static void main(String[] args) {
    }

    public static <A,B,C> Func<A,C> compose(final Func<A,B> f, final Func<B,C> g){
        return new Func<A,C>(){
            public C apply(A x){
                return g.apply(f.apply(x));
            }
        };
    }
}

public类mainClass{
公共静态void main（字符串[]args）{
}
公共静态函数组合（最终函数f、最终函数g）{
返回新的Func（）{
公共C应用（A x）{
返回g.apply（f.apply（x））；
}
};
}
}

我真的不知道如何在主方法中调用这个compose方法，以及这段代码实际上是如何编译的！我的意思是，这里需要java泛型吗？

公共类FirstClassFunction{
public class FirstClassFunction {
   interface Func< A, B > {
      public B apply( A x );
   }

   static <A, B, C>
   Func< A, C > compose( final Func< A, B > f, final Func< B, C > g ) {
      return new Func< A, C >() {
         @Override public C apply( A x ) {
            return g.apply( f.apply( x ) );
         }};
   }

   public static void main( String[] args ) {
      Func< Double, Character > f =
         new Func< Double, Character >(){
            @Override public Character apply( Double x ) {
               return 'a';
            }};
      Func< Character, String > g =
         new Func< Character, String >(){
            @Override public String apply( Character x ) {
               return "Hello";
            }};
      Func< Double, String > c = compose( f, g );
      System.out.println( c.apply( 3.14 ));
   }
}

接口函数{
公共B应用（A x）；
}
静止的
Funccompose（最终Funcf，最终Funcg）{
返回新函数（）{
@覆盖公共C应用（A x）{
返回g.apply（f.apply（x））；
}};
}
公共静态void main（字符串[]args）{
Funcf=
新函数（）{
@覆盖公共字符应用（双x）{
返回“a”；
}};
Funcg=
新函数<字符，字符串>（）{
@覆盖公共字符串应用（字符x）{
回复“你好”；
}};
Funcc=compose（f，g）；
系统输出打印（c.apply（3.14））；
}
}

举个例子：

将字符串（

A

）转换为整数（

B

）的

Func

以及一个演示它的

main

方法

public static void main(String[] args) {
    // compose those to functions and you can convert strings representing
    // numbers (base 10) to Strings that represent the same number (base 2)
    Func<String, String> binaryStringConverter = compose(new Converter(), new Binary());
    System.out.println(binaryStringConverter.apply("123"));
}

publicstaticvoidmain（字符串[]args）{
//将它们组合成函数，您可以转换表示
//数字（以10为基数）到表示相同数字（以2为基数）的字符串
Func binaryStringConverter=compose（新转换器（），新二进制（））；
System.out.println（binaryStringConverter.apply（“123”））；
}

---

为了更好地理解发生了什么，您可以取消注释

System.out.println（）

语句并运行代码。

以下是调用compose的方法：

public class mainClass {
    public static <A, B, C> Func<A, C> compose(final Func<A, B> f, final Func<B, C> g) {
        return new Func<A, C>() {
            public C apply(final A x) {
                return g.apply(f.apply(x));
            }
        };
    }

    public static void main(final String[] args) {
        Func<String, Double> toDouble = new Func<String, Double>() {
            public Double apply(final String x) {
                return Double.parseDouble(x);
            }
        };
        Func<Double, Integer> toInt = new Func<Double, Integer>() {
            public Integer apply(final Double x) {
                return (int) x.doubleValue();
            }
        };
        Func<String, Integer> composed = compose(toDouble, toInt);
        System.out.println("Composed: " + composed.apply("1.23"));
    }
}

public类mainClass{
公共静态函数组合（最终函数f、最终函数g）{
返回新的Func（）{
公共C应用（最终A x）{
返回g.apply（f.apply（x））；
}
};
}
公共静态void main（最终字符串[]args）{
Func toDouble=新Func（）{
公共双应用（最终字符串x）{
返回Double.parseDouble（x）；
}
};
Func toInt=新Func（）{
公共整数应用（最终双x）{
返回（int）x.doubleValue（）；
}
};
Func composed=compose（toDouble，toInt）；
System.out.println（“组合：”+组合应用（“1.23”）；
}
}

---

就泛型的必要性而言，我不太确定你在问什么。从字面意义上说，不，它们不是。Java泛型只提供类型安全性。您当然可以完全废弃它们，将A、B和C更改为对象。但是，如果您想显式定义所使用的类型，如我的示例中的String、Integer和Double，那么是的，在本例中需要使用泛型。

如果您在一个只包含实数操作的问题域中工作，您不一定需要泛型——Func的接口可以是

公共双应用（double x）

。但是使用泛型可以灵活地将函数转换为从一种类型到另一种类型的转换。compose方法只是提供了一种链接函数的方法，就像普通的数学函数组合一样。

您尝试过编译它吗？