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.

在本教程中，我们将研究Kotlin如何处理Singleton Pattern和静态属性。 我们将学习如何创建Kotlin Singleton类以及什么是伴随对象。

Kotlin·辛格尔顿班 (Kotlin Singleton Class)

A Singleton is a software design pattern that guarantees a class has one instance only and a global point of access to it is provided by that class.

Singleton是一种软件设计模式，可以确保一个类仅具有一个实例，并且该类提供了对其的全局访问点。

Singleton Pattern ensures that only one instance would be created and it would act as a single point of access thereby ensuring thread safety. Following is the generic way to create a Singleton class in Java.

单例模式可确保仅创建一个实例，并将其用作单个访问点，从而确保线程安全。 以下是在Java中创建Singleton类的通用方法。

public class Singleton {private static Singleton instance = null;private Singleton(){}private synchronized static void createInstance() {if (instance == null) {instance = new Singleton();}}public static Singleton getInstance() {if (instance == null) createInstance();return instance;}}

The synchronized keyword ensures that there are no thread interferences when creating the instance.

synchronized关键字可确保创建实例时没有线程干扰。

The Kotlin equivalent of the above code is given below.

上面代码的Kotlin等效项如下所示。

object Singleton

Yes, that’s it for creating a singleton class in Kotlin.

是的，就是在Kotlin中创建单例类。

Kotlin对象声明 (Kotlin object Declaration)

• Kotlin’s representation of a Singleton class requires the object keyword only.Kotlin对Singleton类的表示仅需要object关键字。
• Hence a Singleton class in Kotlin can be defined without the use of a class.因此，可以在不使用类的情况下定义Kotlin中的Singleton类。
• An object class can contain properties, functions and the init method.object类可以包含属性，函数和init方法。
• The constructor method is NOT allowed.不允许使用构造方法。
• A singleton object can be defined inside a class. It cannot be defined inside an inner class.可以在类内部定义单例对象。 不能在内部类中定义。
• An object cannot be instantiated in the way a class is instantiated.不能以实例化类的方式实例化对象。
• An object gets instantiated when it is used for the first time.首次使用对象时，将实例化该对象。

Let’s see a basic implementation of an object in Kotlin.

让我们看一下Kotlin中object的基本实现。

object Singletonfun main(args: Array<String>) {print(Singleton.javaClass)
}//Following is printed in the console.
//class Singleton

The javaClass is auto-generated by the singleton class and prints the equivalent name for the Java class name.

javaClass由单例类自动生成，并打印与Java类名称相同的名称。

Let’s add a function and properties in the object singleton class.

让我们在object单例类中添加一个函数和属性。

object Singleton
{init {println("Singleton class invoked.")}var name = "Kotlin Objects"fun printName(){println(name)}}fun main(args: Array<String>) {Singleton.printName()Singleton.name = "KK"var a = A()
}class A {init {println("Class init method. Singleton name property : ${Singleton.name}")Singleton.printName()}
}//Following is printed in the console.
//Singleton class invoked.
//Kotlin Objects
//Class init method. Singleton name property : KK
//KK

In the above code, the changes in the object class are reflected when the class A is instantiated.

在上面的代码中，实例化class A时反映了对象类中的更改。

Object initialization is similar to lazy initialization of kotlin properties. In the below code, object isn’t initialized since it isn’t used.

对象初始化类似于kotlin属性的惰性初始化。 在下面的代码中， object未初始化，因为未使用它。

class A {object Singleton{init {println("Singleton class invoked.")}var name = "Kotlin Objects"fun printName(){println(name)}}init {println("Class init method. Singleton name property")}
}//Console:
//Class init method

Objects have much more to use than just being a Singleton class.

对象不仅仅是单例类，还有更多使用对象。

Kotlin对象表达式 (Kotlin Object Expressions)

Objects in Kotlin, can be used as class variants. An object can extend a class, implement an interface.

Kotlin中的对象可用作类的变体。 一个对象可以扩展一个类，实现一个接口。

Let’s look at extending a class in the object to create a variant.

让我们看一下扩展对象中的类以创建变体。

fun main(args: Array<String>) {var a = A()Singleton.printName()
}open class A {open fun printName() {print("This is class A")}init {println("Class init method.")}
}object Singleton : A() {init {println("Singleton class invoked.")}var name = "Kotlin Objects"override fun printName() {println(name)}
}//Console Output:
//Class init method.
//Class init method.
//Singleton class invoked.
//Kotlin Objects

We’ve defined the class and function printName() as open since they would be subclassed and overridden respectively.

我们将类和函数printName()定义为open因为它们将分别被子类化和覆盖。

Unarguably, the init function of the class is called twice. Thus we are able to able to create an anonymous class in Kotlin using the above method.

无疑，该类的init函数被调用了两次。 因此，我们能够使用上述方法在Kotlin中创建一个匿名类。

Objects can have superclasses.

对象可以具有超类。

Kotlin伴侣对象 (Kotlin Companion Object)

• Kotlin doesn’t have static keyword. So how do we set static variables and methods?Kotlin没有static关键字。 那么我们如何设置静态变量和方法呢？
• companion object is the answer. It is equivalent to static objects in Java.companion object就是答案。 它等效于Java中的static对象。
• A companion object is common to all instances of the classes. It can access all members of the class too, including the private constructors.companion object是所有类实例共有的。 它也可以访问该类的所有成员，包括私有构造函数。
• A companion object is initialized when the class is instantiated.实例化类时，将初始化一个伴随对象。
• A companion object CANNOT be declared outside the class.不能在类外部声明伴随对象。

Let’s look at a simple example of kotlin companion object.

让我们看一个简单的kotlin伴随对象示例。

fun main(args: Array<String>) {var a = A.nameA.name = "Kotlin Tutorials"A.printName() //prints Kotlin Tutorials
}class A {companion object Singleton{init {println("Singleton class invoked.")}var name = "Kotlin Objects"fun printName(){println(name)}}init {println("Class init method.")}
}

Members of the companion object are called by using the class name as the qualifier.

通过使用类名称作为限定符来调用伴随对象的成员。

We can omit the companion object name too. In that case Companion name can be used to call the Singleton object.

我们也可以省略伴随对象的名称。 在这种情况下，可以使用Companion名称来调用Singleton对象。

fun main(args: Array<String>) {A.CompanionA.Companion.name = "Kotlin Tutorials"A.printName() //prints Kotlin Tutorials
}class A {companion object{init {println("Singleton class invoked.")}var name = "Kotlin Objects"fun printName(){println(name)}}init {println("Class init method.")}
}

Note: object isn’t instantiated until it is called. companion object is instantiated as soon as the class is as shown in the below code.

注意： object直到被调用才实例化。 该类一如下面的代码所示，实例化companion object 。

fun main(args: Array<String>) {var a = A()
}class A {companion object SingletonB {init {println("SingletonB class invoked.")}}object SingletonA {init {println("SingletonA class invoked.")}}init {println("Class init method.")}
}//Following is printed in the console.
//SingletonB class invoked.
//Class init method.

Notice that the init of object wasn’t called. This brings an end to kotlin singleton and companion object example tutorial.

注意object的初始化没有被调用。 这样就结束了kotlin单例和伴侣对象示例教程。

Reference:Kotlin Docs

参考： Kotlin文档

翻译自: https://www.journaldev.com/18662/kotlin-singleton-companion-object

kotlin半生对象