접근제한자, 접근제어자 (public, private, protected, internal) 이 뭔데? - Kotlin

 

 

tl;dr

public > protected | internal > private

private : 속해있는 class 에서만 접근가능

internal : private + 같은 모듈 안에서 접근가능

protected : private + 상속받은 클래스에서도 접근가능

public : protected + 접근제한 없음

 

 

서론

kotlin 을 처음 시작하기 전에 kotlin 의 접근제한자는 어떻게 구성되어있는지 알아보고 Java 의 접근제한자와는 어떤 차이점이 있는지 알아보면서 배웠던 것들을 공유하기 위해 포스팅을 하려고 한다.

Java의 접근제한자와의 비교에 중점을 두려고 하니 이전 포스팅을 먼저 확인하고 오면 좋을 것 같다.

 

 

본론

kotlin 의 접근제한자의 종류로는 public, private, protected 그리고 internal 이 있다.

사용하는 변수나 메소드, 생성자 앞에 붙여서 해당 변수, 메소드, 생성자의 사용할 수 있는 자격을 어디까지 줄 것인지 정해 준다.

예를 들어서 설명해 보면 

살고 있는 집에 도어락이 지문인식으로 되어있다고 하면, 지문등록을 내 것만 할 것인지,

가족들도 지문등록을 할 것인지 아니면 친구들이나 누구라도 들어올 수 있도록 만들어 줄 건지 하는 것이다.

 

이러한 접근제한자는 객체지향 ( Object-oriented Programing ) 언어 의 3대요소 캡슐화, 상속 그리고 다향성 중에서 캡슐화에 속한다.

접근제한자를 간단하게 표로 표현해 보면 다음과 같다.

 

java 와 kotlin 의 접근제한자를 비교해 보면 종류의 가지수는 같지만, default 가 없어지고 internal 이 새로 생겼다는 것을 알 수 있다.

kotlin 에서의 접근제한자를 간단하게 표로 표현해 보면 다음과 같다.

 

제한자 \ 범위	같은 class	같은 module	다른 module	제한없음
private	O
protected	O	(상속 받았을 때 O)	(상속 받았을 때 O)
internal	O	O
public	O	O	O	O

표에 나타낸 것과 같이 private 에서 default, protected, public 으로 갈수록 점점 제한이 풀린다는 것을 알 수 있다.

이는 java 에서와 같은 내용이지만 internal 부분을 확인해 보면 같은 package 에서 같은 module 로 바뀌었다는 것을 알 수 있다.

각 제한자가 어떤 역할을 하는 알아보기 이전에 기본용어 먼저 짚고 넘어가도록 하자.

 

project - 최상위 개념이다. 여러 module을 가질 수 있다.

module - 여러 package를 가질 수 있다.

package - 여러 member, function, class 를 가질 수 있다.

class - member, function을 가질 수 있다.

간단하게 project > module > package > class 라고 생각하면 된다.

 

예제를 보면서 어떤 얘기인지 확인해 보도록 하자.

 

 

1. private

open class OuterK {
    private val a = 1
    private class Inner {
        val e = 5
    }
}

class SubClass : OuterK() {
    init {
        val a = this.a // access 불가
        val e = Inner().e // access 불가
    }
}

class Unrelated(o: OuterK) {
    init {
        val a = o.a // access 불가
        val e = OuterK.Inner().e // access 불가
    }
}

OuterK 클래스에 private 가 붙은 변수나 클래스 모두 같은 패키지라도 접근할 수 없다는 것을 알 수 있다.

상속을 받더라도 접근할 수 없다.

이것을 통해 private 이 붙게 되면 속해있는 class 내부를 제외하고는 절대 접근할 수 없다는 것을 알 수 있다. 

즉 완전 폐쇄적인 상황에서만 사용해야 한다.

 

 

2. protected

open class OuterK {
    protected open val b = 2
    protected class Inner2 {
        val f = 6
    }
}

class SubClass : OuterK() {
    override val b = 5 // access 가능
    init {
        val b = this.b // access 가능
        val f = Inner2().f // access 가능
    }
}

class Unrelated(o: OuterK) {
    init {
        val b = o.b // access 불가
        val f = OuterK.Inner2().f // access 불가
    }
}

 

OuterK 클래스에 protected 가 붙어있는 변수나 클래스는 위의 예시에서 확인할 수 있듯이 동일한 class 내에서 뿐만아니라 상속받은 class 에서도 접근이 가능하지만 다른 class 에서는 접근할 수 없는 것을 확인할 수 있다.

