一个对象只有一个实例(你不能调用新的MyObject)。一个类可以有多个实例。

对象与Java中的静态方法和字段具有相同的(以及一些额外的)用途。

博士tl;

class C定义一个类，就像在Java或c++中一样。 object O创建一个单例对象O作为某个匿名类的实例;它可以用来保存与某些类的实例没有关联的静态成员。 对象O扩展了T，使对象O成为性状T的实例;你可以在任何地方传递O，期望传递T。 如果存在类C，则对象C是类C的伴生对象;注意，伴生对象并不自动是C的实例。

也可以参考Scala文档了解对象和类。

对象作为静态成员的宿主

大多数情况下，您需要一个对象来保存可用的方法和值/变量，而不必首先实例化某个类的实例。 这种用法与Java中的静态成员密切相关。

object A {
  def twice(i: Int): Int = 2*i
}

然后，您可以使用A.twice(2)调用上述方法。

如果twice是某个类a的成员，那么你需要先创建一个实例:

class A() {
  def twice(i: Int): Int = 2 * i
}

val a = new A()
a.twice(2)

您可以看到这是多么的冗余，因为twice不需要任何特定于实例的数据。

对象作为特殊的命名实例

您还可以使用对象本身作为类或trait的一些特殊实例。 当你这样做的时候，你的对象需要扩展一些特征，以成为它的一个子类的实例。

考虑下面的代码:

object A extends B with C {
  ...
}

该声明首先声明了一个匿名(不可访问)类，它扩展了B和C，并实例化了这个类的一个名为a的实例。

这意味着A可以传递给期望类型为B或C的对象的函数，或者带有C的B。

对象的附加特征

Scala中还存在一些对象的特殊特性。 我建议阅读官方文档。

def apply(…)启用A(…)常用的无方法名语法 Def unapply(…)允许创建自定义模式匹配提取器 如果伴随同名的类，则对象在解析隐式参数时承担特殊角色

类是一个定义，一个描述。它根据其他类型的方法和组合来定义类型。

一个对象是一个单例——一个类的实例，它保证是唯一的。对于代码中的每个对象，将创建一个匿名类，该类继承于您声明object要实现的任何类。这个类不能从Scala源代码中看到——尽管可以通过反射得到它。

对象和类之间有一种关系。如果一个对象具有相同的名称，则称其为类的伴生对象。当这种情况发生时，双方都可以访问另一方的私有可见性方法。但是，这些方法不会自动导入。您要么必须显式地导入它们，要么以类/对象名作为前缀。

例如:

class X {
  // class X can see private members of object X
  // Prefix to call
  def m(x: Int) = X.f(x)

  // Import and use
  import X._
  def n(x: Int) = f(x)

  private def o = 2
}

object X {
  private def f(x: Int) = x * x

  // object X can see private members of class X
  def g(x: X) = {
    import x._
    x.o * o // fully specified and imported
   }
}

在Scala中定义一个对象就像在Java中定义一个只有静态方法的类。然而，在Scala中，对象可以扩展另一个超类，实现接口，并像类的实例一样传递。(所以它就像类的静态方法，但更好)。

形式上的区别

不能为对象提供构造函数参数 对象不是类型-不能使用new操作符创建实例。但它可以有字段、方法、扩展超类和混合特征。

用法上的区别:

