자바 객체지향(2) - 생성자, 생성자 오버로딩 & 메소드 오버로딩

생성자

// Student s1 = new Student();
// 0. Student 클래스의 내용이 메모리 적재
// 1. main 메소드의 STACK 여역에 s1이 생성
// 2. new 연산자에 의해서 Student 클래스의 객체가 HEAP 메모리에 생성
// 2-1. Student 클래스의 생성자가 호출!
// 3. s1 변수에 생성된 Student 객체의 HEAP 주소가 반환

// 생성자
// - 클래스의 각 객체를 생성할 때, 최초 단 한번 실행되는 '메소드'
// - 멤버필드의 초기화 역할을 담당하는 메소드
// - public 클래스명() {}

// 학생 클래스의 선언
class Student {
	// 정보은닉의 개념으로 멤버 변수는 외부 접근이 차단	
	private String name;
	
	// 생성자의 선언
	// 1. 메소드
	// 2. 클래스의 이름과 동일한 이름을 갖는 메소드
	// 3. 리턴값의 타입이 없는 메소드
	// 4. 만약, 생성자를 선언하지 않으면 컴파일러 수준에서 디폴트 생성자를 제공합니다.
	// - 디폴트 생성자 : 생성자의 매개변수가 없고, 아무것도 하지않는 메소드
	// - public Student() {}
	public Student() {
		System.out.println("생성자 실행!!");
		name = "아직 이름이 없어요...";
	}

	// private 멤버인 name을 위한 getter / setter 메소드
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}	
}

public class Class_05_Constructor {
	public static void main(String[] args) {		
		// 클래스의 객체를 생성한 후, 각 멤버 변수의 값을 설정하는 방식
		// - 객체의 생성 코드와 설정하는 코드가 분리
		Student s1 = new Student();
		System.out.printf("학생의 이름은 %s 입니다.\n", s1.getName());
		
		s1.setName("아무개");
		System.out.printf("학생의 이름은 %s 입니다.\n", s1.getName());
		
		Student s2 = new Student();
		System.out.printf("학생의 이름은 %s 입니다.\n", s2.getName());
		
		// 생성자는 객체의 생성 시, 1번만 호출됩니다.
		// 그리고 생성자는 메소드이지만, 불완전한 메소드입니다.
		// 그렇기 때문에 객체의 레퍼런스 변수를 사용한 호출은 허용되지 않습니다.
		// (객체가 생성될 때 자동으로 실행됩니다.)
		// s2.Student();
	}
}

// 생성자
// - 객체의 생성에 역할(멤버변수의 초기화)을 하는 메소드
// - 생성자는 메소드이기 때문에 매개변수를 가질 수 있습니다.
// - Scanner in = new Scanner(System.in);

class A {
	private int num;
	
	// 매개변수를 사용하는 생성자의 예시
	// - A 클래스는 객체를 생성할 때, 생성자에 정수형 값을 전달해야만 
	//  객체를 생성할 수 있습니다.
	// - 생성자의 매개변수를 사용하여 각각의 객체가 서로다른 값을 가지는 객체로
	//   생성할 수 있습니다.
	public A(int n) {
		num = n;
	}
	
	public void display() {
		System.out.printf("num = %d\n", num);
	}
}

public class Class_06_Constructor {
	public static void main(String[] args) {
		A a1 = new A(15);
		a1.display();
		
		A a2 = new A(77);
		a2.display();
		
		// 중요!!!
		// - 생성자는 개발자가 정의하지 않으면 컴파일러 수준에서 디폴트 생성자가 생성됩니다.
		// - 클래스의 생성자를 하나라도 정의하면, 컴파일러는 디폴트 생성자를
		//   제공하지 않습니다.
		// A a = new A();
	}
}

// 생성자는 메소드
// 생성자는 이름이 결정된 메소드 - 항상 클래스명과 동일!!!
// 메소드는 메소드명 + 매개변수를 기준으로 구분이 됩니다 - 메소드 오버로딩
// 생성자는 메소드 오버로딩이 적용될 수 있습니다.
// - 생성자 오버로딩이 적용된 클래스는 각각의 객체를 서로다른 생성자를 사용하여
//   생성할 수 있습니다.
class B {
	public B() {
		System.out.println("B() 실행");
	}
	public B(int i) {
		System.out.println("B(int) 실행");
	}
	public B(double d) {
		System.out.println("B(double) 실행");
	}
}

public class Class_07_Constructor {
	public static void main(String[] args) {
		// 오버로딩된 생성자를 선택하여 객체를 생성하는 코드 
		B b1 = new B();
		B b2 = new B(1);
		B b3 = new B(1.1);
	}
}

생성자 오버로딩 & 메소드 오버로딩 예제

package chapter02;

class GuGuDan {
	// 생성자 오버로딩
	// 1. 클래스가 시작할때 생성자를 1회만 실행
	public GuGuDan() {
		// 2. 1회만 실행을 밑의 메소드인 display()를 실행
		display();
	}
	// 6. 구구단의 단을 출력하는 메소드를 만듬.		
	public GuGuDan(int dan) {
		display(dan);
	}
	// 메소드 오버로딩
	// 3. 실행 메소드 안에 2단부터 9단까지의 for문을 만듬
	public void display() {
		for( int i = 2 ; i < 10 ; i++ )
			// 4. 반복문을 돌면서 int값의 매개변수가 있는 메소드로 전달.
			display(i);
	}
	// 5. 매개변수 i를 받아 dan에 넣어서 출력화면을 보여줌
	public void display(int dan) {
		System.out.printf("%d단을 출력합니다.\n", dan);
		for( int j = 1 ; j < 10 ; j++ )
			System.out.printf("%d * %d = %d\n", dan, j, dan*j);
		System.out.println();
	}
}

public class Class_08_Constructor_EX {
	public static void main(String[] args) {		
		GuGuDan g = new GuGuDan();
		//GuGuDan g1 = new GuGuDan(5);
	}
}

GuGudan g = new GuGuDan() 을 출력하면

2 ~ 9단까지 불러온다.

GuGuDan g1 = new GuGuDan(5); 2~9까지의 원하는 숫자를 입력하면 그에 해당하는 구구단이 나온다.

생성자 예제

// 계산기 클래스
class Calculator {
	// 연산부호 저장 변수
	private char op;
	
	// 생성자를 사용하여 연산부호를 결정
	public Calculator() {
		op = '+';
	}
	public Calculator(char operator) {
		op = operator;
	}
	
	public String getOp() {		
		return op + " 계산기 입니다.";
	}	
	
	public void execute(int n1, int n2) {
		int r;
		switch( op ) {
			case '+' :
				r = n1 + n2;	break;
			case '-' :
				r = n1 - n2;	break;
			case '*' :
				r = n1 * n2;	break;
			case '/' :
				r = n1 / n2;	break;
			case '%' :
				r = n1 % n2;	break;
			default :
				r = 0;
		}
		System.out.printf("%d %c %d = %d\n", n1, op, n2, r);
	}
}

public class Class_09_Constructor_EX {
	public static void main(String[] args) {
		Calculator c1 = new Calculator();
		Calculator c2 = new Calculator('-');
		Calculator c3 = new Calculator('*');
		Calculator c4 = new Calculator('/');
		Calculator c5 = new Calculator('%');
		
		System.out.println(c1.getOp());
		System.out.println(c2.getOp());
		System.out.println(c3.getOp());
		System.out.println(c4.getOp());
		System.out.println(c5.getOp());
		
		c1.execute(10, 15);
		c2.execute(10, 15);
		c3.execute(10, 15);
		c4.execute(10, 15);
		c5.execute(10, 15);
	}
}