접근제한자, 접근제어자 (public, private, protected, default) 가 뭔데? - Java
tl;dr
public > protected > default > private
private : 속해있는 class 에서만 접근가능
default : private + 같은 패키지 안에서 접근가능
protected : default + 상속받은 클래스에도 접근가능
public : protected + 접근제한 없음
서론
접근제한자는 Java 의 기본이나 다름없지만 자세히 들여다 볼 생각하지 않고, 프로그래밍을 하였다.
상황에 맞게 사용하기 위해서 필요할 때만 찾아서 사용하다 보니 전체 구조가 틀어지고 어지럽혀지는 경험을 해본 적도 있다.
보다 더 자세히 접근제한자에 대해 알아볼 필요성을 느껴서 포스팅을 남기기로 했다.
본론
Java 의 접근제한자의 종류로는 public, private, protected 그리고 default 가 있다.
사용하는 변수나 메소드, 생성자 앞에 붙여서 해당 변수, 메소드, 생성자의 사용할 수 있는 자격을 어디까지 줄 것인지 정해 준다.
예를 들어서 설명해 보면
살고 있는 집에 도어락이 지문인식으로 되어있다고 하면, 지문등록을 내 것만 할 것인지,
가족들도 지문등록을 할 것인지 아니면 친구들이나 누구라도 들어올 수 있도록 만들어 줄 건지 하는 것이다.
이러한 접근제한자는 객체지향 ( Object-oriented Programing ) 언어 의 3대요소 캡슐화, 상속 그리고 다향성 중에서 캡슐화에 속한다.
접근제한자를 간단하게 표로 표현해 보면 다음과 같다.
| 제한자 \ 범위 | 같은 class | 같은 package | 상속받은 class (다른 package) |
제한없음 |
| private | O | |||
| default | O | O | ||
| protected | O | O | O | |
| public | O | O | O | O |
표에 나타낸 것과 같이 private 에서 default, protected, public 으로 갈수록 점점 제한이 풀린다는 것을 알 수 있다.
예제를 보면서 어떤 얘기인지 확인해 보도록 하자.
1. private
public class OuterJ {
private int a = 4;
private class Inner {
public Inner(){}
public int e = 5;
}
}
class SubClass extends OuterJ {
SubClass() {
int a = this.a; // access 불가
int e = this.new Inner().e; // access 불가
}
}
class Unrelated {
Unrelated(OuterJ o) {
int a = o.a; // access 불가
int e = o.new Inner().e; // access 불가
}
}
OuterJ 클래스에 private 가 붙은 변수나 클래스 모두 같은 패키지라도 접근할 수 없다는 것을 알 수 있다.
상속을 받더라도 접근할 수 없다.
이것을 통해 private 이 붙게 되면 속해있는 class 내부를 제외하고는 절대 접근할 수 없다는 것을 알 수 있다.
즉 완전 폐쇄적인 상황에서만 사용해야 한다.
2. default
public class OuterJ {
int b = 2;
static class Inner2 {
public Inner2(){}
public int f = 6;
}
}
class SubClass extends OuterJ {
SubClass() {
int b = this.b; // access 가능
int f = this.new Inner2().f; // access 가능
}
}
class Unrelated {
Unrelated(OuterJ o) {
int b = o.b; // access 가능
int f = o.new Inner2().f; // access 가능
}
}
OuterJ 클래스에 아무것도 붙지 않은 변수나 클래스를 default 라고 한다.
위의 예시에서는 동일한 패키지 내에서 default 변수랑 클래스를 호출하였기 때문에 접근이 가능하다는 것을 확인할 수 있다.
표를 보면 같은 패키지내에서는 접근이 가능하다고 되어있는데
그렇다면 외부 패키지에서 호출할 때는 어떻게 되는지 확인해보자.
class SubClassJ extends OuterJ {
SubClassJ() {
int b = this.b; // access 불가
int f = this.new Inner2().f; // access 불가
}
}
class UnrelatedJ {
UnrelatedJ(OuterJ o) {
int b = o.b; // access 불가
int f = o.new Inner2().f; // access 불가
}
}
위의 예시와 같이 외부패키지에서는 접근불가하다는 것을 알 수 있다.
이를통해 default 는 같은 패키지에서의 접근은 가능하지만 다른 패키지에서는 접근불가하다는 것을 알 수 잇다.
즉 default 는 같은 패키지내에서 사용하고 싶지만 다른 패키지에서는 사용하고 싶지 않을 때 사용하면 된다.
3. protected
public class OuterJ {
protected int c = 3;
protected class Inner3 {
public Inner3() {}
public int g = 7;
}
}
class SubClass extends OuterJ {
SubClass() {
int c = this.c; // access 가능
int g = this.new Inner3().g; // access 가능
}
}
class Unrelated {
Unrelated(OuterJ o) {
int c = o.c; // access 가능
int g = o.new Inner3().g; // access 가능
}
}
protected 같은 경우에는 같은 패키지 뿐만 아니라 다른 패키지에서도 경우에 따라 접근할 수 있다고 되어있었다.
위의 예시를 보면 같은 패키지에서는 접근할 수 있다는 것을 알 수 있다. 그렇다면 다른 패키지의 경우에는 어떻게 될까?
class SubClassJ extends OuterJ {
SubClassJ() {
int c = this.c; // access 가능
int g = this.new Inner3().g; // access 가능
}
}
class UnrelatedJ {
UnrelatedJ(OuterJ o) {
int c = o.c; // access 불가
int g = o.new Inner3().g; // access 불가
}
}
위의 예시를 확인해 보면 OuterJ 클래스를 상속받은 SubClassJ 에서는 protected 에 접근이 가능하다.
하지만 상속받지 않은 UnrelatedJ 클래스에서는 protected 에 접근할 수 없다는 것을 알 수 있다.
이를 통해 같은 패키지 뿐만 아니라 다른 패키지에서도 접근할 수 있지만 상속받았을 때만 가능하다는 제한사항이 붙는 것을 알 수 있다.
즉 protected 는 다른패키지에서 상속받을 수 있게끔 만들고 싶을 때만 사용하면 된다고 할 수 있겠다.
4. public
public class OuterJ {
public int d = 4;
public class Inner4 {
public Inner4(){}
public int h = 8;
}
}
class SubClass extends OuterJ {
SubClass() {
int d = this.d; // access 가능
int h = this.new Inner4().h; // access 가능
}
}
class Unrelated {
Unrelated(OuterJ o) {
int d = o.d; // access 가능
int h = o.new Inner4().h; // access 가능
}
}
public 의 경우에는 접근제한없이 어떤 상황이라도 접근할 수 있다.
위의 예시와 같이 같은 패키지 뿐만 아니라, 아래와 같이 다른 패키지에서도 접근이 가능하다.
class SubClassJ extends OuterJ {
SubClassJ() {
int d = this.d; // access 가능
int h = this.new Inner4().h; // access 가능
}
}
class UnrelatedJ {
UnrelatedJ(OuterJ o) {
int d = o.d; // access 가능
int h = o.new Inner4().h; // access 가능
}
}
이를 통해 같은 패키지 뿐만아니라 다른 패키지에서도 모든 상황에 대해 public 은 접근이 가능하다는 것을 알 수 있다.
즉 상황에 구애받지 않고 사용하고 싶을 때 public 을 붙여주면 된다.
마지막으로 접근제한자 사용 범위에 대해서 알아보도록 하자.
| 클래스 | public, default |
| 생성자 | public, protected, default, private |
| 멤버변수 | public, protected, default, private |
| 멤버메소드 | public, protected, default, private |
| 지역번수 | 접근제한자 사용 제한 (사용할 수 없음) |
결론
접근제한자에 대해 알아보았다.
비교적 어렵지 않은 내용이지만, 정확한 사용법을 알아보지 않고 사용하게 되면 코드가 중구난방식이 될 수 있기 때문에 주의 해야할 필요가 있다. 그리고 Java 의 기본이 되는 내용이니 만큼 반드시 머리속에 들어가 있어야하는 부분이다.
참조
https://www.javatpoint.com/access-modifiers
https://beginnersbook.com/2013/05/java-access-modifiers/
전체코드
// 같은 패키지 일 때
public class OuterJ {
private int a = 1;
int b = 2;
protected int c = 3;
public int d = 4;
private class Inner {
public Inner(){}
public int e = 5;
}
class Inner2 {
public Inner2() {}
public int f = 6;
}
protected class Inner3 {
public Inner3() {}
public int g = 7;
}
public class Inner4 {
public Inner4(){}
public int h = 8;
}
}
class SubClass extends OuterJ {
SubClass() {
int a = this.a; // access 불가
int b = this.b; // access 가능
int c = this.c; // access 가능
int d = this.d; // access 가능
int e = this.new Inner().e; // access 불가
int f = this.new Inner2().f; // access 가능
int g = this.new Inner3().g; // access 가능
int h = this.new Inner4().h; // access 가능
}
}
class Unrelated {
Unrelated(OuterJ o) {
int a = o.a; // access 불가
int b = o.b; // access 가능
int c = o.c; // access 가능
int d = o.d; // access 가능
int e = o.new Inner().e; // access 불가
int f = o.new Inner2().f; // access 가능
int g = o.new Inner3().g; // access 가능
int h = o.new Inner4().h; // access 가능
}
}
// 다른 패키지 일 때
class SubClassJ extends OuterJ {
SubClassJ() {
int a = this.a; // access 불가
int b = this.b; // access 불가
int c = this.c; // access 가능
int d = this.d; // access 가능
int e = this.new Inner().e; // access 불가
int f = this.new Inner2().f; // access 불가
int g = this.new Inner3().g; // access 가능
int h = this.new Inner4().h; // access 가능
}
}
class UnrelatedJ {
UnrelatedJ(OuterJ o) {
int a = o.a; // access 불가
int b = o.b; // access 불가
int c = o.c; // access 불가
int d = o.d; // access 가능
int e = o.new Inner().e; // access 불가
int f = o.new Inner2().f; // access 불가
int g = o.new Inner3().g; // access 불가
int h = o.new Inner4().h; // access 가능
}
}