Clase interna en Scala

Clase interna significa definir una clase en otra. Esta función permite al usuario agrupar de forma lógica las clases que solo se utilizan en un lugar, lo que aumenta el uso de la encapsulación y crea un código más legible y fácil de mantener. En Scala, el concepto de clases internas es diferente de Java. Al igual que en Java, la clase interna es miembro de la clase externa, pero en Scala, la clase interna está vinculada al objeto externo .
Sintaxis:

class Outer_class{
class Inner_class{
// Code..
}
}

Ejemplo:

// Scala program to illustrate how to 
// create inner class
  
// Outer class
class Geek
{
      
    // Inner class
    class G1
    {
        var a = 0
        def method()
        {
            for(a<-0 to 3)
            {
                println("Welcome to inner class: G1");
            }
        }
    }
}
object Main 
{
    def main(args: Array[String]) 
    {
          
        // Creating object of the outer and
        // inner class Here, G1 class is 
        // bounded with the object of Geek class
        val obj = new Geek();
        val o = new obj.G1;
        o.method();
    }
}

Producción:

Welcome to inner class: G1
Welcome to inner class: G1
Welcome to inner class: G1
Welcome to inner class: G1

Explicación: En el ejemplo anterior, Geek es la clase externa y G1 es la clase interna. Ahora, para crear el objeto de la clase interna, en primer lugar, debe crear el objeto de la clase externa y el objeto de la clase externa es obj. Ahora, obj tiene el prefijo clase G1 y crea el objeto o de la clase G1 porque la clase interna está vinculada al objeto de la clase externa.

Cómo crear una clase dentro de un objeto y un objeto dentro de la clase

En Scala también podemos incluir una clase dentro de un objeto o un objeto dentro de una clase. Vamos a discutir con un ejemplo. En el siguiente ejemplo, primero, creamos un objeto dentro de una clase y accedemos al método del objeto con la ayuda de la nueva palabra clave seguida del nombre de la clase, el nombre del objeto y el nombre del método, como se muestra en la siguiente declaración:

new outer_class().inner_object.method;

Ahora, en segundo lugar, creamos una clase dentro de un objeto y accedemos a los métodos presentes en la clase a la que se accede con la ayuda de la nueva palabra clave seguida del nombre del objeto, el nombre de la clase y el nombre del método, como se muestra en la siguiente declaración:

new outer_object.inner_class().method; 

Ejemplo :

// Scala program to illustrate how to 
// create an object inside a class, Or
// a class inside an object
  
// Class inside Object
class outer_class
{
    object inner_object
    {
        val q = 0;
        def method()
        {
            for(q <- 0 to 2)
            {
                println("object inside a class example")
            }
            println()
        }
    }
}
  
// Object inside Class
object outer_object
{
    class inner_class
    {
        val s = 0;
        def method()
        {
            for(s <- 0 to 2)
            {
                println("class inside an object example")
            }
        }
    }
}
  
object Main
{
      
    // Main method
    def main(args: Array[String])
    {
          
        // Object inside a class
        new outer_class().inner_object.method;
          
        // Class inside an object
        new outer_object.inner_class().method;
    }
}

Producción:

object inside a class example
object inside a class example
object inside a class example

class inside an object example
class inside an object example
class inside an object example