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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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()
    }
}

chevron_right


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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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)
    }
}

chevron_right


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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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()
    }
}

chevron_right


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.



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :

Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.