[ch6 자바 객체] 메서드2 ( 오버로딩 & 생성자, this )

오버로딩(overloading)

메서드도 변수와 마찬가지로 같은 클래스 내에 서로 구별될 수 있어야 하기 때문에 각기 다른 이름을 가져야 한다. 그러나 자바에서는 한 클래스 내에 이미 사용하려는 이름과 같은 이름을 가진 메서드가 있더라도 매개변수의 개수 또는 타입이 다르면, 같은 이름을 사용해서 메서드를 정의할 수 있다.

 

이처럼, 한 클래스 내에 같은 이름의 메서드를 여러 개 정의하는 것을 '메서드 오버로딩(method overloading)' 또는 간단히 '오버로딩(overloading)'이라 한다. 같은 이름의 메서드를 정의한다고 해서 무조건 오버로딩인 것은 아니다. 오버로딩이 성립하기 위해서는 다음과 같은 조건을 만족해야한다.

 

1. 메서드 이름이 같아야 한다.
2. 매개변수의 개수 또는 타입이 달라야한다.
3. 반환 타입은 관계 없다.

 

비록 메서드의 이름이 같다 하더라도 매개변수가 다르면 서로 구별될 수 있기 때문에 오버로딩이 가능한 것이다. 위의 조건을 만족시키지 못하는 메서드는 중복 정의로 간주되어 컴파일 시에 에러가 발생한다. 그리고 오버로딩된 메서드들을 매개변수에 의해서만 구별될 수 있으므로 반환 타입은 오버로딩을 구현하는데 아무런 영향을 주지 못한다는 것에 주의하자.

 

오버로딩의 예로 가장 대표적인 것은 println메서드이다. 지금까지 println메서드의 괄호 안에 값만 지정해주면 화면 출력하는데 아무런 어려움이 없었다. 하지만, 실제로는 printl 메서드를 호출할 때 매개변수로 지정하는 값의 타입에 따라서 호출되는 println 메서드가 달라진다. printStream 클래스에는 어떤 종류의 매개변수를 지정해도 출력할 수 있도록 아래와 같이 10개의 오버로딩 된 println메서드를 정의해놓고 있다.

 

void println()
void println(boolean x)
void println(char x)
void println(char[ ] x)
void println(double x)
void println(float x)
void println(int x)
void println(long x)
void println(Object x)
void println(String x)

println메서드를 호출할 때 매개변수로 넘겨주는 값의 타입에 따라서 위의 오버로딩된 메서드들 중의 하나가 선택되어 실행되는 것이다.

 

 

[ 보기 1 ]
int add(int a, in b) {return a+b;}
int add(int x, int y) {return x+y;}

보기 1번은 매개변수의 이름만 다를 뿐 매개변수의 타입이 같기 때문에 오버로딩이 성립하지 않는다. 매개변수의 이름이 다르면 메서드 내에서 사용되는 변수의 이름이 달라질 뿐 아무런 의미가 없다. 즉) 두 메서드는 정확히 같은 것이다.

컴파일하면 'add(int,int) is already defined(이미 같은 메서드가 정의되어 있다)'라는 메시지가 나타날 것이다.

 

 

[보기 2]
int add(int a, int b) { return a+b; }
long add(int a, int b) {return (long)(a+b);}

보기 2번은 리턴타입만 다른 경우이다. 매개변수의 타입과 개수가 일치하기 때문에 add(3,3)과 같이 호출하였을 때 어떤 메서드가 호출된 것인지 결정할 수 없기 때문에 오버로딩으로 간주되지 않는다. 

 

 

[보기 3]
long add(int a, long b) { return a+b;}
long add(long a, int b) { return a+b;}

보기 3은 두 메서드에 모두 int형과 long형 매개변수가 하나씩 선언되어 있지만, 서로 순서가 다른 경우이다. 이 경우는 호출 시 매개변수의 값에 의해 호출될 메서드가 구분될 수 있으므로 중복된 메서드 정의가 아닌, 오버로딩으로 간주한다.

 

 

