13.10 Scala中使用JSON.toJSONString报错:ambiguous reference to overloaded definition13.10 Scala中使用JSON.t

13.10 Scala中使用JSON.toJSONString报错:ambiguous reference to overloaded definition

问题描述:

[ERROR] /Users/jack/book/lightsword/src/main/scala/com/springboot/in/action/filter/LoginFilter.scala:28: error: ambiguous reference to overloaded definition,
[INFO] both method toJSONString in object JSON of type (x$1: Any, x$2: com.alibaba.fastjson.serializer.SerializerFeature*)String
[INFO] and  method toJSONString in object JSON of type (x$1: Any)String
[INFO] match argument types (Object) and expected result type Any
[INFO]     println(JSON.toJSONString(principal))
[INFO]                  ^
[ERROR] one error found

原因分析:

看日志:

[INFO] both method toJSONString in object JSON of type (x$1: Any, x$2: com.alibaba.fastjson.serializer.SerializerFeature*)String
[INFO] and  method toJSONString in object JSON of type (x$1: Any)String
[INFO] match argument types (Object) and expected result type Any
[INFO]     println(JSON.toJSONString(principal))

意思是,JSON.toJSONString的两个方法:

toJSONString(x$1: Any)

toJSONString(x$1: Any, x$2: com.alibaba.fastjson.serializer.SerializerFeature*)

同时匹配了方法的引用。

我们看这是这两个方法的java源码:

public static String toJSONString(Object object) {
        return toJSONString(object, new SerializerFeature[0]);
    }

    public static String toJSONString(Object object, SerializerFeature... features) {
        SerializeWriter out = new SerializeWriter();

        try {
            JSONSerializer serializer = new JSONSerializer(out);
            for (com.alibaba.fastjson.serializer.SerializerFeature feature : features) {
                serializer.config(feature, true);
            }

            serializer.write(object);

            return out.toString();
        } finally {
            out.close();
        }
    }

SerializerFeature... features 是一个可变长参数。

Java可变长参数的方法重载

在Java代码中,我们是不推荐带有变长参数的方法重载的。这样的代码调用人类阅读起来会感到“模糊”。

在项目和系统的开发中,为了提高方法的灵活度和可复用性,我们经常要传递不确定数量的参数到方法中,在Java 5之前常用的设计技巧就是把形参定义成Collection类型或其子类类型,或者是数组类型,这种方法的缺点就是需要对空参数进行判断和筛选,比如实参为null值和长度为0的Collection或数组。

而 Java 5引入变长参数(varags)就是为了更好地提高方法的复用性,让方法的调用者可以“随心所欲”地传递实参数量,当然变长参数也是要遵循一定规则的,

比如变长参数必须是方法中的最后一个参数;一个方法不能定义多个变长参数等,这些基本规则需要牢记,但是即使记住了这些规则,仍然有可能出现错误,我们来看如下代码:

public class Client {     
     //简单折扣计算  
     public void calPrice(int price,int discount){  
           float knockdownPrice =price * discount / 100.0F;  
           System.out.println("简单折扣后的价格是:"+formateCurrency(knockdownPrice));  
     }    
     //复杂多折扣计算  
     public void calPrice(int price,int... discounts){  
           float knockdownPrice = price;  
           for(int discount:discounts){  
                   knockdownPriceknockdownPrice = knockdownPrice * discount / 100;  
        }  
        System.out.println("复杂折扣后的价格是:" +formateCurrency(knockdownPrice));  
     }  
     //格式化成本的货币形式  
     private String formateCurrency(float price){  
            return NumberFormat.getCurrencyInstance().format(price/100);  
     }  
      
     public static void main(String[] args) {  
           Client client = new Client();  
           //499元的货物,打75折  
           client.calPrice(49900, 75);  
    }  
}

运行结果:

简单折扣后的价格是:¥374.25

这是一个计算商品价格折扣的模拟类,带有变长参数的calPrice方法则是较复杂的折扣计算方式,多种折扣的叠加运算(模拟类是一种比较简单的实现)在实际生活中也是经常见到的,比如在大甩卖期间对VIP会员再度进行打折;或者当天是你的生日,再给你打个9折,也就是俗话说的“折上折”。

两个calPrice()方法重载有点特殊:

calPrice(int price,int... discounts)// A

的参数范畴覆盖了

calPrice(int price,int discount)// B

