객체
- [접근제한자][예약어] class 클래스명
cf. default는 표기 생략해서 사용
- 필드(field): 객체의 속성을 작성하는 클래스 내부 영역
== 멤버 변수: 메소드 밖에 작성된 변수
- 인스턴스 변수: 필드에 작성되는 일반 변수
- 클래스 변수(==static 변수): 필드에 static 예약어가 작성된 변수
//why? 같은 클래스로 만들어진 객체가 값을 공유할 수 있기 때문
-static
1. 공유 메모리 영역(정적 메모리 영역이라고도 함)
why? 프로그램 시작 시 static이 붙은 코드들이 모두 static영역에 생성되고, 프로그램 종료까지 사라지지 않음(정적).
그리고 static 영역에 생성된 변수는 어디서든지 공유할 수 있다(공유)
2. 사용법: 클래스명.변수명
- 생성자(constructor)
- new 연산자를 통해서 객체를 생성할 때 생성된 객체의 필드값 초기화 + 지정된 기능을 수행하는 역할
- 생성자 작성 규칙
1) 생성자 이름은 반드시 클래스명과 같아야 한다.
2) 반환형이 존재하지 않는다. - 생성자의 종류
1) 기본 생성자: [접근제한자] 클래스명() { 코드 }
2) 매개변수 생성자: 생성자 수행 시 전달할 값 작성 (자료형, 순서 지키기 필수)
*매개변수 생성자
**사용되는 기술, 변수: 매개변수, OverLoading(오버로딩), this
**매개변수: 생성자나 메소드 호출 시 () 안에 작성되어 전달되어지는 값을 저장하는 변수
-> 전달받은 값을 저장하고 있는 매개체(지니고 있는)역할의 변수
*this 참조변수 _매개변수는 괄호{} 밖에서 사용 불가
-객체가 자기 자신을 참조할 수 있도록 하는 변수
-모든 객채 내부에 숨겨져 있다.
왜 사용하는가?
-> 필드명과 매개변수명이 같은 경우, 이를 구분하기 위해 사용
*this()
-같은 클래스에 다른 생성자를 호출할 때 사용하는 this()
-생성자 내에서 반드시 첫 번째 줄에 작성되어야 함!!!!!!!!
왜 사용하는가?
-> 중복 코드 제거, 코드 길이 감소, 재사용성 증가
but, 가독성이 떨어지기 때문에 자주 사용되지 않음
*오버로딩(Over Loading)
-클래스 내에 동일한 이름의 메소드(생성자도 포함)를 여러 개 작성하는 기법
--> 하나의 이름으로 여러 기능을 수행할 수 있게 하는 것
[오버로딩 조건]
1. 메소드(생성자 포함)의 이름이 동일해야 함
2. 매개변수의 개수, 타입, 순서 중 1개라도 달라야 함 (변수명은 신경쓰지 않는다.)
Student
package edu.kh.oop.cls.model.vo;
public class Student { // 클래스 선언부
//[접근제한자] [예약어] class 클래스명
//cf. default는 표기 생략해서 사용
//1. 필드(field): 객체의 속성을 작성하는 클래스 내부 영역
// == 멤버 변수: 메소드 밖에 작성된 변수
//-인스턴스 변수: 필드에 작성되는 일반 변수
//-클래스 변수(==static 변수): 필드에 static 예약어가 작성된 변수
//why? 같은 클래스로 만들어진 객체가 값을 공유할 수 있기 때문
/*
[접근제한자] [예약어] 자료형 변수명[=초기값];
+ public final 기본 자료형
# protected static 배열
~ (default) final static 클래스명
- private static final (참조형)
*필드의 접근제한자의 뜻: 직접 접근이 가능한 범위를 나타냄
*/
//얘네가 필드 (메소드 밖)
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
}
//--------------------------------------------
//static 예약어
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;
}
//----------------------------------------------------------
//2. 생성자(constructor)
/* - new 연산자를 통해서 객체를 생성할 때
* 생성된 객체의 필드값 초기화 + 지정된 기능을 수행하는 역할
*
* - 생성자 작성 규칙
* 1) 생성자 이름은 반드시 클래스명과 같아야 한다.
* 2) 반환형이 존재하지 않는다.
*
* - 생성자의 종류
* 1) 기본 생성자
* 2) 매개변수 생성자
*/
//기본 생성자
//[접근제한자] 클래스명() { 코드 }
public Student() {
//객체가 생성될 때 수행할 코드
System.out.println("기본 생성자에 의해서 Student 객체가 생성되었습니다.");
}
//public void ex1() {}
//void가 반환형 (생성자는 반환형이 존재하지 않음)
//3. 메소드(method)
}ClsService
package edu.kh.oop.cls.model.service;
import edu.kh.oop.cls.model.vo.Student;
import edu.kh.oop.cls.model.vo.User;
//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("다른 패키지"); //Student와 다른 패키지
System.out.println(std.v1);
//다른 패키지에서도 접근이 가능한 public만 작동 (나머진 오류)
// 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);
}
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)
//static이 붙은 변수는 프로그램 시작 시 바로 static 영역에 메모리가 할당됨
Student std3 = new Student();
System.out.println(std3.schoolName); //KH정보교육원
System.out.println(std3.getName()); //홍길동 --> 초기화 블록 결과
//schoolName에 노란줄이 뜨는 이유: 제대로 작성하지 않아서
//***static이 붙은 필드(변수)는 클래스명.변수명으로 사용함
Student.schoolName = "KH";
System.out.println("Student.schoolName: "+Student.schoolName);
/* static
* 1. 공유 메모리 영역(정적 메모리 영역이라고도 함)
* why? 프로그램 시작 시 static이 붙은 코드들이 모두
* static영역에 생성되고, 프로그램 종료까지 사라지지 않음(정적)
* 그리고 static 영역에 생성된 변수는 어디서든지 공유할 수 있다(공유)
*
* 2. 사용법: 클래스명.변수명
*/
}
public void ex3() {
//생성자 확인 테스트
//Student 객체를 기본 생성자를 이용해 생성하고 이를 참조하는 참조변수 s1에 대입
Student s1 = new Student(); //ctrl 누르고 클릭하면 실제 코드로 이동
//기본 생성자 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 객체를 생성했기 때문
System.out.println("------------------------------------");
//해결방법 1: setter를 이용해서 새로운 값 대입
u2.setUserId("asdf1234");
u2.setUserPw("1ejffjah");
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: 매개변수 생성자를 이용해서
// 객체가 생성될 때부터 다른 값으로 필드를 초기화
User u3 = new User("test3", "pass3"); //매개변수 생성자 // ctrl space 단축키 이용
// // 생성자 수행 시 전달할 값 작성 (자료형, 순서 지키기 필수)
System.out.println(u3.getUserId()); //null
System.out.println(u3.getUserPw()); //null
//매개변수 안에서 작성된 값이기 때문에 필드에 초기화되지 않음
//--> 전달받은 값을 필드에 초기화(this 참조변수)
}
public void ex4() { //매개변수 생성자 예제
User u1 = new User();//기본 생성자
User u2 = new User("newID", "newPW");//매개변수 2개 생성자
User u3 = new User("realID01", "realPW01", "가나다", 20, '남');//매개변수 5개 생성자
User u4 = new User("realID02", "realPW02", "라마바", 21, '여');//매개변수 5개 생성자
User u5 = new User("realID03", "realPW03", "사아자", 22, '남');//매개변수 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());
}
}TestVo
package edu.kh.oop.cls.model.vo;
class TestVo {
//접근 제한자(default): 같은 패키지 내에서만 import 가능함을 나타냄
//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이기 때문에 같은 패키지라도 다른 클래스에서 직접 접근 불가
}
}User
package edu.kh.oop.cls.model.vo;
public class User {
//속성 (==field)
//아이디, 비밀번호, 이름, 나이, 성별 (추상화 진행)
//캡슐화 원칙으로 필드는 기본적으로 모두 private
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 = '남';
}
//매개변수 생성자
// **사용되는 기술, 변수: 매개변수, 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;
}
//필드를 전부 초기화하는 목적의 매개변수 생성자
public User(String userId, String userPw, String userName,
int userAge, char userGender) {
//매개변수로 전달받은 값으로 필드 초기화
// this.userId = userId; //현재 객체가 가지고 있는 필드 userId에
// //매개변수 userId 값 대입
// this.userPw = userPw;
this(userId, userPw); //this() 생성자를 이용해 위에 있는 매개변수 2개짜리 생성자 호출
// - 같은 클래스에 다른 생성자를 호출할 때 사용하는 this()
// - 생성자 내에서 반드시 첫 번째 줄에 작성되어야 함!!!!!!!!
// 왜 사용하는가?
// -> 중복 코드 제거, 코드 길이 감소, 재사용성 증가
// but, 가독성이 떨어지기 때문에 자주 사용되지 않음
this.userName = userName;
this.userAge = userAge;
this.userGender = userGender;
}
// 자바는 기본적으로 필드명, 생성자명, 메소드명, 변수명의 중복 허용 X
/*
private String userId; //Duplicate field User.userId
public User() {} //Duplicate method User() in type User
public String getUserId() {} //This method must return a result of type String
public void ex() {
int num = 10;
int num = 10; //Duplicate local variable num
}
*/
// *** 오버로딩(Over Loading) ***
// - 클래스 내에 동일한 이름의 메소드(생성자도 포함)를 여러 개 작성하는 기법
// --> 하나의 이름으로 여러 기능을 수행할 수 있게 하는 것
// [오버로딩 조건]
// 1. 메소드(생성자 포함)의 이름이 동일해야 함
// 2. 매개변수의 개수, 타입, 순서 중 1개라도 달라야 함
//public User() {} //기본 생성자가 이미 작성되어 있어서 중복
public User(String userId) {} // 매개변수 개수가 같은 생성자가 없음
// -> 오버로딩 성립
public User(int userAge) {} // 매개변수 개수는 같으나 타입이 다름
// -> 오버로딩 성립
public User(int userAge, String userId) {} // 매개변수 개수 같으나 타입 다름
// -> 오버로딩 성립
public User(String userId, int userAge) {} //매개변수 개수, 타입 같으나 순서 다름
// -> 오버로딩 성립
public User(String userId, String userPw, String userName) {}
//public User(String userName, String usrId, String userPw) {} //오류
//매개변수의 개수, 타입, 순서가 모두 같아서 오버로딩 불가
// -> 변수명은 신경쓰지 않는다.
//캡술화로 인한 간접 접근 기능(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;
}
}ClsRun
package edu.kh.oop.cls.run;
import edu.kh.oop.cls.model.service.ClsService;
public class ClsRun {
public static void main(String[] args) {
ClsService service = new ClsService();
// service.ex2(); //static 확인 예제 호출
service.ex3(); //생성자 예제
service.ex4(); //매개변수 생성자 예제
}
}
개발 일지