对象
-
Scala并没有提供Java那样的静态方法或静态字段，但是，可以采用 object关键字实现单例对象，具备和Java静态方法同样的功能。
-
可以看出，单例对象的定义和类的定义很相似，明显的区分是，用object 关键字，而不是用class关键字
object Person{
private var lastId = 0
def newPersonId()={
lastId += 1
lastId
}
}
printf("The first person id is %d.\n" , Person.newPersonId())
printf("The Second person id is %d.\n" , Person.newPersonId())
printf("The Third person id is %d.\n" , Person.newPersonId())
The first person id is 1.
The Second person id is 2.
The Third person id is 3.
伴生对象
-
在Java中，我们经常需要用到同时包含实例方法和静态方法的类，在Scala中可以通过伴生对象来实现
-
当单例对象与某个类具有相同的名称时，它被称为这个 类的“伴生对象”。
-
类和它的伴生对象必须存在于同一个文件中，而且可以 相互访问私有成员（字段和方法）。
class Person {
private var id = Person.newPersonId() //调用了伴生对象中的方法
private var name = ""
def this(name:String){
this()
this.name = name
}
def info(): Unit ={
printf("The id of %s is %d.\n" , name , id)
}
}
object Person{
private var lastId = 0
private def newPersonId()={
lastId += 1
lastId
}
def main(args: Array[String]): Unit = {
val person1 = new Person("Ziyu")
val person2 = new Person("Minxing")
person1.info()
person2.info()
}
}
-
从上面结果可以看出，伴生对象中定义的newPersonId() 实际上就实现了Java中静态（static）方法的功能
-
Scala源代码编译后都会变成JVM字节码，实际上， 在编译上面的源代码文件以后，在Scala里面的class 和object在Java层面都会被合二为一，class里面的成 员成了实例成员，object成员成了static成员
-
为了验证这一点，我们可以一起测试一下。
-
这里做一点小小修改， 那就是把object Person中的 newPersonId()方法前 面的private去掉
class Person {
private var id = Person.newPersonId() //???????????
private var name = ""
def this(name:String){
this()
this.name = name
}
def info(): Unit ={
printf("The id of %s is %d.\n" , name , id)
}
}
object Person{
private var lastId = 0
def newPersonId()={
lastId += 1
lastId
}
def main(args: Array[String]): Unit = {
val person1 = new Person("Ziyu")
val person2 = new Person("Minxing")
person1.info()
person2.info()
}
}
-
在Shell命令提示符状态下，输入以下命令编译并执行：
[root@slave2 ~]# scalac test.scala
[root@slave2 ~]# ll
total 32736
-rw-------. 1 root root 1260 Jul 2 19:02 anaconda-ks.cfg
-rw-r--r--. 1 root root 33485703 May 15 00:56 elasticsearch-5.5.2.tar.gz
-rw-r--r--. 1 root root 2106 Aug 18 10:25 Person.class
-rw-r--r--. 1 root root 958 Aug 18 10:25 Person$.class
-rw-r--r--. 1 root root 171 Aug 18 05:56 test1.scala
-rw-r--r--. 1 root root 1241 Aug 18 06:15 Test2.class
-rw-r--r--. 1 root root 763 Aug 18 06:15 Test2$.class
-rw-r--r--. 1 root root 245 Aug 18 06:15 test2.scala
-rw-r--r--. 1 root root 486 Aug 18 10:23 test.scala
-
在目录下看到两个编译后得到的文件，即Person.class和Person$.class。经 过编译后，伴生类和伴生对象在JVM中都被合并到了一起
-
忽略Person$.class，只看Person.class。请使用下面命令进行“反编译”：
[root@slave2 ~]# javap Person
Compiled from "test.scala"
public class Person {
public static void main(java.lang.String[]);
public static int newPersonId();
public void info();
public Person();
public Person(java.lang.String);
}
应用程序对象
-
每个Scala应用程序都必须从一个对象的main方法开始
-
重新创建一个test.scala，在该文件中输入如下代码：
-
为了运行下面的代码，我们现在可以使用两种不同的方法。
-
第一种方法:scala test.scala
object HelloWorld{
def main(args: Array[String]): Unit = {
println("hello , world!")
}
}
-
第二种方法：先编译再执行
[root@slave2 ~]# scalac test.scala
[root@slave2 ~]# ll
total 32720
-rw-------. 1 root root 1260 Jul 2 19:02 anaconda-ks.cfg
-rw-r--r--. 1 root root 33485703 May 15 00:56 elasticsearch-5.5.2.tar.gz
-rw-r--r--. 1 root root 580 Aug 18 10:34 HelloWorld.class
-rw-r--r--. 1 root root 594 Aug 18 10:34 HelloWorld$.class
-rw-r--r--. 1 root root 97 Aug 18 10:32 test.scala
[root@slave2 ~]# scala HelloWorld
hello , world!
apply方法和update方法
-
我们经常会用到对象的apply方法和update方法，虽然我们表面上并没有察觉，但是，实际上，在Scala中，apply方法和update方法都会遵循相关的约定被调用，约定如下：
-
用括号传递给变量(对象)一个或多个参数时，Scala 会把它转换成对 apply方法的调用
-
当对带有括号并包括一到若干参数的对象进行赋值时，编译器将调用 对象的update方法，在调用时，是把括号里的参数和等号右边的对象 一起作为update方法的输入参数来执行调用
-
-
下面我们测试一下apply方法是否被调用，输入 以下代码：
class Student {
def apply(param: String): String={
println("apply methon called , parameter is: " + param)
"hello world!"
}
}
object Student{
def main(args: Array[String]): Unit = {
val student = new Student()
println(student("student"))
}
}
//执行结果
apply methon called , parameter is: student
hello world!
-
上面是类中定义了apply方法，下面看一个在单例对象中定义apply方法的例子：
object Student{
def apply(param1: String,param2: String): String={
println("apply method called")
param1 + "and" + param2
}
def main(args: Array[String]): Unit = {
println(Student("zhangfei","liubei"))
}
}
//执行结果
apply method called
zhangfeiandliubei
-
下面我们测试一个伴生类和伴生对象中的apply方法实例，输入以下代码：
class ApplyTest{
def apply() ={
println("apply method in class is called!")
}
def greetingOfClass:Unit={
println("Greeting method in class is called.")
}
}
object ApplyTest{
def apply()={
println("apply method in object is called!")
new ApplyTest()
}
}
object Student{
def main(args: Array[String]): Unit = {
val a = ApplyTest()
a.greetingOfClass
a()
}
}
//执行结果
apply method in object is called!
Greeting method in class is called.
apply method in class is called!
-
从上面代码可以看出，当我们执行val a = ApplyTest()时，会导致apply方法的 调用并返回该方法调用的值，也就是ApplyTest的实例化对象。当执行a()时， 又会导致调用伴生类的apply方法，如果我们愿意，就可以在伴生类的apply方 法中写入一些处理逻辑，这样就可以把传入的参数赋值给实例化对象的变量。
-
下面看一个apply方法的例子。由于Scala中的Array对象定义了apply方法， 因此，我们就可以采用如下方式初始化一个数组：
val myStrArr = Array("bigdata","hadoop","spark")
-
也就是说，不需要new关键字，不用构造器，直接给对象传递3个参 数，Scala就会转换成对apply方法的调用，也就是调用Array类的伴 生对象Array的apply方法，完成数组的初始化。
-
实际上，update方法也是类似的，比如：
val myStrArr = new Array[String](3) //声明一个长度为3的字符串数据，每个数组元素初始化为null
myStrArr(0) = "bigdata" //调用了伴生类Array中的update方法，执行myStrArr.update(0,"bigdata")
myStrArr(1) = "hadoop" //调用了伴生类Array中的update方法，执行myStrArr.update(1,"hadoop")
myStrArr(2) = "spark" //调用了伴生类Array中的update方法，执行myStrArr.update(2,"spark")
-
从上面可以看出，在进行元组赋值的时候，之所以没有采用Java中的方括 号myStrArr[0]，而是采用圆括号的形式，myStrArr(0)，是因为存在上述的 update方法的机制。