Shulou(Shulou.com)06/02 Report--

Editor to share with you how to use the overloading method and implicit conversion in Scala. I hope you will get something after reading this article. Let's discuss it together.

Method overload

Come back to the Rational class. After the last change, you can add and multiply fractions in a natural style. But don't forget that there are hybrid operations. For example, you cannot multiply a fraction by an integer because the Operand of'* 'can only be a fraction. So you can't write r * 2 for the fraction r. It must be written as r * new Rational (2), which doesn't look beautiful. To make Rational easier to use, you can add new methods to the class that can perform addition and multiplication between fractions and integers. Now that we are here, we can add subtraction and division. The result is shown in Code 6.5:

Class Rational (n: Int, d: Int) {require (d! = 0) privateval g = gcd (n.abs, d.abs) val numer = n / g val denom = d / g def this (n: Int) = this (n, 1) def + (that: Rational): Rational = new Rational (numer * that.denom + that.numer * denom, denom * that.denom) def + (I: Int): Rational = new Rational (numer + I * denom) Denom) def-(that: Rational): Rational = new Rational (numer * that.denom-that.numer * denom, denom * that.denom) def-(I: Int): Rational = new Rational (numer-I * denom, denom) def * (that: Rational): Rational = new Rational (numer * that.numer, denom * that.denom) def * (I: Int): Rational = new Rational (numer * I Denom) def / (that: Rational): Rational = new Rational (numer * that.denom, denom * that.numer) def / (I: Int): Rational = new Rational (numer, denom * I) override def toString = numer+ "/" + denom private def gcd (a: Int, b: Int): Int = if (b = 0) an else gcd (b, a% b)}

Code 6.5 Rational with overloaded methods

There are now two versions of each mathematical method: one with a fraction as a parameter and the other with an integer. Or rather, these method names are overloaded: overload, because each name is now used by multiple methods. For example, the name + is used by one method with Rational and another method with Int. In a method call, the compiler picks out the overloaded method version that correctly matches the parameter type. For example, if the parameter y of x. + (y) is Rational, the compiler picks up the + method with the Rational parameter. Conversely, if the argument is an integer, the compiler will choose the + method with the Int parameter instead. If you try to enter:

Scala > val x = new Rational (2,3) x: Rational = 2 + 3 scala > x * x res37: Rational = 4 * res38 9 scala > x * 2 res38: Rational = 4 * 3

You will see that the call to the * method depends on the type of Operand on the right in each example.

Be careful

The process of resolving overload method by Scala is very similar to that of Java. In any case, the selected overloaded version is the one of the static type of the * parameter. Sometimes if there is more than one version of *; in this case the compiler will give you a "reference blur" error.

Implicit conversion

Now that you can write r * 2, maybe you want to swap operands, like 2 * r. Unfortunately, this is not enough:

Scala > 2 * r

: 7: error: overloaded method value * with alternatives (Double) Double

(Float) Float

(Long) Long

(Int) Int

(Char) Int

(Short) Int

(Byte) Int cannot be applied to (Rational) val res2 = 2 * r

The problem here is that 2 * r equals 2 * (r), so this is a method call on the integer 2. But the Int class does not have multiplication with the Rational parameter-- there is no way, because the class Rational is not the standard class of the Scala library.

However, there is another way to solve this problem in Scala: you can create an implicit conversion that automatically converts integers to fractions when needed. Try to add this line to the interpreter:

Scala > implicit def intToRational (x: Int) = new Rational (x)

This line of code defines the conversion method from Int to Rational. The implicit modifier in front of the method tells the compiler to call it automatically in several cases. After defining the transformation, you can now retry the previous failed example:

Scala > val r = new Rational (2pm 3) r: Rational = 2pm 3 scala > 2 * r res0: Rational = 4pm 3

Please note that implicit conversion needs to be defined within scope for it to work. If you put the implicit method definition within the class Rational, it is out of the scope of the interpreter. Now you need to define it directly in the interpreter.

As you can see in this example, implicit conversion is a very powerful technology that makes libraries more flexible and convenient. Because they are so powerful, they are easy to be misused. You'll find more details about implicit conversions in Chapter 21, including ways to bring them into scope when needed.

After reading this article, I believe you have a certain understanding of "how to use overloading methods and implicit conversion in Scala". If you want to know more about it, please follow the industry information channel. Thank you for reading!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.