Scala - Access Modifiers

---

---

This chapter takes you through the Scala access modifiers. Members of packages, classes or objects can be labeled with the access modifiers private and protected, and if we are not using either of these two keywords, then access will be assumed as public. These modifiers restrict accesses to the members to certain regions of code. To use an access modifier, you include its keyword in the definition of members of package, class or object as we will see in the following section.

Private Members

A private member is visible only inside the class or object that contains the member definition.

Following is the example code snippet to explain Private member −

Example

class Outer {
   class Inner {
      private def f() { println("f") }
      
      class InnerMost {
         f() // OK
      }
   }
   (new Inner).f() // Error: f is not accessible
}

In Scala, the access (new Inner). f() is illegal because f is declared private in Inner and the access is not from within class Inner. By contrast, the first access to f in class Innermost is OK, because that access is contained in the body of class Inner. Java would permit both accesses because it lets an outer class access private members of its inner classes.

Protected Members

A protected member is only accessible from subclasses of the class in which the member is defined.

Following is the example code snippet to explain protected member −

Example

package p {
   class Super {
      protected def f() { println("f") }
   }
   
   class Sub extends Super {
      f()
   }
   
   class Other {
      (new Super).f() // Error: f is not accessible
   }
}

The access to f in class Sub is OK because f is declared protected in Super class and Sub class is a subclass of Super. By contrast the access to f in Other class is not permitted, because class Other does not inherit from class Super. In Java, the latter access would be still permitted because Other class is in the same package as Sub class.

Public Members

Unlike private and protected members, it is not required to specify Public keyword for Public members. There is no explicit modifier for public members. Such members can be accessed from anywhere.

Following is the example code snippet to explain public member −

Example

class Outer {
   class Inner {
      def f() { println("f") }
      
      class InnerMost {
         f() // OK
      }
   }
   (new Inner).f() // OK because now f() is public
}

Scope of Protection

Access modifiers in Scala can be augmented with qualifiers. A modifier of the form private[X] or protected[X] means that access is private or protected "up to" X, where X designates some enclosing package, class or singleton object.

Consider the following example −

Example

package society {
   package professional {
      class Executive {
         private[professional] var workDetails = null
         private[society] var friends = null
         private[this] var secrets = null

         def help(another : Executive) {
            println(another.workDetails)
            println(another.secrets) //ERROR
         }
      }
   }
}

Note − the following points from the above example −

• Variable workDetails will be accessible to any class within the enclosing package professional.

• Variable friends will be accessible to any class within the enclosing package society.

• Variable secrets will be accessible only on the implicit object within instance methods (this).

Private[Scope] and Protected[Scope] Access Modifiers

You can define more granular access control using scoped private and protected access. Scoped access modifiers restrict access to a specific package and enclosing class.

Syntax

class ClassName {
  private[packageName] var privateField: Type = initialValue

  protected[packageName] def protectedMethod(): ReturnType = {
    // Method body
  }
}

Example

The following example shows scoped private and protected access modifiers.

package com.example

class Outer {
  private[example] var outerField: Int = 10

  protected[example] def outerMethod(): Unit = {
    println(s"Outer field: $outerField")
  }

  class Inner {
    def display(): Unit = {
      outerField = 20
      outerMethod()
    }
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val outer = new Outer()
    val inner = new outer.Inner()
    inner.display()
  }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

> scalac Demo.scala
> scala Demo

Output

Outer field: 20

In the example, Outer class has a scoped private field outerField and scoped protected method outerMethod. Both restricted to the com.example package. The Inner class can access these members because it is in the same package.

Access Modifiers Summary

• Public − Members are accessible from anywhere and are the default if no access modifier is specified.
• Private − Members are accessible only within the class and object where these are defined.
• Protected − Members are accessible within the class and its subclasses but not from outside.
• Scoped Private and Protected − Provide more granular access control by restricting access to a specific package and enclosing class.