[내보내번] Properties | Kotin

Kotlin을 공부하면서 상속에 대한 부분을 공부하고자 공식 문서를 직접 번역했다.
해당 문서는 2022년 3월 3일자 공식 문서이다.
중간중간 👀 표시가 있는 문장이나 소제목은 번역이 부정확할 수 있으며 구글이나 파파고 번역기의 도움을 받았다. 

Kotlin 공식문서 확인하기 ➡️

Properties | Kotlin

 

※ 영어 전공자도 해외 유학파도 아니기에 번역에는 의역, 오역, 구글 번역이 무수히 많을 수 있으며, 혼자 공식문서를 참조해가며 번역하다 보니 오타도 많을 수 있다. 정확한 내용은 공식문서를 직접 살펴보거나 다른 정보들을 더 찾아보는 것을 추천한다.

(하지만 댓글 피드백도 환영합니다😃 )

 

Declaring properties

Properties in Kotlin classes can be declared either as mutable, using the var keyword, or as read-only, using the val keyword.

코틀린 클래스의 속성들은 var 키워드를 사용하여 가변적으로 선언하거나 val 키워드를 사용하여 읽기 전용으로만 선언할 수 있다.

class Address {
    var name: String = "Holmes, Sherlock"
    var street: String = "Baker"
    var city: String = "London"
    var state: String? = null
    var zip: String = "123456"
}

 

To use a property, simply refer to it by its name:

속성을 사용하려면 그 이름으로 참조하면 된다:  

fun copyAddress(address: Address): Address {
    val result = Address() // there's no 'new' keyword in Kotlin
    result.name = address.name // accessors are called
    result.street = address.street
    // ...
    return result
}

 

 

Getters and setters

The full syntax for declaring a property is as follows:

속성을 선언하기 위한 전체 문법은 아래와 같다: 

var <propertyName>[: <PropertyType>] [= <property_initializer>]
    [<getter>]
    [<setter>]

 

The initializer, getter, and setter are optional. The property type is optional if it can be inferred from the initializer or the getter’s return type, as shown below:

초기화, getter, setter은 선택사항이다. 속성의 타입은 초기화 값이나 getter의 반환 타입으로 아래와 같이 추론될 수 있으면 선택사항이다:

var initialized = 1 // has type Int, default getter and setter
// var allByDefault // ERROR: explicit initializer required, default getter and setter implied

 

The full syntax of a read-only property declaration differs from a mutable one in two ways: it starts with val instead of var and does not allow a setter:

읽기 전용 속성의 선언의 문법은 가변형과 두 가지 점에서 차이가 있다: var 대신 val로 시작하며 setter를 허용하지 않는다:

val simple: Int? // has type Int, default getter, must be initialized in constructor
val inferredType = 1 // has type Int and a default getter

 

You can define custom accessors for a property. If you define a custom getter, it will be called every time you access the property (this way you can implement a computed property). Here's an example of a custom getter:

속성을 위한 사용자 지정 접근자를 정의할 수 있다. 사용자 지정 getter를 정의하면, 해당 속성에 접근할 때마다 호출될 것이다(이러한 방법은 계산된 속성을 구현할 수 있다). 사용자 지정 getter의 예시이다:  

class Rectangle(val width: Int, val height: Int) {
    val area: Int // property type is optional since it can be inferred from the getter's return type
        get() = this.width * this.height
}
fun main() {
    val rectangle = Rectangle(3, 4)
    println("Width=${rectangle.width}, height=${rectangle.height}, area=${rectangle.area}")
}

Width=3, height=4, area=12

You can omit the property type if it can be inferred from the getter:

getter로부터 추론할 수 있으면 속성 타입을 생략할 수 있다: 

val area get() = this.width * this.height

 

If you define a custom setter, it will be called every time you assign a value to the property, except its initialization. A custom setter looks like this:

사용자 지정 setter를 선언하면 초기화할 때를 제외하고 속성에 값을 할당할 때마다 호출될 것이다. 사용자 지정 setter는 이와 같다: 

var stringRepresentation: String
    get() = this.toString()
    set(value) {
        setDataFromString(value) // parses the string and assigns values to other properties
    }

 

