Scala 它是什么意思'；列表（1,2,3）和#x27；在斯卡拉？

我是Scala的新手，我有一个问题——我读了很多文章和书中的一些部分，但我不明白为什么我可以用

val list = List(1, 2, 3)

当我尝试创建新列表时

val list = new List(1, 2, 3)

我得到以下错误

class List is abstract; cannot be instantiated

i、 List是一个抽象类，但为什么我只能用params创建它呢

我理解以下代码：

class SomeClass

object SomeClass {
  def factory() = new SomeClass()
}

object Main extends App {
  val first = new SomeClass()
  val second = SomeClass.factory()
}

---

i、 我可以用'new'关键字或工厂方法创建一个新的SomeClass对象，但是我如何既不使用'new'关键字也不使用工厂方法创建一个新的SomeClass对象呢

List有一个包含apply方法的伴生对象。在执行List（1,2,3）时，实际上是在调用List对象中的apply方法。apply方法创建默认列表实现的新实例，这可能有助于说明@AssafMendelson的答案：

scala> :paste
// Entering paste mode (ctrl-D to finish)

abstract class AFoo(id: Int) {}

class Foo(id: Int) extends AFoo(id) {}

object AFoo {
  def apply(id: Int): AFoo = new Foo(id)
}

// Exiting paste mode, now interpreting.

defined class AFoo
defined class Foo
defined object AFoo

scala> val foo = new AFoo(3)
<console>:13: error: class AFoo is abstract; cannot be instantiated
       val foo = new AFoo(3)
             ^

scala> val foo = AFoo(3)
foo: Foo = Foo@2e349cf2

scala>：粘贴
//进入粘贴模式（按ctrl-D键完成）
抽象类AFoo（id:Int）{}
类Foo（id:Int）扩展了AFoo（id）{}
对象AFoo{
def应用（id:Int）：AFoo=新的Foo（id）
}
//正在退出粘贴模式，现在正在解释。
定义类AFoo
定义类Foo
定义对象AFoo
scala>val foo=新AFoo（3）
：13：错误：类AFoo是抽象的；无法实例化
val foo=新AFoo（3）
^
scala>val foo=AFoo（3）
foo:foo=Foo@2e349cf2

---

在上面的示例中，

AFoo

是一个带有伴生对象的抽象类（也称为

AFoo

）。伴随对象有一个

apply

方法，该方法创建一个

Foo

，它是

AFoo

的一个实现。因此，虽然您不能直接用

new AFoo（3）

实例化

AFoo

，因为它是抽象的，但您可以调用

AFoo（3）

来调用伴生对象的

apply

方法并创建

Foo

实例。

List[t]

是Scala中的一个抽象类

调用

List（）

时，您没有调用类

List

的构造函数方法。相反，您正在调用

List

对象的

apply（）

因此
List（）
与
newlist（）
不同，它是
List
类的语法糖，而是
List.apply（seq:T*）
的语法糖，其中
List
是伴生对象，
seq
是
T
类型的对象序列。本例中的
apply
方法只调用
seq.toList（）

List
类是抽象的，有两个子类-（也称为cons）和
Nil
（实际上是一个对象）
Nil
是一个空列表，
：
是一个具有两个值的对象—头或第一个元素，尾或其余元素的列表。如果需要，可以调用
：
构造函数，例如
new:（1，new:（2，new:（3，Nil））
。顺便说一句，这与编写
1:：2:：3:：Nil
的结果相同，后者反过来又是
：：（1，：：（2，：：（3，Nil））
的语法糖，其中，您再次调用
：
的
apply
方法

列表
类是抽象的，其背后有几个设计原因。例如，了解它的实际工作原理（cons和
Nil
）对于模式匹配列表非常有用。
如果没有名为
foo
的方法在作用域中具有正确的类型，并且有名为
apply
的方法在
foo
中定义了正确的类型，那么

foo(bar, baz)

语法上的糖是什么

foo.apply(bar, baz)

List.apply(1, 2, 3)

（这允许您编写自己的“类似函数”的对象。）

所以

语法上的糖是什么

foo.apply(bar, baz)

List.apply(1, 2, 3)

和

我可以用“new”关键字或工厂方法创建一个新的SomeClass对象，但是如何既不使用“new”关键字也不使用工厂方法创建一个新的SomeClass对象呢

List.apply
是工厂方法。
严格来说，
1:：2:：3:：Nil
是
Nil:：（3）。：（2）。：（1）
而不是
：（1，：：（2，：（3，Nil））