Scope of Variables In Scala

Variable declaration specifies the name of the variable that would be stored in the memory and memory can be accessed further with this name of variable. There are three types of scope for Scala variable.

• Fields.
• Method Parameters.
• Local Variables.

Let's discuss each of them in detail. Fields We can access these kind of variables from every method in the object & from outside the object if we declared them with the right access modifiers.A field may be mutable or immutable, they can define them using ‘var’ or ‘val’. Example: Scala

// Scala program of field 
// scope for Scala variable

// class created with field 
// variables x and y.
class disp 
{
    var x = 10.3f
    var y = 7f
    def windet() 
    {
        println("Value of x : "+x)
    }
        println("Value of y : "+y);
}

object Example 
{
    // Main method
    def main(args:Array[String]) 
    {
        val Example = new disp()
        Example.windet()
    }
}

Output:

Value of y : 7.0
Value of x : 10.3

Above example shows disp class is created with field variables x and y. These variables can be accessed inside a method and invoked this from an object by creating reference.Hence below is the output obtained.   Method Parameters We use these variables when we want to pass a value inside the method when we call it. They can be accessed inside the method and outside method if there is a reference to the object from outside the method. these variables are always mutable Using with 'val' keyword. Example: Scala

// Scala program of Method 
// scope for Scala variable

// class created with Method 
// variables s1 and s2.
class rect 
{
    def mult(s1: Int, s2: Int)
    {
        var result = s1 * s2
       println("Area is: " + result);
    }
}

object Area 
{
    // Main method
    def main(args:Array[String])
    {
        val su = new rect()
        su.mult(5, 10)
    }
}

Output:

Area is: 50

Above Example shows rect class is created with mult method accepting two method parameter variables s1 and s2. Area object is created and rect method is invoking by passing the values to variables s1 and s2.Hence below is the output obtained.   Local Variables These type of variables are declared inside a method and are accessible within it only.Using 'var' & 'val' keywords, these variables can be both mutable & immutable. Example: Scala

// Scala program of Method 
// scope for Scala variable

// class created with Local
// variables s1 and s2.
class Area 
{
    def mult() 
    {
        var(s1, s2) = (3, 80);
        var s = s1 * s2;
        println("Area is: " + s)
    }
}

object Test 
{
    // Main method
    def main(args:Array[String]) 
    {
        val ex = new Area()
        ex.mult()
    }
}

Output:

Area is: 240

Above example shows class Area having local variables s1, s2 & s inside method mult.These variables are not accessible outside the method.Hence the output obtained is below.