[접근 제한자] [예약어] class 클래스명 { 1. 필드(field) : 객체의 속성을 작성하는 클래스 내부 영역 2. 생성자(constructor) 3. 메서드(method) }
: 같은 패키지 내에서만 import가 가능함을 나타냄
: 직접 접근 가능한 범위를 나타냄
접근 제한자 | 예약어 | 자료형 | 변수명 [ = 초기값]; |
---|---|---|---|
+ public | final | 기본 자료형 | |
# protected | static | 참조형(배열, 클래스명) | |
~ (default) | abstract | ||
- private | final static |
접근 제한자 | 해당 클래스 내부 | 같은 패키지 내 | 후손 클래스 내 | 전체 |
---|---|---|---|---|
+ public | O | O | O | O |
# protected | O | O | O | |
~ (default) | O | O | ||
- private | O |
이제 각 패키지 속에 있는 클래스들을 살펴보자.
package edu.kh.oop.cls.model.vo;
public class Student { // 클래스 선언부
//[접근제한자] [예약어] class 클래스명
// 1. 필드(field) : 객체의 속성을 작성하는 클래스 내부 영역 (== 멤버 변수)
public int v1 = 10;
protected int v2 = 20;
int v3 = 30;
private int v4 = 40;
// 접근 제한자 예제
public void ex() {
System.out.println("같은 클래스 내부");
System.out.println( v1 ); // 10
System.out.println( v2 ); // 20
System.out.println( v3 ); // 30
System.out.println( v4 ); // 40
}
// 2. 생성자(constructor)
// 3. 메서드(method)
}
package edu.kh.oop.cls.model.vo;
class TestVO {
// Student와 같은 패키지
// -> public, protected, (default) 3개만 접근 가능
public void ex() {
System.out.println("같은 패키지");
Student std = new Student(); // 학생 객체 생성
System.out.println(std.v1);
System.out.println(std.v2);
System.out.println(std.v3);
// System.out.println(std.v4);
// v4는 private이기 때문에 같은 패키지라도
// 다른 클래스에서 직접 접근 불가
}
}
package edu.kh.oop.cls.model.service;
import edu.kh.oop.cls.model.vo.Student;
// import edu.kh.oop.cls.model.vo.TestVO;
// The type edu.kh.oop.cls.model.vo.TestVO is not visible
public class ClsService /*extends Student*/{
// 부모 Student를 상속받음
public void ex1() {
// 클래스 접근 제한자 확인하기
Student std = new Student();
// public class인 Student는 import 가능
// TestVO test = new TestVO();
// (default) class인 TestVO는 import가 불가능 (다른 패키지)
System.out.println("다른 패키지");
System.out.println(std.v1);
// 다른 패키지에서도 접근 가능한 public만 에러 X
// System.out.println(std.v2);
// System.out.println(std.v3);
// System.out.println(std.v4);
// 상속 관계에서 직접 접근 가능
// System.out.println(v1);
// System.out.println(v2); // protected 직접 접근 가능
// System.out.println(v3);
// System.out.println(v4);
}
}
- 공유 메모리 영역 (또는 정적 메모리 영역)이라고 함
-> why? 프로그램 시작 시 static이 붙은 코드들이 모두 static 영역에 생성되고,
프로그램이 종료될 때까지 사라지지 않음 (정적)
static 영역에 생성된 변수는 어디서든지 공유할 수 있음 (공유)
클래스명.변수명
[예제 2] - static 필드 확인
vo 패키지 - Student 클래스
package edu.kh.oop.cls.model.vo;
public class Student {
public static String schoolName = "KH고등학교";
private String name; // 캡슐화 원칙 때문에 private -> 간접 접근 방법 필요
{ // 초기화 블록 : 객체 생성 시 필드 값 초기화
name = "홍길동";
}
// getter / setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public void ex2() {
// static 필드 확인 예제
// 학생 객체 2개 생성
Student std1 = new Student();
Student std2 = new Student();
// 학생 객체에 name 세팅
std1.setName("김철수");
std2.setName("이영희");
// 정보 출력
System.out.println(std1.schoolName); // public이기 때문에 직접 접근 가능
System.out.println(std1.getName());
System.out.println(std2.schoolName); // public이기 때문에 직접 접근 가능
System.out.println(std2.getName());
// schoolName 변경
std1.schoolName = "KH정보교육원";
System.out.println("변경 후 std1 : " + std1.schoolName); // KH정보교육원
System.out.println("std2 : " + std2.schoolName); // KH고등학교 (X) -> KH정보교육원
// std3 생성
Student std3 = new Student();
System.out.println("std3 : " + std3.schoolName);
// schoolName에 노란줄이 뜨는 이유 -> 제대로 작성하지 않아서
// *** static이 붙은 필드(변수)는 클래스명.변수명으로 사용함
Student.schoolName = "KH";
System.out.println("Student.schoolName : " + Student.schoolName);
}
- 객체의 속성을 작성하는 클래스 내부 영역
== 멤버 변수 : 메서드 밖에 작성된 변수
① 인스턴스 변수 : 필드에 작성되는 일반 변수
② 클래스 변수(== static 변수) : 필드에 static 예약어가 작성된 변수
-> why? 같은 클래스로 만들어진 객체가 값을 공유할 수 있기 때문에
- new 연산자를 통해서 객체를 생성할 때
생성된 객체의 필드 값 초기화 + 지정된 기능을 수행하는 역할
1) 생성자의 이름은 반드시 클래스명과 같아야 한다.
2) 반환형이 존재하지 않는다.
1) 기본 생성자
2) 매개변수 생성자
[접근제한자] 클래스명() { 코드 }
[예제 3] - 생성자 코드 작성 및 생성자 확인
vo 패키지 - Student 클래스
// 기본 생성자 작성법
// [접근제한자] 클래스명() { 코드 }
public Student() {
// 객체가 생성될 때 수행할 코드
System.out.println("기본 생성자에 의해서 Student 객체가 생성되었습니다.");
}
// public void ex1() {}
// -> void가 반환형 (생성자는 존재하지 않음)
// 3. 메서드(method)
}
package edu.kh.oop.cls.model.vo;
public class User {
// 속성(== 필드)
// 아이디, 비밀번호, 이름, 나이, 성별 (추상화 진행)
private String userId;
private String userPw;
private String userName;
private int userAge;
private char userGender;
// 기능(== 생성자 + 메서드)
// 생성자 : new 연산자를 통해서 객체가 생성될 때
// 생성된 객체의 필드 값 초기화 + 기능 수행 역할
// 기본 생성자
public User() {
// 기능
System.out.println("기본 생성자로 User 객체 생성");
// 필드 초기화
userId = "user01";
userPw = "pass01";
userName = "홍길동";
userAge = 20;
userGender = '남';
}
// 캡슐화로 인한 간접 접근 기능(getter / setter)
public String getUserId() { // userId의 getter
return userId;
}
public void setUserId(String userId) { // userId의 setter
this.userId = userId;
}
public String getUserPw() {
return userPw;
}
public void setUserPw(String userPw) {
this.userPw = userPw;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public int getUserAge() {
return userAge;
}
public void setUserAge(int userAge) {
this.userAge = userAge;
}
public char getUserGender() {
return userGender;
}
public void setUserGender(char userGender) {
this.userGender = userGender;
}
}
public void ex3() {
// 생성자 확인 테스트
// Student 객체를 기본 생성자를 이용해 생성하고 이를 참조하는 참조변수 s1에 대입
Student s1 = new Student();
// 기본 생성자
// 1. Student 클래스를 보고 Student 객체를 만들겠다.
// 2. Student 객체가 생성된 후 기본 생성자에 작성된 코드를 수행하겠다.
// User 기본 생성자를 이용해서 객체 생성
User u1 = new User();
// User 객체 필드 초기화 확인
System.out.println( u1.getUserId() );
System.out.println( u1.getUserPw() );
System.out.println( u1.getUserName() );
System.out.println( u1.getUserAge() );
System.out.println( u1.getUserGender() );
// User 기본 생성자를 이용해서 객체 생성
User u2 = new User();
System.out.println( u2.getUserId() );
System.out.println( u2.getUserPw() );
System.out.println( u2.getUserName() );
System.out.println( u2.getUserAge() );
System.out.println( u2.getUserGender() );
u1이 참조하고 있는 User 객체와 u2가 참조하고 있는 User 객체의 필드 값이
모두 동일하다는 문제점이 발생한다.
-> why? 같은 기본 생성자 User 객체를 생성했기 때문에 기본 생성자에 저장되어 있는 값으로 동일하게 초기화되었기 때문에
u2.setUserId("asdf1234");
u2.setUserPw("1q2w3e4r");
u2.setUserName("김길동");
u2.setUserAge(19);
u2.setUserGender('여');
System.out.println( u2.getUserId() );
System.out.println( u2.getUserPw() );
System.out.println( u2.getUserName() );
System.out.println( u2.getUserAge() );
System.out.println( u2.getUserGender() );
2) 매개변수 생성자를 이용해서 객체가 생성될 때부터 다른 값으로 필드를 초기화
생성자나 메소드 호출 시 () 안에 작성되어 전달되어지는 값을 저장하는 변수
-> 전달받은 값을 저장하고 있는 매개체(지니고 있는) 역할의 변수
- 사용되는 기술, 변수 : 매개변수, Overloading(오버로딩), this
public User( String userId, String userPw ) {
// 매개변수
System.out.println("매개변수 생성자를 이용해서 User 객체 생성");
System.out.println(userId + " / " + userPw);
// 전달받은 값을 필드에 초기화(this 참조 변수)
// *** this 참조 변수 ***
// - 객체가 자기 자신을 참조할 수 있도록 하는 변수
// - 모든 객체 내부에 숨겨져 있다.
// ?? 왜 사용하는가 ??
// -> 필드명과 매개변수명이 같을 경우
// 이를 구분하기 위해서 주로 사용
this.userId = userId;
// 필드 = 매개 변수
this.userPw = userPw;
}
User u3 = new User("test3", "pass333"); // 매개변수 생성
// 생성자 수행 시 전달할 값을 작성 (순서를 꼭 지켜야 함!)
System.out.println( u3.getUserId() );
System.out.println( u3.getUserPw() );
정상적으로 초기화된 모습을 볼 수 있다.
[예제 4] - 매개변수 생성자 예제
vo 패키지 - User 클래스
// 필드를 전부 초기화하는 목적의 매개변수 생성자
public User(String userId, String userPw, String userName,
int userAge, char userGender) {
// 매개변수로 전달받은 값으로 필드 초기화
this.userId = userId; // 현재 객체가 가지고 있는 필드 userId에
// 매개변수 userId 값을 대입
this.userPw = userPw;
this.userName= userName;
this.userAge = userAge;
this.userGender = userGender;
}
public void ex4() { // 매개변수 생성자 예제
User u1 = new User();// 기본 생성자
User u2 = new User("user02", "pass02");// 매개변수 2개 생성자
User u3 = new User("user03", "pass03", "김민수", 24, '남');// 매개변수 5개 생성자
User u4 = new User("user04", "pass04", "박영희", 25, '여');// 매개변수 5개 생성자
User u5 = new User("user05", "pass05", "이수지", 26, '여');// 매개변수 5개 생성자
System.out.printf("u1 : %s / %s / %s / %d / %c\n",
u1.getUserId(), u1.getUserPw(), u1.getUserName(),
u1.getUserAge(), u1.getUserGender() );
System.out.printf("u2 : %s / %s / %s / %d / %c\n",
u2.getUserId(), u2.getUserPw(), u2.getUserName(),
u2.getUserAge(), u2.getUserGender() );
System.out.printf("u3 : %s / %s / %s / %d / %c\n",
u3.getUserId(), u3.getUserPw(), u3.getUserName(),
u3.getUserAge(), u3.getUserGender() );
System.out.printf("u4 : %s / %s / %s / %d / %c\n",
u4.getUserId(), u4.getUserPw(), u4.getUserName(),
u4.getUserAge(), u4.getUserGender() );
System.out.printf("u5 : %s / %s / %s / %d / %c\n",
u5.getUserId(), u5.getUserPw(), u5.getUserName(),
u5.getUserAge(), u5.getUserGender() );
}
u2의 경우 매개변수 2개만 값이 대입되었기 때문에 나머지 3개는 기본 값으로 초기화되었다. (null, o, (공백))