Scala 自身类型注释

特质的 自我类型注解 是 指该 特质的假定类型，在特质中，要使用的接收器。任何混入特质的具体类必须确保其自我类型符合混入的特质。这意味着使用自我类型不会将局部变量和方法暴露给其子类和子trait。对于将一个大类划分为几个特质是自类型最常见的用途。自类型是一种声明一个特质必须混入另一个特质或类的方式，即使它没有直接扩展它，这使得那些混入特质的依赖成员无需导入就可以使用。

要在特质中使用自我类型，请写下标识符_name，旁边是要混入的特质类型，后面是=>符号；如下所示。

语法

trait A{
    //statements
}
trait B{
    this: A => //here we can use methods & variables of trait A
}

让我们来讨论一些例子。

例子

// Scala Program that uses self type
trait with_powers
{ 
    var mind ="extra-ordinary"; 
      
}
trait without_powers
{
    var mind="ordinary";
}
trait person
{ 
    def brain();
}
  
// class extend trait
class extraordinary_person extends person
{   
    // reassign this
    this: with_powers => 
    override def brain() = println(s"super hero brain is mind!");
}
  
// class extend trait
class ordinary_person extends person
{   
    // reassign this
    this: without_powers => 
    override def brain() = println(s"normal human brain ismind.");
}
  
// Creating object
object GFG
{
    // Main method
    def main(args:Array[String])
    {
        val hero = new extraordinary_person() with with_powers;
        val mohan = new ordinary_person() with without_powers;
          
        //val mohan= new ordinary_person() with with_powers; ERROR
        //does not conform to ordinary_person's self type
        hero.brain();
        mohan.brain();
    }
}

输出:

super hero brain is extra-ordinary!.
normal human brain is ordinary.

在上面的例子中，我们创建了traits with_powers, without_powers和person。在这里，class extraordinary_person扩展了trait person。同样，class ordinary_person也扩展了trait person。通过使用这个trait name =>
val mohan= new ordinary_person() with with_powers; 显示一个错误，不符合ordinary_person的自我类型。

示例 :

// Scala Program that uses self type
trait A
{ 
    def x = 1;
}
  
// trait extend another trait
trait B extends A
{
    override def x = super.x * 5;
}
  
// trait extend another trait
trait C1 extends B
{
    override def x = 2;
}
  
// trait extend another trait
trait C2 extends A
{ 
    this: B=> override def x = 2; 
      
}
  
// Creating object
object GFG
{
    // Main method
    def main(args:Array[String])
    {
        println((new C1 with B).x);
        println((new C2 with B).x);
    }
}

输出:

2
10

这里，在上面的例子中，C2是一个抽象类型，C2的自我类型是B。（（new C2 with B））符合C2的自我类型是B（this: B=>）所以，自我类型让你指定哪些类型的特征允许混合。

例子:

// Scala Program that uses self type
trait Being
{
    var name: String
    var age: Int
    var gender: String
}
  
// Creating trait
trait Sayings
{
    this: Being =>
    def greetings(greet: String) = println(s"name:greet");
    def info() = println(s"I am age years oldgender");
}
  
// extend both trait with single class
class Person(var r_name: String, var r_age: Int, 
                            var r_gender: String)
extends Sayings with Being
{
    var name = s"Person $r_name";
    var age = r_age;
    var gender = r_gender;
}
  
// Creating object
object GFG
{
    // Main method
    def main(args: Array[String])
    {
        val person = new Person("Lakshya", 24, "Male");
        person.greetings("hello, hi there!!");
        person.info();
    }
}

输出:

Person Lakshya: hello, hi there!!
I am 24 years old Male

在上面的例子中（this: Being => ），基本上意味着Being的变量name、age、gender现在在greetings和info方法的范围内，但没有暴露给任何其他子类或扩展它的trait。所以，一个自我类型指定了对任何具体类的要求，该类型的特质应该被混合在其中。