scala - 类 ：apply方法、伴生类和伴生对象

本文主要是介绍scala - 类 ：apply方法、伴生类和伴生对象，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1. apply方法

  在调用单例对象方法时不需要创建对象，可以把单例对象看作某个已经存在的类的实例（对象），所以“.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:
//下面单例对象（object ApplyTest）的伴生类
class ApplyTest(var x: Int, var y: Int){ //构造参数前加上'var'，可以使参数成为类的一个可变字段， 'val'则不可以def haveTry() = { println("x: " + x + ", y: " + y) }
}//上面类（class ApplyTest）的半生对象
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: 2

2. 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: Blue

3.  case class

         当一个类被声明为case class时，编译器会自动进行如下操作：

   (1). 构造器中参数如果没有被声明为var，则默认为val类型；

   (2). 自动创建伴生对象，同时在伴生对象中实现apply方法，这样在使用时就不用显式地使用new对象；

   (3). 伴生对象中同样可以实现unapply()，从而可以将case class应用于模式匹配；

4. 在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!
8

5. 伴生类和伴生对象

   单例对象与类同名时，这个单例对象被称为这个类的伴生对象，而这个类被称为这个单例对象的伴生类。伴生类和伴生对象要在同一个源文件中定义，伴生对象和伴生类可以互相访问其私有成员。不与伴生类同名的单例对象称为孤立对象。

// 私有构造方法
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

 

这篇关于scala - 类 ：apply方法、伴生类和伴生对象的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---