이처럼 단지 매개변수의 순서만을 다르게 하여 오버로딩을 구현하면, 사용자가 매개변수의 순서를 외우지 않아도 되는 장점이 있지만, 오히려 단점이 될 수도 있기 때문에 주의하자.

예를 들어 add(3, 3L)과 같이 호출되면 첫 번째 메서드가, add(3L, 3)과 같이 호출되면 두 번째 메서드가 호출된다. 단 이 경우에는 add(3,3)과 같이 호출할 수 없다. 이와 같이 호출할 경우, 두 메서드 중 어느 메서드가 호출된 것인지 알 수 없기 때문에 메서드를 호출하는 곳에서 컴파일 에러가 발생한다.

 

 

※ 예제 1번 ※ 

package ch6;

public class Ex6_10 {

	public static void main(String[] args) {
		MyMath3 mm = new MyMath3();
		System.out.println("mm.add(3,3) 결과: " + mm.add(3,3));
		System.out.println("mm.add(3L,3) 결과: " + mm.add(3L,3));
		System.out.println("mm.add(3,3L) 결과: " + mm.add(3,3L));
		System.out.println("mm.add(3L,3L) 결과: " + mm.add(3L,3L));
		
		int [] a = {100, 200, 300};
		System.out.println("mm.add(a) 결과 : " + mm.add(a));

	}
}

class MyMath3{
	int add(int a, int b) {
		System.out.print("int add(int a, int b) - ");
		return a+b;
	}
	
	long add(int a, long b) {
		System.out.print("long add(int a, long b) - ");
		return a+b;
	}
	
	long add(long a, int b) {
		System.out.print("long add(long a, int b) - ");
		return a+b;
	}

	long add(long a, long b) {
		System.out.print("long add(long a, long b) - ");
		return a+b;
	}
	
	int add(int[] a) { //배열의 모든 요소의 합을 결과로 돌려준다.
		System.out.print("int add(int[] a) - ");
		int result=0;
		for(int i=0; i<a.length; i++)
			result += a[i];
		
		return result;
	}
	
}

 

메서드 이름이 같아도 오버로딩 되어 인자에 따라 해당되는 메서드가 실행된다. 

 

 

생서자(constructor)

생성자는 인스턴스가 생성될 때 호출되는 '인스턴스 초기화 메서드'이다. 따라서 인스턴스변수의 초기화 작업에 주로 사용되며, 인스턴스 생성 시에 실행되어야 하는 작업을 위해서도 사용된다. (인스턴스 초기화란, 인스턴스변수들을 초기화하는 것을 뜻한다.)

 

생성자 역시 메서드처럼 클래스 내에 선언되며, 구조도 메서드와 유사하지만 리턴값이 없다는 점이 다르다. 그렇다고 해서 생성자 앞에 리턴값이 없음을 뜻하는 키워드 void를 사용하지는 않고 단지 아무것도 적지 않는다.

1. 생성자의 이름은 클래스의 이름과 같아야한다.
2. 생성자는 리턴 값이 없다.

생성자도 메서드이기 때문에 리턴값이 없다는 의미의 void를 붙여야 하지만, 모든 생성자가 리턴값이 없으므로 void를 생략할 수 있게 한 것이다.

 

 

생성자는 아래와 같이 정의한다. 생성자도 오버로딩이 가능하므로 하나의 클래스에 여러 개의 생성자가 존재할 수 있다.

클래스이름(타입 변수명, 타입 변수명, ...) {
//인스턴스 생성 시 수행될 코드,
// 주로 인스턴스 변수의 초기화 코드를 적는다.
}

 

연산자 new가 인스턴스를 생성하는 것이지 생성자가 인스턴스를 생성하는 것은 아니다. 생성자라는 용어 때문에 오해하기 쉬운데, 생성자는 단순히 인스턴스변수들의 초기화에 사용되는 조금 특별한 메서드일 뿐이다. 

 

 

