Scala中的对象和类的区别
我只是在浏览互联网上的一些Scala教程，并已经注意到在一些例子中，一个对象是在示例的开始处声明的。
Scala中的class和object什么区别？
简要地
您可以将object关键字想象为创build隐式定义的类的单例对象。
不那么简单
考虑这个例子
object A extends B with C { def f(x: Any): Any = ??? }
从Scala视图来看，这个声明
- 声明一个匿名（不可访问）的类，扩展了
B和C， - 创build一个名为
A类的单个实例。
这意味着可以将A传递给期望B或Ctypes对象的函数，并且可以使用Af(...)调用方法f 。
object附加function
存在一些可以为对象定义的特殊方法：
-
def apply(...)启用A(...)的常用方法无名称语法 -
def unapply(...)允许创build自定义模式匹配提取器 - 如果伴随一个同名的类，当parsing隐式参数时，该对象承担一个特殊的angular色
一个class是一个定义，一个描述。 它用其他types的方法和组合来定义types。
一个object是一个单例 – 一个保证是唯一的类的实例。 对于代码中的每个object ，都会创build一个匿名类，该类从您声明的要实现的objectinheritance。 这个类不能从Scala源代码中看到 – 尽pipe你可以通过reflection来获得它。
object和class之间有一个关系。 如果一个对象拥有相同的名字，则称它为类的伴侣对象。 发生这种情况时，每个人都可以访问另一方的private可见性方法。 虽然这些方法不会自动导入。 您必须显式导入它们，或者以类/对象名称作为前缀。
例如：
class X { // class X can see private members of object X // Prefix to call def m(x: Int) = Xf(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._ xo * o // fully specified and imported } }
一个对象只有一个实例（不能调用new MyObject ）。 你可以有一个类的多个实例。
对象与Java中的静态方法和字段相同 （以及其他一些） 用途 。
正如许多人所解释的， object定义了一个单例实例。 我相信在这里回答的一件事是，这个object几个目的。
-
它可以是
class/trait的伴随对象，包含可能被认为是静态方法或便利方法的东西。 -
它可以很像一个模块，包含相关/子types和定义等。
-
它可以通过扩展一个
class或一个或多个trait来实现一个接口。 -
它可以代表一个没有数据的
sealed trait。 在这方面，通常认为比没有参数的case class更正确。 只有case object实现者的特殊情况下的sealed trait或多或less是一个枚举的Scala版本。 -
它可以作为
implicit驱动逻辑的证据。 -
它引入了一个单例types。
这是一个非常强大和普遍的构造。 Scala初学者可能会感到困惑的是，相同的构造可能有很大的不同用途。 一个object可以同时为这些不同的用途提供服务，这可能会更令人困惑。
在Scala中定义一个对象就像在Java中定义一个只有静态方法的类。 但是，在Scala中，一个对象可以扩展另一个超类，实现接口，并且像一个类的实例一样被传递。 （所以它就像一个类的静态方法，但更好）。
正式的区别 –
- 你不能提供构造函数参数
- 它不是一个types – 你可能不会创build一个新的操作符的实例。 但它可以有字段，方法，扩展超类和混合的特性。
用法上的差异：
- Scala没有静态方法或字段。 相反，你应该使用
object。 你可以使用它或不使用相关的类。 在第一种情况下，它被称为伴侣对象。 你必须：- 为类和对象使用相同的名称
- 把他们放在同一个源文件中。
-
要创build一个程序，你应该在
object使用main方法，而不是class。object Hello { def main(args: Array[String]) { println("Hello, World!") } } -
你也可以在java中使用单例对象。
object关键字创build一个新的单例types，就像一个只有一个命名实例的类。 如果您熟悉Java，那么在Scala中声明一个对象就像创build一个匿名类的新实例一样。
Scala没有与Java的静态关键字等价，并且在Scala中经常使用一个对象 ，您可以在Java中使用静态成员的类。
对象相当于Java中的静态类，有些扩展，静态特性是指静态类在放入JVM时不需要创build对象，可以直接使用它的类名
对象是一个类，但它已经有一个实例，所以你不能调用new ObjectName 。 另一方面， 类只是types，它可以通过调用new ClassName()来实例化。
Scala类与Java Class相同，但是Scala不会在类中提供任何入口方法，如java中的main方法。 与关键字关联的主要方法。 您可以将object关键字想象为创build隐式定义的类的单例对象。
更多的信息请参阅scala编程中的这篇文章class和object关键字
在斯卡拉，没有static概念。 所以scala创build一个单例对象来为你的程序执行提供入口点。 如果您不创build单例对象，您的代码将成功编译，但不会产生任何输出。 在Singleton对象中声明的方法可以全局访问。 单例对象可以扩展类和特征。
Scala Singleton对象示例
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中，当你有一个与singleton对象同名的类时，它被称为伴侣类，而这个单例对象被称为伴随对象（companion object）。
伴随类和伴随对象都必须在同一个源文件中定义。
Scala Companion对象示例
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.超级信息等
您必须初始化类中的所有实例variables。 没有默认范围。 如果你不指定访问范围，它是公开的。 必须有一个定义主要方法的对象。 它为您的程序提供了起点。 在这里，我们创build了一个类的例子。
类的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); } }
我很抱歉，我太晚了，但希望它能帮助你。
一个类是对象的蓝图。 一旦定义了一个类，就可以使用关键字new从类蓝图中创build对象。 通过该对象，您可以使用定义的类的所有function。
图解更好的解释：
import java.io._ class Point(val xc: Int, val yc: Int) { var x: Int = xc var y: Int = yc def move(dx: Int, dy: Int) { x = x + dx y = y + dy println ("Point x location : " + x); println ("Point y location : " + y); } } object Demo { def main(args: Array[String]) { val pt = new Point(10, 20); // Move to a new location pt.move(10, 10); } }
资源
类和对象：类是描述实体或对象的所有属性的定义。 对象是一个类的实例。