Scala没有静态方法或字段。相反，你应该使用object。您可以与相关类一起使用它，也可以不使用它。在第一种情况下，它被称为同伴对象。你必须: 对类和对象使用相同的名称 把它们放在同一个源文件中。 要创建一个程序，你应该在object中使用main方法，而不是在class中。 对象Hello { def main(args: Array[String]) { println(“Hello, World !”) ｝ ｝ 你也可以像在java中使用单例对象一样使用它。           

正如许多人所解释的，object定义了一个单例实例。在这里的答案中，我认为有一件事被遗漏了，那就是对象有几个用途。

It can be the companion object to a class/trait, containing what might be considered static methods or convenience methods. It can act much like a module, containing related/subsidiary types and definitions, etc. It can implement an interface by extending a class or one or more traits. It can represent a case of a sealed trait that contains no data. In this respect, it's often considered more correct than a case class with no parameters. The special case of a sealed trait with only case object implementors is more or less the Scala version of an enum. It can act as evidence for implicit-driven logic. It introduces a singleton type.

这是一个非常强大和普遍的结构。Scala初学者可能非常困惑的是，相同的构造可能有截然不同的用途。一个物体可以同时用于多种不同的用途，这可能会更令人困惑。

对象在某种程度上类似于Java中的静态类，静态特性意味着静态类在放入JVM时不需要创建对象，它可以直接由它的类名使用，并且无论在哪里使用，都共享相同的实例(相同的数据状态)。

object关键字创建了一个新的单例类型，就像只有一个命名实例的类。如果您熟悉Java，那么在Scala中声明一个对象非常类似于创建一个匿名类的新实例。

Scala没有与Java的静态关键字等价的东西，在Scala中经常使用对象，在Java中可以使用带有静态成员的类。

Object是一个类，但它已经是一个实例，因此不能调用new ObjectName。另一方面，Class只是类型，它可以通过调用new ClassName()作为实例。

Scala类和Java类一样，但是Scala没有在类中提供任何入口方法，就像Java中的main方法一样。与object关键字关联的主要方法。可以将object关键字视为创建隐式定义的类的单例对象。

更多信息请查看这篇文章 scala编程中的类和对象关键字

在scala中，没有静态的概念。因此，scala创建了一个单例对象，为程序执行提供入口点。 如果您不创建单例对象，您的代码将成功编译，但不会产生任何输出。在单例对象中声明的方法是全局可访问的。单例对象可以扩展类和特征。

Scala单例对象示例

object Singleton{  
    def main(args:Array[String]){  
        SingletonObject.hello()         // No need to create object.  
    }  
}  


object SingletonObject{  
    def hello(){  
        println("Hello, This is Singleton Object")  
    }  
}  

输出:

Hello, This is Singleton Object

在scala中，当你有一个与单例对象同名的类时，它被称为伴侣类，而单例对象被称为伴侣对象。

伴生类及其伴生对象必须在同一个源文件中定义。

Scala配套对象示例

class ComapanionClass{  
    def hello(){  
        println("Hello, this is Companion Class.")  
    }  
}  
object CompanoinObject{  
    def main(args:Array[String]){  
        new ComapanionClass().hello()  
        println("And this is Companion Object.")  
    }  
}  

输出:

Hello, this is Companion Class.
And this is Companion Object.

在scala中，一个类可以包含:

1. 数据成员

2. 成员方法

3.构造函数块

4. 嵌套类

5. 超班信息等。

必须初始化类中的所有实例变量。没有默认作用域。如果不指定访问范围，则为public。必须有一个对象，其中定义了main方法。它为您的程序提供了起点。在这里，我们创建了一个类的示例。

Scala类示例

class Student{  
    var id:Int = 0;                         // All fields must be initialized  
    var name:String = null;  
}  
object MainObject{  
    def main(args:Array[String]){  
        var s = new Student()               // Creating an object  
        println(s.id+" "+s.name);  
    }  
} 

对不起，我来晚了，但我希望这能帮助到你。

如果你有java背景，scala中类的概念与java类似，但是scala中的类不能包含静态成员。

scala中的对象是单例类型的，你可以使用对象名在它内部调用方法，在scala中object是一个关键字，在java中object是一个类的实例

类就像其他语言中的任何其他类一样。定义类就像任何其他语言一样，只是在语法上有所不同。

class Person(val name: String)
val me = new Person("My name")

然而，object是一个只有单个对象的类。这使得它很有趣，因为它可以用于使用伴生对象创建类的静态成员。这个伴随对象可以访问类定义的私有成员，并且它与您正在定义的类具有相同的名称。

class Person(var name: String) {

  import Person._

  def hi(): String = sayHello(name)
}

object Person {
  private def sayHello(name: String): String = "Hello " + name
}

val me = new Person("My name")
me.hi()

另外，值得注意的一点是对象类是惰性创建的，这是另一个重要的点。除非在代码中需要，否则这些不会被实例化。

如果您正在为JDBC定义连接创建，您可以在对象内部创建它们以避免重复，就像我们在Java中对单例对象所做的那样。