Una anotación de tipo propio de un rasgo es el tipo asumido de este , dentro de un rasgo, el receptor que se utilizará. Cualquier clase concreta que se mezcle en un rasgo debe asegurarse de que su tipo propio se ajuste al rasgo que se mezcla. Eso significa que el uso de tipos propios no expone la variable local y los métodos a sus subclases y subcaracterísticas. Porque dividir una clase grande en varios rasgos es el uso más común de tipos propios. Los tipos propios son una forma de declarar que un rasgo debe mezclarse con otro rasgo o clase, aunque no lo extienda directamente, lo que hace que los miembros de la dependencia de los rasgos mezclados estén disponibles sin importar.
Para usar un tipo propio en un rasgo, escriba nombre_identificador , junto a él, el tipo de rasgo que desea mezclar y, a continuación, el símbolo =>; como se indica a continuación.
Sintaxis:
trait A{
//statements
}
trait B{
this: A => //here we can use methods & variables of trait A
}
Analicemos algunos ejemplos.
Ejemplo :
// 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 is $mind.");
}
// 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();
}
}
Producción :
super hero brain is extra-ordinary!. normal human brain is ordinary.
En el ejemplo anterior, creamos rasgos con_poderes, sin_poderes y persona. aquí la clase persona_extraordinaria extiende el rasgo persona. De manera similar, la clase persona_ordinaria también extiende el rasgo de persona. la anotación de tipo propio ocurre en ambas clases usando este nombre de rasgo =>
val mohan= nueva persona_ordinaria() con with_powers; muestra un error que no se ajusta al tipo propio de la persona ordinaria.
Ejemplo :
// 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);
}
}
Producción :
2 10
Aquí, en el ejemplo anterior, C2 es un tipo abstracto y un tipo propio de C2 con B. ((nuevo C2 con B)) se ajusta al tipo propio de C2 con B (esto: B=>) Entonces, un tipo propio le permite especificar qué tipos de rasgos pueden mezclarse.
Ejemplo :
// 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 old $gender");
}
// 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();
}
}
Producción :
Person Lakshya: hello, hi there!! I am 24 years old Male
En el ejemplo anterior (esto: Ser => ) básicamente significa que las variables nombre, edad, género de Ser ahora están en el alcance de los métodos de saludo e información pero sin exponerlos a ninguna otra subclase o rasgo que lo amplíe. Entonces, un tipo propio especifica los requisitos en cualquier clase concreta en la que se debe mezclar el tipo de rasgo.