기본 생성자(default constructor)

지금까지 생성자를 모르고 프로그래밍을 해 왔지만, 사실 모든 클래스에는 반드시 하나 이상의 생성자가 정의되어 있어야 한다. 코드를 작성하면서 생성자를 정의하지 않았는데 인스턴스를 생성할 수 있던 이유는 컴파일러가 제공하는 '기본 생성자(default constructor)'덕분이었다.

 

컴파일 할 때, 소스파일(*.java)의 클래스에 생성자가 하나도 정의되지 않은 경우 컴파일러는 자동으로 같은 내용의 기본 생성자를 추가하여 컴파일한다. 컴파일러가 자동으로 추가해주는 기본 생성자는 매개변수도 없고 아무런 내용도 없는 간단한 것이다. 특별히 인스턴스 초기화 작업이 요구되지 않는다면 생성자를 정의하지 않고 컴파일러가 제공하는 기본 생성자를 사용하는 것도 좋다. 

 

※ 예제 2번 ※

package ch6;


class Data_1{
	int value;
}

class Data_2{
	int value;
	
	Data_2(int x){ //매개변수가 있는 생성자
		value =x; 
	}
}
public class Ex6_11 {

	public static void main(String[] args) {
		Data_1 d1 = new Data_1();
		Data_2 d2 = new Data_2();

	}

}

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
The constructor Data_2() is undefined

at ch6.Ex6_11.main(Ex6_11.java:19)

 

예제 2번을 컴파일하면 에러 메시지가 나타난다. 이것은 Data_2 클래스에서 Data_2()라는 생성자를 찾을 수 없다는 에러메시지인데, Data_2클래스에 생성자 Data_2()가 정의되어 있지 않기 때문에 에러가 발생한 것이다.

그렇다면 Data_1의 인스턴스를 생성하는 코드를 살펴볼 때 에러가 없는데, Data_2의 인스턴스를 생성하는 코드에서 에러가 발생하는 이유는 무엇일까?

 

그 이유는 Data_1에는 정의되어 있는 생성자가 하나도 없으므로 컴파일러가 기본 생성자를 추가해주었지만, Data_2에는 이미 생성자 Data_2(int x)가 정의되어 있으므로 기본 생성자가 추가되지 않았기 때문이다. 컴파일러가 자동적으로 기본 생성자를 추가해주는 경우는 '클래스 내에 생성자가 하나도 없을 때'뿐 이라는 걸 명심해야한다.

 

Data_2 d2 = new Data_2(10); 

이렇게 적어주면 에러가 사라진다. 

 

 

매개변수가 있는 생성자

생성자도 메서드처럼 매개변수를 선언하여 호출 시 값을 넘겨받아서 인스턴스의 초기화 작업에 사용할 수 있다. 인스턴스마다 각기 다른 값으로 초기화되어야 하는 경우가 많기 때문에 매개변수를 사용한 초기화는 매우 유용하다. 아래 예제는 자동차를 클래스로 정의한 것인데, 단순히 color, gearType, door 세 개의 인스턴스 변수와 두 개의 생성자만을 가지고 있다.

 

class Car{
   String color;
   String gearType;
   int door;
   
   Car(){} //기본 생성자
   Car(String c, String g, int d){//생성자
      color = c;
      gearType = g;
      door = d;
   }
}

Car 인스턴스를 생성할 때, 생성자 Car()를 사용한다면, 인스턴스를 생성한 다음에 인스턴스 변수들을 따로 초기화해줘야 하지만, 매개변수가 있는 생성자 Car(String c, String g, int d)를 사용한다면 인스턴스를 생성하는 동시에 원하는 값으로 초기화할 수 있다. 인스턴스를 생성한 다음에 인스턴스 변수의 값을 변경하는 것보다 매개변수를 갖는 생성자를 사용하는 것이 코드를 보다 직관적이고 간결하게 만든다.

 

