Home > Backend Development > PHP Tutorial > [TOUR OF Scala] 2-Basics - TOUR OF SCALA

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

不言
Release: 2023-03-22 19:18:01
Original
1485 people have browsed it

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
Copy after login

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!
Copy after login

Value

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

val x = 1 + 1println(x) // 2
Copy after login

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.
Copy after login

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

val x: Int = 1 + 1
Copy after login

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
Copy after login

As with values, you can declare types explicitly:

var x: Int = 1 + 1
Copy after login

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
Copy after login

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
Copy after login

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
Copy after login

Function can use multiple parameters.

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

Or it requires no parameters.

val getTheAnswer = () => 42
println(getTheAnswer()) // 42
Copy after login

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
Copy after login

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
Copy after login

Or there is no parameter list at all.

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

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
}
Copy after login

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)
}
Copy after login

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!
Copy after login

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)
Copy after login

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)
Copy after login

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.
Copy after login

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
  }
}
Copy after login

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
Copy after login

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
}
Copy after login

Features can also have default implementations.

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

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?
Copy after login

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!")
}
Copy after login

                                                



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!

Related labels:
source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template