클래스 (class)
- 객체를 만들기 위한 설계도
- 클래스의 첫 글자는 무조건 대문자
객체 (object)
- 객체는 "실제로 존재하는 것" 우리가 주변에서 볼 수 있는 컴퓨터, 자동차, 계산기 등등
- 추가로 어떤 개념이나 논리 같은 것들도 객체가 될 수 있음
- 예를 들어 덧셈, 뺄셈 등 눈에 보이지 않는 것들을 무형의 객체가 될 수 있음
- 클래스가 준비되어 있다면 클래스를 기준으로 여러 객체들을 만들어 낼 수 있음
- Preson 클래스를 예시로 들어보자,
클래스는 객체를 만들기 위한 "설계도"라고 했다, Person 클래스는 말 그대로 "사람"객체를 만들기 위한 설계도가 되는 것이고, 객체를 만들 때는 "new"라는 키워드를 사용하여 생성하고, 객체를 만드는 과정을 "인스턴스화" 혹은 "객체화"라고 표현한다.
*인스턴스화가 되면 Java 메모리 상에 객체가 만들어짐
- new 키워드 사용하여 객체를 만듦 (Main)
Person personA = new Person();
클래스의 구조
1. 속성
- 속성은 변수 선언으로 표현할 수 있음
- ***속성을 만들 때는 어떠한 클래스를 만드는지 생각하여 클래스와 관련된 속성을 만드는 것이 중요함!
- Person 클래스의 속성을 만든다고 생각해보면, "사람"이라는 "설계도"를 만드는 것이기 때문에, 이름, 나이, 주소 같은 것들이 사람의 속성이 될 수 있음.
- Person 클래스의 속성
설계도에서 Person의 속성을 이렇게 만들게 되면
- 예시 1
Main에 생성된 Person 객체들은 Person클래스의 속성을 기반으로 만들어지게 됨.
Person 설계도에서 속성에 name, age, address를 만들어줌으로써 Main의 Person객체들도 name, age, address 의 속성들을 가지게 됨. (Person 설계도를 기반으로 Main에서 Person객체를 생성했기 때문임)
그리고, personA와 personB는 각각의 고유의 영역을 가지고 있음,
설계도에서 속성을 만들고, Main에 Person객체를 생성은 했는데, 아직 name, age, address의 값이 없는 상태, 이름, 나이, 주소를 먼저 설정해보자.
- 객체 생성 (인스턴스화)
Person personA = new Person();
Person personB = new Person();
- 속성에 직접 접근
personA.name = "hojin";
personB.name = "Sam";
personA하고 ( . )"점"을 찍으면 personA가 접근할 수 있는 내역들을 보여줌 즉, 설계도의 속성에 직접 접근하여 name, age,address의 값을 설정할 수 있음. (일단 지금은 name, age만 설정해줄거임) 이렇게 설정을 해주면 빈 공간이었던 예시 1의 name, age, address가 설정한 값으로 채워지게 되는 것임
System.out.println("설정 전 이름 " + personA.name);
personA.name = "hojin";
System.out.println("설정 후 이름" + personA.name);
설정 전 이름과 설정 후 personA의이름을 출력해보면 설정 전에는 "null" 비어있는 값이 나오고, 설정 후에는 "hojin"으로 출력이 된다. personB도 마찬가지임.
2. 생성자 (조립설명서)
- 객체를 만들때 사용
- 객체를 어떻게 만들지 정의해 놓는 것 (조립설명서)
*생성자가 없으면 클래스를 인스턴스화(객체화)시킬 수 없음 - 클래스를 만들면 우리 눈에 보이지 않는 기본 생성자라는 녀석이 존재 하고 있었기 때문에 이때까지는 생성자를 안 만들어도 객체화가 가능했음
- 기본 생성자
Person() {} >> 기본 생성자
- 생성자 호출
Person personA = new Person();
new Person(); 에서 Person을 컨트롤 + 마우스 좌클릭 해보면 커서가 설계도의 생성자 Person으로 이동하는 것을 볼 수 있음.
new라는 키워드를 통해 생성자를 호출하는 것, new Person(); >> 생성자를 호출했다는 의미
Person(String name, int age) {
// 메서드의 매개변수와 비슷함
this.name = name;
this.age = age;
// this.name은 속성에서 String name;을 의미하고
// this.age는 속성에서 int age;를 의미
// = name;은 Person(String name, int age)에서 name을 의미
// = age;는 Person(String name, int age)에서 age를 의미
// this 는 Main에 있는 personA 객체 자기 자신을 의미
}
*생성자를 새롭게 만들면 기본 생성자는 사라짐.
생성자 Person의 ( ) 괄호 안은 매개변수와 비슷한 형태임, 조립설명서를 만들었다면 기존의 속성만 만들었을 때와 다른 점이 발생함, Main의 Person personA = new Person(); 에 가보면 (); 부분에 빨간색 밑줄이 그어저 있음.
그 이유는 조립설명서를 만들었는데 조립설명서대로 사용하고 있지 않아서임, 즉 Peson (String name, int age)라고 생성자를 만들었으니, String name과 int age 매개변수를 Main의 Person personA = new Person(); 에서 (); 부분에 맞춰줘야함!
- Person (String name, int age) 를 Main의 Person personA = new Person();에 맞춰준 모습
Person personA = new Person("hojin", 28);
Person personB = new Person("sam", 15);
- 생성자의 특징
1. 클래스와 이름이 같다.
2. 메서드와 다르게 반환 타입이 존재하지 않음
3. 여러개가 존재할 수 있음 (여러개를 만들어 놓고, 사용할 때 필요한 생성자 조립설명서 대로 사용 가능)
여러개가 존재할 수 있다는게 무슨 의미일까? 예시로 확인해보자
Person(String name, int age) {
this.name = name;
this.age = age;
}
Person() {};
만약 이렇게 두개의 생성자를 만들었다고 생각해보자, (맨 밑에는 기본생성자)
Person personA = new Person("hojin", 28);
Person personB = new Person();
이렇게 만들었을 때 Main에서 확인해보면, 아까와는 다르게 (); 부분에 빨간밑줄이 안그어져 있는 것을 확인할 수 있다.
그 이유는 기본생성자 한개를 더 만들어줘서인데, 한 마디로 personA는 Person (String name, int age)의 조립 설명서대로 만든 것이고, personB는 기본 생성자(Person() {})의 조립설명서 대로 만든 것이다.
자 그럼 다시 돌아와서 생성자를 좀 더 살펴보자,
- Main
Person personA = new Person("hojin", 28);
Person personB = new Person("sam", 15);
- Person 설계도 (클래스)
Person(String name, int age) {
this.name = name;
this.age = age;
}
Person personA = new Person("hojin", 28);에서 보면 "hojin" 부분이 설계도의 Person(String name, int age)에서 String name에 해당되고, 28이 int age에 해당 되는 것이다. personB도 마찬가지다.
그리고 생성자의 { } 중괄호 안에 있는 this.name = name; 과 this.age = age; 이 부분은 속성과 같이 봐야되는데,
public class Person {
// 1. 속성 - 변수 선언으로 표현할 수 있음
String name;
int age;
String address;
// 2. 생성자 - 조립 설명서
// Person() {} >> 기본 생성자
Person(String name, int age) {
this.name = name;
this.age = age;
}
Person(String name, int age) { } 에서 생성자의 범위( { } 중괄호) 안에서 접근할 수 있는 갯수가 몇개일까? >> 총 5개이다.
그 이유는 속성과 생성자 모두 Person class 안에 정의되어 있기 때문이다. 즉, 클래스 안에 정의되어 있으면 내부에서도 사용이 가능함, 그래서 this.name 이 의미 하는 것은 속성의 String name; 이고, this.age가 의미하는 것은 속성의 int age;가 되는 것이다.
앞서 말한대로 같은 클래스 안에 정의되어 있으면 내부에서도 사용이 가능하기 때문이다.
조금 더 자세히 알아보자.
- 속성
String name;
int age;
String address;
- 생성자
Person(String name, int age) {
this.name = name;
this.age = age;
}
생성자의 this.name = name; 에서 this.name 은 속성의 String name; 을 의미한다고 했는데 = name; 은 무엇을 의미 할까? >>>>> 생성자 Person(String name, int age)에서 name을 의미함.
- this.name > 속성의 String name;을 의미
- this.name = name; 에서 name; 은 생성자의 String name에서 name을 의미함.
- Main
Person personA = new Person("hojin", 28);
Person personB = new Person("sam", 15);
- Person 설계도 (클래스)
// 1. 속성 - 변수 선언으로 표현할 수 있음
String name;
int age;
String address;
// 2. 생성자 - 조립 설명서
Person(String name, int age) {
this.name = name;
this.age = age;
}
전부 이어보면 personA의 "hojin"이 생성자의 Person(String name, int age)에서 String name으로 들어오게되고, 이 값이 또 this.name = name 에서 name에 들어가고, 이 name을 this.name의 name 부분에 받게되는 것이다.
this,name 변수가 의미하는 것은 Person 속성의 String name이기 때문에 personA는 빈 공간에 "hojin"이라는 이름을 넣어서 Person 속성의 이름을 설정해주는 것이다. age 도 마찬가지임.
*여기서 헷갈리지 말자,
this.name에서 this키워드는 personA를 의미함, 즉 객체 자기 자신을 의미하는 것임.
this키워드가 없으면, 넘겨 받은 "hojin"이란게 어떤 변수에서 받은 것인지 설명이 어려움.
*이러한 원리로 personA와 personB의 name, age 값들을 생성자를 통해서 초기값을 설정해 줄 수 있다.
3. 기능 (메서드)
- 기능 부분 또한 어떤 설계도를 만드는지에 따라 달라지는데, Person 설계도를 만드는 것 이라면 "사람"과 관련된 기능을 만드는 것이 된다. 이처럼 내가 만드는 설계도와 관련된 기능을 만드는것이 바람직하다.
예를 들어서 사람과 관련된 기능중 사람에게 "더하기"를 시키는 기능을 만든다고 가정해보자,
- 사람에게 더하기를 시키는 기능 (Person 설계도)
//3. 기능 (메서드 부분)
// 사람에게 더하기 기능을 시키는 메서드
int sum(int value1, int value2){
int result = value1 + value2;
return result;
}
- Main
int result1 = personA.sum(1, 2);
int result2 = personB.sum(2, 4);
이러한 식으로 설계도의 기능부분을 활용할 수 있고, personA는 hojin이 더하기를 하는 것이고, personB는 Sam이 더하기를 한다고 볼 수 있다.
게터(getter)
- 클래스의 속성을 참조(읽기 전용, 훔쳐보고 오기 같은)하는 기능
- Person class (설계도)
- 속성
String name;
int age;
String address;
- 게터 활용 - 속성의 String name;을 외부에서 가져올 수 있게 해주는 기능
// 게터 - 클래스의 속성을 가져오는 기능
String getName() {
return this.name;
}
이렇게 Person 설계도(클래스)의 기능 부분에 게터를 만들고 Main에서 게터를 호출하여 사용 가능.
- Main
String name = personA.getName();
System.out.println("name = " + name);
Main에서 personA. >> ( . ) 점을 사용하여 getName();을 호출하여 사용할 수 있고, String name 상자에 담아서 출력해보면 "hojin"이라고 출력됨. (위에서 Person 설계도를 진행하며 속성의 Srtring name 을 "hojin"으로 설정해놨기 때문임)
personB도 마찬가지로 personB.getName();을 출력해보면 "Sam"이 출력됨.
게터는 return값으로 나오는 이유가 Person설계도의 속성을 가져와 주는 기능이기 때문에, Main에서 게터를 호출하게 되면 설계도에 있는 속성을 게터가 return값으로 반환해주기 때문임.
게터는 반환값이 있기 때문에 String name 상자에 받아준다.
세터(setter)
- 외부에서 속성에 접근하여 수정 가능하게 만들어주는 기능
- Person class (설계도)
- 속성
String name;
int age;
String address;
- 세터 - 외부에서 속성을 설정해주는 기능
// 세터 - 객체의 속성을 설정해주는 기능
void setAddress(String address) {
this.address = address;
Person 설계도(클래스)의 기능 부분에 세터를 만들고, Main에서 세터를 호출하여 활용 가능
- Main
System.out.println("personA의 주소 = " + personA.address);
personA.setAddress("서울");
System.out.println("personA의 주소 = " + personA.address);
앞서 Person 설계도를 진행해보면 알 수 있듯이, 현재 Person의 String name;과 int age;는 값을 설정해줬는데 String address;는 설정을 안해놓은 상태여서 세터를 통해 속성을 설정해준다.
personA. >> ( . ) 점을 활용해서 setAddress를 호출하여 사용할 수 있음
위의 내용을 출력해보면 세터를 사용하기 전에는 address가 설정 전이기 때문에, null값이 나오고 세터를 활용하여 address를 "서울"로 설정한 이후에 출력에서는 "서울"이 출력된다.
게터와는 다르게 반환값이 없으므로 void를 활용주고, 외부에서 설정하려는 속성이 Person 설계도(클래스)의 속성이기 때문에 this.address = address;가 있는것
- 클래스의 내부 속성을 참조하는 기능 > 게터
- 외부에서 클래스의 내부 속성을 수정 가능하게 만들어 주는 기능 > 세터
- 잊지말자! 게터와 세터는 참조하는 것이다!
한눈으로 보는 게터와 세터의 차이점
- 게터
- 반환 값이(return) 있음, 그러다 보니 자료형(int, String, boolean등등..)이 메서드 앞에 붙음
- 세터
- 보통 set으로 시작하는 이름을 사용하며, 외부에서 속성에 접근하여 설정할 수 있게 해주는 메서드
- 게터와 다르게 반환값이 없다 보니 void가 사용되고, 속성을 설정해주는 기능이여서 ( ) 괄호 안에 자료형과 속성이 들어가고, this.address = address; >> 설정 하려는 속성 값이 들어감,