위에 그림에서 양쪽 코드는 모두 같은 내용이지만, 오른쪽 코드가 더 간결하다. 이처럼 클래스를 작성할 때 다양한 생성자를 제공함으로써 인스턴스 생성 후에 별도로 초기화를 하지 않아도 되게 하는 것이 바람직하다.

 

 

인스턴스를 생성할 때 다음 2가지 사항을 결정해야한다.
1. 클래스 - 어떤 클래스의 인스턴스를 생성할 것인가?
2. 생성자 - 선택한 클래스의 어떤 생성자로 인스턴스를 생성할 것인가?

 

※ 예제 3번 ※

package ch6;

public class Ex6_12 {

	public static void main(String[] args) {
		Car c1 = new Car();
		c1.color = "black";
		c1.gearType = "auto";
		c1.door = 4;
		
		Car c2 = new Car("black", "auto", 4);
		
		System.out.printf("c1의 속성 %s %s%2d%n",c1.color, c1.gearType, c1.door);
		System.out.printf("c2의 속성 %s %s%2d%n" ,c2.color, c2.gearType, c2.door );

	}

}

class Car{
	String color;
	String gearType;
	int door;
	
	Car(){} //기본 생성자
	Car(String c, String g, int d){//생성자
		color = c;
		gearType = g;
		door = d;
	}
}

예제 3번 출력 값

 

 

생성자에서 다른 생성자 호출하기 - this()

같은 클래스의 멤버들 간에 서로 호출할 수 있는 것처럼 생성자 간에도 서로 호출이 가능하다. 단 2개의 조건을 만족시켜야 한다. 

1. 생성자의 이름으로 클래스이름 대신 this를 사용한다.
2. 한 생성자에서 다른 생성자를 호출할 때는 반드시 첫 줄에서만 호출이 가능하다.

생성자에서 다른 생성자를 첫 줄에서만 호출이 가능하도록 한 이유는 생성자 내에서 초기화 작업도중에 다른 생성자를 호출하게 되면, 호출된 다른 생성자 내에서도 멤버변수들의 값을 초기화할 것이므로 다른 생성자를 호출하기 이전의 초기화 작업이 무의미해질 수 있기 때문이다. 

 

 

※ 예제 4번 ※

package ch6;

public class Ex6_13 {

	public static void main(String[] args) {
	
		Car2 c1 = new Car2();
		Car2 c2 = new Car2("blue");
		
		System.out.printf("c1의 속성 %s %s%2d%n",c1.color, c1.gearType, c1.door);
		System.out.printf("c2의 속성 %s %s%2d%n" ,c2.color, c2.gearType, c2.door );

	}

}

class Car2{
	String color;
	String gearType;
	int door;
	
	Car2(){
		this("white", "auto",4);
	}
	Car2(String color){
		this(color, "auto",4);
	}

	Car2(String color, String gearType, int door) {
		this.color = color;
		this.gearType = gearType;
		this.door = door;
	}
}

예제 4번 출력 값

 

생성자 Car2()에서 또다른 생성자 Car2(String color, String gearType, int door)를 호출하였다. 이처럼 생성자간의 호출에는 생성자의 이름 대신 this를 사용해야만 하므로 'Car2'대신 this를 사용했고, 생성자 Car2()의 첫째 줄에서 호출하였다는 점을 유의하기 바란다.

 

같은 클래스 내의 생성자들은 일반적으로 서로 관계가 깊은 경우가 많아서 이처럼 서로 호출하도록 하여 유기적으로 연결해주면 더 좋은 코드를 얻을 수 있다. 그리고 수정이 필요한 경우에 보다 적은 코드만을 변경하면 되므로 유지보수가 쉬워진다. 

 

 

 

객체 자신을 가리키는 참조변수 - this

