第一类函数

Question

所以我们有一个接口，叫Func.java，看起来像这样：

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

然后我们的主类，称为mainClass.java，它看起来像这样：

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)); 
      } 
     }; 
    } 
} 

我不太确定那么如何在主要方法中调用这个组合方法，以及这段代码如何实际编译！我的意思是，在这里工作需要java泛型？

Answer 1

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)); 
    } 
} 

Answer 2

一个例子：

甲Func<A,B>一个字符串（A）转换为一个整数（B）。

class Converter implements Func<String, Integer> { 
    @Override 
    public Integer apply(String x) { 
     // System.out.println("Converter converting String \"" + x + "\" to an Integer"); 
     return Integer.valueOf(x); 
    } 
} 

另一个Func<A,B>实现中，一个Integer（A）转换为字符串（B），即表示该STRIG

class Binary implements Func<Integer, String> { 
    @Override 
    public String apply(Integer x) { 
     // System.out.println("Binary converting Integer " + x + " to binary String"); 
     return Integer.toBinaryString(x); 
    } 
} 

二进制表示和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")); 
} 

为了更好地了解发生了什么，你可以取消的System.out.println()语句和运行代码。

Answer 3

这里是你如何可以调用撰写：

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")); 
    } 
} 

我不太清楚，据你问什么是仿制药是必要的。在字面意义上，不，他们不是。 Java泛型只是给你类型安全。你当然可以完全取消它们，并将A，B和C改为仅仅是Object。但是，如果你想显式地定义正在使用的类型，比如我的例子中的String，Integer和Double，那么是的，你需要在这种情况下使用泛型。

Answer 4

如果你在一个只包含实数操作的问题域中工作，你不一定需要泛型--Func的接口可能只是public double apply(double x)。但是使用泛型可以让您灵活地将函数转化为另一种类型。撰写方法只是给你一种链接功能的方式，就像普通的数学函数组合一样。