scala 类的多态_Scala多态方法和显式引用

scala 类的多态

The methods in scala can be parametrized with both value and types. Value parameters are enclosed within a pair of parenthesis whereas type parameters within a pair of brackets. For example;

scala中的方法可以使用值和类型进行参数化。值参数括在一对括号内，而类型参数括在一对括号内。例如;

polymorphic.scala

object polymorphic {def main(args: Array[String]) {def add(a: Int, b: Int) {val c = a + b;println(c)}def addStrings(a: String, b: String) {val s = a + bprintln(s)}add(72, 67);addStrings("Hello", "World");}
}

In this example the + plus operator is used for adding numbers as well as concatenating the strings. The add method performs the addition of two numbers and returns the result. The addString method use the same + operator and concatenates the two strings specified by the user. This is default operator polymorphism provided by Scala. Below image shows the output produced by the above program.

在此示例中，+加号运算符用于添加数字以及连接字符串。加法执行两个数字的加法并返回结果。 addString方法使用相同的+运算符，并连接用户指定的两个字符串。这是Scala提供的默认运算符多态性。下图显示了以上程序产生的输出。

Scala方法多态 (Scala Method Polymorphism)

Now let’s see an example of polymorphism in method. We will write a generic method to get the list where we will pass the type, default values and number of items in the list.

现在让我们看一个方法中多态的例子。我们将编写一个通用方法来获取列表，并在其中传递列表中的类型，默认值和项目数。

PolymorphicMethod.scala

object PolymorphicMethod {def getList[T](x:T, y:Int): List[T] = {if (y == 0)Nilelsex :: getList(x, y - 1)}def main(args: Array[String]) {println(getList[Int](3,2))println(getList[String]("Hi", 3))}
}

Below image shows the output produced when above program is executed in the Scala IDE.

下图显示了在Scala IDE中执行上述程序时产生的输出。

Scala明确键入引用 (Scala Explicitly typed References)

Sometimes we need to explicitly specify the type of value “this” in a program. Let’s see an example for this scenario.

有时我们需要在程序中显式指定值“ this”的类型。让我们看一下这种情况的例子。

We have a Train abstract class as below.

我们有一个Train抽象类，如下所示。

Train.scala

abstract class Train {type Link;type Compartment <: CompartmentIntfabstract class CompartmentIntf {def join(compartment: Compartment): Link}def compartments: List[Compartment]def links: List[Link]def addCompartment: Compartment
}

The abstract class Train consists of List of links and compartments. The abstract class CompartmentIntf is defined and contains join method which takes Compartment as parameter. The methods compartments, links and addCompartment are declared but the implementation will be defined in concrete classes.

抽象类Train由链节和车厢列表组成。定义了抽象类CompartmentIntf ，并包含将Compartment作为参数的join方法。方法隔离区，链接和addCompartment被声明，但是实现将在具体类中定义。

Now we will define the abstract class MetroTrain that extends train class as;

现在，我们将定义抽象类MetroTrain，将火车类扩展为；

MetroTrain.scala

abstract class MetroTrain extends Train {type Link <: LinkImplclass LinkImpl(comptA: Compartment, comptB: Compartment) {def c1 = comptAdef c2 = comptB}class CompartmentImpl extends CompartmentIntf {def join(compartment: Compartment): Link = {val link = newLink(this, compartment)links = link :: linkslink}}protected def newCompartment: Compartmentprotected def newLink(c1: Compartment, c2: Compartment): Linkvar compartments: List[Compartment] = Nilvar links: List[Link] = Nildef addCompartment: Compartment = {val compartment = newCompartmentcompartments = compartment :: compartmentscompartment}
}

This class provides a partial implementation extending Train class. The implementation details are open and thus link and compartment are left abstract. We add factory methods newLink and newCompartment since it is required to create new compartment and link objects. The methods addCompartment and join are defined using factory methods.

此类提供了扩展Train类的部分实现。实现细节是开放的，因此链接和隔离专区被抽象化了。由于创建新的隔离专区和链接对象是必需的，因此我们添加了工厂方法newLink和newCompartment。方法addCompartment和join是使用工厂方法定义的。

However above class will throw compilation error in line no 11 as “type mismatch; found : CompartmentImpl.this.type (with underlying type MetroTrain1.this.CompartmentImpl) required: MetroTrain1.this.Compartment” because “this” is assigned the type CompartmentImpl, so it’s not compatible with type Compartment required by the corresponding factory method.

但是，上述类将在第11行中将编译错误抛出为“ 类型不匹配； 找到：CompartmentImpl.this.type（具有基本类型MetroTrain1.this.CompartmentImpl）：MetroTrain1.this.Compartment，因为“ this”被分配了CompartmentImpl类型，因此它与相应工厂方法所需的Compartment类型不兼容。

Let us solve this type mismatch by using explicitly typed self reference for CompartmentImpl as below.

让我们通过如下使用CompartmentImpl显式类型自引用来解决此类型不匹配的问题。

class CompartmentImpl extends CompartmentIntf {self: Compartment =>def join(compartment: Compartment): Link = {val link = newLink(this, compartment)links = link :: linkslink}
}

According to the new definition of CompartmentImpl, this has type Compartment. We specify the explicit typed reference so that CompartmentImpl denotes sub type of Compartment to be instantiate.

根据CompartmentImpl的新定义，此类型为Compartment。我们指定显式类型的引用，以便CompartmentImpl表示要实例化的Compartment的子类型。

We will now define a concrete class ConcreteMetroTrain as;

现在，我们将一个具体的类ConcreteMetroTrain定义为；

ConcreteMetroTrain.scala

class ConcreteMetroTrain extends MetroTrain {type Link = LinkImpltype Compartment = CompartmentImplprotected def newCompartment: Compartment = new CompartmentImplprotected def newLink(c1: Compartment, c2: Compartment): Link =new LinkImpl(c1, c2)
}

We can now instantiate CompartmentImpl because now we know that CompartmentImpl denotes a subtype of type Compartment. Now create a Scala object TestTrain as;

现在我们可以实例化CompartmentImpl，因为现在我们知道CompartmentImpl表示Compartment类型的子类型。现在创建一个Scala对象TestTrain作为；

TestTrain.scala

object TestTrain {def main(args: Array[String]) {println("Linking Compartments.....")val t: Train = new ConcreteMetroTrainval c1 = t.addCompartmentval c2 = t.addCompartmentval c3 = t.addCompartmentc1.join(c2)c2.join(c3)}
}

That’s all for polymorphic methods and explicitly typed references in scala programming, we will look into more scala features in coming posts.

这一切都用于scala编程中的多态方法和显式键入的引用，我们将在以后的文章中研究更多的scala功能。

翻译自: https://www.journaldev.com/8495/scala-polymorphic-methods-and-explicitly-typed-references

scala 类的多态