Kotlin单例和伴生对象

最新推荐文章于 2025-07-23 12:37:33 发布

原创最新推荐文章于 2025-07-23 12:37:33 发布 · 291 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#kotlin #java #开发语言

Kotlin 专栏收录该内容

12 篇文章

订阅专栏

文章介绍了Kotlin中实现单例的object修饰符方式，以及饿汉式和懒汉式的概念。同时，详细讲解了伴生对象的companion关键字，指出伴生对象的成员类似于Java的静态成员，且在整个类中只存在一个实例。

1.kotlin单例实现方式:
修饰符 object

饿汉式,懒汉式,DCL模式与java一致

2.伴生对象

1.修饰符 companion

 companion object comA {
    }

反编译:

 public static final class comA {
      private comA() {
      }

      // $FF: synthetic method
      public comA(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }

是和静态方法一样，就可以直接类名.方法调用

注意:

每个类可以对应一个伴生对象
伴生对象的成员全局只有一个!!!!!
伴生对象的成员类似于java的静态成员

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

zz白龙

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
打赏
打赏
打赏举报

举报

专栏目录

kotlin实现单例模式

天花板的随笔

10-31

2323

类加载的时机，或者说类的初始化（两者是类加载到内存中达到可用状态的两个阶段），包括：创建类的实例对象，或者类的静态成员访问，类的反射，父类中的子类初始化的时候，虚拟机特定类。所以并不是程序初始化的时候就会加载所有的类，声明一个类型的变量时也不会加载该类，而是真的使用该类的时候才会去加载。通过伴生对象实现类似于static的静态变量，同时通过by lazy，实现了属性委托，延迟初始化，即在使用instance属性字段的时候，才会去初始化。同时，由于by lazy是线程安全的，也就实现了多线程的校验功能。

Kotlin中实现单例的几种常见方式？

qq_30279137的博客

07-07

889

在 Kotlin 中，实现单例模式（Singleton）非常简洁，主要依赖语言特性（如object关键字）和设计模式。object最简单的单例实现，线程安全且惰性初始化（首次访问时创建）。反序列化时不会创建新实例（但需实现防止序列化破坏单例）。Kotlin 的object在编译后会生成一个静态 final 类（类似 Java 的静态内部类实现单例）。

参与评论您还未登录，请先登录后发表或查看评论

Kotlin——伴生对象

转载和创作优秀的博客

10-20

821

Kotlin——伴生对象

kotlin伴生类

小牧在一直在学习,在前进的道路上大家一起学习，进步。

05-08

978

伴生对象: 类内部的对象声明可以用companion关键字标记写一个demo 关键字companion表示伴随，object表示对象，Test表示伴生对象的名称另外创建一个java的方法调用 伴生对象的名称是可以去掉的如下去掉伴生对象名称之后java调用需要Companion 如下 kotlin中调用感觉有没有伴生对象名都一样 ...

Kotlin伴生对象

weixin_40763897的博客

08-05

2084

Kotlin伴生对象的行为看起来就是Java的static的方法和属性。但它们本质区别还是很大的。什么是伴生对象呢？一个在类里面用companion关键字标记的对象声明，这个对象就是伴生对象。 class MyClass { companion object Factory { fun create(): MyClass = MyClass() } } 伴生对象的成员可以用类名直接调用，就像Java中用类名直接它的静态成员： val instance = MyClass.create() 伴

Kotlin对象和伴生对象

nicolelili1的专栏

05-10

1520

1、object kotlin中的对象是指的是使用object关键字定义的类型声明，一般用作单例模式和伴生对象。它让单例变得十分简单 2、伴生对象 kotlin的一个特性：没有静态成员静态成员在java中有很大的作业，因为java没有全局变量，也不存在包级函数，一切属性和方法都是在类里面，所以在写一些工具函数和全局变量时，都需要用到static关键字修饰的静态成员。 kotlin之所以能抛弃静态成员，主要原因在于它允许包级属性和函数的存在。经典做饭： kotlin允许在类中使用co

4、Kotlin 类与对象：构造、单例与伴生对象详解

sugar的博客

07-23

本文详细介绍了 Kotlin 中类与对象的核心概念，包括构造函数的使用、单例对象和伴生对象的特性与应用场景。通过实例代码和练习，帮助开发者掌握如何高效地使用这些特性进行 Android 开发，提升代码的可维护性和可读性。

聊聊Kotlin单例，从object单例，到带参数单例，论如何优雅的封装！

weixin_33859844的博客

05-29

899

一. 序单例模式是我们在日常编程中，比较常用的设计模式。一个好的单例，必然需要满足唯一性和线程安全性。而 Java 中，关于单例的文章讲解已经很完善了，单例模式已经成为一种编程范式。在谷歌强推 Kotlin 的今天，不少人使用 Kotlin 时，还带着 Java 的编程思维，并没有有效的利用 Kotlin 的一些特性。如果还用 Java 的编程思想来写 Kotlin 的单例，会有种四不像的感...

Kotlin单例模式与Android空格符使用示例项目_包含饿汉式单例懒汉式单例实现线程安全处理companionobject用法lazy延迟初始化Java与Kotli.zip

08-14

项目中的“附赠资源.docx”和“说明文件.txt”文件可能提供了更详细的教程和说明，帮助开发者理解和实现Kotlin单例模式与Android空格符的使用。这些资源对于初学者和经验丰富的开发者都是宝贵的，因为它们提供了实践...

【深入kotlin】- 伴生对象和扩展

kmyhy的专栏

12-09

2404

kotlin

深入解析Kotlin类与对象：构造、伴生、单例全面剖析

烨之魅儿的专栏

08-31

1899

前言本篇文章将带您了解Kotlin编程中的重要概念：类及构造函数、访问修饰符、伴生对象和单例模式。就像搭积木一样，我们会逐步揭开这些概念的面纱，让您轻松理解它们的作用和用法。无论您是编程新手还是有经验的开发者，本文都将为您提供有趣而易懂的内容，帮助您更好地掌握Kotlin中类与对象的重要知识点。让我们一起开始这段有趣的学习之旅吧！

kotlin中构造函数，伴生对象的讲解

weixin_37873786的博客

09-26

636

kotlin中构造函数，伴生对象的讲解在kotlin中有一些知识点看起来好像挺简单的，好像我们使用着确实也没有问题？但是这不意味我们懂了这些只是点，我们只是知道了怎么用，要说懂，就需要我们去了解它们的本质。今天我们就介绍kotlin中，一些我们看似懂了，却又没有完全懂的知识点。 Kotlin Class中那些被我们忽略的知识点首先第一个知识点是class，首先来看一个java类。 class MyJavaClass { static String staticMember; //静态变量

kotlin面向对象总结-伴生对象

且听真言

02-09

1908

在Java中，static修饰的内容属于类，而不属于具体对象。在Kotlin中，引入了全新的关键字object，代替使用static的场景。Kotlin中伴生对象——companion object两个关键字。 伴生对象，“伴生”是相较于一个类而言的，，意为伴随某个类的对象，它属于这个类所有，因此伴生对象跟Java中static修饰效果性质一样，全局只有一个单例。它需要声明在类的内部，在类被...

【Kotlin】object（对象）与companion object（伴生对象）

tian2342的专栏

11-20

1637

object：对象一般两种用法： 1.修饰对象，object A{}类似于static class A{}并把其中所有属性和方法变为静态的。 object Sington { val name = "Sington"//直接通过Sington.name调用 fun printlnName() {//直接通过Sington.printlnName()调用 ...

在Kotlin伴生类中使用@Synchronized的问题记录

weixin_42344241的博客

03-06

508

kotlin伴生类的静态方法使用@synchronized的问题记录

Kotlin 之单例

T丶快乐知己丬

09-08

5142

前言在学完kotlin的基本语法之后，大部分同学就尝试着写以前在java中运用的单例模式，我们在java中写单例有很多种方式，比如：懒汉，饿汉，静态内部类，枚举，双重校验锁等等，然而kotlin里实现单例模式就比java简单多了，甚至一行代码就能实现单例模式。实现单例1： object SingleTon 一行代码就可以搞定一个单例，初学者看到这里估计

kotlin半生对象_Kotlin单一对象，Kotlin伴侣对象

从零开始的教程世界

07-07

325

kotlin半生对象In this tutorial, we’ll look at how Kotlin deals with Singleton Pattern and static properties. We will learn how to create Kotlin Singleton class and what is companion object. 在本教程中，我们将研究Kot...

设计模式-单例模式（Kotlin）

qq_37635604的博客

10-14

512

设计模式-单例模式

kotlin单例模式调接口

最新发布

08-28

<think>首先，用户的问题是：“我想查找Kotlin单例模式调用接口的方法请问Kotlin单例模式调用接口的实现方法”。这翻译成英文是：“I want to find the method for Kotlin singleton pattern to call an interface. Please advise on the implementation method for Kotlin singleton pattern to call an interface.” 用户的核心需求是关于Kotlin单例模式如何调用接口的实现方法。单例模式是一种设计模式，确保一个类只有一个实例，并提供全局访问点。在Kotlin中，单例模式通常使用object关键字实现。现在，用户提到了“调用接口”，这可能意味着单例类实现一个接口，然后通过单例实例调用接口的方法。或者，它可能意味着单例类调用外部接口的方法。从问题表述看，似乎是前者：如何在单例模式中实现接口并调用其方法。回顾系统级指令： - 所有行内数学表达式必须使用$...$格式，但这个问题是关于Kotlin编程的，不涉及数学，所以可能不需要数学表达式。 - 独立公式必须使用$$...$$，但同样，这里不适用。 - LaTeX语法正确：确保任何代码或格式正确。 - 使用中文回答：整个响应必须用中文。 - 生成相关问题：在回答末尾，生成相关问题，类似于示例。 - 引用标识：在回答中引用段落末尾自然地添加引用标识，例如[^1]。用户提供了引用，我需要参考这些引用。用户提供的引用： - [^1]: 关于Kotlin单例类、伴生对象等的讨论。 - [^2]: Android Kotlin的5种单例模式，包括object关键字。 - [^3]: Kotlin静态内部类单例模式的正确实现方式。 - [^4]: Kotlin下的5种单例模式，包括懒汉式和饿汉式。这些引用讨论了Kotlin中的单例模式实现，包括使用object关键字、伴生对象、静态内部类等。用户想知道如何在单例模式中调用接口。在Kotlin中，单例类可以通过实现接口来定义接口方法。然后，通过单例实例调用这些方法。结构化回答： 1. **介绍**：简要解释Kotlin单例模式如何调用接口。 2. **实现方法**：提供代码示例，展示如何在单例类中实现接口并调用方法。 3. **引用参考**：自然地引用提供的引用，以支持回答。 4. **生成相关问题**：在末尾添加相关问题。确保回答清晰、可靠。关键点： - 在Kotlin中，使用object关键字创建单例类。 - 单例类可以实现接口，就像普通类一样。 - 然后，通过单例类的名称直接调用接口方法，因为单例实例是全局的。代码示例：例如，定义一个接口： ```kotlin interface MyInterface { fun doSomething() } ``` 然后，实现单例类： ```kotlin object Singleton : MyInterface { override fun doSomething() { println("Doing something") } } ``` 调用方法： ```kotlin fun main() { Singleton.doSomething() // 直接调用 } ``` 这很简单。用户可能想知道更复杂的场景，比如在单例中调用外部接口，但从问题看，是“调用接口的实现方法”，所以应该是实现接口。参考引用： - [^1]提到单例类和伴生对象。 - [^2]讨论object关键字用于单例。 - [^3]和[^4]提供更多实现细节。在回答中，引用这些来支持。生成相关问题：基于主题，如单例模式的其他方面、优化、应用等。最终响应结构： - 开头：直接回答问题。 - 主体：解释并展示代码。 - 结尾：总结和生成相关问题。</think>### Kotlin单例模式调用接口的实现方法在Kotlin中，单例模式通过`object`关键字实现，确保一个类只有一个实例，并提供全局访问点。调用接口的方法需要让单例类实现该接口，然后直接在单例实例上调用接口方法。以下是逐步解释和实现方法，结合Kotlin特性（如对象声明和伴生对象）来确保代码简洁高效。 #### 1. **基本实现：单例类实现接口** Kotlin的`object`关键字用于声明单例类，它可以像普通类一样实现接口。接口方法在单例内部重写后，通过单例名称直接调用。 - **步骤**： 1. 定义一个接口（如`MyInterface`）。 2. 使用`object`创建单例类并实现该接口。 3. 在单例中重写接口方法。 4. 通过单例名称直接调用方法（无需实例化）。 - **代码示例**： ```kotlin // 定义接口 interface MyInterface { fun doSomething(): String } // 单例类实现接口 object Singleton : MyInterface { override fun doSomething(): String { return "接口方法被调用" } } // 调用接口方法 fun main() { val result = Singleton.doSomething() // 直接通过单例名称调用 println(result) // 输出: "接口方法被调用" } ``` 此方法利用了Kotlin的对象声明特性，单例类在首次访问时自动初始化，并全局共享[^1][^2]。 #### 2. **进阶实现：处理线程安全或初始化逻辑** 如果接口调用需要线程安全或延迟初始化（如懒汉式单例），可以使用伴生对象（`companion object`）结合委托或静态内部类。 - **场景**：当接口方法涉及资源加载时，需确保单例初始化线程安全。 - **代码示例（线程安全的懒汉式单例）**： ```kotlin interface MyInterface { fun loadData(): List<String> } class Singleton private constructor() : MyInterface { override fun loadData(): List<String> { return listOf("数据1", "数据2") // 模拟接口调用 } companion object { // 使用Lazy委托确保线程安全 val instance: MyInterface by lazy { Singleton() } } } // 调用方法 fun main() { val data = Singleton.instance.loadData() // 通过伴生对象访问 println(data) // 输出: [数据1, 数据2] } ``` 此方式通过`by lazy`实现延迟初始化，避免资源浪费，并保证多线程安全[^3][^4]。 #### 3. **调用外部接口：单例作为接口使用者** 如果单例需要调用外部接口（如网络服务），可将接口实例注入单例。 - **步骤**： 1. 定义外部接口（如`ApiService`）。 2. 在单例中持有接口引用，并通过构造函数或方法注入。 3. 调用接口方法。 - **代码示例**： ```kotlin // 外部接口定义 interface ApiService { fun fetchData(): String } // 模拟接口实现 class RealApiService : ApiService { override fun fetchData(): String = "从API获取数据" } // 单例类使用外部接口 object Singleton { private var apiService: ApiService? = null // 注入接口实例 fun initService(service: ApiService) { apiService = service } fun callApi(): String { return apiService?.fetchData() ?: "接口未初始化" } } // 调用示例 fun main() { Singleton.initService(RealApiService()) // 注入接口实现 println(Singleton.callApi()) // 输出: "从API获取数据" } ``` 此方法灵活支持依赖注入，适合测试和扩展[^2][^4]。 #### 关键注意事项 - **线程安全**：在Kotlin中，`object`单例默认是线程安全的（类加载时初始化），但懒汉式需用`by lazy`或同步块。 - **接口与单例结合优势**：单例模式通过实现接口，能统一管理全局状态（如配置或缓存），同时保持代码可测试性。 - **性能**：直接使用`object`是最简洁的方式，适用于大多数场景；复杂初始化时优先选择伴生对象委托[^1][^3]。通过以上方法，您可以轻松在Kotlin单例中调用接口，无论是实现接口还是使用外部接口。实际应用中，需根据需求选择简单对象声明或进阶模式。