아래 왼쪽 코드의 ' color =c;'는 생성자의 매개변수로 선언된 지역변수 c의 값을 인스턴스 변수 color에 저장한다. 이 때 변수 color와 c는 이름만으로도 서로 구별되므로 아무런 문제가 없다. 

하지만 오른쪽 코드에서처럼 생성자의 매개변수로 선언된 변수의 이름이 color로 인스턴스 변수 color와 같을 경우에는 이름만으로는 두 변수가 서로 구별이 안 된다. 이런 경우에는 인스턴스변수 앞에 'this'를 사용하면 된다. 

이렇게 하면 this.color는 인스턴스변수이고, color는 생성자의 매개변수로 정의된 지역변수로 서로 구별이 가능하다. 만일 오른쪽에서 'this.color=color' 대신 'color=color'와 같이 작성하면 둘 다 지역변수로 간주된다. 

 

이처럼 생성자의 매개변수로 인스턴스변수들의 초기값을 제공받는 경우가 많기 때문에 매개변수와 인스턴스변수의 이름이 일치하는 경우가 자주 있다. 이때는 왼쪽코드와 같이 매개변수의 이름을 다르게 하는 것 보다 'this'를 사용해서 구별되도록 하는 것이 더 명확하고 이해하기 쉽다. 

 

'this'는 참조변수로 인스턴스 자신을 가리킨다. 참조변수를 통해 인스턴스의 멤버에 접근할 수 있는 것처럼, 'this'로 인스턴스변수에 접근할 수 있는 것이다. 하지만 'this'를 사용할 수 있는 것은 인스턴스멤버뿐이다. static메서드(클래스 메서드)에서는 인스턴스 멤버들을 사용할 수 없는 것처럼, 'this'역시 사용할 수 없다. 왜냐면, static 메서드는 인스턴스를 생성하지 않고도 호출될 수 있으므로 static 메서드가 호출된 시점에 인스턴스가 존재하지 않을 수도 있기 때문이다. 

 

this : 인스턴스 자신을 가리키는 참조변수, 인스턴스의 주소가 저장되어 있다. 모든 인스턴스메서드에 지역변수로 숨겨진 채 존재한다.
this(), this(매개변수) : 생성자, 같은 클래스의 다른 생성자를 호출할 때 사용한다.

 

 

변수의 초기화

변수를 선언하고 처음으로 값을 저장하는 것을 '변수의 초기화'라고 한다. 변수의 초기화는 경우에 따라서 필수적이기도하고 선택적이기도 하지만,가능하면 선언과 동시에 적절한 값으로 초기화 하는 것이 바람직하다. 

멤버변수는 초기화를 하지 않아도 자동적으로 변수의 자로형에 맞는 기본값으로 초기화가 이뤄지므로 초기화를 하지 않고 사용해도 되지만, 지역변수는 사용하기 전에 반드시 초기화해야 한다. 

 

class Initest{
   int x; //인스턴스 변수
   int y = x; //인스턴스 변수
   
   void method1() {
      int i; //지역변수
      int j =i; // 에러, 지역변수를 초기화하지 않고 사용
   }
}

 

위의 코드에서 x,y는 인스턴스 변수이고, i, j는 지역변수 이다. 그 중 x와 i는 선언만 하고 초기화를 하지 않았다. 인스턴스 변수 x는 초기화 해주지 않아도 자동적으로 int형의 기본값인 0으로 초기화되므로, 'int y = x;'와 같이 할 수 있다. x의 값이 0이므로 y도 역시 0이 저장된다. 

하지만, model()의 지역변수 i는 자동적으로 초기화되지 않으므로 컴파일하면 에러가 발생한다. 

 

각 타입의 기본 값

 

 

멤버변수의 초기화

지역변수와 달리 멤버변수는 각 타입의 기본값으로 자동 초기화된다. 그 다음에 명시적 초기화, 초기화 블럭, 생성자의 순으로 초기화 된다. 그리고 클래스 변수(cv)가 인스턴스 변수(iv)보다 먼저 초기화 된다. 멤버변수의 초기화에 대해서는 이 두가지만 기억하면 된다. 

