Scala 构造

一些基本的 Scala 构造是表达式、块、类、对象、函数、方法、特征、主要方法、字段和闭包。
1. Scala 表达式：Scala中的可计算语句称为表达式。例如，以下是一个表达式： 3 + 4 。使用 println() 打印表达式的输出。
句法

println(expression)

例子

// Scala program to illustrate expressions
object Main 
{
    def main(args: Array[String]) 
    {
        println(3)
        println(3 + 4)
        println("Scala")
        println("How " + "are" + " you?") 
    }
}

输出：

3
7
Scala
How are you?

2. 值：我们可以使用 'val' 关键字来命名。此表达式返回一个结果。
句法

val variable_name = 'Result to be printed'

例子

// Scala program to illustrate values
object Main 
{
    def main(args: Array[String]) 
    {
        val name1 ="Arjun"
        println(name1)
          
        val name2 = "Sheena"
        println(name2)
    }
}

输出

Arjun
Sheena

在这里，这种类型的实体只能有一个值。如果我们尝试重新分配该值，那么它将给出错误。

3. Scala变量：变量只是一个存储位置，它的名字是已知的，它存储了一些已知和未知的信息，称为值。要声明变量，我们使用“var”关键字。
句法

var variable_name = Any_number

例子

// Scala program to illustrate variables
object Main 
{
    def main(args: Array[String]) 
    {
        // Here, p is a variable
        var p = 3
        p = 4 
        println(p * p) 
    }
}

输出

4. Scala 块：由花括号（{}）分隔的一组表达式称为块。
句法

println({// Expression})

例子

// Scala program to illustrate blocks
object Main 
{
    def main(args: Array[String]) 
    {
        println({val p = 10 * 2
                     p + 1}) 
    }
}

输出

5. Scala 类：类是用户定义的蓝图或原型，从中创建对象。它包含统称为成员的值、变量、类型、类、函数、方法、对象和特征。为了声明一个类，我们使用'class'关键字和一个标识符。

句法

{
    class class_name{}
    val variable_name = new class_name
}

例子

// Scala program to illustrate class
  
// class 
class Geeks 
{ 
        
    // Class variable
    var name: String = "GeeksforGeeks"
        
    // Class method 
    def Show() 
    { 
        println("Company's name : " + name); 
    } 
} 
object Main  
{ 
        
    // Main method 
    def main(args: Array[String])  
    { 
            
        // Class object 
        var obj = new Geeks(); 
        obj.Show(); 
    } 
}

输出：

Company's name : GeeksforGeeks

6. 对象：对象是它自己的类的一个单例，即它是它自己定义的一个实例。
强的：

object MyObject{
      def method_name() = {
      // Expression
  }
}

例子：

// Scala program to illustrate object
object Main extends App
{
    object MyObject
    {
        def plusthree() = { 
            val x = 2 + 2
            x + 3
        }
    }
    println(MyObject.plusthree) 
}

输出：

7. Scala函数：接受参数的表达式称为函数。或者换句话说，它是执行特定任务的语句的集合。它可以分配给一个变量，这种类型的函数称为匿名函数。 => 的左侧是参数列表，右侧是它将返回的表达式。

句法

(y:Int)=>y+y

这个函数接受一个整数参数 y，并返回它的加法。我们也可以给值命名。
例子：

// Scala program to illustrate function
object Main 
{
    def main(args: Array[String]) 
    {
        val addition = (y:Int) => y + y
        println(addition(4)) 
    }
}

输出：

8. Scala 方法：我们使用关键字“def”定义方法。它几乎类似于一个函数。接下来是标识符、参数列表、返回类型和正文。或者换句话说，它是执行特定任务的语句的集合。
句法

def method_name ([parameter_list]) : [return_type] = {
   
  // Method body

}

例子

// Scala program to illustrate method
object Main 
{
    def display()
    {
        println("Welcome to GFG")
    }
    def main(args: Array[String]) 
    {
        // Calling method
        display()
    }
}

输出

Welcome to GFG

9. Scala Trait： Traits 就像Java中的接口。但是特征允许您实现成员。它可以有方法（抽象的和非抽象的）和字段作为它的成员。它是使用关键字“特征”定义的。
句法

trait trait_name
{
// Fields
// Methods
}

例子

// Scala program to illustrate traits 
  
// Trait 
trait MyTrait 
{ 
    def show
  
} 
  
// MyGfg inherits a trait 
class MyGfg extends MyTrait 
{ 
      
    // Implementation of methods of MyTrait 
    def show() 
    { 
        println("Hey Geeks") 
    } 
      
} 
  
object Main 
{ 
      
    // Main method 
    def main(args: Array[String]) 
    { 
        val ob = new MyGfg(); 
        ob.show(); 
    } 
}

输出：

Hey Geeks

10. Scala Main 方法：任何程序的入口点都是 main 方法。 JVM 需要一个带有参数的方法，该参数是一个字符串数组。
11. 字段：这些字段有助于定义对象状态。它是属于每个对象的一组唯一实例变量。
12. 闭包：闭包是一个函数，它的返回值取决于在它外面声明的变量。