展开

关键词

【学习笔记】区别Kotlin中的objectcompanion object关键字

就是单例模式的化身object 可以实现 Java 中的匿名类companion object 就是 Java 中的 static 变量companion object 只能定义在对应的类中但是,这些认识都是停留在表面上 4. companion object使用方法和 object 不同, companion object 的定义完全属于类的本身,所以 companion object 肯定是不能脱离类而定义在全局之中 同时,和 object 类似,可以给 companion object 命名,也可以不给名字,这个时候它会有个默认的名字: Companion ,而且,它只在类里面能定义一次:class MyClass2 类名可作为接口参数传入和 object 还是一样, companion object 也可以实现接口,因为 companion object 寄生于类,甚至类还可以直接作为实现了相应得接口的参数形式传入 这个时候当然是 companion object 派上用场的时刻了!

1.3K30

Kotlin 类声明与伴生对象(companion

1. companion object 的诞生 Scala 说,要有伴生对象。 于是 Kotlin 便有了 companion objectcompanion object 的出现是为了解决 Java static 方法的反面向对象(Anti-OOP)的问题。 2. companion 的实现在 Kotlin 中,调用 Java 的 static 方法和调用 Kotlin 的 companion object 方法是一样的:AJavaClass.staticFun ()AKotlinClass.companionFun()而在 Java 中,调用 static 方法和 Kotlin 的伴生 companion object 方法,有一点不同:AJavaClass.staticFun ();AKotlinClass.Companion.companionFun();从 Java 的调用我们可以发现,companion object 的 JVM 字节码体现,是一个声明了一个叫 Companion

46810
  • 广告
    关闭

    云产品限时秒杀

    云服务器1核2G首年50元,还有多款热门云产品满足您的上云需求

  • 您找到你想要的搜索结果了吗?
    是的
    没有找到

    重学 Kotlin —— object,史上最 “快” 单例 ?

    class Singleton private constructor(private val param: Int) { companion object { @Volatile private var class User(val male: Int){ companion object { val MALE = 0 fun isMale(male:Int) = male == MALE }} 这样就可以像调用 ; } }} 编译器为我们生成了一个叫做 Companion 的静态内部类,注意它的 getMale() 和 isMale() 方法并不是静态方法,所以实际去访问的时候还是需要一个 Companion 另外,我们可以给伴生对象命名,如下所示:companion object X { ... } 那么,编译器生成的类就不是 Companion 了,而是 X 。 创建静态工厂方法interface Car { val brand: String companion object { operator fun invoke(type: CarType): Car

    8510

    Kotlin 注解 第三篇 @JvmField 与 @JvmStatic

    object { @JvmStatic val TAG_NAME = Sample val NON_STATIC_VALUE = non_static_value @JvmStatic fun callStatic Sample.Companion.callNonStatic(); Sample.getTAG_NAME(); Sample.Companion.getNON_STATIC_VALUE(); CompanionKotlin中我们可以借助object 实现静态的形式,比如下面的代码package com.example.jvmannotationsample class SomeClass { companion object { fun getCommonProperties (): List { return emptyList() } } } 其实除此之外,我们还能命名companion的名称,如下代码package com.example.jvmannotationsample class AnotherClass { companion object Assistant { fun scheduleSomething() { } } } 调用代码示例test companion

    62410

    Kotlin中单例模式和Java的对比浅析

    null) { instance = new Singleton(); } return instance; }}kotlin中class Singleton private constructor{ companion ) { instance = new Singleton(); } return instance; } }kotlin中class Singleton private constructor(){ companion { instance = new Singleton(); } } } return instance; }}kotlinclass Singleton private constructor(){ companion static Singleton getInstance(){ return Holder.instance; }}kotlin中class Singleton private constructor(){ companion object { fun getInstance(): Singleton { return Holder.instance } } private object Holder { val instance

    19320

    Kotlin中单利常用的五种写法

    getInstance(){ if(null==INSTANCE){ INSTSANCE=new Config(); } return INSTANCE; }}Kotlin实现 public class Config{ companion getInstance(){ if(null==INSTANCE){ INSTANCE=new Config(); } return INSTANCE; }}Kotlin实现 class Config{ companion object{ private var instance:Config? static Config getInstance(){ return Helper.INSTANCE; }}Kotlin实现 class Config private constructor(){ companion object{ fun getInstance = Helper.instance } private object Helper{ val instance = Config() }}总结以上就是这篇文章的全部内容了

    14230

    Kotlin中单利常用的五种写法

    getInstance(){ if(null==INSTANCE){ INSTSANCE=new Config(); } return INSTANCE; }}Kotlin实现 public class Config{ companion getInstance(){ if(null==INSTANCE){ INSTANCE=new Config(); } return INSTANCE; }}Kotlin实现 class Config{ companion object{ private var instance:Config? static Config getInstance(){ return Helper.INSTANCE; }}Kotlin实现 class Config private constructor(){ companion object{ fun getInstance = Helper.instance } private object Helper{ val instance = Config() }}总结以上就是这篇文章的全部内容了

    10430

    Handler中的内存泄露究竟是怎么回事?

    savedInstanceState) 延迟10s val msg = Message.obtain() msg.what = WHAT_MSG mHandler.sendMessageDelayed(msg, 10000) } companion mHandler.sendMessageDelayed(msg, 10000) } override fun onDestroy() { mHandler.removeMessages(WHAT_MSG) super.onDestroy() } companion savedInstanceState) val msg = Message.obtain() msg.what = WHAT_MSG mHandler.sendMessageDelayed(msg, 100_000) } companion Log.e(TAG, mWeakReference.get() is null ) } } class Callback { fun handleMessage(msg: Message) {} } companion savedInstanceState) val msg = Message.obtain() msg.what = WHAT_MSG mHandler.sendMessageDelayed(msg, 10_000) } companion

    38240

    About Kotlin-Kotlin中的类2About Kotlin(2)

    object DataProviderManager{ fun registerDataProvider(provider:DataProvider){}}伴生对象类内部的对象声明可以使用companion companion object Factory{ fun create():MyClass=MyClass() }} 调用方式类似于Java中的静态方法val instance = MyClass.create () 如果按照下列写法,调用时,可以使用名称 Companionclass MyClass{ companion object{}} val x = MyClass.Companion这里需要注意的是: 都只是实例变量即使伴生对象的成员看起来像其他语言的静态成员,在运行时他们仍然是真实对象的实例成员,而且,例如还可以实现接口:interface Factory { fun create(): T}class MyClass { companion 更多详细的内容之后再看class MyClassJVM { companion object : Factory { @JvmStatic override fun create(): MyClassJVM

    19020

    Kotlin---扩展

    介绍除了与Java类比的这些功能之外,Kotlin还新增了一些新的概念数据类(data)扩展函数密封类(sealed)匿名类伴生对象(Companion)数据类通过data关键字来定义数据类。 而匿名类也可以继承类:class Teenager { fun runFast() { var round = object { var time: Long = 0 var distance: Long : Child(Bob) { var time: Long = 0 var distance: Long = 0 }}伴生对象(Companion)用伴生对象声明的对象,与类没有什么关系,可以使用类名直接调用 class Teenager private constructor() { companion object Teen { var teenager: Teenager = Teenager() } fun runFast() { Log.e(Tag, runFast) }}在使用的时候,可以直接访问并且调用Teenager.teenager.runFast()如果不使用companion修饰的话,

    20530

    Kotlin使用静态变量与静态方法详解

    其实很简单,只需要一个将变量和方法包含在 companion object 域中即可,比如这样: class Constant { companion object { 接口根地址 const val 例如这样: ** * @author moosphon on 20181212 * desc: 异常的统一处理者 *class ExceptionHandler { companion object {

    88420

    设计模式-单例模式

    Kotlin** * 饿汉式 *object Single {}有童鞋要说了,这什么都没写呀。对,饿汉式在Kotlin中,只需要一个object修饰符就行了,这就是Kotlin非常厉害的地方。 companion object的意思相当于Java中public static。3. 懒汉式——线程安全(1)因为懒汉式的出现,虽然解决了饿汉式的不足,但也出现了多线程的问题。 object { private var single: Single? Kotlin** * 懒汉式 --- 线程安全 双重校验锁 *class Single private constructor() { companion object { ** * Kotlin原生写法 ** * 内部类实现 *class Single private constructor() { companion object { fun getInstance(): Single { return

    20130

    【读书笔记】《Kotlin in Action》学习笔记(上)

    :joy3、 Kotlin中的companion object可以实现接口这点对我来说,真的非常怪异!我目前还从未使用过,在之后开发过程中引起注意,希望自己能够弄懂这一点! 一直认为 companion object 就像 Java 中静态方法一样,没任何区别,但是它居然还能实现 interface 接口,有点不可思议啊! 下面的代码来自官方例子的修改,大家可以研究一下:A companion object can implement interfacesinterface JSONFactory { fun fromJSON (jsonText:String):T} class Person(val name:String) { companion object:JSONFactory { override fun fromJSON 当然,我们也可以采用和 Java 一样的方式:使用 object 实现 SAM 接口,但是这样做的话,可能会在每次调用函数的时候都会创建一个新的 object 实例。参考下面的代码,来自官方的例子。

    30120

    基于 Kotlin + Netty 实现一个简单的 TCP 自定义协议

    ** * 序列化方式的常量列表 *interface Serialize { companion object { const val JSON: Byte = 0 }}每个 Packet 也包含了其对应的 ** * 指令集,支持从 -128 到 127 总共 256 个指令 *interface Commands { companion object { ** * 心跳包 * const val HEART_BEAT , evt: IdleStateEvent) { logInfo(logger) { ctx.channel().close() $HERT_BEAT_TIME 秒内没有收到心跳,则断开连接 } } companion 魔数校验不通过,则关闭连接 logInfo(logger,魔数校验失败) ctx.channel().close() return null } return super.decode(ctx, `in`) } companion { logInfo(logger,发送心跳....) ctx.writeAndFlush(HeartBeatPacket()) } companion object { private const val

    35410

    当Kotlin邂逅设计模式之单例模式(一)

    1、Kotlin实现在Kotlin中实现一个饿汉式单例模式可以说是非常非常简单,只需要定义一个object对象表达式即可,无需手动去设置构造器私有化和提供全局访问点,这一点Kotlin编译器全给你做好了 object KSingleton : Serializable {实现Serializable序列化接口,通过私有、被实例化的readResolve方法控制反序列化 fun doSomething() 如果硬生生把Companion对象暴露给Java开发者他们可能会感到一脸懵逼。 可能大家对lazy和Companion Object功能强大感到一脸懵,让我们一起瞅瞅反编译后的Java代码你就会恍然大悟了:public final class KLazilyDCLSingleton return (KLazilyDCLSingleton)var1.getValue(); } private Companion() {Companion构造器私有化 } $FF: synthetic

    32830

    Kotlin之旅——类特性

    object { fun isEmpty(str: String): Boolean { return == str } }}由于 Kotlin 没有静态方法。 如果你需要写一个可以无需用一个类的实例来调用、但需要访问类内部的函数(例如,工厂方法或单利),你可以把它写成一个用 companion修饰的对象内的方法。 我们称companion修饰的对象为伴生对象。 将上面的代码编译后查看,实际上是编译器生成了一个public的内部对象。 public final class StringUtils public constructor() { public companion object { public final fun isEmpty 以下代码将线程安全问题交给虚拟机在静态内部类加载时处理,是一种推荐的写法: class Single private constructor() { companion object { fun get

    30220

    Kotlin之自定义 Live Templates详解(模板代码)

    现在,我们就可以照着葫芦画瓢,来把 newinstance 搬到 kotlin 里边了:首先先明确我们最终要生成的代码:companion object { fun newInstance(): TestKotlinFragment :companion object { fun newInstance($args$): $fragment$ { $nullChecks$ val args = android.os.Bundle()

    33041

    Kotlin中常量的探究

    如何才能生成真正的常量呢想要实现真正的常量其实不难,方法有两种,一种是const,另一个使用@JvmField注解constconst,顾名思义,就是常量的单词简写,使用它可以声明常量,不过仅限于在top-level和object top-levelconst val name = Kotlin object中class DemoConstant { companion object { const val subName = object中可以指的是最外部的object也可以指的是companion object.@JvmField在val常量前面增加一个@JvmField就可以将它变成常量。

    28050

    Kotlin中的5种单例模式示例详解

    instance=new SingletonDemo(); } return instance; }}Kotlin实现class SingletonDemo private constructor() { companion object { private var instance: SingletonDemo? instance=new SingletonDemo(); } return instance; }}Kotlin实现class SingletonDemo private constructor() { companion object { private var instance: SingletonDemo? instance=new SingletonDemo(); } } } return instance; }}kotlin实现class SingletonDemo private constructor() { companion

    63041

    SpringBoot 集成 JFinal的ActiveRecordPlugin 实现轻量级的CURD

    ****”) return arp }}_MappingKit 代码如下:class _MappingKit { companion object{ fun mapping(arp: ActiveRecordPlugin { arp.addMapping(JHolder.TABLE_NAME, JHolder::class.java) } }}Model 的定义如下:class JHolder : Model() { companion object { const val TABLE_NAME = “base_holder” val dao = JHolder().dao() }}至此,集成已经完成,可以直接在项目中使用了!

    33730

    扫码关注云+社区

    领取腾讯云代金券