How to control Scala method scope with private, package, and more

This is an excerpt from the Scala Cookbook (partially modified for the internet). This is Recipe 5.1, “How to control method scope in Scala (private, package, more).”

Back to top

Problem

Scala methods are public by default, and you want to control their scope in ways similar to Java.

Back to top

Solution

Scala lets you control method visibility in a more granular and powerful way than Java. In order from “most restrictive” to “most open,” Scala provides these scope options:

  • Object-private scope
  • Private
  • Package
  • Package-specific
  • Public

These scopes are demonstrated in the examples that follow.

Back to top

Object-private scope

The most restrictive access is to mark a method as “object-private.” When you do this, the method is available only to the current instance of the current object. Other instances of the same class cannot access the method.

You mark a method as object-private by placing the access modifier private[this] before the method declaration:

private[this] def isFoo = true

In the following example, the method doFoo takes an instance of a Foo object, but because the isFoo method is declared as an object-private method, the code won’t compile:

class Foo {
    private[this] def isFoo = true
    def doFoo(other: Foo) {
        if (other.isFoo) {  // this line won't compile
            // ...
        }
    }
}

The code won’t compile because the current Foo instance can’t access the isFoo method of the other instance, because isFoo is declared as private[this]. As you can see, the object-private scope is extremely restrictive.

Back to top

Private scope

A slightly less restrictive access is to mark a method private, which makes the method available to (a) the current class and (b) other instances of the current class. This is the same as marking a method private in Java. By changing the access modifier from private[this] to private, the code will now compile:

class Foo {
    private def isFoo = true
    def doFoo(other: Foo) {
        if (other.isFoo) {  // this now compiles
            // ...
        }
    }
}

By making a method private, it is not available to subclasses. The following code won’t compile because the heartBeat method is private to the Animal class:

class Animal {
    private def heartBeat {}
}

class Dog extends Animal {
    heartBeat  // won't compile
}
Back to top

Protected scope

Marking a method protected makes the method available to subclasses, so the following code will compile:

class Animal {
    protected def breathe {}
}

class Dog extends Animal {
    breathe
}

The meaning of protected is slightly different in Scala than in Java. In Java, protected methods can be accessed by other classes in the same package, but this isn’t true in Scala. The following code won’t compile because the Jungle class can’t access the breathe method of the Animal class, even though they’re in the same package:

package world {
    class Animal {
        protected def breathe {}
    }
    class Jungle {
        val a = new Animal
        a.breathe   // error: this line won't compile
    }
}
Back to top

Package scope

To make a method available to all members of the current package — what would be called “package scope” in Java — mark the method as being private to the current package with the private[packageName] syntax.

In the following example, the method doX can be accessed by other classes in the same package (the model package), but the method doY is available only to the Foo class:

package com.acme.coolapp.model {
    class Foo {
        private[model] def doX {}
        private def doY {}
    }
    class Bar {
        val f = new Foo
        f.doX  // compiles
        f.doY  // won't compile
    }
}
Back to top

More package-level control

Beyond making a method available to classes in the current package, Scala gives you more control and lets you make a method available at different levels in a class hierarchy. The following example demonstrates how you can make the methods doX, doY, and doZ available to different package levels:

package com.acme.coolapp.model {
    class Foo {
        private[model] def doX {}
        private[coolapp] def doY {}
        private[acme] def doZ {}
    }
}

import com.acme.coolapp.model._

package com.acme.coolapp.view {
    class Bar {
        val f = new Foo
        f.doX  // won't compile
        f.doY
        f.doZ
    }
}

package com.acme.common {
    class Bar {
        val f = new Foo
        f.doX  // won't compile
        f.doY  // won't compile
        f.doZ
    }
}

In this example, the methods can be seen as follows:

  • The method doX can be seen by other classes in the model package (com.acme.coolapp.model).
  • The method doY can be seen by all classes under the coolapp package level.
  • The method doZ can be seen by all classes under the acme level.

As you can see, this approach allows a fine-grained level of access control.

Back to top

Public scope

If no access modifier is added to the method declaration, the method is public. In the following example, any class in any package can access the doX method:

package com.acme.coolapp.model {
    class Foo {
      def doX {}
    }
}

package org.xyz.bar {
    class Bar {
        val f = new com.acme.coolapp.model.Foo
        f.doX
    }
}
Back to top

Discussion

The Scala approach to access modifiers is different than Java. Though it offers more power than Java, it’s also a little more complicated.

Table 5-1 describes the levels of access control that were demonstrated in the examples in the Solution.

Table 5-1. Descriptions of Scala’s access control modifiers

Access modifier Description
private[this] The method is available only to the current instance of the class it’s declared in.
private The method is available to the current instance and other instances of the class it’s declared in.
protected The method is available only to instances of the current class and subclasses of the current class.
private[model] The method is available to all classes beneath the com.acme.coolapp.model package.
private[coolapp] The method is available to all classes beneath the com.acme.coolapp package.
private[acme] The method is available to all classes beneath the com.acme package.
(no modifier) The method is public.
Back to top

The Scala Cookbook

This tutorial is sponsored by the Scala Cookbook, which I wrote for O’Reilly:

You can find the Scala Cookbook at these locations:

Back to top

Add new comment

The content of this field is kept private and will not be shown publicly.

Anonymous format

  • Allowed HTML tags: <em> <strong> <cite> <code> <ul type> <ol start type> <li> <pre>
  • Lines and paragraphs break automatically.
By submitting this form, you accept the Mollom privacy policy.