2024. 3. 19. 19:07ㆍ백엔드/자바
자바 - 클래스(인스턴스, 필드, 메서드, 생성자)
클래스란 무엇이며 어떻게 구성되어 있을까? 먼저 클래스의 개념을 살펴보고, 클래스를 이루는 필드, 메서드, 생성자에 대해 소개하고자 한다. 객체 지향 프로그래밍에서는 모든 데이터를 객체(Object)로 취급하며, 이러한 객체가 프로그래밍의 중심이 된다. 객체에 대한 자세한 내용은 이전 게시글에서 자세히 설명하므로 객체 지향 프로그래밍이 다시 헷갈리면 보고 오자.
객체(object)란 간단히 이야기하자면 실생활에서 우리가 인식할 수 있는 사물로 설명할 수 있다. 객체의 상태(state)와 행동(behavior)을 구체화하는 형태의 프로그래밍이 바로 객체 지향 프로그래밍이다. 이때 객체를 만들어내기 위한 설계도와 같은 개념을 클래스(class) 라고 한다.
클래스(class)
자바에서 클래스란 객체를 정의하는 틀 또는 설계도와 같은 의미로 사용된다. 자바에서는 이러한 설계도인 클래스를 가지고, 여러 객체를 사용하게 된다.
클래스는 객체의 상태를 나타내는 필드(field)와 객체의 행동을 나타내는 메서드(method)로 구성된다. 즉, 필드란 클래스에 포함된 변수(variable)를 의미하며, 메서드란 어떠한 특정 작업을 수행하기 위한 명령문의 집합이라 할 수 있다.
class Car {
/* 필드(field) */
String carName;
int modelYear;
/* 메서드(method) */
void drive() {
System.out.println("자동차가 앞으로 갑니다.");
}
}객체(object) / 인스턴스(instance)
클래스가 어떤 데이터의 구조 설계도라면, 객체는 설계도를 이용해 찍어낸 실제 데이터라고 보면 된다. 클래스와 객체의 관계를 설명할 때 흔히 붕어빵 틀과 붕어빵의 관계가 예시로 들어진다. 붕어빵 틀이 클래스, 붕어빵이 객체라고 생각하면 된다.
그리고 클래스에 의해서 만들어진 객체를 인스턴스라고 부르기도 한다. 객체와 인스턴스는 뜻하는 바가 비슷해서 종종 혼동되어 쓰이곤 한다. 객체는 모든 인스턴스를 대표하는 포괄적인 의미라면 인스턴스는 어떤 클래스로부터 만들어진 것인지를 보다 강조하는 구체적인 의미를 가지고 있다.
아래의 예시 코드를 보자.
//클래스
class Car { ... }
public class Sample {
public static void main(String[] args) {
// 변수 rover는 객체 = 변수 rover는 Car 클래스의 인스턴스
Car rover = new Car(); // 클래스라는 설계도를 통해 객체 데이터를 생성
}
}
`Car rover = new Car()` 이렇게 만들어진 `rover`는 객체이다. 그리고 `rover`라는 객체는 `Car`의 인스턴스이다. 즉, 인스턴스라는 말은 특정 객체(rover)가 어떤 클래스(Car)의 객체인지를 관계 위주로 설명할 때 사용된다.
필드(field)
클래스의 필드(field)란 클래스에 포함된 변수(variable)를 가리킨다. 클래스의 필드는 속성 또는 멤버라고도 부른다. 또한 클래스 필드는 선언된 위치와 선언자에 따라 다음과 같이 구분된다.
- 클래스 변수(static variable)
- 인스턴스 변수(instance variable)
- 지역 변수(local variable)
클래스 영역에 위치한 변수 중에서 static 키워드를 가진 변수를 클래스 변수라고 한다. 반대로 static 키워드를 가지지 않은 변수를 인스턴스 변수라고 한다. 메서드나 생성작 블록 내에 위치한 변수를 지역 변수라고 한다. static에 대해선 메서드를 다룬 후에 설명하도록 하겠다.
아래의 코드로 각 변수를 확인하자.
class Field {
static int classVar = 10; // 클래스(스태틱) 변수 선언
int instanceVar = 20; // 인스턴스 변수 선언
int method() {
int locaVar = 30; // 지역 변수 선언
return localVar;
}
}
public class Meneber01 {
public static void main(String[] args) {
System.out.println(Field.classVar); // 클래스(스태틱) 변수 참조
Field myField1 = new Filed(); // 인스턴스 생성
System.out.println(myField1.instanceVar); // 인스턴스 변수 참조
System.out.println(myFiled1.method()); //메서드 안의 지역변수 출력
}
}
위의 코드를 보면 클래스 변수, 인스턴스 변수, 지역 변수가 각각 다른 위치에 선언되었음을 알 수 있다. 특히 클래스 변수는 인스턴스를 따로 생성하지 않아도 클래스를 통해 참조가 가능하다. 어떻게 이런 일이 가능할까? 이유는 클래스 변수, 인스턴스 변수, 지역 변수가 각각 다른 생명 주기와 저장 메모리를 갖기 때문이다.
| 변수 | 생성 시기 | 소멸 시기 | 저장 메모리 |
| 클래스 변수 | 클래스가 메모리에 올라갈 때 | 프로그램이 종료될 때 | 메소드 영역 |
| 인스턴스 변수 | 인스턴스가 생성될 때 | 인스턴스가 소멸할 때 | 힙 영역 |
| 지역 변수 | 블록 내에서 변수의 선언문이 실행될 때 | 블록을 벗어날 때 | 스택 영역 |
클래스 변수는 해당 클래스의 모든 인스턴스가 공유해야 하는 값을 유지하기 위해서 사용된다. 즉, 클래스 변수에 담고 있는 값은 여러 인스턴스의 범위를 포함하는 메서드 영역에 저장되어야 한다. 위의 코드 예제처럼 인스턴스를 생성하지 않고도 바로 사용할 수 있다는 특징이 있다. 마치 특정 클래스의 전역 공유 변수처럼 이용할 수 있다.
다음 코드를 보면 Field 클래스로 인스턴스 3개를 생성해 사용하고 있는데, 만일 이 3개의 인스턴스가 공통적으로 사용할 변수가 필요하면 클래스 변수를 이용하면 된다는 것을 볼 수 있다.
반면, 인스턴스 변수는 인스턴스마다 가져야 하는 개별적인 값을 유지하기 위해 사용된다고 볼 수 있다.
class Field {
static int classVar = 0; // 클래스(스태틱) 변수 선언
int instanceVar; //인스턴스 변수 선언
}
public class Member01 {
public static void main(String[] args) {
Field myField1 = new Field(); //인스턴스 생성
Field myField2 = new Field(); //인스턴스 생성
Field myField3 = new Field(); //인스턴스 생성
// 인스턴스 변수는 각 객체마다 개별적으로 저장된다.
myField1.instanceVar = 10;
myField2.instanceVar = 20;
myField3.instanceVar = 30;
System.out.println(myField1.instanceVar); // 10
System.out.println(myField2.instanceVar); // 20
System.out.println(myField3.instanceVar); // 30
// 클래스(스태틱) 변수는 하나의 값으로 모든 인스턴스에게 공유됨
myField1.classVar = 100;
myField2.classVar = 200;
myField3.classVar = 300;
System.out.println(myField1.classVar); // 300
System.out.println(myField2.classVar); // 300
System.out.println(myField3.classVar); // 300
/* !위의 코드는 실행은 되지만 컴파일 경고를 냄! */
// Field.classVar 처럼 클래스명으로 바로 클래스 변수에 접근 가능
System.out.println(Field.classVar); //300
}
]
메서드
흔히 프로그로밍에서 말하는 함수는 "하나의 기능을 수행하는 일련의 코드"를 말한다. 함수는 어떤 기능을 수행하도록 미리 구현해 놓고 필요할 때마다 호출하여 사용할 수 있다. 자바에선 소스 파일에 메인 함수만 있더라도 반드시 클래스를 정의해야 한다는 객체 지향적 특성이 있다. 따라서 다른 프로그래밍 언어에서 사용하는 함수(function)이라는 개념을 자바에서는 메서드(method)라고 표현한다. 기존 함수의 개념에 객체지향 맛이 살짝 첨가된 것뿐이니 큰 차이를 두지 않아도 된다.
메서드 정의
- 접근 제어자/ 지정자: 해당 메서드에 접근할 수 있는 범위를 명시
- 반환 타입(return type): 메서드가 모든 작업을 마치고 반환하는 데이터의 타입을 명시
- 메서드명: 메서드를 호출하기 위한 이름을 명시
- 매개변수 목록(parameters): 메서드 호출 시에 전달되는 인수의 값을 저장할 변수들을 명시
- 구현부: 메서드의 고유 기능을 구행하는 명령문의 집합, 중괄호 { } 안에 표현됨
파라미터/ 아규먼트
메서드에는 메서드에 입력값을 설정해주는 변수 목록이 있는데, 매개변수(parameter)와 인수(argument)는 뜻이 미묘하게 다르면서 비슷하므로 이 참에 차이점을 알아두자.
- 매개변수(parameter): 메서드를 정의할 때 입력으로 전달된 값을 받는 변수를 의미한다.
- 인수(argument): 메서드를 호출할 때 전달하는 입력값을 의미한다.
public class Sample {
public static int sum(int a, int b) { // 메서드를 정의하는 입력값 a, b는 매개변수(parameter)
return a + b;
}
public static void main(String[] args) {
sample.sum(3, 4); // 메서드를 사용하는 입력값 3, 4는 인수(argument)
}
}
클래스 메서드 / 인스턴스 메서드
클래스 필드에는 클래스 변수, 인스턴스 변수가 있듯이 메서드에서도 두 가지로 나뉜다. static 키워드를 가지는 메서드를 클래스 메서드(static method)라고 하며, static 키워드를 가지지 않는 메서드를 인스턴스 메서드(instance method)라고 한다.
클래스 메서드는 클래스 변수와 마찬가지로 인스턴스를 생성하지 않고도 바로 사용할 수 있다. 다만 주의할 점은 클래스 메서드는 static 메서드 내부에서 인스턴스 변수를 사용할 수 없다는 특징이 있다. 그러므로 메서드 내부에서 인스턴스 변수나 인스턴스 메서드를 사용하지 않는 메서드를 클래스 메서드로 정의하는 것이 일반적이다.
메서드 오버로딩(overloading)
`println()` 메서드를 사용할 때 우리는 입력값(argument)에 정수, 실수, 문자열, 객체 등 다양한 입력값을 넣어 콘솔에 출력할 수 있다.
System.out.println(100); // 정수값을 넣어 메소드 호출
System.out.println(0.4532); // 실수값을 넣어 메소드 호출
System.out.println("안녕"); // 문자열값을 넣어 메소드 호출
System.out.println(true); // 불리언값을 넣어 메소드 호출
분명 같은 메서드에 다른 타입의 데이터를 넣었는데 같은 기능이 수행된다. 이게 가능한 이유는 자바 문법 중에 같은 함수의 다양한 매개변수를 받는 오버로딩(overloading)이 있기 때문이다.
메서드 오버로딩(overloading)이란 같은 이름의 메서드를 중복해서 정의해 다양한 상황에서 사용하는 것을 의미한다.
원래는 한 클래스 내에 같은 이름의 메서드를 둘 이상 가질 수 없다. 하지만 매개 변수의 개수나 타입을 다르게 하면, 하나의 이름으로 메서드를 작성할 수 있다.
즉, 메서드 오버로딩은 서로 다른 시그니처를 갖는 여러 메서드를 같은 이름으로 정의하는 것이라고 할 수 있다.
까비: 메서드 시그니쳐...?
메서드 시그니처(method signature)
메서드 시그니처란 메서드의 선언부에 명시되는 매개변수의 리스트를 가리킨다.
만약 두 메서드가 매개변수의 개수와 타입, 그 순서까지 모두 같다면, 이 두 메서드의 시그니처는 같다고 할 수 있다. 요컨대 메서드 오버로딩이란 동일한 메서드 이름을 가지면서 메서드 시그니처가 다른 메서드를 뜻하는 것이라 보면 된다.
처음에 보았던 `System.out.println()` 메서드는 동작 코드를 보면 다음처럼 생겼다.
/* println 메소드 원형 */
public static void println() { ... }
public static void println(boolean x) { ... }
public static void println(char x) { ... }
public static void println(char[] x) { ... }
public static void println(double x) { ... }
public static void println(float x) { ... }
public static void println(int x) { ... }
public static void println(long x) { ... }
public static void println(Object x) { ... }
public static void println(String x) { ... }
코드를 보면 동일한 메서드 안에 여러 가지 타입의 매개변수가 들어가 있는 것을 볼 수 있다. 자바 컴파일러는 사용자가 오버로딩된 함수를 호출하면, 전달된 매개변수의 개수와 타입과 같은 시그니처를 가지는 메서드를 찾아 호출하게 된다.
다만 메서드 오버로딩을 구현하기 위해서는 다음과 같은 조건을 만족해야 한다.
- 메서드의 이름이 같아야 한다.
- 메서드의 시그니처, 즉 매개변수의 개수 또는 타입이 달라야 한다.
만약 메서드의 시그니처는 같은데 반환 타입이 다른 경우에는 오버로딩이 성립하지 않는다.
class Test {
// 메소드 원형
void displaySum(int num1) {
System.out.println(num1);
}
// 메소드 오버로딩 : 매개변수 갯수가 다른 유형
void displaySum(int num1, int num2) {
System.out.println(num1 * num2);
}
// 메소드 오버로딩 : 매개변수는 같지만, 매개변수 타입이 다른 유형
void displaySum(int num1, double num2) {
System.out.println(num1 + num2);
}
// 매개변수는 같지만, 메서드 반환 타입이 다른 유형은 오버로딩이 되지 않는다.
// 따라서 정수 타입을 반환하는 메서드를 작성하고 싶다면 그냥 새로 메서드를 만들면 된다.
int returnSum(int num1, int num2) {
return num1 + num2;
}
}
public class Method {
public static void main(String[] args) {
Test myfunc = new Test();
myfunc.display(10);
myfunc.display(10, 20);
myfunc.display(10, 3.14);
}
}
물론 오버로딩 개념없이 그냥 메서드명을 다르게 하여 각기 다른 메서드 형태로 정의해서 사용할 수 있다. 하지만 인자만 바뀌고 같은 기능을 하는 함수를 이름 여러 개로 관리하는 것은 너무 귀찮을 것이다. 오버로딩 또한 객체 지향의 원리 중 하나인 다형성에 포함되는 개념이다.
스태틱(static)
위의 필드와 메서드를 다루며 static이란 키워드가 많이 등장했다. static은 제어자로써 클래스에서 공유되는 변수나 메서드를 정의할 때 사용된다. 이번 기회에 static을 자세히 다뤄보고자 한다.
static 변수
다음과 같은 HouseLee 클래스가 있다.
class HouseLee {
String lastname = "이";
}
public class Sample {
public static void main(String[] args) {
HouseLee lee1 = new HouseLee();
HouseLee lee2 = new HouseLee();
}
}
HosueLee 클래스를 만들고 객체를 생성하면 객체마다 객체 변수 lastname을 저장하기 위한 메모리가 별도로 할당된다.
하지만 곰곰히 생각해 보면 HouseLee 클래스의 lastname은 어떤 객체이든지 동일한 값인 '이' 이어야 할 것 같지 않은가? 응 그럼 엄마는요? 이렇게 항상 값이 변하지 않는다면 static을 사용해 메모리 낭비를 줄일 수 있다. 앞서 본 예제를 수정해 보자.
class HouseLee {
static String lastname = "이";
}
public class Sample {
public static void main(String[] args) {
HouseLee lee1 = new HouseLee();
HouseLee lee2 = new HouseLee();
}
}
lastname 변수에 static 키워드를 붙이면 자바는 메모리 할당을 딱 한 번만 하게 되어 메모리를 적게 사용할 수 있다.
만약 HouseLee 클래스의 lastname 값이 변경되지 않기를 바란다면 static 키워드 앞에 final이라는 키워드를 붙이면 된다. final 키워드를 한 번 설정하면 그 값을 변경할 수 없다. 만약 변경하려고 하면 오류가 발생한다. 제어자(modifier)에 대해선 나중에 모두 정리하는 시간을 가지고자 한다.
static을 사용하는 또 다른 이유는 값을 공유할 수 있기 때문이다. static으로 설정하면 같은 메모리 주소만을 바라보기 때문에 static 변수의 값을 공유하게 된다.
다음의 예를 보면 더욱 명확해진다. 객체를 생성할 때마다 숫자를 증가시키는 Counter 클래스가 다음과 같이 존재한다.
class Counter {
int count = 0;
Counter() {
this.count++;
System.out.println(this.count);
}
}
public class Sample {
public static void main(String[] args) {
Counter c1 = new Counter();
Counter c2 = new Counter();
}
}
// 실행 결과
// 1
// 1
객체 c1, c2를 생성할 때 생성자에게 객체 변수인 count의 값을 1씩 증가시키더라도 c1, c2와 count 서로 다른 메모리를 가리키고 있기 때문에 원하던 결과(=count가 증가된 결과)가 나오지 않는다. 객체 변수는 항상 독립적인 값을 갖기 때문에 당연하다.
다음 예제를 보자.
class Counter {
static int count = 0;
Counter() {
this.count++;
System.out.println(this.count);
}
}
public class Sample {
public static void main(String[] args) {
Counter c1 = new Counter();
Counter c2 = new Counter();
}
}
// 실행 결과
// 1
// 2
`int count = 0` 앞에 static 키워드를 붙였더니 count 값이 공유되어 count가 증가되어 출력된다.
보통 변수에 쓰는 static 키워드는 프로그래밍을 할 때 메모리의 효율을 높이기 위한 목적보다는 공유의 목적으로 훨씬 더 많이 사용된다.
static 메서드
static이라는 키워드가 메서드 앞에 붙으면 이 메서드는 스태틱 메서드(static method)가 된다.
다음 예제를 보자.
class Counter {
static int count = 0;
Counter() {
this.count++;
System.out.println(this.count);
}
public static int getCount() {
return count;
}
}
public class Sample {
public static void main(String[] args) {
Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(Counter.gerCount()); //스태틱 메서드는 클래스를 이용하여 호출
}
}
// 실행 결과
// 1
// 2
// 2
위의 메서드 부분에서도 이미 한 번 다룬 내용이다. Counter 클래스에 getCount()라는 스태틱 메서드를 추가했다. 메서드 앞에 static 키워드를 붙이면 `Counter.getCount()` 와 같이 객체 생성 없이도 클래스를 통해 메서드를 직접 호출할 수 있다.
다시 한번 강조하지만 스태틱 메서드 안에서는 인스턴스(객체) 변수 접근이 불가능하다. 이 예에서는 count 변수가 static 변수이기 때문에 스태틱 메서드에서 접근이 가능하다.
특히 스태틱 메서드는 유틸리티성 메서드를 작성할 때 많이 사용된다. 예를 들어 '오늘의 날짜 구하기`, `숫자에 콤마 추가하기` 등의 메서드를 작성할 때 스태틱 메서드를 사용하는 것이 유리하다.
유틸리성 메서드는 특정 클래스나 인스턴스에 종속되지 않고, 재사용이 가능하고 범용 기능을 제공하는 스태틱 메서드를 말한다. 이 메서드들은 코드의 중복을 줄이고 가독성을 향상한다.
다음은 오늘의 날짜를 구하는 Util 클래스의 예이다. 스태틱 메서드가 어떻게 사용되는지 알아보자.
import java.text.SimpleDateFormat;
import java.util.Date;
class Util {
public static String getCurrentDate(String fmt) {
SimpleDateFormat sdf = new SimpleDateFormat(fmt);
return sdf.format(new Date());
}
}
public class Sample {
public static void main(String[] args) {
System.out.println(Util.getCurrentDate("yyyyMMdd")) //오늘 날짜 출력
}
}
위와 같이 메서드의 기능만을 정의해 여러 번 반복해서 쓰고자 할 때 스태틱 메서드를 사용해 코드를 짜면 편리하다.
생성자(constructor)
자바에서는 객체의 생성과 동시에 인스턴스 변수를 원하는 값으로 초기화할 수 있는 생성자(constructor)라는 메서드를 제공한다. 자바에서 생성자(constructor)의 이름은 해당 클래스의 이름과 같아야 한다. 즉, Car 클래스의 생성자 이름은 항상 Car가 된다.
생성자는 다음과 같은 특징이 있다.
- 1. 생성자는 반환값이 없지만, 반환 타입을 void 형으로 선언하지 않는다.
- 2. 생성자는 초기화를 위한 데이터를 인수로 전달받을 수 있다.
- 3. 생성자는 new 예약어를 통해 객체를 생성할 때, 객체당 한 번 호출
- 4. 객체를 초기화하는 방법이 여러 개 존재할 경우에는 하나의 클래스가 여러 개의 생성자를 가질 수 있다. 즉, 생성자도 하나의 메서드이므로, 메서드 오버로딩이 가능하다.
생성자의 선언
자바에서 클래스 생성자를 선언하는 문법은 다음과 같다.
Car() { ... } //매개변수가 없는 생성자 선언
Car(args1, args2) { ... } //매개변수가 있는 생성자 선언
위와 같이 생성자 중에는 매개변수를 전달받아 인스턴수 변수를 초기화하는 생성자도 선언할 수 있다.
다음 예제는 Car 클래스의 생성자를 선언하는 예제이다.
Car(String modelName, int modelYear, String color, int maxSpeeds) {
... // 어떠한 반환값도 명시하지 않음
}
생성자의 호출
자바에서는 new 키워드를 사용하여 객체를 생성할 때 자동으로 생성자가 호출된다.
class Car {
private String modelName;
private int modelYear;
private String color;
private int maxSpeed;
private int currentSpeed;
Car(String modelName, int modelYear, String color, int maxSpeed) {
this.modelName = modelName;
this.modelYear = modelYear;
this.color = color;
this.maxSpeed = maxSpeed;
this.currentSpeed = 0;
}
public String getModel() {
return this.modelYear + "년식 " + this.modelName + " " + this.color;
}
}
public class Method02 {
public static void main(String[] args) {
Car myCar = new Car("아반떼", 2024, "흰색", 200); // 생성자의 호출
System.out.println(myCar.getModel()); // 생성자에 의해 초기화되었는지를 확인함.
}
}
//2024년식 아반떼 흰색
기본 생성자
자바의 모든 클래스에는 하나 이상의 생성자가 정의되어 있어야 한다. 하지만 특별히 생성자를 정의하지 않고도 인스턴스를 생성할 수 있는데, 자바 컴파일러가 기본 생성자(default constructor)라는 것을 기본적으로 제공해 주기 때문이다.
기본 생성자는 매개변수를 하나도 가지지 않으며, 아무런 명령어도 포함하고 있지 않다.
자바 컴파일러는 컴파일 시 클래스에 생성자가 하나도 정의되어 있지 않으면 자동으로 다음과 같은 기본 생성자를 추가한다.
Car() {}
위와 같이 기본 생성자는 어떠한 매개변수도 전달받지 않으며, 기본적으로 아무런 동작도 하지 않는다.
다음 예제는 Car 클래스에 생성자를 정의하지 않고, 기본 생성자를 호출하는 예제이다.
class Car {
private String modelName = "소나타";
private int modelYear = 2024;
private String color = "파란색";
/*
다음 기본 생성자가 생략되어 있음
Car() {
}
*/
public String getModel() {
return this.modelYear + "년식 " + this.color + " " + this.modelName;
}
}
public class Method03 {
public static void main(String[] args) {
Car myCar = new Car(); // 기본 생성자의 호출
System.out.println(myCar.getModel()); // 2024년식 파란색 소나타
}
}
위의 예제에서 Car 클래스의 인스턴스인 myCar는 기본 생성자를 사용하여 생성된다.
하지만 기본 생성자는 아무런 동작도 하지 않으므로, 인스턴스 변수를 클래스 필드에서 바로 초기화한다. 이처럼 인스턴수 변수의 초기화는 생성자를 사용하여 수행할 수도 있지만, 클래스 필드에서 바로 수행할 수도 있다.
이때 만약 매개변수를 가지는 생성자를 하나라도 정의했다면, 기본 생성자는 자동으로 추가되지 않는다. 따라서 매개변수를 가지는 생성자를 하나 이상 정의한 후 기본 생성자를 호출하면 오류가 발생한다.
기본 생성자는 어디까지나 개발의 편의성을 위해 존재하는 기능이다.
this 참조 변수
여태껏 나온 코드를 자세히 보면 this라는 키워드를 볼 수 있다. 이 this는 어떤 역할을 가지고 있을까? this는 단어의 뜻과 같이 인스턴스가 자기 자신을 참조하는 데 사용하는 변수이다.
이러한 this 참조 변수는 해당 인스턴스의 주소를 가리키고 있다. 모든 인스턴스 메서드에는 this 참조 변수가 숨겨진 지역 변수로 존재하고 있어 사용이 가능한 것이다. (클래스 메서드에는 this 변수가 없기 때문에 사용이 불가능하다)
class Car {
private String modelName;
private int modelYear;
private String color;
private int maxSpeed;
private int currentSpeed;
Car(String modelName, int modelYear, String color, int maxSpeed) {
this.modelName = modelName;
this.modelYear = modelYear;
this.color = color;
this.maxSpeed = maxSpeed;
this.currentSpeed = 0;
}
...
}
사실 this 키워드를 붙이지 않아도 자동으로 클래스의 인스턴스 변수로 인식한다. 하지만 위의 코드와 같이 매개변수와 변수 이름이 같을 경우 매개변수와 인스턴스 변수명을 구분하기 위해서 this 키워드를 붙여주어야 한다. 또한 객체 자신의 래퍼런스를 반환할 때 유용하게 쓰인다.
this() 메서드
`this()` 메서드는 같은 클래스의 다른 생성자를 호출할 때 사용하는 메서드이다. 주의할 점은 생성자 내부에서만 사용할 수 있다는 점이다. `this()` 메서드에 인수를 전달하면, 정의되어 있는 다른 생성자를 찾아 호출해 준다.
아래 코드를 보자.
class Car {
private String modelName;
private int modelYear;
private String color;
private int maxSpeed;
private int currentSpeed;
Car(String modelName, int modelYear, String color, int maxSpeed) {
this.modelName = modelName;
this.modelYear = modelYear;
this.color = color;
this.maxSpeed = maxSpeed;
this.currentSpeed = 0;
}
Car() {
this("소나타", 2024, "검정색", 160); // 해당 아규먼트가 일치하는 다른 생성자를 호출함.
}
public String getModel() {
return this.modelYear + "년식 " + this.modelName + " " + this.color;
}
}
public class Main {
public static void main(String[] args) {
// 초기화 인수를 보내주지 않아 Car() 생성자가 호출되지만, 안에서 this() 메서드가 호출되어
// 결과적으로 Car(String modelName, int modelYear, String color, int maxSpeed) 생성자가 호출되는 결과를 얻는다.
Car tcpCar = new Car();
System.out.println(tcpCar.getModel()); // 2024년식 소나타 검정색
}
}
이런 식으로 this() 메서드를 사용해 주면 생성자의 인수를 null로 받아도 this() 메서드를 통해 디폴트 값을 지정해 줄 수 있다는 장점이 있다. 다만 한 생성자에서 다른 생성자를 호출할 때에는 반드시 해당 생성자의 첫 줄에서 `this()` 메서드를 호출해야 한다.
생성자 오버로딩
생성자도 메서드의 종류 중 하나이다. 따라서 메서드 오버로딩이 가능한 것처럼, 생성자도 오버로딩이 가능하다.
생성자를 오버로딩하게 되면, 하나의 클래스에 여러 개의 초기화 입력 항목을 구현할 수 있다. 이는 다채로운 객체를 만드는 데 도움이 된다.
예를 들어 학번, 이름, 주소 3개의 입력값을 받는 생성자를 이전에 만들었는데, 만일 학번이나 이름만 적어줘도 객체가 정상적으로 생성되게 하고 싶으면 생성자 오버로딩을 통해 매개변수가 다른 생성자를 여러 개 구현하면 된다.
class Student {
public int studentID; //학번
public String studentName; //이름
public String address; //주소
public Student(int id, String name, String address) {
this.studentID = id;
this.studentName = name;
this.address = address;
}
public Student(int id, String name) {
this.studentID = id;
this.studentName = name;
this.address = "대한민국"; // 주소를 정하지 않으면 대한민국 으로 설정
}
public Student(String name) {
this.studentID = 0; // 학번을 정하지 않으면 0으로 설정
this.studentName = name;
this.address = "대한민국"; // 주소를 정하지 않으면 대한민국 으로 설정
}
public Student() {
// 아무것도 입력값이 없다면 디폴트로 설정
this.studentID = 0;
this.studentName = "이름없음";
this.address = "대한민국";
}
}
public class Main {
public static void main(String[] args) {
Student studentPark = new Student(20219712,"김유신", "신라"); // public Student(int id, String name, String address) 생성자 호출
Student studentKim = new Student(20227721, "이순신"); // public Student(int id, String name) 생성자 호출
Student studentJames = new Student("제임스"); // public Student(String name) 생성자 호출
Student studentJames = new Student(); // public Student() 생성자 호출
// 정의되어 있지 않은 오버로딩 생성자는 호출 할 수 없음
Student studentJeff = new Student(20221024); // 학번만 입력값으로 보내 초기화 - 불가능
}
}
여기까지 객체 지향 프로그래밍을 위한 클래스와 클래스를 구성하는 필드, 메서드, 생성자에 대해 알아보았다. 이번 포스팅에선 다루지 않았지만 클래스 내부에 존재하는 클래스를 내부 클래스라고 한다. 내부 클래스는 기회가 되면 추후에 다뤄보기로 하고, 다음은 객체 지향 프로그래밍을 위한 다시 말해 추상화, 상속, 다형성, 캡슐화를 위한 자바 문법은 무엇이 있는지 알아보고자 한다.
참고
☕ 자바 객체 지향(OOP) 클래스 문법 - 한방 가이드
클래스(class) 구성 자바에서 클래스(class)란 객체를 정의하는 틀 또는 설계도와 같은 의미로 사용된다. 자바에서는 이러한 설계도를 가지고, 여러 객체를 생성하여 사용하는 식으로 프로그래밍을
inpa.tistory.com
https://www.tcpschool.com/java
코딩교육 티씨피스쿨
4차산업혁명, 코딩교육, 소프트웨어교육, 코딩기초, SW코딩, 기초코딩부터 자바 파이썬 등
tcpschool.com
https://doozi0316.tistory.com/
[JAVA] 클래스란? (클래스, 객체, new, 메소드, 생성자, this...)
🍌 클래스 클래스 객체를 정의해 놓은 것 객체의 설계도 또는 틀 객체를 생성하는데 사용됨 클래스를 정의하는 방법 클래스란 객체를 정의한 것이므로, 클래스에는 객체의 모든 속성과 기능이
doozi0316.tistory.com
07-03 스태틱
스태틱(static)은 클래스에서 공유되는 변수나 메서드를 정의할 때 사용된다. 이번 절에서는 스태틱에 대해서 자세히 알아보자. [TOC] ## static 변수 다음과 …
wikidocs.net
'백엔드 > 자바' 카테고리의 다른 글
| 자바 - 추상 클래스(abstract class) (0) | 2024.03.26 |
|---|---|
| 자바 - 상속(Inheritance) (0) | 2024.03.20 |
| 자바 - 객체 지향 프로그래밍의 4가지 특징(추상화, 상속, 다형성, 캡슐화) (0) | 2024.03.15 |
| 자바 - 래퍼 클래스(Wrapper Class) (0) | 2024.03.14 |
| 자바 - 자바 변수의 자료형(Data Type) (0) | 2024.03.13 |