Methods
Info: JavaScript is currently disabled, code tabs will still work, but preferences will not be remembered.
Scala methods
Scala classes, case classes, traits, enums, and objects can all contain methods. The syntax of a simple method looks like this:
def methodName(param1: Type1, param2: Type2): ReturnType =
// the method body
// goes here
Here are a few examples:
def sum(a: Int, b: Int): Int = a + b
def concatenate(s1: String, s2: String): String = s1 + s2
You don’t have to declare a method’s return type, so you can write those methods like this, if you prefer:
def sum(a: Int, b: Int) = a + b
def concatenate(s1: String, s2: String) = s1 + s2
This is how you call those methods:
val x = sum(1, 2)
val y = concatenate("foo", "bar")
Here’s an example of a multiline method:
def getStackTraceAsString(t: Throwable): String = {
val sw = new StringWriter
t.printStackTrace(new PrintWriter(sw))
sw.toString
}
def getStackTraceAsString(t: Throwable): String =
val sw = new StringWriter
t.printStackTrace(new PrintWriter(sw))
sw.toString
Method parameters can also have default values.
In this example, the timeout parameter has a default value of 5000:
def makeConnection(url: String, timeout: Int = 5000): Unit =
println(s"url=$url, timeout=$timeout")
Because a default timeout value is supplied in the method declaration, the method can be called in these two ways:
makeConnection("https://localhost") // url=http://localhost, timeout=5000
makeConnection("https://localhost", 2500) // url=http://localhost, timeout=2500
Scala also supports the use of named parameters when calling a method, so you can also call that method like this, if you prefer:
makeConnection(
url = "https://localhost",
timeout = 2500
)
Named parameters are particularly useful when multiple method parameters have the same type.
At a glance, with this method you may wonder which parameters are set to true or false:
engage(true, true, true, false)
The extension keyword declares that you’re about to define one or more extension methods on the parameter that’s put in parentheses.
As shown with this example, the parameter s of type String can then be used in the body of your extension methods.
This next example shows how to add a makeInt method to the String class.
Here, makeInt takes a parameter named radix.
The code doesn’t account for possible string-to-integer conversion errors, but skipping that detail, the examples show how it works:
extension (s: String)
def makeInt(radix: Int): Int = Integer.parseInt(s, radix)
"1".makeInt(2) // Int = 1
"10".makeInt(2) // Int = 2
"100".makeInt(2) // Int = 4
See also
Scala Methods can be much more powerful: they can take type parameters and context parameters. They are covered in detail in the Domain Modeling section.