Fundición de tipos en Scala

Una conversión de tipo es básicamente una conversión de un tipo a otro. En lenguajes de programación dinámicos como Scala, a menudo es necesario convertir de un tipo a otro. La conversión de tipos en Scala se realiza mediante el método asInstanceOf[] . 

• Esta perspectiva es necesaria para manifestar beans desde un archivo de contexto de aplicación.
• También se utiliza para convertir tipos numéricos.
• Incluso se puede aplicar en códigos complejos como comunicarse con Java y enviarle una serie de instancias de objetos.

Sintaxis: 
obj1 = obj.asInstanceOf[clase];
donde 
obj1 es el objeto al que se devuelve la instancia convertida de obj, 
obj es el objeto que se va a convertir y 
class es el nombre de la clase en la que se va a convertir obj. 
 

Aquí, solo un objeto de una clase extendida (secundaria) puede convertirse en un objeto de su clase principal, pero no al revés. Si la clase A amplía la clase B, el objeto de A puede convertirse en un objeto de la clase B y el objeto de B no puede convertirse en un objeto de la clase A. Este método informa al compilador que el valor es del tipo especificado. Durante el tiempo de ejecución, si el valor/objeto proporcionado no es compatible con el tipo o la clase especificados, se lanza una excepción.

Ejemplos:  

// Scala program of type casting
object GFG
{
    // Function to display name, value and
    // class-name of a variable
    def display[A](y:String, x:A)
    {
        println(y + " = " + x + " is of type " +
                            x.getClass.getName);
    }
     
    // Main method
    def main(args: Array[String])
    {
        var i:Int = 40;
        var f:Float = 6.0F;
        var d:Double = 85.2;
        var c:Char = 'c';
         
        display("i", i);
        display("f", f);
        display("d", d);
        display("c", c);
         
        var i1 = i.asInstanceOf[Char]; //Casting
        var f1 = f.asInstanceOf[Double]; //Casting
        var d1 = d.asInstanceOf[Float]; //Casting
        var c1 = c.asInstanceOf[Int]; //Casting
 
        display("i1", i1);
        display("f1", f1);
        display("d1", d1);
        display("c1", c1);
    }
}

Producción: 

i = 40 is of type java.lang.Integer
f = 6.0 is of type java.lang.Float
d = 85.2 is of type java.lang.Double
c = c is of type java.lang.Character
i1 = ( is of type java.lang.Character
f1 = 6.0 is of type java.lang.Double
d1 = 85.2 is of type java.lang.Float
c1 = 99 is of type java.lang.Integer

Ejemplos: 

// Scala program of type casting
 
// The parent class
class Parent
{
    var i: Int = 10;
    var j: Int = 5;
     
    // Function to display i and j values
    def display()
    {
        println("Value of i : " + i +
                "\nValue of j : " + j);
    }
}
 
// The child class
class Child extends Parent
{
    // Used to change i and j values
    def change()
    {
        i = 6;
        j = 12;
        println("Values Changed");
    }
}
 
// Creating object
object GFG
{
    // Main method
    def main(args: Array[String])
    {
        var c:Child = new Child();
        c.display();
        c.change();
         
        // Casting
        var p:Parent = c.asInstanceOf[Parent];
        p.display();
         
        /* p.change(); This will have raised an error
        as p is seen as an object of class Parent and
        Parent does not contain change() */
    }
}

Producción: 

Value of i : 10
Value of j : 5
Values Changed
Value of i : 6
Value of j : 12

En el ejemplo anterior p.change(); se añadirá, se habría producido el siguiente error:  

error:value change is not a member of parent.

Ejemplos:  

// Scala program of type casting
 
class Parent
{
    // Member variables and functions.    
}
 
class Child extends Parent
{
    // Member variables and functions.    
}
 
class Unrelated
{
    // Member variables and functions.    
}
 
// Creating object
object GFG
{
    // Main method
    def main(args: Array[String])
    {
        var p:Parent = new Parent();
        try
        {
            p.asInstanceOf[Unrelated];
        }
        catch
        {
            // Used to print the thrown exception.
            case e: Exception => e.printStackTrace();
                        print(e);
        }
        try
        {
            p.asInstanceOf[Child];
        }
        catch
        {
            // Used to print the thrown exception.
            case e1: Exception => e1.printStackTrace();
                        print(e1);
        }
    }
}

Producción: 

java.lang.ClassCastException: Parent cannot be cast to Unrelated
java.lang.ClassCastException: Parent cannot be cast to Child