Java 缺失的特性:操作符重载

private static final BigInteger BI_2 = BigInteger.valueOf(2);

BigInteger res = a.multiply(a).subtract(BI_2.multiply(a).multiply(b)).add(b.multiply(b));

BigInteger res = a * a - BI_2 * a * b + b * b;

—— 用过 Kotlin 的同学应该会会心一笑，这就是模仿的 Kotlin 的操作符重载。

为了方便举例说明，我们定义一个数值类型 Num：

public class Num {    private final int v;    public Num(int v) {        this.v = v;    }    public Num plus(Num that) {        return new Num(this.v + that.v);    }    public Num minus(Num that) {        return new Num(this.v - that.v);    }    public Num times(Num that) {        return new Num(this.v * that.v);    }}

对于下面的代码：

Num a = new Num(1);Num b = new Num(2);Num c = a + b - a;

Manifold 在编译期处理之后，会变成：

Num c = a + a * b - b;

public class Num {    ...    public Num plus(Num that) {        return new Num(this.v + that.v);    }    public Num plus(int i) {        return new Num(v + i);    }}

Num c = a + 1 + b;

在 Manifold 处理之后：

值得注意的是，因为 + 和 * 都是满足交换律的，所以 a + b 首先会去对象 a 中寻找符合的 plus 方法，如果 a 中存在，则执行的是 a.plus(b)；如果 a 中不存在，而 b 中存在符合的 plus 方法，则执行的是 b.plus(a)。a * b 同理。

public class Num implements Comparable<Num> {    ...    @Override    public int compareTo(Num that) {        return this.v - that.v;    }}

那么对于这样的代码：

Num a = new Num(1);Num b = new Num(2);if (a > b) {    System.out.println("a > b");}if (a < b) {    System.out.println("a < b");}

运行代码会输出 a < b，因为代码在被 Manifold 处理之后会变为：

• 如果是 
  EqualityMode.CompareTo
  ，则 
  ==
   和 
  !=
   的重载分别对应的是 
  compareTo
   方法返回值为 0 和 非0 的情况。
• 如果是 
  EqualityMode.Equals
  ，则 
  ==
   和 
  !=
   的重载分别对应的是 
  equals
   方法返回值为 
  true
   和 
  false
   的情况。
• 如果是 
  EqualityMode.Identity
  ，那使用的是 Java 的默认实现，即比较对象的引用地址是否相同。

而 equalityMode 默认的方法返回值为 EqualityMode.Equals，即 Manifold 默认使用 equals 方法来进行 == 和 != 的判断。当然，你也可以不使用 Manifold 的 equalityMode 这套逻辑，直接实现自己的 compareUsing 方法，处理各种 Operator 的比较逻辑。

public class Num implements ComparableUsing<Num> {    ...    @Override    public int compareTo(Num that) {        return this.v - that.v;    }    @Override    public boolean equals(Object obj) {        if (this == obj) { return true; }        if (obj instanceof Num) {            Num that = (Num) obj;            return this.v == that.v;        }        return false;    }    @Override    public int hashCode() {        return Objects.hash(v);    }}

Num a = new Num(1);Num b = new Num(1);if (a == b) {    System.out.println("a == b");}if (a != b) {    System.out.println("a != b");}

你应该也发现了，如果某个类型 T 要实现 ComparableUsing<T>，那么说明 T 一定是 Comparable<T>。也就是说，如果你想要对 T 重载 == 和 !=，则要求 T 一定是可比较的。Manifold 之所以这样做，而不是为重载 == 和 != 提供单独的接口，是因为作者目前认为用 == 和 != 来代替 equals，弊大于利 —— 毕竟用 equals 来比较两个对象是否相等这件事，在 Java 中太深入人心了。所以目前 Manifold 作者希望大家只对数值和量词这类的对象使用 == 和 !=，不要产生滥用行为。

@Extensionpublic class MapExt {    public static <K, V> V set(@This Map<K, V> map, K key, V value) {        return map.put(key, value);    }}

然后我们就可以这样写代码了：

int[] nums = {1, 2, 3};int value = nums[0] = 10;

List<String> list = Arrays.asList("a", "b", "c");String value = list[0] = "A";

Manifold 处理之后，代码会变成：

public class DateTimeUnit {    private static final     DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");    public LocalDateTime postfixBind(String value) {        return LocalDateTime.parse(value, FORMATTER);    }}

postfixBind 表示这个单位是“后缀单位”，就是你看到的 "xxx"dt，dt 在 "xxx" 的后面。Manifold 同时也支持“前缀单位”，对应的方法是 prefixBind，比如：

public class DateTimeUnit {    ...    public LocalDateTime prefixBind(String value) {        return LocalDateTime.parse(value, FORMATTER);    }}

添加了 prefixBind(String) 后，那么就可以这样定义 LocalDateTime：

public class BigIntegerUnit {    public BigInteger postfixBind(Integer value) {        return BigInteger.valueOf(value);    }    public BigInteger postfixBind(String value) {        return new BigInteger(value);    }}

配合 Manifold 的 auto（类似于 Java10 提供的 var，但是 auto 还可以用来定义属性）：

public class MapEntryBuilder {    public <K> EntryKey<K> postfixBind(K key) {        return new EntryKey<>(key);    }    public static class EntryKey<K> {        private final K key;        public EntryKey(K key) {            this.key = key;        }        public <V> Map.Entry<K, V> prefixBind(V value) {            return new AbstractMap.SimpleImmutableEntry<>(key, value);        }    }}

那么，便可以通过下面这种方式来创建 Map.Entry（先通过 to.postfixBind 创建 EntryKey，再通过 EntryKey 的 prefixBind 方法创建 Map.Entry）：

@Extensionpublic class MapExt {    @Extension    @SafeVarargs    public static <K, V> Map<K, V> of(Map.Entry<K, V>... entries) {        Map<K, V> map = new LinkedHashMap<>(entries.length);        for (Map.Entry<K, V> entry : entries) {            map.put(entry.getKey(), entry.getValue());        }        return Collections.unmodifiableMap(map);    }}

那么你可以这样创建 Map：

[1]https://github.com/manifold-systems/manifold

[2]https://openjdk.org/jeps/8277163