一、 object关键字
object 关键字可以表达两种含义：一种是对象表达式,另一种是 对象声明。
1、对象表达式
继承一个匿名对象
val textView = findViewById<TextView>(R.id.tv)
textView.setOnClickListener(object : OnClickListener {
override fun onClick(p0: View?) {
Toast.makeText(this@TestActivity, "点击事件生效", Toast.LENGTH_LONG)
}
})
上面代码其实就是我们经常要给 view 设置的点击事件，OnClickListener 事件是一个匿名类的对象，用object来修饰。
2、对象声明
用object修饰的类为静态类，里面的方法和变量都为静态的。
2.1 直接声明类
object DemoManager {
private val TAG = "DemoManager"
fun a() {
Log.e(TAG,"此时 object 表示 声明静态内部类")
}
}
2.2 声明静态内部类
类内部的对象声明，没有被inner 修饰的内部类都是静态的
class DemoManager{
object MyObject {
fun a() {
Log.e(TAG,"此时 object 表示 直接声明类")
}
}
}
如果需要调用 a()方法
kotlin中调用
fun init() {
MyObject.a()
}
java中调用
MyObject.INSTANCE.a();
二、companion object
companion object 修饰为伴生对象,伴生对象在类中只能存在一个，类似于java中的静态方法 Java 中使用类访问静态成员，静态方法。
companion object {
private val TAG = "DemoManager"
fun b() {
Log.e(TAG,"此时 companion objec t表示 伴生对象")
}
}
kotlin 中调用
fun init(){
b()
}
java 中调用
DemoManager.Companion.b();
三、在companion object中如何调用外部的成员变量
3.1 为什么companion object 中调用不到外部成员变量
class DemoManager {
private val MY_TAG = "DemoManager"
fun init(){
b()
}
companion object {
fun b() {
Log.e(MY_TAG,"此时 companion objec t表示 伴生对象")
}
}
}
在上面代码中MY_TAG 是不会被调用到的。
原理很简单：
在java中我们写一个静态方法，如果需要调用成员变量，是无法调用到的
private String TAG = "MainActivity";
public static void init(){
Log.e(TAG,"init() ");
}
只有将TAG修改为静态成员变量才能调用到
private static String TAG = "MainActivity";
public static void init(){
Log.e(TAG,"init() ");
}
由此可以看出来，java中静态方法调用成员变量，要求成员变量必须是静态的， 在kotlin 中也是一样，所以当companion object 中调用非静态的成员变量也是调用不到的。
3.2 怎样解决才能调用到呢？
companion object {
private val MY_TAG = "DemoManager"
fun b() {
Log.e(MY_TAG,"此时 companion objec t表示 伴生对象")
}
}
将所引用的成员变量也修饰静态的，这样就可以引用到了。
继承
override里边的方法是OnScrollListener 这个类里边的方法
var scrollListener = object : RecyclerView.OnScrollListener() {
override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
if (newState == OnScrollListener.SCROLL_STATE_IDLE || newState == OnScrollListener.SCROLL_STATE_TOUCH_SCROLL){
var view = recyclerView.getChildAt(recyclerView.childCount-1) as View
val pos = recyclerView.getChildLayoutPosition(view)+1
var mIndex:Int = BigDecimal(pos/pageSize.toDouble()).setScale(0,BigDecimal.ROUND_UP).toInt()
if (mIndex > mPageCount) { mIndex = mPageCount }
}
}
override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
}
}
代理
menuFragment.listener = object : Fragment.MenuFragmentListener {
override fun button1Click() {
finish()
}
override fun button2Click() {
orderlist_drawer_layout.closeDrawer(GravityCompat.START)
}
override fun button3ButtonClick() {
}
}
不同点：
第一个object：有（）表示是对象
第二个object：没有（）直接listener 表示interface
伴生对象
1.概念
在对象声明的前面加上companion关键字就生成了伴生对象。作用就是为其所在的外部类模拟静态成员。
语法：（ObjectName可省略）
companion object ObjectName : [0~N个父类型] {
//伴生对象类体
}
2.特点
- 每个类最多定义一个伴生对象；
- 伴生对象相当于外部类的对象，可以直接通过外部类名访问伴生对象的成员；
- 由于kotlin取消了static关键字，伴生对象是为了弥补kotlin没有static关键字修饰的静态成员的不足；
- 虽然伴生对象是为其所在对象模拟静态成员，但是伴生对象成员依然属于伴生对象本身的成员，而不属于其外部类的成员。
3.定义伴生对象
fun main() {
println(OuterClass.name)//伴生对象属性
OuterClass.companionFun()//调用伴生对象方法
OuterClass.CompanionObjectName//通过伴生对象名称获取伴生对象本身
}
class OuterClass {
companion object CompanionObjectName {
val name = "伴生对象属性"
fun companionFun() {
println("调用伴生对象方法")
}
}
}
4.省略伴生对象名字
伴生对象名称可以省略，省略伴生对象名称后，如果想获取伴生对象本身，可以通过Companion获取。
fun main() {
println(OuterClass.name)//伴生对象属性
OuterClass.companionFun()//调用伴生对象方法
OuterClass.Companion//通过Companion获取伴生对象本身
}
class OuterClass {
companion object {
val name = "伴生对象属性"
fun companionFun() {
println("调用伴生对象方法")
}
}
}
5.为伴生对象扩展成员
为伴生对象扩展成员，如果伴生对象有名字，则通过“外部类.伴生对象名字.成员”的方式扩展；
如果伴生对象没名字，则通过“外部类.Companion.成员”的方式扩展
fun main() {
println(OuterClass.name)//伴生对象属性
OuterClass.companionFun()//调用伴生对象方法
println(OuterClass.extraParam)//为伴生对象扩展属性
OuterClass.test()//为伴生对象扩展方法
}
class OuterClass {
companion object {
val name = "伴生对象属性"
fun companionFun() {
println("调用伴生对象方法")
}
}
}
/**
* 为伴生对象扩展方法
*/
fun OuterClass.Companion.test() {
println("为伴生对象扩展方法")
}
/**
* 为伴生对象扩展属性
*/
val OuterClass.Companion.extraParam: String
get() = "为伴生对象扩展属性"