By convention, the name of the setter parameter is value, but you can choose a different name if you prefer.

관례에 따라 setter 파라미터의 이름은 value이지만 선호하는 이름으로 변경할 수도 있다. 

If you need to annotate an accessor or change its visibility, but you don't need to change the default implementation, you can define the accessor without defining its body:

접근자에 어노테이션을 달아야하거나 visibility를 변경하고 싶으면, 기본 구현을 변경할 필요는 없고 바디를 정의하지 않는 접근자를 정의해주면 된다:

var setterVisibility: String = "abc"
    private set // the setter is private and has the default implementation

var setterWithAnnotation: Any? = null
    @Inject set // annotate the setter with Inject

 

👀Backing fields

In Kotlin, a field is only used as a part of a property to hold its value in memory. Fields cannot be declared directly. However, when a property needs a backing field, Kotlin provides it automatically. This backing field can be referenced in the accessors using the field identifier:

코틀린에서 필드는 그 값을 메모리에 가지고 있기 위한 속성의 부분으로만 사용된다. 필드는 직접적으로 선언될 수 없다. 그러나 속성에 backing 필드가 필요한 경우, 코틀린은 자동으로 제공해준다. 이 backing 필드는 필드 식별자를 사용하여 접근자에서 참조할 수 있다: 

var counter = 0 // the initializer assigns the backing field directly
    set(value) {
        if (value >= 0)
            field = value
            // counter = value // ERROR StackOverflow: Using actual name 'counter' would make setter recursive
    }

 

The field identifier can only be used in the accessors of the property.

필드 식별자는 속성의 접근자에서만 사용될 수 있다. 

A backing field will be generated for a property if it uses the default implementation of at least one of the accessors, or if a custom accessor references it through the field identifier.

접근자 중 하나 이상의 기본 구현을 사용하거나 사용자 지정 접근자가 필드 식별자를 통해 참조하는 경우 속성에 대한 backing 필드가 생성될 것이다. 

For example, there would be no backing field in the following case:

예를 들면, 아래의 경우 backing 필드가 없다. 

val isEmpty: Boolean
    get() = this.size == 0

 

Backing properties

If you want to do something that does not fit into this implicit backing field scheme, you can always fall back to having a backing property:

만약 이러한 암시 backing 필드 scheme이 잘 맞지 않는 무언가를 하길 원할 때 backing 속성을 사용할 수 있다: 

private var _table: Map<String, Int>? = null
public val table: Map<String, Int>
    get() {
        if (_table == null) {
            _table = HashMap() // Type parameters are inferred
        }
        return _table ?: throw AssertionError("Set to null by another thread")
    }

 

On the JVM: Access to private properties with default getters and setters is optimized to avoid function call overhead.

JVM에서: 기본 getter와 setter가 있는 private 속성에 대한 접근은 함수 호출 오버헤드를 방지하기 위해 최적화되어 있다. 

 

Compile-time constants

If the value of a read-only property is known at compile time, mark it as a compile time constant using the const modifier. Such a property needs to fulfil the following requirements:

읽기 전용 속성의 값이 컴파일 시간에 알려진 경우, const modifier를 사용하여 컴파일 시간 상수로 표시한다. 이러한 속성은 다음 요구사항을 충족해야한다: 

• It must be a top-level property, or a member of an object declaration or a companion object.
• It must be initialized with a value of type String or a primitive type
• It cannot be a custom getter

• 반드시 최상위 레벨의 속성이어야 하거나 객체 선언의 혹은 companion 객체의 멤버여아한다. 
• String 타입이나 기본 타입의 값으로 초기화 되어야만 한다.
• 사용자 지정 getter일 수 없다.

The compiler will inline usages of the constant, replacing the reference to the constant with its actual value. However, the field will not be removed and therefore can be interacted with using reflection.

컴파일러는 상수의 사용을 인라인하여 상수에 대한 참조를 실제 값으로 바꾼다. 하지만 필드는 제거되지 않을 것이고 그렇기 때문에 reflection을 사용하여 상호작용할 수 있다. 

Such properties can also be used in annotations:

그러한 속성들은 어노테이션에서도 사용할 수 있다: 

