序列理解语句由一个生成器部分和一个对这些生成的元素进行操作的语句组成，该生成器部分从指定的输入范围生成一个值列表，该语句然后存储在输出列表中，以在计算结束时返回。
例如;

object Sequence {
 def main(args:Array[String]) {
 def increment(from: Int, to:Int):List[Int] =
  
 for(i <- List.range(from,to) if  i % 5 == 0) yield i    
println(increment(1,30))
}
}

在此示例中，我们正在创建一个方法，该方法从到接受两个Integer参数，并采用数字范围。
对于从1开始的每个数字，我们都在检查该数字是否可以被5整除，因为i％5 == 0，它仅打印1-30范围内的被5整除的数字。

下图显示了产生的输出，您可以看到它们都可以被5整除。

考虑一个示例，该示例在相乘等于指定值y时返回一对数字。

object Seq {
 def main(args:Array[String]){
   def multiples(x:Int, y:Int) =
     for(a <- 0 until x;
     b <- a until x if a * b == y) yield
     Tuple2(a,b);
     multiples(42,40) foreach {
       case(a,b) =>
         println("(" + a + " ," + b + ")")
     }
 }
}

在此示例中，我们定义了" multiples"方法，该方法接受两个整数参数x和y。
我们正在检查变量a和b相乘时得出的值等于用户指定的y的条件。
结果是一对数字，如下图所示。

考虑一个返回Unit的理解示例。

object Comprehension {
 def main(args:Array[String]){
 for (i <- Iterator.range(0, 15);
 j <- Iterator.range(i, 15) if i*j == 12)
 println("(" + i + ", " + j + ")")
 }
}

yield关键字不应用于这种理解。
数字范围是使用Iterator.range指定的。
上面的代码产生以下输出。

Scala通用类

Scala支持对收集类的开发有用的泛型类。
例如;

object GenericClass {
 
def main(args:Array[String]) {
abstract class Multiply[x] {
 def multiply(a: x, b: x): x;
}

class intMultiply extends Multiply[Int] {
 def multiply(a: Int, b: Int): Int = a * b;
}

class DoubleMultiply extends Multiply[Double] {
 def multiply(a : Double, b : Double) : Double = a * b;
}
 
 val m1 = new intMultiply().multiply(20,15);
 val m2 = new DoubleMultiply().multiply(20.34, 6.56);
 println(m1);
 println(m2);
}
}

在本示例中，我们声明一个抽象类Multiply with x，它可以接受任何数据类型，并使用x数据类型的a和b变量定义乘法方法。
现在，我们定义两个类intMultiply和DoubleMultiply分别接受Integer和Double类型。
我们创建m1和m2并通过传递参数来调用方法相乘。

Scala内部类

可以在Scala中的另一个类(称为内部类)中定义一个类。
内部类绑定到外部对象。
例如;

class Add {
class Addtwonumbers {
 var a = 12;
 var b = 31;
 var c = a + b;
  
}
}

object Innerclass {

def main(args:Array[String]) {

val a1 = new Add
val a2 = new Add
val b1 = new a1.Addtwonumbers
val b2 = new a2.Addtwonumbers

b1.a = 30;
b1.b = 45;
b2.a = 55;
b2.b = 24;
println(s"b1.a = ${b1.a}")
println(s"b1.b = ${b1.b}")
println(s"b2.a = ${b2.a}")
println(s"b2.b = ${b2.b}")
println(s"Result = ${b2.c}")

}
}

在此示例中，我们定义了外部类Add，并且在该类内部定义了另一个类Addtwonumbers，它是内部类。
在内部类Twotwonumbers中，我们定义变量a，b，c，并将a + b的结果存储在c中。

我们为变量a和b赋值，并通过创建外部类的实例，然后通过此外部类实例创建内部类的实例来访问它。
下图显示了调用"内部类"的主方法时产生的输出。