표를 보면 상속받은 class 에서는 접근이 가능하다고 했는데

그렇다면 다른 패키지에서 호출할 때는 어떻게 되는지 확인해보자.

 

class SubClassK : OuterK() {
    init {
        val b = b // access 가능
        val f = Inner2().f // access 가능
    }
}

class UnrelatedK(o: OuterK) {
    init {
        val b = o.b // access 불가
        val f = OuterK.Inner2().f // access 불가
    }
}

 

처음 예시에서와 완전히 똑같다는 것을 알 수 있다. 이를통해 다른 패키지에서도 접근할 수 있다는 것을 알 수 있다.

그렇다면 모듈이 바뀐다면 어떻게 될까?

 

class SubClassK : OuterK() {
    init {
        val b = b // access 가능
        val f = Inner2().f // access 가능
    }
}

class UnrelatedK(o: OuterK) {
    init {
        val b = o.b // access 불가
        val f = OuterK.Inner2().f // access 불가
    }
}

 

모듈이 바뀌더라도 처음과 똑같이 상속받을 때만 접근할 수 있는 것을 알 수 있다.

이를 통해 protected 가 붙게 되면 상속하는 class 에서는 접근할 수 있지만, 그외에는 접근할 수 없다는 것을 알 수 있다.

즉 다른 class 에서 상속이 필요한 상황에 사용해야 한다.

 

 

3. internal

open class OuterK {
    internal val c = 3
    internal class Inner3 {
        val g = 7
    }
}

class SubClass : OuterK() {
    init {
        val c = this.c // access 가능
        val g = Inner3().g // access 가능
    }
}

class Unrelated(o: OuterK) {
    init {
        val c = o.c // access 가능
        val g = OuterK.Inner3().g // access 가능
    }
}

 

OuterK 클래스에 internal 가 붙어있는 변수나 클래스는 위의 예시에서 확인할 수 있듯이 동일한 class 나 다른 class 내에서 뿐만아니라 상속받은 class 에서도 접근이 가능하다는 것을 확인할 수 있다.

표를 보면 같은 모듈 에서만 상속된 class 가 접근이 가능하다고 했는데

그렇다면 다른 패키지랑 다른 모듈에서 호출할 때는 어떻게 되는지 확인해보자.

 

같은 모듈이고 다른 패키지 일 때

class SubClassK : OuterK() {
    init {
        val c = c // access 가능
        val g = Inner3().g // access 가능
    }
}

class UnrelatedK(o: OuterK) {
    init {
        val c = o.c // access 가능
        val g = OuterK.Inner3().g // access 가능
    }
}

 

다른 모듈일 때

class SubClassK : OuterK() {
    init {
        val c = c // access 불가
        val g = Inner3().g // access 불가
    }
}

class UnrelatedK(o: OuterK) {
    init {
        val c = o.c // access 불가
        val g = OuterK.Inner3().g // access 불가
    }
}

 

위의 예시들을 통해 같은 모듈에서 패키지가 바뀌게 되면 영향이 없지만 모듈이 바뀌게 되면 접근이 제한된다는 것을 알 수 있다.

이를 통해 internal 가 붙게 되면 상속과 상관 없이 모듈이 같다면 접근할 수 있고 그렇지 않다면 접근할 수 없다는 것을 알 수 있다.

즉 같은 모듈내 에서만 적용하고 싶은 상황에 사용해야 한다.

 

 

4. public

같은 모듈 같은 패키지 일 때 (java 에서의 default 접근제한자 표현법이랑 같음. public 을 붙여줘도 됨.)

open class OuterK {
    val d = 4 // public val d = 4 이랑 같음
    class Inner4 {
        val h = 8
    }
}

class SubClass : OuterK() {
    init {
        val d = this.d // access 가능
        val h = Inner4().h // access 가능
    }
}

class Unrelated(o: OuterK) {
    init {
        val d = o.d // access 가능
        val h = OuterK.Inner4().h // access 가능
    }
}

 

같은 모듈 다른 패키지 일 때

class SubClassK : OuterK() {
    init {
        val d = d // access 가능
        val h = Inner4().h // access 가능
    }
}

class UnrelatedK(o: OuterK) {
    init {
        val d = o.d // access 가능
        val h = OuterK.Inner4().h // access 가능
    }
}

 

다른 모듈 일 때

class SubClassK : OuterK() {
    init {
        val d = d // access 가능
        val h = Inner4().h // access 가능
    }
}

class UnrelatedK(o: OuterK) {
    init {
        val d = o.d // access 가능
        val h = OuterK.Inner4().h // access 가능
    }
}

 