1. 클래스 변수(cv) 초기화 -> 인스턴스 변수(iv) 초기화
2. 자동 초기화 -> 명시적 초기화(간단) -> 초기화 블럭, 생성자(복잡)

 

명시적 초기화(explicit initialization)

: 변수를 선언과 동시에 초기화하는 것을 명시적 초기화라고 한다. 가장 기본적이면서도 간단한 초기화 방법이므로 여러 초기화 방법중에 가장 우선적으로 고려되어야 한다. 명시적 초기화가 간단하고 명료하긴 하지만, 보다 복잡한 초기화 작업이 필요할 때는 '초기화 블럭(initialization block)' 또는 생성자를 사용해야 한다.

 

class Car {
   int door 4; //기본형(primitive type) 변수의 초기화
   Engine e = new Engine();  // 참조형(reference type)변수의 초기화
}

 

 

초기화 블럭(initialization block)

: 초기화 블럭에는 ' 클래스 초기화 블럭'과 '인스턴스 초기화 블럭' 두 가지 종류가 있다. 클래스의 초기화 블럭은 클래스 변수의 초기화에 사용되고, 인스턴스 초기화 블럭은 인스턴스변수의 초기화에 사용된다. 

 

초기화 블럭을 작성하려면, 인스턴스 초기화 블럭은 단순히 클래스 내에 블럭{ }을 만들고 그 안에 코드를 작성하기만 하면 된다. 그리고 클래스 초기화 블럭은 인스턴스 초기화 블럭 앞에 단순히 static을 덧붙이기만 하면 된다. 

 

 

※ 예제 5번 ※

package ch6;

public class Ex6_14 {

	static { //클래스 초기화 블럭
		System.out.println("static { } ");
	}
	{ //인스턴스 초기화 블럭
		System.out.println("{ }");
	}
	
	public Ex6_14() {
		System.out.println("생성자");
	}
	
	public static void main(String[] args) {
		System.out.println("Ex6_14 bt = new Ex6_14(); ");
		Ex6_14 bt = new Ex6_14();
		
		System.out.println("Ex6_14 bt2 = new Ex6_14(); ");
		Ex6_14 bt2 = new Ex6_14();

	}

}

예제 5번 출력 값

 

예제 5번이 실행되면서 Ex6_14이 메모리에 로딩될 때, 클래스 초기화 블럭이 가장먼저 수행되어 'static {}'이 화면에 출력된다. 그 다음에 main 메서드가 수행되어 Ex6_14의 인스턴스가 생성되면서 인스턴스 초기화블럭이 먼저 수행되고, 끝으로 생성자가 수행된다. 클래스 초기화 블럭은 처음 메모리에 로딩될 때 한번만 수행되었지만, 인스턴스 초기화 블럭은 인스턴스가 생성될 때 마다 수행되었다.

 

 

※ 예제 5번 ※

package ch6;

public class Ex6_15 {

	static int [] arr = new int[10]; //명시적 초기화
	
	static { // 클래스 초기화 블럭
		for(int i=0; i<arr.length; i++) {
			arr[i] = (int)(Math.random()*10 )+1;
		}
			
	}
	public static void main(String[] args) {
		for(int i=0; i<arr.length; i++) {
			System.out.println("arr[" +i+"] : " + arr[i]);
		}

	}

}

예제 5번 출력 값

명시적 초기화를 통해 배열 arr을 생성하고, 클래스 초기화 블럭을 이용해서 배열의 각 요소들을 random()을 사용해서 임의의 값으로 채우도록 했다. 이처럼 배열이나 예외처리가 필요한 초기화에서는 명시적 초기화만으로는 복잡한 초기화 작업을 할 수 없다. 이런 경우에 추가적으로 클래스 초기화 블럭을 사용하도록 한다.