1、 object 相当于class的单个实例，因此，在object里声明的变量都是静态变量，静态方法
2、 在object里声明的变量，都是全局变量，也就是类的公共属性，或者类似于java中父类的属性
3、 object里的构造器，也就是object 内部不在method中的代码，都属于构造器的内容
4、 同样，object的主构造器只会在第一次调用时执行，多次调用，只会执行一次。
-
object使用场景
1、 单例模式
2、 工具类
-
伴生对象与 伴生类？
如果有一个class，还有一个与class同名的object，那么就称这个object是class的伴生对象，class是object的伴生类
-
要求：
伴生类和伴生对象必须存放在一个.scala文件之中
特性？
//伴生对象、伴生类里的私有属性 跟 普通的私有属性 相比？
//伴生对象，伴生类里的私有属性的 使用范围，扩大了。
//伴生对象 与 伴生类可以互相访问彼此的私有属性，而普通私有属性仅仅只能在自己类里使用的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package
com.xej.learning.objectLearning
/**
* objectLearning 测试
*/
private
[objectLearning]
class
Kafka(
val
name
:
String){
//目的:测试多次调用object时，其主构造方法调用几次
def
sayHello()
:
Unit
=
{
objectTest.name
objectTest.name
objectTest.name
println(
"--------------------"
)
}
}
object
objectTest {
val
name
=
"spark"
println(
"----object----主构造器--------"
)
def
main(args
:
Array[String])
:
Unit
=
{
new
Kafka(
"spark"
).sayHello()
}
}
|
执行结果如下：
|
1
2
|
----
object
----主构造器--------
--------------------
|
测试用例二：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
package
com.xej.learning.objectLearning
/**
* 主要测试伴生对象，伴生类里的私有属性的访问范围
*/
private
[objectLearning]
class
Student(
val
name
:
String,
val
age
:
Int, address
:
String
=
"xizhimen"
){
private
val
sex
=
"male"
val
weight
=
80
def
sayHello()
:
Unit
=
{
Student.address
=
address
//访问伴生对象里的普通属性 以及 私有属性
println(
"name:\t"
+ name +
" ----> "
+
" age:\t"
+ age +
"\naddress:\t"
+ Student.address +
" ----> school:\t"
+ Student.school)
}
}
object
Student{
//伴生对象里的私有属性 跟 普通的私有属性 相比？
//伴生对象，伴生类里的私有属性的 使用范围，扩大了。
//伴生对象 与 伴生类可以互相访问彼此的私有属性，而普通私有属性仅仅只能在自己类里使用的
private
val
school
=
"bjtu"
//只能在伴生类里，调用，其他地方不能调用
var
address
=
"beijing"
//除了伴生类里，其他地方也可以调用，跟普通属性一样
//访问伴生类里的属性
val
stu
=
new
Student(
"lisi"
,
22
,
"haidian"
)
println(
"----访问----伴生类里的---属性-----name:\t"
+ stu.name)
println(
"----访问----伴生类里的---私有属性-----sex:\t"
+ stu.sex)
println(
"----访问----伴生类里的---属性-----weight:\t"
+ stu.weight)
}
object
objectTest
2
{
def
main(args
:
Array[String])
:
Unit
=
{
//调用伴生对象里的public属性
println(
"----address:\t"
+ Student.address)
//school是伴生对象的私有属性，这里不能访问的
//println("----school:\t" + Student.school)
new
Student(
"zhansan"
,
19
).sayHello()
new
Student(
"xiaoming"
,
22
,
"haidian"
).sayHello()
}
}
|
测试结果：
|
1
2
3
4
5
6
7
8
9
10
|
----访问----伴生类里的---属性-----name
:
lisi
----访问----伴生类里的---私有属性-----sex
:
male
----访问----伴生类里的---属性-----weight
:
80
----address
:
beijing
name
:
zhansan ----> age
:
19
address
:
xizhimen ----> school
:
bjtu
name
:
xiaoming ----> age
:
22
address
:
haidian ----> school
:
bjtu
Process finished
with
exit code
0
|
总之：
看到伴生对象，伴生类，要立马想到私有属性
伴生对象的使用场景，也就是说，伴生对象是干什么用的，这样的话，对于理解marathon源码，spark源码是有帮助的，不至于一头雾水。
本文转自故新51CTO博客，原文链接： http://blog.51cto.com/xingej/1961016，如需转载请自行联系原作者
