[Kotlin 기초] 코틀린 기본 문법 - 클래스와 설계

 

 

 

 

7 클래스와 설계

 

• 클래스: 변수와 함수의 모음
• 그룹화할 수 있는 함수와 변수를 한군데에 모아 놓고 사용하기 쉽게 이름을 붙여놓은 것
• 객체 지향 프로그래밍(Object-Oriented Programming)에서 중요한 개념, 붕어빵 틀

 

---

 

클래스의 기본 구조

class 클래스명 {
    var 변수
    fun 함수() {
        // 코드
    }


class String{
    var length: Int
    fun plus(other: Any){
        // code
    }
    fun compareTo(other: String){
        // code
    }
}

• 위 예제에서 length 변수로 문자열의 길이를 알 수 있고, plus 함수는 문자열을 이어붙일 수 있음
• compareTo는 문자열을 비교하는 기능을 제공

 

 

 

클래스와 함수의 차이점

• 구조화 및 캡슐화
  - 클래스: 데이터+메서드를 묶어 캡슐화. 데이터와 기능을 구조화하는 데 도움
  - 함수: 단독으로 존재하며 특정 작업을 수행하는 데 집중
• 재사용성
  클래스: 코드의 재사용성이 높아짐. 동일한 특성과 동작을 가진 여러 객체 쉽게 생성
  함수: 특정 작업을 수행하는 코드를 재사용할 수 있게 해주지만, 데이터 구조와 관련된 재사용성은 없음
• 추상화
  클래스: 현실 세계의 개체를 모델링하여 추상화하는데 사용 (예: '자동차' 클래스는 실제의 다양한 특성과 동작 모델링)
  함수: 추상화 수준이 더 낮으며, 주로 특정 작업을 수행하는 데 초점
• 클래스는 객체를 생성하기 위한 템플릿, 함수는 특정 작업을 수행하는 코드 조각
  클래스는 데이터와 동작을 함께 묶어서 추상화하고, 함수는 단일한 작업을 수행

 

 

 

클래스 코드 작성하기

class 클래스이름 {
    // 클래스 스코프 (class scope)
}

• 중괄호 { }는 스코프(Scope)라고 부르는데, 클래스에서 사용하면 클래스 스코프라고 함
• 몇몇 예외를 제외하고, 대부분의 코드는 클래스 스코프 안에 작성
• 클래스를 사용하기 위해서는 생성자라고 불리는 함수가 호출되어야 하는데,
  Kotlin은 프라이머리(Primary)와 세컨더리(Secondary) 2개의 생성자를 제공
• 생성자: 클래스의 인스턴스(객체)를 생성할 때 초기화하는 특수한 함수

 

 

프라이머리 생성자 (Primary Constructor)

class Person 프라이머리 생성자() {
}

class Person constructor(value: String){
    // code
}

• 프라미머리 생성자는 마치 클래스의 헤더처럼 사용할 수 있음
• 프라이머리 생성자는 constructor 키워드를 사용해서 정의하는데 조건에 따라 생략 가능
• 프라이머리 생성자도 결국은 함수이기 때문에 파라미터를 사용할 수 있음

 

class Person(value: String){
    // code
}

• 생성자에 접근 제한자나 다른 옵션이 없다면 constructor 키워드를 생략 가능

 

class Person(value: String){
    init{
        Log.d("class", "생성자로부터 전달받은 값은 ${value}입니다.")
    }
}

• 프라이머리 생성자는 마치 헤더처럼 class 키워드와 같은 위치에 작성
• 클래스의 생성자가 호출되면 init 블록의 코드가 실행되고, 
  init 블록에서는 생성자를 통해 넘어온 파라미터에 접근할 수 있음

 

class Person(val value: String) {
    fun process() {
        print(value)
    }
}

• init 초기화 작업이 필요하지 않다면 init 블록을 작성하지 않아도 됨
• 대신 파라미터로 전달된 값을 사용하기 위해서는 파라미터 앞에 변수 키워드인 val을 붙여주면 클래스 스코프 전체에서 해당 파라미터를 사용할 수 있음
• 생성자 파라미터 앞에 var도 사용할 수 있지만, 읽기 전용인 val을 사용하는 것을 권장

 

 

 

세컨더리 생성자 (Secondary Constructor)

class Person {
    constructor (value: string) {
        Log.d("class", "생성자로부터 전달받은 값은 ${value}입니다.")
    }
}

• 세컨더리 생성자는 constructor 키워드를 마치 함수처럼 클래스 스코프 안에 직접 작성 가능
• init 블록을 작성하지 않고 constructor 다음에 괄호를 붙여서 코드 작성 가능

 

class Kotlin {
    constructor (value: String){
        Log.d("class", "생성자로부터 전달받은 값은 ${value}입니다.")        
    }
    constructor (value: Int){
        Log.d("class", "생성자로부터 전달받은 값은 ${value}입니다.")        
    }
    constructor (value1: Int, value2: String){
        Log.d("class", "생성자로부터 전달받은 값은 ${value1}, ${value2}입니다.")        
    }
}

• 세컨더리 생성자는 파라미터의 개수, 또는 파라미터의 타입이 다르다면 여러 개를 중복해서 만들 수 있음

 

 

 

Default 생성자

class Student { // 생성자를 작성하지 않아도 기본 생성자가 동작합니다.
    init {
        // 기본 생성자가 없더라도 초기화가 필요하면 여기에 코드를 작성합니다.
    }
}

• 생성자는 작성하지 않을 경우 파라미터가 없는 프라이머리 생성자가 하나 있는 것과 동일

 

 

---

 

 

클래스의 사용

클래스명()

• 클래스의 이름에 괄호를 붙여서 클래스의 생성자를 호출
• constructor 키워드를 호출하지는 않음
• 아무런 파라미터 없이 클래스명에 괄호를 붙여주면 생성자가 호출되면서 init 블록 안의 코드가 자동으로 실행
• 세컨더리 생성자의 경우 init 블록이 먼저 실행되고, constructor 블록 안의 코드가 그다음 실행

 

var kotlin = Kotlin()

붕어빵틀 = 클래스, 계속 만들 수 있는 붕어빵 = 인스턴스
var one = Person("value")
// 또는
var two = Person(1004)

• 클래스의 생성자를 호출한 후 생성되는 것을 인스턴스(Instance)라고 함
• 클래스가 붕어빵틀이라고 생각한다면, 인스턴스는 붕어빵이라고 생각하면 됨
• 생성된 인스턴스는 변수에 담아둘 수 있음
• 생성자에 파라미터가 있으면 값을 입력해서 호출해야 함

 

💡 프로퍼티와 메서드

class 클래스명 {
    var 변수A    // 프로퍼티: 함수 밖
    fun 함수(){
        var 변수B    // 변수(또는 지역변수): 함수 안
    }
}

• 클래스 내부에 정의되는 변수와 함수를 멤버 변수, 멤버 함수라고 부름
• 멤버 변수는 프로퍼티(Property), 멤버 함수는 메서드(Method)라고도 부름
• Cf. 함수 내부에 정의된 변수는 프로퍼티가 아닌 변수(지역 변수)

 

// 프로퍼티 1개와 메서드 1개를 갖는 클래스를 만들기
class Pig {
    var name: String = "Pinky"
    fun printName(){
        Log.d("class", "Pig의 이름은 ${name}입니다.")
    }
}


//생성자로 다음과 같이 인스턴스화해서 변수에 담기
var pig = Pig()


//인스턴스가 담긴 변수명 다음에 도트 연산자(.)를 붙여서 프로퍼티와 메서드를 사용
pig.name = "Pooh"
pig.printName()
​
/** 실행결과
Pig의 이름은 Pooh입니다.
*/

 

 

클래스 안에 정의된 함수와 변수 사용하기

• 클래스를 사용한다는 것은 사실상 클래스 내부에 정의된 변수와 함수를 사용하는 것
• 생성자를 통해 변수에 저장된 클래스의 인스턴스는 내부에 정의된 변수와 함수를 도트 연산자(.)로 접근 가능

 

 

 

---

 

 

오브젝트(object)

 

object Pig{
    var name: String = "Pinky"
    fun printName() {
        Log.d("class", "Pig의 이름은 ${name}입니다.")
    }
}

Pig.name = "Mikey"
Pig.printName()

• 오브젝트를 사용하면 클래스 생성자로 인스턴스화 하지 않아도 블록 안의 프로퍼티와 메서드를 호출해서 사용 가능
• Java의 static과 같은 역할
• object 코드 블록 안의 프로퍼티와 메서드는 클래스명에 도트 연산자를 붙여서 생성자 없이 직접 호출할 수 있음
• 클래스명을 그대로 사용하기 때문에 호출하는 클래스명의 첫 글자가 대문자인 것에 유의
• object는 클래스와 다르게 앱 전체에 1개만 생성

 

 

컴패니언 오브젝트 (companion object)

class Pig {
    companion object {
        var name: String = "None"
        fun printName(){
            Log.d("class", "Pig의 이름은 ${name}입니다.")
        }
    }
    fun walk() {
        Log.d("class", "Pig가 걸어갑니다.")
    }
}

 

• 일반 클래스에 object 기능을 추가하기 위해서 사용
• 예시의 Pig 코드를 companion object 블록으로 감싸주면 생성 과정 없이 오브젝트처럼 사용 가능
• 위 Pig는 클래스로 선언했기 때문에 일반 함수인 walk()는 생성자인 Pig()를 호출한 다음 변수에 저장한 후에 사용 가능

 

// companion object 안의 코드 사용하기
Pig.name = "Linda"
Pig.printName()    // Pig의 이름은 Linda입니다.


// companion object 밖의 코드 사용하기
val cutePig = Pig()
cutePig.walk()    // Pig가 걸어갑니다.

• Log 클래스의 메서드 d(), e()가 모두 object 코드 블록 안에 만들어져 있어서, 생성자 없이 바로 호출해서 사용 가능

 

 

 

---

 

 

 

데이터 클래스 (data class)

data class 클래스명(val 파라미터1: 타입, var 파라미터2: 타입)

// 정의 - 주로 코드 블록(클래스 스코프)을 사용하지 않고 간단하게 작성
data class UserData(val name: String, var age: Int)

// 생성 - 일반 class의 생성자 함수를 호출하는 것과 동일
var userData = UserData("Michael", 21)
​
// name은 val로 선언되었기 때문에 변경 불가능
userData.name = "Sindy" // (X)

// age는 var로 선언되었기 때문에 변경 가능
userData.age = 18 // (O)

• Kotlin은 간단한 값의 저장 용도로 데이터 클래스(data class)를 제공
• 데이터 클래스를 정의할 때 class 앞에 data 키워드를 사용해야 함 
• 생성자 파라미터 앞에 입력하는 var(또는 val) 키워드는 생략할 수 없음
• 생성하는 코드는 일반 클래스와 동일하게 작성
• 일반 변수 선언처럼 데이터 클래스의 파라미터를 val로 정의하면 읽기 전용

 

 

 

toString() 메서드와 copy() 메서드

Log.d("DataClass", "DataUser는 ${dataUser.toString()}")
// DataUser는 DataUser(name=Michael, age=21)

var newData = dataUser.copy()

• 일반 클래스에서 toString() 메서드를 호출하면 인스턴스의 주소 값을 반환하지만,
  데이터 클래스는 값을 반환하기 때문에 실제 값을 모니터링할 때 좋음
• copy() 메서드로 간단하게 값을 복사

 

 

 

일반 클래스처럼 사용하기

data class UserData(var name: String, var age: Int){
    init{
        Log.d("UserData", "initialized")
    }
    fun process(){
        // 클래스와 동일하게 메서드 사용이 가능
    }
} // 클래스가 생성되면 "initialized"가 출력

• 일반 클래스와 동일하게 생성자를 호출하면 init 블록이 동작하고 메서드도 사용 가능
• 이처럼 클래스와 사용법이 동일하지만 주로 네트워크를 통해 데이터를 주고받거나, 혹은 로컬 앱의 데이터베이스에서 데이터를 다루기 위한 용도로 사용하는 것이 데이터 클래스

 

 

---

 

 

 

클래스의 상속과 확장

 

class Activity {
    fun drawText()
    fun draw()
    fun showWindow()
    // ...
}
​
class MainActivity: Activity() {
    fun onCreate(){
        draw("새 그림")    // 미리 만들어진 기능(draw)을 호출만으로 사용할 수 있음
    }
}

 

💡 상속이란?

• 도트 연산자(.)를 통해 클래스의 메서드와 프로퍼티를 사용하는 것처럼 클래스의 자원을 사용하는 또 다른 방법
• 상속을 사용하면 부모 클래스의 메서드와 프로퍼티를 마치 내 클래스의 일부처럼 사용할 수 있음

 

💡상속을 사용하는 이유

• 안드로이드에는 Activity라는 클래스가 미리 만들어져 있으며, 이 Activity 클래스 내부에는 글자를 쓰는 기능, 그림을 그리는 기능, 화면에 새로운 창을 보여주는 기능이 미리 정의되어 있음
• 상속이 있기에 이러한 기능을 직접 구현하지 않고 Activity 클래스를 상속받아 앱의 기능을 만들 수 있음
• 코드를 체계적으로 관리할 수 있기 때문에 규모가 큰 프로젝트도 효과적으로 설계

 

 

 

클래스의 상속

open class 상속될 부모 클래스 {
    // 코드
}
​
class 자식 클래스: 부모 클래스() {
    // 코드
}

• 상속 대상이 되는 부모 클래스는 open 키워드로 만들어야만 자식 클래스에서 사용할 수 있음
• 만약 open 키워드로 열려 있지 않으면 상속할 수 없음 (코틀린에서 클래스는 기본적으로 'final' - 상속 불가)
• 상속을 받을 자식 클래스에서는 콜론(:)을 이용해서 상속할 부모 클래스를 지정
• 상속은 부모의 인스턴스를 자식이 갖는 과정이기 때문에, 꼭 부모 클래스명 다음에 괄호()를 입력해서 부모의 생성자를 호출해야 함

 

 

 

생성자 파라미터가 있는 클래스의 상속

open class 부모 클래스(value: String) {
    // 코드
}
​
class 자식 클래스(value: String): 부모 클래스(value) {
    // 코드
}



// 안드로이드의 View 클래스를 상속받는 예제
// 자식 클래스에 세컨더리 생성자만 있을 경우 상속되는 클래스 이름 다음에 괄호가 생략
class CustomView: View {    // 부모 클래스명 다음 괄호를 생략
    constuctor(ctx: Context): super(ctx)
    constructor(ctx: Context, attrs: AttributeSet): super(ctx, attrs)
}

• 상속될 부모 클래스의 생성자에 파라미터가 있다면 자식 클래스의 생성자를 통해 값을 전달할 수 있음
• 부모 클래스에 세컨더리 생성자가 있다면, 역시 자식 클래스의 세컨더리 생성자에서 super 키워드로 부모 클래스에 전달할 수 있음
• 자식 클래스에 세컨더리 생성자만 있을 경우, 상속되는 클래스 이름 다음은 괄호가 생략됨

 

 

 

부모 클래스의 프로퍼티와 메서드 사용하기

open class Parent {
    var hello: String = "안녕하세요"
    fun sayHello(){
        Log.d("inheritance", "${hello}")
    }
}
​
class Child: Parent(){
    fun myHello() {
        hello = "Hello!"
        sayHello()
    }
}
// Child에는 hello라는 프로퍼티와 sayHello라는 메서드가 없지만 
// myHello() 메서드를 실행하면 로그에 "Hello!"가 출력

• 부모 클래스에서 정의된 프로퍼티와 메서드를 내 것처럼 사용할 수 있음

 

 

 

프로퍼티와 메서드의 재정의: 오버라이드

• 상속받은 부모 클래스의 프로퍼티와 메서드 중에 자식 클래스에서는 다른 용도로 사용해야 하는 경우가 있음
• 앞의 예제에서 Parent 클래스의 메서드와 Child의 메서드명이 다른 걸 볼 수 있음
• 그러나 사실 저런 경우 오버라이드로 Child 클래스의 메서드도 sayHello라고 하는 것이 의미상 더 적합함
• 동일한 이름의 메서드나 프로퍼티를 사용할 필요가 있을 경우에 override 키워드를 사용해서 재정의할 수 있음
• 오버라이드할 때는 프로퍼티나 메서드도 클래스처럼 앞에 open을 붙여서 상속할 준비가 되어 있어야 함

 

 

 

메서드 오버라이드

open class BaseClass {
    open fun opened() {
    }
    fun notOpened(){
    }
}
​
class ChildClass: BaseClass(){
    override fun opened(){
    }
    override fun notOpened(){ // notOpened 메서드는 open 키워드가 없으므로 잘못된 사용
    }
}

• 상속할 메서드 앞에 open 키워드를 붙여야만 오버라이드할 수 있음
• 클래스의 세컨더리 생성자를 여러 개 중복해서 사용할 수 있는 것도 오버라이딩이 가능하기 때문

 

 

 

프로퍼티 오버라이드

open class BaseClass2 {
    open var opened: String = "I am"
}
​
class ChildClass2: BaseClass2(){
    override var opened: String = "You are"
}

• 메서드 오버라이드처럼 프로퍼티 역시 open으로 열려 있어야만 오버라이드 가능

 

 

 

익스텐션

fun 클래스.확장할 메서드(){
    // 코드
}

• Kotlin은 클래스, 메서드, 프로퍼티에 대해 익스텐션(Extension)을 지원
• 이미 만들어져 있는 클래스에 위와 같은 형태로 메서드 추가
• 상속 - 미리 만들어져 있는 클래스를 가져다 쓰기
  익스텐션 - 미리 만들어져 있는 클래스에 메서드를 넣기
• 자신이 만든 클래스에 사용하기보다는 누군가 작성해둔, 이미 컴파일되어 있는 클래스에 메서드를 추가 용도
• 익스텐션을 사용한다고 해서 실제 클래스의 코드가 변경되는 것은 아니며 단지 실행 시에 도트 연산자로 호출해서 사용할 수 있도록 해줌. 특별한 경우를 제외하고는 거의 메서드 확장 용도

 

 

 

---

 

 

설계 도구

• 객체지향 프로그래밍은 구현(실제 로직을 갖는 코딩)과 설계(껍데기만 있는 코딩)로 구분
• 지금까지 위에서 배운 내용은 모두 구현에 중점을 둔 기법
• 아래 내용은 프로그래밍 설계에 사용하는 설계 도구 중 기본 내용

 

 

패키지 (Package)

package 메인 디렉터리.서브 디렉터리
class 클래스 {
​
}

//예시: 파일 상단 package com.limheejin.calculator

• 컴퓨터 언어에서의 패키지 사용 목적은 설계에 가까움
• 코딩하면서 파일을 분류하고, 이름을 짓고, 특정 디렉터리에 모아 놓는 것이 모두 설계
• 패키지는 클래스와 소스 파일을 관리하기 위한 디렉터리 구조의 저장 공간
  현재 클래스가 어떤 패키지(디렉터리)에 있는지 표시
• 디렉터리가 계층 구조로 만들어져 있으면 온점(.)으로 구분해서 각 디렉터리를 모두 나열
  
  

 

 

추상화

abstract class Design {
    abstract fun drawText()
    abstract fun draw()
    fun showWindow() {
        // code
    }
}
​
class Implements: Design(){
    fun drawText() {
        // 구현 코드
    }
    fun draw() {
        // 구현 코드
    }
}

 

abstract class Animal {
    fun walk(){
        Log.d("abstract", "걷습니다.")
    }
    abstract fun move()
}

class Bird: Animal(){
    override fun move(){
        Log.d("abstract", "날아서 이동합니다.")
    }
}

• 초반 개념 설계를 하는 단계에서는 클래스의 이름과 클래스 안에 있음 직한 기능을 유추해서 메서드 이름 나열
• 명확한 코드는 설계 단계에서 메서드 블록 안에 직접 코드를 작성,
  그렇지 않은 경우에는 구현 단계에서 코드를 작성하도록 메서드의 이름만 작성
• 후자를 추상화(Abstract)라고 하며 abstract 키워드를 사용해서 명시
• 구현 단계에서는 추상화된 클래스를 상속받아서 아직 구현되지 않은 부분을 마저 구현
• 예시를 보면 move는 Animal에 따라 다를 수 있음
  앞으로 상속받을 자식 클래스의 특징에 따라 코드가 결정될 가능성이 있다면 해당 기능은 abstract 키워드로 추상화
• 실제 구현 클래스인 Bird에서 이 추상 클래스를 상속받아서 아직 구현되지 않은 추상화되어 있는 기능을 모두 구현
• 추상 클래스는 독립적으로 인스턴스화 할 수 없어서 구현 단계가 고려되지 않는다면 잘못된 설계가 될 수 있음
• 안드로이드의 Activity도 수많은 클래스를 상속 받는데, 이 상속받는 클래스 중 최상위 클래스인 Context가 바로 abstract로 설계되어 있음

 

 

 

인터페이스 (Interface)

interface 인터페이스명 {
    var 변수: String
    fun 메서드1()
    fun 메서드2()
}

• 실행 코드 없이 메서드 이름만 가진 추상 클래스
• 누군가 설계해 놓은 개념 클래스 중에 실행 코드가 한 줄이라도 있으면 추상화,
  코드 없이 메서드 이름만 나열되어 있으면 인터페이스
• 인터페이스는 상속 관계의 설계보다는 외부 모듈에서 내가 만든 모듈을 사용할 수 있도록 메서드의 이름을 나열해둔 일종의 명세서로 제공
• 인터페이스는 interface 예약어를 사용해서 정의할 수 있고 인터페이스에 정의된 메서드를 오버라이드해서 구현
• Kotlin은 프로퍼티도 인터페이스 내부에 정의할 수 있음 (대부분의 객체지향 언어에서는 지원하지 않음)
• 추상 클래스와 다르게 class 키워드는 사용되지 않음
  
  

 

💡 인터페이스를 쓰지 않는 게 좋을 때

• 인터페이스는 외부의 다른 모듈을 위한 의사소통 방식을 정의하는 것
• 혼자 개발하거나 소수의 인원이 하나의 모듈 단위를 개발할 때는 인터페이스를 사용하지 않는 것이 좋음
• 인터페이스를 남용하면 코드의 가독성과 구현 효율성이 떨어지기 때문
• 인터페이스를 자주 사용하는 이유는 안드로이드가 보았을 때 개발자가 만드는 모듈이 외부 모듈이기 때문

 

 

 

인터페이스 만들기

interface InterfaceKotlin{
    var variable: String // var 앞에 abstract 키워드가 생략되어 있음!!!
    fun get()
    fun set()
}

• 메서드는 코드 블록 없이 이름만 작성
• 인터페이스의 프로퍼티와 메서드 앞에는 abstract 키워드가 생략된 형태
  
  

 

 

 

클래스에서 구현하기

class KotlinImpl: InterfaceKotlin {
    override var variable: String = "init value"
    override fun get() {
        // code
    }
    override fun set() {
        // code
    }
}

var kotlinImpl = object: InterfaceKotlin {
    override var variable: String = "init value"
    override fun get() {
        // code
    }
    override fun set() {
        // code
    }   
}

• 인터페이스를 클래스에서 구현할 때는 상속과는 다르게, 생성자를 호출하지 않고 인터페이스 이름만 지정
• 인터페이스를 클래스의 상속 형태가 아닌 소스 코드에서 직접 구현할 때는 object 키워드를 사용하여 구현 (자주 씀)
  
  

 

 

 

 

접근 제한자

• Kotlin에서 정의되는 클래스, 인터페이스, 메서드, 프로퍼티는 모두 접근 제한자(Visibility Modifiers)를 가질 수 있음
• 함수형 언어라는 특성 때문에 코틀린은 기존 객체지향의 접근 제한자 기준인 패키지 대신에 모듈 개념을 도입
• internal 접근 제한자로 모듈 간에 접근을 제한 가능
• 모듈이란? 한 번에 같이 컴파일되는 모든 파일 (하나의 앱 == 하나의 모듈, 라이브러리 == 하나의 모듈)

 

 

접근 제한자의 종류

접근 제한자	제한 범위
private	다른 파일에서 접근 불가
internal	같은 모듈에 있는 파일만 접근 가능
protected	private와 같이 다른 파일에서 접근 불가 다만, 상속 관계에서 자식 클래스가 접근 가능
public	제한 없이 모든 파일에서 접근 가능

• 접근 제한자는 서로 다른 파일에게 자신에 대한 접근 권한을 제공
• 각 변수나 클래스 이름 앞에 아무런 예약어를 붙이지 않았을 때는 기본적으로 public 접근 제한자가 적용

 

 

접근 제한자의 적용

open class Parent {
    private val privateVal = 1
    protected open val protectedVal = 2
    internal val internalVal = 3
    val defaultVal = 4
}

class Child: Parent() {
    fun callVariables() {
        // privateVal은 private 멤버이기 때문에 접근 불가
        Log.d("Modifier", "protected 변수의 값은 ${protectedVal}"). 
        // protected 멤버 protectedVal은 상속 관계이므로 접근 가능
        Log.d("Modifier", "internal 변수의 값은 ${internalVal}"). // 
        // internal 멤버 internalVal은 동일한 모듈이므로 접근 가능
        Log.d("Modifier", "기본 제한자 변수 defaultVal의 값은 ${defaultVal}"). 
        // 접근 제한자가 없는 멤버 defaultVal에는 public이 적용되어 접근 가능
    }
}

• 접근 제한자를 붙이면 해당 클래스, 멤버 프로퍼티 또는 메서드에 대한 사용이 제한됨

 

 

제네릭 (Generic)

public interface MutableList<E> {
    var list: Array<E>
    // ...
}

var list: MutableList<Generic> = mutableListOf("Mon", "Tue", "Wed")

fun testGenerics() {
    var list: MutableList<String> = mutableListOf()
    // String을 제네릭으로 사용했기 때문에 list 변수에는 문자열만 담을 수 있음
    list.add("Mon")
    list.add("Tue")
    list.add("Wed")
    // list.add(35) <- 입력 오류 발생
    for (item in list){
        Log.d("Generic", "list에 입력된 값은 ${item}입니다.")
        // String 타입의 item 변수로 꺼내서 사용할 수 있음
    }
}

• 제네릭(Generic)은 입력되는 값의 타입을 자유롭게 사용하기 위한 설계 도구
• 클래스명 옆에 <E>라고 되어 있는 부분에 String과 같은 특정 타입이 지정되면 클래스 내부에 선언된 모든 E에 String이 타입으로 지정
• 결과적으로 var list: Array<E>가 var list: Array<String>으로 변경되는 것
• 컬렉션이나 배열에서 입력되는 값의 타입을 특정하기 위해 사용
  
  

 

 

---

 

정리

• 클래스(class): 변수와 함수의 모음으로, 연관성 있는 코드를 그룹화하고 이름을 매긴 것
• constructor: 클래스를 사용하기 위해서 호출하는 일종의 함수
• init: 기본 생성자를 호출하면 실행되는 코드 블록
• 프로퍼티(property): 클래스에 정의된 변수 = 프로퍼티 또는 멤버 변수
• 메서드(method): 클래스에 정의된 함수 = 메서드 또는 멤버 함수
• 컴패니언 오브젝트(comapnion object): 컴패니언 오브젝트의 블록 안에서 변수와 함수를 정의하면 생성자를 통하지 않고 클래스의 멤버들을 사용
• 상속: 코드를 재사용하기 위한 설계 도구. 상속 관계에서 자식 클래스는 부모 클래스의 멤버들을 자신의 것처럼 사용
• 추상화(abstract): 클래스를 개념 설계하기 위한 도구
• 인터페이스(interface): 외부 모듈에 제공하기 위해 메서드 이름을 나열한 명세서
• 패키지(package): 연관성 있는 클래스들을 분류하기 위한 디렉터리 구조
• 접근 제한자: 클래스의 멤버에 지정된 접근 제한자에 따라 외부에서 사용 여부가 결정
• 제네릭(generic): 타입을 특정해서 안정성을 유지하기 위한 설계 도구

 

추가 내용 정리

💡파라미터(Parameter)와 매개변수(Argument)의 구분

fun add(x: Int, y: Int): Int {
    return x + y
}
// 파라미터: x, y


val result = add(5, 3)
// 매개변수: 5, 3

• 파라미터: 함수나 메서드 정의에서 선언된 변수 (x, y)
• 매개변수: 함수나 메서드 호출 시 전달되는 실제 값 (5, 3)