的参数范畴。

那问题就出来了:对于

calPrice(49900,75)

这样的计算,到底该调用哪个方法来处理呢?

从运行结果来看是调用了B方法,而不是变长参数A的方法.

原因分析:Java在编译时,首先会根据实参的数量和类型(这里是2个实参,都为int类型,注意没有转成int数组)来进行处理,也就是查找到calPrice(int price,int discount)方法,而且确认它是否符合方法签名条件。现在的问题是编译器为什么会首先根据2个int类型的实参而不是1个int类型、1个int数组类型的实参来查找方法呢?这是个好问题,也非常好回答:因为int是一个原生数据类型,而数组本身是一个对象,编译器想要“偷懒”,于是它会从最简单的开始“猜想”,只要符合编译条件的即可通过,于是就出现了此问题。

问题是阐述清楚了,为了让我们的程序能被“人类”看懂,还是慎重考虑变长参数的方法重载吧,否则让人伤脑筋不说,说不定哪天就陷入这类小陷阱里了。

Scala编译器的处理方式就比较“显式”了,直接抛出“ambiguous reference to overloaded definition” ERROR。

针对可变参数的方法重载机制,这是Scala的与java在编译处理上区别的地方。

Scala分辨重载方法的过程与Java极为相似。任何情况下,被选中的重载版本都是最符合参数静态类型的那个。有时如果不止一个最符合的版本;这种情况下编译器会给你一个“ambiguous reference to overloaded definition”(模糊引用了重载定义的方法)的错误。

解决方案:

在scala代码中显式调用:toJSONString(Object object, SerializerFeature... features) 。

另外,不推荐带有变长参数的方法重载。

参考资料: 1.http://www.cnblogs.com/DreamDrive/p/5412359.html

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏一个会写诗的程序员的博客

第6章 类型系统

6.3 基本类型(Primitive Types) 6.3.1 Number: 包含整型与浮点型等 6.3.2 Char: 字符类型(Character) ...

1083
来自专栏编码前线

在java中String类为什么要设计成final?

String很多实用的特性,比如说“不可变性”,是工程师精心设计的艺术品!艺术品易碎!用final就是拒绝继承,防止世界被熊孩子破坏,维护世界和平!

912
来自专栏菩提树下的杨过

字符编码-使用c#研究

微软的那个臭屁的JOEL(就是写《JOEL说软件》的那个牛人)曾说:“每一位软件开发人员必须、绝对要至少具备UNICODE与字符集知识(没有任何例外)”,我也常...

1927
来自专栏顶级程序员

为什么Java中1000==1000为false而100==100为true?

原文:Why 1000 == 1000 Returns False, but 100 == 100 Returns True in Java? 作者:Bazl...

2797
来自专栏python3

python3--对象之间的交互,类命名空间与对象、实例的命令空间

现在有个游戏人与狗,人定义一个类,狗定义一个类,如何让两个类之间互相交互起来,让这个游戏变得更加有意思,代码如下

1181
来自专栏函数式编程语言及工具

Akka(7): FSM:通过状态变化来转换运算行为

  在上篇讨论里我们提到了become/unbecome。由于它们本质上是堆栈操作,所以只能在较少的状态切换下才能保证堆栈操作的协调及维持程序的清晰逻辑。对于比...

8298
来自专栏一个会写诗的程序员的博客

第4章 类与面向对象编程第4章 类与面向对象编程

在前面的章节中,我们学习了Kotlin的语言基础知识、类型系统等相关的知识。在本章节以及下一章中,我们将一起来学习Kotlin对面向对象编程以及函数式编程的支持...

942
来自专栏小詹同学

【记录帖】(No.004)从零打卡刷Leetcode

小詹一直觉得自己编程能力不强,想在网上刷题,又怕不能坚持。不知道有木有和小伙伴和小詹一样想找个人一起刷题呢?欢迎和小詹一起定期刷leetcode,每周一周五更新...

1312
来自专栏大史住在大前端

野生前端的数据结构基础练习(1)——栈

934
来自专栏老马说编程

(93) 函数式数据处理 (下) / 计算机程序的思维逻辑

上节初步介绍了Java 8中的函数式数据处理,对于collect方法,我们只是演示了其最基本的应用,它还有很多强大的功能,比如,可以分组统计汇总,实现类似数据库...

2188

扫码关注云+社区

领取腾讯云代金券