const val SUBSYSTEM_DEPRECATED: String = "This subsystem is deprecated"

@Deprecated(SUBSYSTEM_DEPRECATED) fun foo() { ... }

 

 

 

Late-initialized properties and variables

Normally, properties declared as having a non-null type must be initialized in the constructor. However, it is often the case that doing so is not convenient. For example, properties can be initialized through dependency injection, or in the setup method of a unit test. In these cases, you cannot supply a non-null initializer in the constructor, but you still want to avoid null checks when referencing the property inside the body of a class.

대개 속성들은 생성자에서 초기화되는 non-null 타입으로 선언된다. 하지만 이것이 그다지 편하지 않은 경우가 종종 있다. 예를 들면, 속성들은 dependency injection이나 유닛 테스트의 setup 메서드 내에서 초기화될 수 있다. 이러한 경우들에는 생성자에서 non-null 초기화를 제공할 수 없지만 클래스 바디 내에서 속성을 참조할 때 null 체크를 피하고 싶을 것이다. 

To handle such cases, you can mark the property with the lateinit modifier:

이러한 경우들을 처리하기 위해서 해당 속성을 lateinit modifier로 표시할 수 있다:

public class MyTest {
    lateinit var subject: TestSubject

    @SetUp fun setup() {
        subject = TestSubject()
    }

    @Test fun test() {
        subject.method()  // dereference directly
    }
}

 

This modifier can be used on var properties declared inside the body of a class (not in the primary constructor, and only when the property does not have a custom getter or setter), as well as for top-level properties and local variables. The type of the property or variable must be non-null, and it must not be a primitive type.

이 modifier는 클래스의 바디 내부에(기본 생성자 내부가 아니고 속성이 사용자 선언 getter나 setter가 없는 경우에만) 선언된 var 속성과 최상위 속성, 지역 변수에 사용될 수 있다. 속성이나 변수의 타입은 non-null이어야하고 기본타입이 아니어야 한다. 

Accessing a lateinit property before it has been initialized throws a special exception that clearly identifies the property being accessed and the fact that it hasn't been initialized.

lateinit 속성에 초기화 되기 전에 접근하는 것은 접근 중인 속성과 초기화되지 않았다는 사실을 명확하게 식별하는 특별한 예외를 던진다. 

 

Checking whether a lateinit var is initialized

To check whether a lateinit var has already been initialized, use .isInitialized on the reference to that property:

lateinit var이 이미 초기화 되었는지 확인하기 위해 해당 속성에 대한 참조에서 .isInitialized 사용하라: 

if (foo::bar.isInitialized) {
    println(foo.bar)
}

 

This check is only available for properties that are lexically accessible when declared in the same type, in one of the outer types, or at top level in the same file.

👀이러한 확인은 동일한 타입, 외부 타입 중 하나 또는 같은 파일의 최상위 레벨에서 선언 될 때 어휘적으로 접근 가능한 속성에 대해서만 가능하다. 

 

Overriding properties

See Overriding properties

 

👀Delegated properties

The most common kind of property simply reads from (and maybe writes to) a backing field, but custom getters and setters allow you to use properties so one can implement any sort of behavior of a property. Somewhere in between the simplicity of the first kind and variety of the second, there are common patterns for what properties can do. A few examples: lazy values, reading from a map by a given key, accessing a database, notifying a listener on access.

👀가장 일반적인 종류의 속성은 단순히 읽거나 혹은 쓸 수 있지만 사용자 지정 getter와 setter를 사용하면 속성을 사용할 수 있기 때문에 속성의 모든 종류의 동작도 구현할 수 있게 해준다. 첫 번째 종류의 단순함과 두 번째 종류의 다양성 사이에 어딘가에 속성이 수행할 수 있는 작업에 대한 공통 패턴이 있다. 몇 가지 예시: lazy values, 주어진 key로 map에서 읽어오기, 데이터베이스에 접근하기, 접근 시 리스너에 알림. 

Such common behaviors can be implemented as libraries using delegated properties.

이러한 보통의 동작들은 delegated 속성을 사용한 라이브러리들을 통해 구현될 수 있다.