Glossary

Language
Glossary from the definitive book on Scala, Programming in Scala.
 
  • algebraic data type

    通过提供多种选择定义的类型,每种选择都有其自己的构造函数. 它通常带有一种通过模式匹配来分解类型的方法. 可在规范语言和功能编程语言中找到该概念. 可以使用案例类在Scala中模拟代数数据类型.

  • alternative

    匹配表达式的一个分支. 它的形式为" case pattern => expression ".替代的另一个名称是case .

  • annotation

    注释出现在源代码中,并附加到语法的某些部分. 注释是计算机可处理的,因此您可以使用它们将扩展有效地添加到Scala.

  • anonymous class

    匿名类是Scala编译器从新表达式生成的合成子类,其中新类或特性名称后跟花括号. 花括号包含匿名子类的主体,该主体可能为空. 但是,如果在new之后的名称是指包含抽象成员的特征或类,则必须在定义匿名子类主体的花括号内将它们具体化.

  • anonymous function

    函数文字的别称 .

  • apply

    您可以将方法,函数或闭包应用于自变量,这意味着您可以在这些自变量上调用它.

  • argument

    调用一个函数时,将为该函数的每个参数传递一个参数. 参数是引用参数的变量. 参数是调用时传递的对象. 此外,应用程序可以采用(命令行)自变量,该自变量在传递给单例对象主要方法的Array[String]中显示.

  • assign

    您可以将对象分配给变量. 之后,变量将引用该对象.

  • auxiliary constructor

    在类定义的花括号内定义了额外的构造函数,这些构造函数看起来像名为this方法定义,但没有结果类型.

  • block

    用大括号括起来的一个或多个表达式和声明. 当该块求值时,将按顺序处理其所有表达式和声明,然后该块返回最后一个表达式的值作为其自己的值. 块通常用作函数的主体, 用于表达式while循环以及要将多个语句组合在一起的任何其他位置. 更正式地讲,块是一种封装构造,您只能看到其副作用和结果值. 因此,您不能在其中定义类或对象的花括号形成一个块,因为从外面可以看到字段和方法(在这些花括号内定义). 这样的花括号形成模板.

  • bound variable

    表达式的绑定变量是在表达式内部使用和定义的变量. 例如,在函数文字表达式(x: Int) => (x, y) ,使用了变量xy ,但仅绑定了x ,因为在表达式中将其定义为Int并且将其定义为表达式描述的功能.

  • by-name parameter

    在参数类型前面用=>标记的参数,例如(x: => Int) . 与by-name参数对应的自变量不会在调用方法之前进行评估,而是在每次在方法内部通过名称引用该参数时进行评估. 如果参数不是按名称的,则为按值.

  • by-value parameter

    在参数类型前面没有用=>标记的参数,例如(x: Int) . 在调用方法之前,将评估与按值参数对应的参数. 按值参数与按名称参数形成对比.

  • class

    class关键字定义的可以是抽象的或具体的,并且在实例化时可以使用类型和值进行参数化. 在new Array[String](2) ,要实例化的类是Array ,结果值的类型是Array[String] . 带有类型参数的类称为类型构造函数 . 可以说类型也具有一个类,例如: Array[String]类型的类是Array .

  • closure

    一个函数对象,它捕获自由变量,并且被说成是在创建时可见变量之上的"封闭"对象.

  • companion class

    与在同一源文件中定义的单例对象共享相同名称的类. 该类是单例对象的伴随类.

  • companion object

    与同一源文件中定义的类共享相同名称的单例对象. 伙伴对象和类可以访问彼此的私有成员. 另外,在伴随对象中定义的任何隐式转换都将在使用该类的任何位置的范围内.

  • contravariant

    通过在类型参数前面加上减号(-),可以将逆向注释应用于类或特征的类型参数. 然后,类或特征的子类型与类型注释的参数相反(与之相反). 例如, Function1在其第一类型参数中是互变的,因此Function1[Any, Any]Function1[String, Any]的子类型.

  • covariant

    通过将加号(+)置于类型参数之前,可以将协变注释应用于类或特征的类型参数. 然后,类或特征与类型注释的参数在相同的方向上共同变型. 例如, List在其type参数中是协变的,因此List[String]List[Any]的子类型.

  • currying

    一种使用多个参数列表编写函数的方法. 例如def f(x: Int)(y: Int)是带有两个参数列表的咖喱函数. 通过传递几个参数列表来应用curried函数,例如: f(3)(4) . 但是,也可以编写诸如f(3)之类的咖喱函数的部分应用程序 .

  • declare

    您可以声明一个抽象字段,方法或类型,该字段为实体提供名称,但不能为实现提供名称. 声明和定义之间的主要区别在于,定义为命名实体建立实现,而声明则没有.

  • define

    在Scala程序中定义某些内容就是为其指定名称和实现. 您可以定义类,特征,单例​​对象,字段,方法,局部函数,局部变量 . 因为定义总是涉及某种实现,所以抽象成员被声明为未定义.

  • direct subclass

    类是其直接超类的直接子类.

  • direct superclass

    The class from which a class or trait is immediately derived, the nearest class above it in its inheritance hierarchy. If a class Parent is mentioned in a class Child’s optional extends clause, then Parent is the direct superclass of Child. If a trait is mentioned in Child’s extends clause, the trait’s direct superclass is the Child’s direct superclass. If Child has no extends clause, then AnyRef is the direct superclass of Child. If a class’s direct superclass takes type parameters, for example class Child extends Parent[String], the direct superclass of Child is still Parent, not Parent[String]. On the other hand, Parent[String] would be the direct supertype of Child. See supertype for more discussion of the distinction between class and type.

  • equality

    当不加限定地使用时, 相等是由==表示的值之间的关系. 另请参见引用相等 .

  • existential type

    存在类型包括对未知类型变量的引用. 例如, Array[T] forSome { type T }是一个存在类型. 它是T的数组,其中T是某种完全未知的类型. 关于T所有假定条件是它完全存在. 这个假设很弱,但是至少意味着Array[T] forSome { type T }确实是一个数组而不是香蕉.

  • expression

    产生结果的任何Scala代码. 你也可以说,一个表达式计算为一个值的结果或结果 .

  • filter

    ifif表达式中后接一个if布尔值表达式 . 在for(i <- 1 to 10; if i % 2 == 0) ,过滤器为" if i % 2 == 0 ". if右边的值是过滤器表达式 . 也称为守卫.

  • filter expression

    过滤器表达式for表达式中 if后面的布尔表达式 . 在for( i <- 1 to 10 ; if i % 2 == 0) ,过滤器表达式为" i % 2 == 0 ".

  • first-class function

    Scala supports 一流的功能, which means you can express functions in function literal syntax, i.e., (x: Int) => x + 1, and that functions can be represented by objects, which are called function values.

  • for comprehension

    for理解是一种用于创建新集合的for表达式 . 对于for理解的每次迭代, yield子句定义新集合的一个元素. 例如, for (i <- (0 until 2); j <- (2 until 4)) yield (i, j)返回集合Vector((0,2), (0,3), (1,2), (1,3)) .

  • for expression

    for表达式可以是for循环 (对一个或多个集合进行迭代),或者是for comprehension ,其可以根据一个或多个集合的元素构建新的集合. for表达式由generatorsfilter ,变量定义和yield子句组成( 对于for comprehensions ).

  • for loop

    for循环是一种在一个或多个集合上循环的for表达式 . 由于for循环返回单位,因此它们通常会产生副作用. 例如, for (i <- 0 until 100) println(i)打印数字0到99.

  • free variable

    表达式的自由变量是在表达式内部使用但未在表达式内部定义的变量. 例如,在函数文字表达式(x: Int) => (x, y) ,变量xy都被使用,但是只有y是自由变量,因为它没有在表达式内部定义.

  • function

    函数可以调用与参数,以产生一个结果列表. 函数具有参数列表,主体和结果类型. 属于类,特征或单例对象的成员的函数称为方法 . 在其他函数内部定义的函数称为局部函数 . 结果类型为Unit函数称为过程 . 源代码中的匿名函数称为函数文字 . 在运行时,函数文字被实例化为称为函数值的对象.

  • function literal

    Scala源代码中没有名称的函数,使用函数文字语法指定. 例如, (x: Int, y: Int) => x + y .

  • function value

    可以像其他任何函数一样调用的函数对象. 函数值的类从包scala扩展了FunctionN特征之一(例如Function0Function1 ),通常在源代码中通过函数文字语法表示. 调用函数的apply方法时,将"调用"函数值. 捕获自由变量的函数值是一个闭包 .

  • functional style

    编程的功能风格强调功能和评估结果,而不强调操作发生的顺序. 该样式的特征是将函数值传递到循环方法,不可变数据,无副作用的方法中. 它是Haskell和Erlang等语言的主要范式,并且与命令式风格形成对比.

  • generator

    生成器定义一个命名的val,并在for表达式中为其分配一系列值. 例如,在for(i <- 1 to 10) ,生成器是" i <- 1 to 10 ". <-右边的值是生成器表达式 .

  • generator expression

    生成器表达式在for表达式中生成一系列值. 例如,在for(i <- 1 to 10) ,生成器表达式为" 1 to 10 ".

  • generic class

    一个接受类型参数的类. 例如,由于scala.List具有类型参数,因此scala.List是泛型类.

  • generic trait

    具有类型参数的特征. 例如,因为特征scala.collection.Set采用类型参数,所以它是通用特征.

  • guard

    See filter.

  • helper function

    一种功能,旨在为附近的一个或多个其他功能提供服务. 辅助功能通常实现为本地功能.

  • helper method

    A helper function that’s a member of a class. Helper methods are often private.

  • immutable

    如果以客户端可见的任何方式创建对象后不能更改其值,则该对象是不可变的 . 对象可能是不变的,也可能不是不变的.

  • imperative style

    势在必行的编程风格强调对操作进行仔细的排序,以便按正确的顺序进行操作. 该样式的特征是具有循环的迭代,适当改变数据的位置以及具有副作用的方法. 它是诸如C,C ++,C#和Java之类的语言的主要范例,并且与功能样式形成对比.

  • initialize

    在Scala源代码中定义变量后,您必须使用对象对其进行初始化.

  • instance

    实例或类实例是一个对象,一个仅在运行时存在的概念.

  • instantiate

    实例化一个类就是从该类中创建一个新对象,该操作仅在运行时发生.

  • invariant

    不变式有两种使用方式. 这可能意味着当数据结构格式正确时,该属性始终成立. 例如,它是已排序的二叉树的不变式,如果每个节点都有一个正确的子节点,那么每个节点将在其右边的子节点之前排序. 不变变量有时也用作不变变量的同义词:"类Array的类型参数不变."

  • invoke

    您可以参数 调用方法,函数或闭包,这意味着将使用指定的参数执行其主体.

  • JVM

    The JVM is the Java Virtual Machine, or runtime, that hosts a running Scala program.

  • literal

    1"One"(x: Int) => x + 1文字的示例. 文字是描述对象的简写方式,其中简写恰好反映了创建的对象的结构.

  • local function

    局部函数是在块内部定义的def . 相比之下,定义为类,特征或单例对象的成员的def称为method .

  • local variable

    局部变量是在块内定义的valvar . 尽管与局部变量相似,但函数的参数并不称为局部变量,而简称为没有"局部"的参数或"变量".

  • member

    成员是类,特征或单例对象的模板的任何命名元素. 可以使用其所有者的名称,一个点及其简单名称来访问成员. 例如,类中定义的顶级字段和方法是该类的成员. 在类内部定义的特征是其封闭类的成员. 用类中的type关键字定义的类型是该类的成员. 类是定义它的包的成员. 相反,局部变量或局部函数不是其周围块的成员.

  • message

    演员通过发送彼此的信息互相交流. 发送消息不会中断接收者的操作. 接收者可以等待,直到它完成了当前活动,并且已经重新建立了其不变性.

  • meta-programming

    Meta-programming software is software whose input is itself software. Compilers are meta-programs, as are tools like scaladoc. Meta-programming software is required in order to do anything with an annotation.

  • method

    方法是属于某个类,特征或单例对象的成员的函数.

  • mixin

    Mixin是在mixin组合物中使用的一种特性. 换句话说,在" trait Hat "中, Hat只是一个特质,但是在" new Cat extends AnyRef with Hat "中, Hat可以称为mixin. 当用作动词时,"混入"是两个单词. 例如,你可以上课或其他性状混合特征.

  • mixin composition

    将特征混合到类或其他特征中的过程. Mixin的组成与传统的多重继承不同之处在于,超级引用的类型在定义特征时不知道,而是每次将特征混合到一个类或其他特征时都重新确定.

  • modifier

    以某种方式限定类,特征,字段或方法定义的关键字. 例如, private修饰符表示所定义的类,特征,字段或方法是private.

  • multiple definitions

    如果使用语法val v1, v2, v3 = exp则可以在多个定义中分配相同的表达式.

  • nonvariant

    默认情况下,class或trait的类型参数为nonvariant . 然后,当该参数更改时,类或特征就不会成为子类型. 例如,由于Array类的类型参数是不变的,因此Array[String]既不是Array[Any]的子类型也不是其超类型.

  • operation

    在Scala中,每个操作都是一个方法调用. 方法可以用运算符表示法 (例如b + 2调用,而当使用该表示法时, +运算符 .

  • parameter

    函数可能需要零到许多参数 . 每个参数都有一个名称和类型. 参数与参数之间的区别在于,参数是指调用函数时传递的实际对象. 参数是引用那些传递的参数的变量.

  • parameterless function

    一个不带参数的函数,该函数的定义没有任何空括号. 无参数函数的调用可能不提供括号. 这支持统一访问原则 ,该原则使def可以更改为val而无需更改客户端代码.

  • parameterless method

    参数方法是无参数函数,是类,特征或单例对象的成员.

  • parametric field

    定义为类参数的字段.

  • partially applied function

    表达式中使用的函数,但缺少某些参数. 例如,如果函数f具有类型Int => Int => Int ,则ff(1)部分应用的函数 .

  • path-dependent type

    swiss.cow.Food类的类型. swiss.cow部分是形成对对象的引用的路径. 类型的含义对您用来访问它的路径很敏感. 例如, swiss.cow.Foodfish.Food类型是不同的类型.

  • pattern

    match表达式的替代方案中, 模式在每个case关键字之后,并在模式保护符或=>符号之前.

  • pattern guard

    match表达式的替代方案中, 模式后卫可以遵循pattern . 例如,在" case x if x % 2 == 0 => x + 1 "的情况下,模式保护为" if x % 2 == 0 ". 仅当模式匹配且模式保护产生为true时,才会选择具有模式保护的案例.

  • predicate

    谓词是具有Boolean结果类型的函数.

  • primary constructor

    类的主构造函数在必要时调用超类构造函数,将字段初始化为传递的值,并执行在该类的花括号之间定义的所有顶级代码. 字段仅针对未传递给超类构造函数的值参数进行初始化,除了在类主体中未使用的任何参数之外,因此可以对其进行优化.

  • procedure

    过程是结果类型为Unit的函数,因此仅出于副作用而执行.

  • reassignable

    变量可以重新分配,也可以不重新分配 . var是可重新分配的,而val不是.

  • recursive

    如果函数调用自身,则该函数是递归的 . 如果函数调用自身的唯一位置是函数的最后一个表达式,则该函数为tail递归 .

  • reference

    引用是指针的Java抽象,它唯一地标识驻留在JVM堆上的对象. 引用类型变量保留对对象的引用,因为引用类型( AnyRef实例)被实现为驻留在JVM堆上的Java对象. 相比之下,值类型变量有时可以保存引用(对装箱的包装器类型),而有时不保存引用(当对象被表示为原始值时). 一般来说,Scala变量是指一个对象. 术语"引用"比"持有引用"更抽象.如果当前将scala.Int类型的变量表示为原始Java int值,则该变量仍引用Int对象,但不涉及引用.

  • reference equality

    引用相等意味着两个引用标识了完全相同的Java对象. 可以通过调用AnyRef eq来确定引用相等性(仅对于引用类型). (在Java程序中,可以使用Java 参考类型上的==来确定参考相等性.)

  • reference type

    引用类型AnyRef的子类. 引用类型的实例始终在运行时驻留在JVM的堆上.

  • referential transparency

    功能的属性,与时间上下文无关,没有副作用. 对于特定输入,引用透明函数的调用可以用其结果替换,而无需更改程序语义.

  • refers

    正在运行的Scala程序中的变量始终引用某个对象. 即使该变量分配为null ,它在概念上也指向Null对象. 在运行时,对象可以由Java对象或原始类型的值实现,但是Scala允许程序员在想象代码运行时对其代码进行更高级别的抽象. 另请参阅参考 .

  • refinement type

    通过为基本类型提供大括号内的多个成员而形成的类型. 花括号中的成员会细化基本类型中存在的类型. 例如,"吃草的Animal { type SuitableFood = Grass } "的Animal { type SuitableFood = Grass }Animal { type SuitableFood = Grass } .

  • result

    Scala程序中的表达式会产生结果 . Scala中每个表达式的结果都是一个对象.

  • result type

    方法的结果类型是调用该方法所得到的值的类型. (在Java中,此概念称为返回类型.)

  • return

    A function in a Scala program returns a value. You can call this value the result of the function. You can also say the function 结果是 the value. The result of every function in Scala is an object.

  • runtime

    托管正在运行的Scala程序的Java虚拟机或JVM . 运行时既包含Java虚拟机规范定义的虚拟机,又包含Java API和标准Scala API的运行时库. 运行时(运行与时间之间有空格)是指程序何时运行,并与编译时形成对比.

  • runtime type

    运行时对象的类型. 相比之下, 静态类型是编译时表达式的类型. 大多数运行时类型只是没有类型参数的裸类. 例如, "Hi"的运行时类型为String ,而(x: Int) => x + 1的运行时类型为Function1 . 可以使用isInstanceOf来测试运行时类型.

  • script

    包含顶级定义和​​语句的文件,可以直接在scala运行而无需显式编译. 脚本必须以表达式而不是定义结尾.

  • selector

    match表达式中匹配的值. 例如,在" s match { case _ => } "中,选择器为s .

  • self type

    性状的自类型是假定类型的this ,接收器,被该性状内使用. 混入特征的任何具体类必须确保其类型符合特征的自身类型. 自我类型最常见的用途是将一个大类分为几个特征(如Scala编程第29章所述).

  • semi-structured data

    XML数据是半结构化的. 它比平面二进制文件或文本文件更具结构性,但它不具有编程语言的数据结构的完整结构.

  • serialization

    您可以将对象序列化为字节流,然后将其保存到文件或通过网络传输. 以后甚至在不同的计算机上,也可以反序列化字节流,并获得与原始序列化对象相同的对象.

  • shadow

    在一个封闭的范围内同名的局部变量屏蔽一个新的声明.

  • signature

    签名类型签名的缩写.

  • singleton object

    用object关键字定义的对象. 每个单例对象只有一个实例. 与类共享名称并在与该类相同的源文件中定义的单例对象是该类的伴随对象 . 这个班是它的同伴班 . 没有同伴类的单身对象是独立对象 .

  • standalone object

    没有配套类的 单例对象 .

  • statement

    表达式,定义或导入, 可以放入Scala源代码的模板或块中的内容.

  • static type

    See type.

  • structural type

    细化类型 ,其中细化用于不在基本类型中的成员. 例如, { def close(): Unit }是一种结构类型,因为基本类型是AnyRef ,并且AnyRef没有名为close的成员.

  • subclass

    一类是其所有的子类 supertraits .

  • subtrait

    性状是其全部的subtrait supertraits .

  • subtype

    Scala编译器将允许任何类型的亚型用作任何需要这种类型的替代品. 对于不带类型参数的类和特征,子类型关系反映了子类关系. 例如,如果类Cat是抽象类Animal的子类,并且都不使用类型参数,则类型CatAnimal的子类型. 同样,如果特征Apple是特征Fruit的子特征,并且都不接受类型参数,则Apple类型是Fruit的子类型. 但是,对于带有类型参数的类和特征,方差起作用. 例如,因为抽象类List在其唯一类型参数中声明为协变的(即List被声明为List[+A] ),所以List[Cat]List[Animal]的子类型,而List[Apple]是其子类型. List[Fruit] . 即使每种类型的类都是List存在这些子类型关系. 相比之下,由于Set的类型参数未声明为协变的(即, Set被声明为Set[A]且没有加号),因此Set[Cat]不是Set[Animal]的子类型. 子类型应该正确地实现其超类型的协定,以便应用"李斯科夫替换原理",但是编译器仅在类型检查级别验证此属性.

  • superclass

    一个类的超类包括其直接超类,其直接超类的直接超类,等等,一直到Any .

  • supertrait

    一个类或特质的上级特征(如果有的话)包括直接混入该类或特质或其任何超类中的所有特征,以及这些特征的任何上级特征.

  • supertype

    类型是其所有子类型的类型.

  • synthetic class

    合成类是由编译器自动生成的,而不是由程序员手动编写的.

  • tail recursive

    如果该函数调用自身的唯一位置是该函数的最后一个操作,则该函数为尾递归 .

  • target typing

    目标类型是一种类型推断的形式,它考虑了预期的类型. 例如,在nums.filter((x) => x > 0) ,Scala编译器将x类型推断为nums的元素类型,因为filter方法在nums每个元素上调用函数.

  • template

    模板是类,特征或单例对象定义的主体. 它定义类,特征或对象的类型签名,行为和初始状态.

  • trait

    性状 ,其与所定义的trait的关键字,就好像是不能取任意值参数,可以"混入"通过称为过程类或其他性状一个抽象类混入组合物 . 将一个特征混合到一个类或特征中时,称为mixin . 可以使用一种或多种类型对特征进行参数化. 当用类型参数化时,特征构造一个类型. 例如, Set是采用单个类型参数的特征,而Set[Int]是类型. 同样, Set被称为Set[Int]类型的"特征".

  • type

    Scala程序中的每个变量和表达式都具有在编译时已知的类型 . 类型限制了在运行时变量可以引用或表达式可以产生的可能值. 如果有必要将变量或表达式的类型与对象的运行时类型区分开,则也可以将其称为静态 类型 . 换句话说,"类型"本身是指静态类型. 类型与类不同,因为使用类型参数的类可以构造许多类型. 例如, List是一个类,但不是类型. List[T]是带有自由类型参数的类型. List[Int]List[String]也是类型(由于没有自由类型参数,因此称为地面类型). 类型可以具有" "或" 特征 ".例如,类型List[Int]List . Set[String]类型的特征是Set .

  • type constraint

    一些注释类型约束 ,这意味着它们会在类型包含的值上添加其他限制或约束. 例如, @positive可能是Int类型的类型约束,将32位整数的类型限制为正数. 标准的Scala编译器不检查类型约束,而必须由额外的工具或编译器插件检查类型约束.

  • type constructor

    具有类型参数的类或特征.

  • type parameter

    泛型类或泛型方法的参数,必须由类型填充. 例如,类List定义为" class List[T] { . . . class List[T] { . . . ",方法identity (对象Predef的成员)被定义为" def identity[T](x:T) = x ". 在两种情况下, T都是类型参数.

  • type signature

    方法的类型签名包括其名称,数量,顺序和参数的类型(如果有)及其结果类型. 类,特征或单例对象的类型签名包括其名称,其所有成员和构造函数的类型签名及其声明的继承和混合关系.

  • uniform access principle

    统一访问原则规定,应使用相同的语法访问变量和无参数函数. Scala通过不允许在无参数函数的调用位置放置括号来支持此原则. 结果,无参数函数定义可以更改为val反之亦然 ,而不会影响客户端代码.

  • unreachable

    在Scala级别,对象可能变得不可访问 ,这时它们所占用的内存可能会在运行时被回收. 无法访问不一定表示未引用. 引用类型( AnyRef实例)被实现为驻留在JVM堆上的对象. 当引用类型的实例变得不可访问时,它的确会变为未引用的并且可用于垃圾回收. 值类型( AnyVal实例)被实现为原始类型值和驻留在堆上的Java包装器类型的实例(例如java.lang.Integer ). 值类型实例可以在引用它们的变量的整个生命周期中进行装箱(从原始值转换为包装对象)和取消装箱(从包装对象转换为原始值). 如果当前表示为JVM堆上的包装对象的值类型实例变得不可访问,则它实际上变为未引用,并且可用于垃圾回收. 但是,如果当前表示为原始值的值类型变得不可访问,则它不会成为未引用的,因为在那个时间点它不作为对象存在于JVM堆上. 运行时可能会回收无法访问的对象占用的内存,但是例如,如果某个Int是在运行时由原始Java int实现的,而该Java int在执行方法的堆栈框架中占用了某些内存,则该对象的内存将"回收"该方法完成后弹出堆栈框架时,将显示"". JVM的垃圾回收器在无法访问引用类型的内存(例如Strings ,可以将其回收.

  • unreferenced

    See unreachable.

  • value

    Scala中任何计算或表达式的结果都是一个 ,而在Scala中,每个值都是一个对象. 术语值本质上表示内存中对象(在JVM的堆或堆栈上)的映像.

  • value type

    值类型AnyVal任何子类,例如IntDoubleUnit . 该术语在Scala源代码级别具有含义. 在运行时,可以根据原始类型值或包装类型的实例(例如java.lang.Integer来实现与Java基本类型相对应的值类型的实例. 在值类型实例的生存期内,运行时可以在原始类型和包装类型之间来回转换( ,将其装箱和拆箱).

  • variable

    引用对象的命名实体. 变量可以是valvar . 定义时必须同时初始化valvar ,但是以后只能重新分配var来引用不同的对象.

  • variance

    类别或特征的类型参数可以用方差注释标记,可以是协变 (+)或相反 (-). 这样的差异注释指示子类型如何为通用类或特征工作. 例如,通用类List在其类型参数中是协变的,因此List[String]List[Any]的子类型. 默认情况下, 没有+-注释,类型参数是nonvariant .

  • yield

    表达式可以产生结果. yield关键字指定a 的理解结果.

Contributors to this page:

by  ICOPY.SITE