1. apply方法
在调用单例对象方法时不需要创建对象，可以把单例对象看作某个已经存在的类的实例（对象），所以“.apply”显不显著地写出来都可以。
object Greet { //单例对象
def apply(name: String): Unit = {
println("Call From %s".format(name))
}
}
object Test {
def main(args: Array[String]): Unit = {
Greet.apply("Gpwner") // 在调用单例对象方法时不需要创建对象
println("==========================")
Greet("pwner") // 等价于Greet.apply("pwner")
}
}
// 运行结果
Call From Gpwner
==========================
Call From pwner一个object中的apply方法不一定要返回其自身对象，比如
//Example 1:
case class Company(name: String)
object Person {
def apply(name: String): Company = new Company(name)
}
object Test{
def main(args: Array[String]){
val c: Company = Person("HW")
println("c.name = " + c.name)
}
}
// 运行结果
c.name = HW
---------------------------------------------------------
// Example 2:
class ApplyTest(var x: Int, var y: Int){ //构造参数前加上'var'，可以使参数成为类的一个可变字段， 'val'则不可以
def haveTry() = {
println("x: " + x + ", y: " + y)
}
}
object ApplyTest{
def apply(x: Int, y: Int) = { //返回class ApplyTest的一个对象
println("I am in object! I will create a project of class ApplyTest.");
new ApplyTest(x, y);
}
}
object Test {
def main(args: Array[String]): Unit = {
val a = ApplyTest(8, 9); // 由于没有new关键词，此处调用伴生对象ApplyTest的apply方法,
// 返回伴生类ApplyTest的一个对象，".apply"没有显示的写出来
val b = new ApplyTest(1,2);
println(a.x);
println(a.y);
a.haveTry( );
println(b.x);
println(b.y); //构造参数前加上'var'，可以使参数成为类的一个可变字段， 'val'则不可以
b.haveTry( );
}
}
//运行结果
I am in object! I will create a project of class ApplyTest.
8
9
x: 8, y: 9
1
2
x: 1, y: 22. scala会自动为case class 生成apply方法
case类会自动生成伴随对象及其apply方法， apply方法会返回case类的对象，见下例中的对象p1、p2。
case class Person(name: String, age: Int, favColor: String )
object Test{
def main(args: Array[String]){
// 创建一下三个对象的操作的结果一样
val p0 = new Person("Frank", 23, "Blue"); // 正常由Person类生产的对象
val p1 = Person("Frank", 23, "Blue"); // case类Person自动生成“伴随对象”及其
// apply方法，apply方法返回Person类的对
// 象，p1就是伴随对象Person调用apply方
// 法时返回的Person类对象。
val p2 = Person.apply("Frank", 23, "Blue"); // p2是伴随对象Person调用apply方
// 法时返回的Person类对象。
println("p0 Name: " + p0.name + ", Age: " + p0.age + ", Favorite Color: " + p0.favColor);
}
}
// 运行结果
p0 Name: Frank, Age: 23, Favorite Color: Blue3. 在class中定义apply方法
下例中amazing是class Amazing的一个对象，“.apply”显不显著地写出来都可以。
class Amazing(var y: Int) {
def apply(x: String, z: Int): String ={
y = z;
return "Amazing %s!".format(x) }
}
object Test{
def main(args: Array[String]){
val amazing = new Amazing(3);
println( amazing.y );
println( amazing("World", 5)); //等价于调用amazing.apply("World", 5)
println( amazing.y );
println( amazing.apply("Universe", 8));
println( amazing.y );
}
}
// 运行结果
3
Amazing World!
5
Amazing Universe!
84. 伴生类和伴生对象
单例对象与类同名时，这个单例对象被称为这个类的伴生对象，而这个类被称为这个单例对象的伴生类。伴生类和伴生对象要在同一个源文件中定义，伴生对象和伴生类可以互相访问其私有成员。不与伴生类同名的单例对象称为孤立对象。
// 私有构造方法
class Marker private(val color:String) {
println("创建" + this)
override def toString(): String = "颜色标记：" + color
}
// 伴生对象，与类共享名字，可以访问类的私有属性和方法
object Marker{
private val markers: Map[String, Marker] = Map(
"red" -> new Marker("red"),
"blue" -> new Marker("blue"),
"green" -> new Marker("green")
)
def apply(color:String) = {
if(markers.contains(color)) markers(color) else "Sjq_apply"
}
def getMarker(color:String) = {
if(markers.contains(color)) markers(color) else "Sjq_getMarker"
}
def main(args: Array[String]) {
// 默认调用伴生对象的apply方法
println(Marker("sjq_a"))
// 单例函数调用，省略了.(点)符号
println(Marker getMarker "sjq_g")
}
}
// 运行结果
创建颜色标记：red
创建颜色标记：blue
创建颜色标记：green
Sjq_apply
Sjq_getMarker