[TOUR OF Scala] 2-Basics - TOUR OF SCALA

In this page, we will introduce the basics of Scala.

Try Scala in the browser

You can run Scala in the browser using ScalaFiddle.

1. Open https://scalafiddle.io

2. Paste in the left paneprintln("Hello, world!")

3. Click the "Run" button. The output is displayed in the right pane.

This is a simple, zero-setup way to test Scala code snippets.

Expression

Expressions are computable statements.

1 + 1

You can use println to output the result of an expression.

println(1) // 1
println(1 + 1) // 2
println("Hello!") // Hello!
println("Hello," + " world!") // Hello, world!

Value

You can use the val keyword to name the result of an expression.

val x = 1 + 1println(x) // 2

The named result, like x here, is called the value. Referencing a value does not recalculate it.

Values ​​cannot be reassigned.

val x = 1 + 1x = 3 // This does not compile.

The compiler can infer the type of the value, but you can also declare the type explicitly, as follows:

val x: Int = 1 + 1

Note that the type declaration Int is in The identifier x appears after the identifier, and a : needs to be added between the two.

Variables

Variables are like values, but you can reassign them. You can define a variable using the var keyword.

var x = 1 + 1x = 3 // This compiles because "x" is declared with the "var" keyword.
println(x * x) // 9

As with values, you can declare types explicitly:

var x: Int = 1 + 1

Code blocks

You can combine surrounding expressions. We call this code block.

The result of the last expression in the block is also the result of the entire block.

println({
  val x = 1 + 1
  x + 1
}) // 3

Function

A function is an expression with parameters.

You can define an anonymous function (i.e. without a name) that returns a given integer + 1:

(x: Int) => x + 1

On the left side of the launch symbol => is A parameter list. On the right is an expression containing parameters.

You can also name functions.

val addOne = (x: Int) => x + 1
println(addOne(1)) // 2

Function can use multiple parameters.

val add = (x: Int, y: Int) => x + y
println(add(1, 2)) // 3

Or it requires no parameters.

val getTheAnswer = () => 42
println(getTheAnswer()) // 42

Methods

Methods look very similar to functions, but there are some key differences between them.

Methods are defined using the def keyword. def is followed by the method name, parameter list, a return type and a body.

def add(x: Int, y: Int): Int = x + y
println(add(1, 2)) // 3

Note that the return type is declared after the parameter list and the colon : Int.

Methods can use multiple parameter lists.

def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
println(addThenMultiply(1, 2)(3)) // 9

Or there is no parameter list at all.

def name: String = System.getProperty("name")
println("Hello, " + name + "!")

There are some other differences, but for now, you can think of them as something similar to functions.

Methods can also have multi-line expressions. The last expression of

def getSquareString(input: Double): String = {
  val square = input * input
  square.toString
}

body is the return value of the method. (Scala has a return keyword return, but it is rarely used.)

Class

You can use the class keyword class to define a class , and then use its name and constructor parameters. The return type of the

class Greeter(prefix: String, suffix: String) {
  def greet(name: String): Unit =
    println(prefix + name + suffix)
}

method greet is Unit, which means that the return has no meaning. It is similar to the keyword void in Java and C (the difference is that because every Scala expression must have a certain value, there is actually a type Unit Singleton value, written as (). It does not carry any information)

You can use the keyword new to create an instance of a class.

val greeter = new Greeter("Hello, ", "!")
greeter.greet("Scala developer") // Hello, Scala developer!

We will introduce classes in detail later.

Sample Class

Scala has a special type of class called a "sample" class. By default, sample classes are immutable and compare by value.

You can define a case class using the case class keyword.

case class Point(x: Int, y: Int)

You do not need to use the new keyword to instantiate the sample class.

val point = Point(1, 2)
val anotherPoint = Point(1, 2)
val yetAnotherPoint = Point(2, 2)

They are compared by value.

if (point == anotherPoint) {
  println(point + " and " + anotherPoint + " are the same.")
} else {
  println(point + " and " + anotherPoint + " are different.")
}
// Point(1,2) and Point(1,2) are the same.
if (point == yetAnotherPoint) {
  println(point + " and " + yetAnotherPoint + " are the same.")
} else { 
  println(point + " and " + yetAnotherPoint + " are different.")
}
// Point(1,2) and Point(2,2) are different.

There are many more sample classes we want to introduce, we believe you will fall in love with them! We will introduce them in detail later.

Objects

Objects are single instances of their own definition. You can think of them as singletons of their own class.

You can define objects by using the keyword object.

object IdFactory {  
  private var counter = 0 
  def create(): Int = { 
    counter += 1    
    counter
  }
}

You can access an object by referencing its name.

val newId: Int = IdFactory.create()
println(newId) // 1
val newerId: Int = IdFactory.create()
println(newerId) // 2

We will introduce objects in detail later.

Traits

Traits are types that contain certain fields and methods. Multiple features can be combined together.

You can define traits by using the keyword trait.

trait Greeter { 
  def greet(name: String): Unit
}

Features can also have default implementations.

trait Greeter {
  def greet(name: String): Unit = 
    println("Hello, " + name + "!")
}

You can extend features using the extends keyword and override implementations using the override keyword.

class DefaultGreeter extends Greeter
class CustomizableGreeter(prefix: String, postfix: String) extends Greeter { 
  override def greet(name: String): Unit = {    
    println(prefix + name + postfix)
  }
}
val greeter = new DefaultGreeter()
greeter.greet("Scala developer") // Hello, Scala developer!
val customGreeter = new CustomizableGreeter("How are you, ", "?")
customGreeter.greet("Scala developer") // How are you, Scala developer?

Here, DefaultGreeter only extends a single trait, but it can extend multiple traits.

We will introduce traits in detail later.

Main method

The main method is the entry point of a program. The Java virtual machine requires a main method named main and accepts one parameter, a string array.

Using objects, you can define a main method as follows:

object Main {  
  def main(args: Array[String]): Unit = 
    println("Hello, Scala developer!")
}

                                                

The above is the detailed content of [TOUR OF Scala] 2-Basics - TOUR OF SCALA. For more information, please follow other related articles on the PHP Chinese website!