[내보내번] Classes | Kotlin

Kotlin을 공부하면서 상속에 대한 부분을 공부하고자 공식 문서를 직접 번역했다.
해당 문서는 2022년 3월 3일자 공식 문서이다.

Kotlin 공식문서 확인하기 ➡️

Classes | Kotlin

 

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

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

 

Classes in Kotlin are declared using the keyword class:

코틀린의 클래스는 class 키워드를 사용하여 선언된다:

class Person { /*...*/ }

 

The class declaration consists of the class name, the class header (specifying its type parameters, the primary constructor, and some other things), and the class body surrounded by curly braces. Both the header and the body are optional; if the class has no body, the curly braces can be omitted.

클래스 선언은 클래스의 이름, 클래스 헤더(클래스의 타입 파라미터, 기본 생성자와 그 밖의 것들) 그리고 중괄호로 둘러쌓인 클래스 바디로 구성되어있다. 헤더와 바디 모두 선택사항이고 바디가 없으면 중괄호는 생략될 수 있다.  

class Empty

 

 

Constructors

A class in Kotlin can have a primary constructor and one or more secondary constructors. The primary constructor is a part of the class header, and it goes after the class name and optional type parameters.

코틀린에서 클래서는 하나의 기본 생성자와 하나나 그 이상의 보조 생성자를 가질 수 있다. 기본 생성자는 클래스 헤더의 일부분이고 클래스 이름과 선택적으로 추가할 수 있는 타입 파라미터 뒤에 온다. 

class Person constructor(firstName: String) { /*...*/ }

 

If the primary constructor does not have any annotations or visibility modifiers, the constructor keyword can be omitted:

만일 기본 생성자가 어떠한 어노테이션이나 눈에 보이는 modifier 키워드를 가지고 있지 않다면 constructor 키워드는 생략가능하다:

class Person(firstName: String) { /*...*/ }

 

The primary constructor cannot contain any code. Initialization code can be placed in initializer blocks prefixed with the init keyword.

기본 생성자는 어떠한 코드도 포함할 수 없다. 초기화 코드는 init이라는 키워드가 접두사로 붙은 초기화 블럭에 작성할 수 있다. 

During the initialization of an instance, the initializer blocks are executed in the same order as they appear in the class body, interleaved with the property initializers:

👀인스턴스를 초기화하는 동안 초기화 블럭들은 속성 초기화가 사이에 들어간 클래스 바디에 나타난 순서와 일치하게 실행된다:

class InitOrderDemo(name: String) {
    val firstProperty = "First property: $name".also(::println)
    
    init {
        println("First initializer block that prints $name")
    }
    
    val secondProperty = "Second property: ${name.length}".also(::println)
    
    init {
        println("Second initializer block that prints ${name.length}")
    }
}

fun main() {
    InitOrderDemo("hello")
}

First property: hello
First initializer block that prints hello
Second property: 5
Second initializer block that prints 5

Primary constructor parameters can be used in the initializer blocks. They can also be used in property initializers declared in the class body:

기본 생성자의 파라미터들은 초기화 블럭에서 사용될 수 있다. 이것들은 또한 클래스 바디에 선언된 속성 초기화에서도 사용될 수 있다. 

class Customer(name: String) {
    val customerKey = name.uppercase()
}

 

Kotlin has a concise syntax for declaring properties and initializing them from the primary constructor:

코틀린은 속성을 선언하고 기본 생성자에서 초기화하기 위한 축약된 문법을 갖고 있다. 

class Person(val firstName: String, val lastName: String, var age: Int)

 

Such declarations can also include default values of the class properties:

이와 같은 선언에는 클래스 속성의 기본값도 포함될 수 있다: 

class Person(val firstName: String, val lastName: String, var isEmployed: Boolean = true)

 

You can use a trailing comma when you declare class properties:

후행 쉼표를 사용하여 클래스 속성을 선언할 수 있다:

class Person(
    val firstName: String,
    val lastName: String,
    var age: Int, // trailing comma
) { /*...*/ }

 

Much like regular properties, properties declared in the primary constructor can be mutable (var) or read-only (val).

보통의 속성과 같이 기본 생성자에 선언된 속성은 가변적일수도 (var) 읽기 전용(val)일 수도 있다.

If the constructor has annotations or visibility modifiers, the constructor keyword is required and the modifiers go before it:

생성자에 어노테이션이나 눈에 보이는 modifier가 있다면 constructor 키워드가 요구되고 modifier는 그 전에 온다: 

class Customer public @Inject constructor(name: String) { /*...*/ }

 

Learn more about visibility modifiers.

visibility modifiers에 대해 더 배워보기.

 

Secondary constructors

A class can also declare secondary constructors, which are prefixed with constructor:

클래스는 constructor라는 키워드가 붙은 보조 생성자도 선언할 수 있다:

class Person(val pets: MutableList<Pet> = mutableListOf())

class Pet {
    constructor(owner: Person) {
        owner.pets.add(this) // adds this pet to the list of its owner's pets
    }
}

 

If the class has a primary constructor, each secondary constructor needs to delegate to the primary constructor, either directly or indirectly through another secondary constructor(s). Delegation to another constructor of the same class is done using the this keyword:

클래스에 기본 생성자가 있다면 각 보조 생성자는 직접적으로나 다른 보조 생성자를 통해 간접적으로 기본 생성자에 위임할 필요가 있다.

class Person(val name: String) {
    val children: MutableList<Person> = mutableListOf()
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

 

Code in initializer blocks effectively becomes part of the primary constructor. Delegation to the primary constructor happens as the first statement of a secondary constructor, so the code in all initializer blocks and property initializers is executed before the body of the secondary constructor.

초기화 블럭의 코드는 효과적으로 기본 생성자의 일부분이 된다. 기본 생성자로의 위임은 보조 생성자의 첫번째 구문에서 발생하여 초기화 블럭의 모든 코드와 속성 초기화는 보조 생성자의 바디 전에 실행된다. 

Even if the class has no primary constructor, the delegation still happens implicitly, and the initializer blocks are still executed:

클래스에 기본 생성자가 없다하더라도 위임은 암시적으로 일어나고초기화 블럭은 여전히 실행된다. 

class Constructors {
    init {
        println("Init block")
    }

    constructor(i: Int) {
        println("Constructor $i")
    }
}

fun main() {
    Constructors(1)
}

Init block
Constructor 1

If a non-abstract class does not declare any constructors (primary or secondary), it will have a generated primary constructor with no arguments. The visibility of the constructor will be public.

비추상 클래스가 어떠한 생성자(기본이나 보조)도 선언하지 않는다면 인자가 없는 기본 생성자를 생성할 것이다. 생성자의 visibility는 public이 된다.

If you don't want your class to have a public constructor, declare an empty primary constructor with non-default visibility:

클래스가 public 생성자를 갖기 원하지 않는다면 기본의 visibility가 아닌 기본 생성자를 선언하라:

class DontCreateMe private constructor () { /*...*/ }

 

On the JVM, if all of the primary constructor parameters have default values, the compiler will generate an additional parameterless constructor which will use the default values. This makes it easier to use Kotlin with libraries such as Jackson or JPA that create class instances through parameterless constructors.

JVM에서 모든 기본 생성자의 파라미터가 기본값을 가지고 있다면 컴파일러는 기본값을 사용할 파라미터가 없는 기본 생성자를 추가적으로 생성할 것이다. 이를 통해 Jackson이나 JPA같이 파라미터가 없는 생성자를 통해 클래스 인스턴스를 생성하는 라이브러리와 함께 코틀린을 더 쉽게 사용하게 해준다. 

class Customer(val customerName: String = "")

 

Creating instances of classes

To create an instance of a class, call the constructor as if it were a regular function:

클래스의 인스턴스를 생성하려면 보통의 함수인 것 같이 생성자를 호출하라:

val invoice = Invoice()

val customer = Customer("Joe Smith")

 

Kotlin does not have a new keyword.
코틀린은 new 키워드가 없다.

The process of creating instances of nested, inner, and anonymous inner classes is described in Nested classes.

중첩된, 내부의 그리고 무명의 내부 클래스의 인스턴스를 생성하는 과정은 Nested classes 에 기술되어 있다. 

 

Class members

Classes can contain:

클래스는 다음을 포함할 수 있다:

• Constructors and initializer blocks
• Functions
• Properties
• Nested and inner classes
• Object declarations

• 생성자와 초기화 블럭
• 함수
• 속성
• 중첩 및 내부 클래스
• 객체 선언

 

Inheritance

Classes can be derived from each other and form inheritance hierarchies. Learn more about inheritance in Kotlin.

클래스는 서로로부터 파생될 수 있고 상속 계층관계를 구성할 수 있다. 코틀린의 상속에 대해서 더 알아보라. 

 

Abstract classes

A class may be declared abstract, along with some or all of its members. An abstract member does not have an implementation in its class. You don't need to annotate abstract classes or functions with open.

클래스는 몇몇 혹은 전체의 멤버와 함께 추상으로 선언될 수 있다. 추상 멤버는 해당 클래스에 구현되어 있지 않다. 추상 클래스에 대해 어노테이션을 달거나 함수를 open으로 표시해둘 필요가 없다. 

abstract class Polygon {
    abstract fun draw()
}

class Rectangle : Polygon() {
    override fun draw() {
        // draw the rectangle
    }
}

 

You can override a non-abstract open member with an abstract one.

추상이 아닌 open 멤버를 추상적인 것으로 오버라이드 할 수 있다. 

open class Polygon {
    open fun draw() {
        // some default polygon drawing method
    }
}

abstract class WildShape : Polygon() {
    // Classes that inherit WildShape need to provide their own
    // draw method instead of using the default on Polygon
    abstract override fun draw()
}

 

 

Companion objects

If you need to write a function that can be called without having a class instance but that needs access to the internals of a class (such as a factory method), you can write it as a member of an object declaration inside that class.

만일 클래스 인스턴스 없이 호출될 수 있지만 클래스의 내부에(factory 메서드와 같이) 엑세스가 필요한 함수를 작성하고 싶다면 클래스 내부에 객체 선언의 멤버로 작성할 수 있다. 

Even more specifically, if you declare a companion object inside your class, you can access its members using only the class name as a qualifier.

더 구체적으로 말하면, 클래스 내부에 companion 객체를 선언하면 클래스 이름을 한정자로 사용할 때만 그 멤버에 접근할 수 있다.