public 의 경우에는 접근제한없이 어떤 상황이라도 접근할 수 있다.

위의 예시와 같이 같은 패키지 뿐만 아니라, 같은 모듈 그리고 다른 모듈에서도 접근이 가능하다.

이를 통해 모든 상황에 대해 public 은 접근이 가능하다는 것을 알 수 있다.

즉 상황에 구애받지 않고 사용하고 싶을 때 public 을 붙여주면 된다.

 

 

 

마지막으로 kotlin의 접근제한자 사용 범위에 대해서 알아보도록 하자.

 

클래스	public, internal, private
생성자	public, internal, protected, private
멤버변수	public, internal, protected, private
멤버메소드	public, internal, protected, private
지역번수	접근제한자 사용 제한 (사용할 수 없음)

 

 

 

결론

kotlin의 접근제한자에 대해 알아보았다.

비교적 어렵지 않은 내용이지만, java 와의 차이는 뚜렷이 있다는 것을 확인할 수 있었다.

 

• java 에서 아무런 접근제한자도 적지 않으면 default 였던 데에 반해 kotlin 에서는 public 이 된다
• 같은 모듈일 때 다른 모듈에서의 접근을 제한하려면 internal 을 상속받을 때만 protected 를 사용한다
• java 에서와 달리 kotlin 에서의 protected 는 상속받았을 때만 접근할 수 있다

 

정확한 사용법을 알아보지 않고 사용하게 되면 코드가 중구난방식이 될 수 있기 때문에 주의 해야할 필요가 있다. 그리고 kotlin 의 기본이 되는 내용이니 만큼 반드시 머리속에 들어가 있어야하는 부분이다.

 

참조

https://kotlinlang.org/docs/reference/visibility-modifiers.html

 

 

 

전체코드

// 같은 모듈 같은 패키지 일 때

open class OuterK {
    private val a = 1
    protected open val b = 2
    internal val c = 3
    val d = 4 // public val d = 4 이랑 같음

    private class Inner {
        val e = 5
    }
    protected class Inner2 {
        val f = 6
    }
    internal class Inner3 {
        val g = 7
    }
    class Inner4 {
        val h = 8
    }
}

class SubClass : OuterK() {
    override val b = 2 // access 가능
    init {
        val a = this.a // access 불가
        val b = this.b // access 가능
        val c = this.c // access 가능
        val d = this.d // access 가능
        val e = Inner().e // access 불가
        val f = Inner2().f // access 가능
        val g = Inner3().g // access 가능
        val h = Inner4().h // access 가능
    }
}

class Unrelated(o: OuterK) {
    init {
        val a = o.a // access 불가
        val b = o.b // access 불가
        val c = o.c // access 가능
        val d = o.d // access 가능
        val e = OuterK.Inner().e // access 불가
        val f = OuterK.Inner2().f // access 불가
        val g = OuterK.Inner3().g // access 가능
        val h = OuterK.Inner4().h // access 가능
    }
}

// 같은 모듈 다른 패키지 일 때


class SubClassK : OuterK() {
    init {
        val a = a // access 불가
        val b = b // access 가능
        val c = c // access 가능
        val d = d // access 가능
        val e = Inner().e // access 불가
        val f = Inner2().f // access 가능
        val g = Inner3().g // access 가능
        val h = Inner4().h // access 가능
    }
}

class UnrelatedK(o: OuterK) {
    init {
        val a = o.a // access 불가
        val b = o.b // access 불가
        val c = o.c // access 가능
        val d = o.d // access 가능
        val e = OuterK.Inner().e // access 불가
        val f = OuterK.Inner2().f // access 불가
        val g = OuterK.Inner3().g // access 가능
        val h = OuterK.Inner4().h // access 가능
    }
}

// 다른 모듈 일 때

class SubClassK : OuterK() {
    init {
        val a = a // access 불가
        val b = b // access 가능
        val c = c // access 불가
        val d = d // access 가능
        val e = Inner().e // access 불가
        val f = Inner2().f // access 가능
        val g = Inner3().g // access 불가
        val h = Inner4().h // access 가능
    }
}

class UnrelatedK(o: OuterK) {
    init {
        val a = o.a // access 불가
        val b = o.b // access 불가
        val c = o.c // access 불가
        val d = o.d // access 가능
        val e = OuterK.Inner().e // access 불가
        val f = OuterK.Inner2().f // access 불가
        val g = OuterK.Inner3().g // access 불가
        val h = OuterK.Inner4().h // access 가능
    }
}