scala007_面向对象编程之对象

1 bject在这里插入代码片

所有实例对象共享的部分
object，相当于class的单个实例，通常在里面放一些静态的field或者method
第一次调用object的方法时，就会制动object的constructor，也就是object内部不在method中的代码；但是object不能定义接收参数的constructor
注意，object的constructor只会在其死一次调用时制定一次，以后再调用就不会再次执行constructor了
object通常用于作为单例模式的实现，或者放class的静态成员，比如工具方法

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

object Person{
 private var eyeNume = 2
 println("this person object")
 def getEyeNume = eyeNume
}

// Exiting paste mode, now interpreting.

scala> Person.eyeNume
<console>:14: error: variable eyeNume in object Person cannot be accessed in object Person
       Person.eyeNume
              ^

scala> Person.getEyeNume
this person object
res8: Int = 2

scala> Person.getEyeNume
res9: Int = 2

scala>

2 伴生对象

如果游戏一个class，还有一个与class同名的object，那么就称这个object是class的伴生对象，class是object的伴生类。
伴生类和伴生对象必须存放在一个.cscala文件中
伴生类和伴生对象，最大的特点就在于，互相可以访问private field

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

object Person{
 private val eyeNum = 2
 def getEyeNum = eyeNum
}
class Person(val name:String,val age :Int){
 def sayHello = println("Hi, " +name+" ,I guess you are "+ age + " years old! "+" and usually you must have " + Person.eyeNum + " eyes.")
}

// Exiting paste mode, now interpreting.

defined object Person
defined class Person

scala> val c = new Person("Leo",20)
c: Person = Person@1efe439d

scala> c.sayHello
Hi, Leo ,I guess you are 20 years old!  and usually you must have 2 eyes.

scala> Person.eyeNum
<console>:13: error: value eyeNum is not a member of object Person
       Person.eyeNum
              ^

3 让object继承一个抽象类

object的功能其实和class类似，除了不能定义接收参数的constructor之外
object也可以集成抽象类，并覆盖抽象类中的方法。
抽象类：只给出来签名，没有实现

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

abstract class Hello(var message:String){
 def sayHello(name:String):Unit
}
object HelloImpl extends Hello("hello"){
 override def sayHello(name:String) = {
  println(message + "," +name)
 }
}

// Exiting paste mode, now interpreting.

defined class Hello
defined object HelloImpl

scala> HelloImpl.sayHello("leo")
hello,leo

scala>

4 apply方法

object中非常重要的一个特殊方法，就是apply方法
通常在伴生对象中实现apply方法，并在其中实现构造伴生类的对象的功能
而创建伴生类的对象时，通常不会使用new Class的方式，而是使用Class（）的方式，隐式地调用伴生对象的apply方法，这样会让对象创建更加简洁。

比如，Array类的伴生对象apply方法就实现了接收可变数量的参数，并创建一个Array对象的功能

scala> val a = Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)

比如，定义自己的伴生类和伴生对象

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

class Person(val name:String)
object Person{
 def apply(name:String) = new Person(name)
}

// Exiting paste mode, now interpreting.

defined class Person
defined object Person

scala> val p1 = new Person("leo")
p1: Person = Person@27f1bbe0

scala> val p2 = Person("leo")
p2: Person = Person@4f20a5e0

scala>

5 main方法

就如同java中，如果运行一个程序，必须编写一个包含main方法类一样；在scala中，如果要运行一个应用程序，name必须有一个main方法，作为入口
scala中的main方法定义为def main（args：Array[String]），而且必须定义在object中

object HelloWorld{
 def main (args : Array[String]){
  println("Hello World!!!")
 }
}

C:\Users\zhu\Desktop>scalac HelloWorld.scala

C:\Users\zhu\Desktop>scala HelloWorld
Hello World!!!

C:\Users\zhu\Desktop>

除了自己实现main方法之外，还可以继承App Trait，然后将需要在main方法中运行的代码，直接作为object的constructor代码；而且用args可以接受传入的参数

C:\Users\zhu\Desktop>scalac HelloWorld.scala

C:\Users\zhu\Desktop>scala HelloWorld
Hello World!

C:\Users\zhu\Desktop>scala HelloWorld "Leo"
Hello, Leo

object HelloWorld extends App{
 if(args.length > 0) println("Hello, " + args(0))
 else println("Hello World!")
}

如果要运行上述代码，需要将其放入.scala文件，然后先使用scalac编译，再用scala运行
scalac HelloWorld.scala
scala -Dscala.time HelloWolrd

App Trait的工作原理为：App trait继承自DelayedInit Trait，scalac 命令进行编译时，会把继承App Trait的object的constructor代码都放到DelayedInit Trait的delayedInit方法中执行

6 用object来实现枚举功能

scala没有直接提供类似于java中的Enum这样的美剧特性，如果要实现枚举，则需要object集成Enumeration类，并且调用Value方法来初始化枚举类型。

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

object Season extends Enumeration{
 val SPRING,SUMMER,AUTUM,WINTER = Value
}

// Exiting paste mode, now interpreting.

defined object Season

scala> Season.SPRING
res3: Season.Value = SPRING

scala> :aste
aste: no such command.  Type :help for help.

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

object Season extends Enumeration{
 val SPRING = Value(0,"spring")
 val SUMMER = Value(1,"summer")
 val AUTUMN = Value(2,"autumn")
 val WINTER = Value(3,"winter")
}

// Exiting paste mode, now interpreting.

defined object Season

scala> Season(0)
res4: Season.Value = spring

scala> Season(1)
res5: Season.Value = summer

scala> Season.SPRING.id
res6: Int = 0

scala> Season.SPRING.toString
res7: String = spring

scala> Season.withName("winter")
res8: Season.Value = winter

scala> for(ele <- Season.values) print(ele)
springsummerautumnwinter