23.02.13(월): 생성자(Constructor), 초기화 블록, 메서드 오버로딩, 배열

---

오늘 배운 내용
01. 클래스 설계 실습
02. 생성자

03. 배열 

---

---

01.  클래스 설계 실습 

 

실습073

import java.util.Scanner;
import java.io.IOException;  // read()는 예외처리 필요 

class Calculate
{	
	int n1, n2;  //정수 입력값
	char op;	// 연산자 입력값 

	void input() throws IOException // 입력 메소드 
	{	
		Scanner sc = new Scanner(System.in);
		System.out.print("2개의 정수 입력(공백 구분) : ");
		n1 = sc.nextInt();
		n2 = sc.nextInt();	
		System.out.print("연산자 입력[+ - * /] : ");
		op = (char)System.in.read();
	}
	
	int calc() // 연산 메소드 
	{
		int result = 0;

		if (op == '+')
			result = n1 + n2;
		else if(op == '-')
			result = n1 - n2;	
		else if(op == '*')
			result = n1 * n2;
		else if(op == '-')
			result = n1 / n2;
		else
			System.out.println("+, -, *, / 중에서 1개를 선택 입력하세요!");
		return result;
	}
	void print(int r) //출력 메소드
	{
		System.out.printf("%d %c %d = %d\n", n1, op, n2, r);
	}
}
/*--------------- 메인 메소드 ---------------*/
public class Test073
{
	public static void main(String[] args) throws IOException
	{	
		Calculate ca = new Calculate();
		ca.input();
		int res = ca.calc();
		ca.print(res);
	}
}

---

실습 073 - 강사님 코드

// 상략 

	double cal() // 연산 메소드 
	{
		double result = -1;

		switch(op)
		{
			case '+' : result = n1 + n2; break;
			case '-' : result = n1 - n2; break;
			case '*' : result = n1 * n2; break;
			case '/' : result = (double)n1 / n2; break; 
			//default : result = -1;
		}
		return result;
	}
// 중략 
/*--------------- 메인 메소드 ---------------*/
public class Test073_1
{
	public static void main(String[] args) throws IOException
	{	
		// Calculate 인스턴스 생성
		Calculate cal = new Calculate();
		cal.input(); //입력 메소드 호출
		double r = cal.cal(); //연산 메소드 호출, 실수 변수 선언 및 초기화
		cal.print(r); //출력 메소드 호출 
	}
}

 

참고 포스팅

(: if / switch 차이, 성능에 대한 글)

https://devmoony.tistory.com/121

---

02.  생성자

실습074 ~ 078

 

생성자(Constructor)

*역할 :
1. 인스턴스 생성 → 메모리 할당
2. 초기화

*특징 :
1. 메서드지만, 일반적인 메소드처럼 호출할 수 없고 반환 자료형을 가질 수 없다.
(void조차 가질 수 없고, 값 반환도 불가능)

2. 클래스와 동일한 이름을 가져야 한다.

( 메소드지만 대문자로 시작)

3. 생성자는 객체를 생성하는 과정에서 new의 형태로 호출된다.
   (인스턴스 생성 시 단 한 번만 호출)
   → final 변수(상수화된 변수) 초기화 가능.

4. 클래스에 사용자 정의 생성자를 정의하지 않았다면 컴파일 과정에서 
   디폴트 생성자가 자동 삽입된다. 따라서 정의했다면 자동 삽입하지 않는다.

 

---

실습074 

class NumberTest
{
	int num;
	/*NumberTest()  디폴트 생성자
	{
		내용이 없다.
	}*/
	NumberTest()
	{
		num = 10;
		System.out.println("사용자 정의 생성자 호출!");
	}	
	int getNum()
	{
		return num;
	}
}

public class Test074
{
	public static void main(String[] args)
	{
		NumberTest nt1 = new NumberTest();
		// 인스턴스 생성과 동시에 생성자 호출 필수 발생

		/*
        // 이 구문은 아래가 합쳐진 형태
		NumberTest nt1 = new NumberTest();  
		NumberTest nt1 = new NumberTest; + NumberTest(); 
		*/

		//nt1.action(); 컴파일 에러 
		//int num1 = nt1.getNum();

		System.out.println(nt1.getNum()); // 10 

		nt1.num = 200; // nt1 의 num 변수에 200 할당.
		System.out.println(nt1.getNum()); // 200

		NumberTest nt2 = new NumberTest(); 	
		System.out.println(nt2.num);  //10 
	}
}

---

실습075

/*===================== 02/13 (월) ======================
	         ■■■ 클래스와 인스턴스 ■■■
			- 생성자 실습 2
    -----------------------------------------------------
 *1 : 직접 정의했으므로 디폴트 자동 생성 하지 않음
	  사용자 정의 생성자는 매개변수를 갖는 형태이기 때문에 
	  매개변수 없이 생성자를 호출하면 오류가 생긴다. 
=========================================================*/

class NumberTest2
{
	int num;
	NumberTest2(int n)   // 사용자 정의 생성자! *1
	{
		num = n;
		System.out.println("생성자 호출! 동시에 매개변수 전달!: " + n); 
	}
	int getNum()
	{
		return num;
	}
}

public class Test075
{
	public static void main(String[] args)
	{
		// NumberTest2 클래스 기반 인스턴스 생성
		// NumberTest2 nt1 = new NumberTest2(); => 컴파일 에러 *1

		NumberTest2 nt1 = new NumberTest2(10); 
		System.out.println("메소드 반환 값:" + nt1.getNum()); //10
		System.out.println("nt1.num:" + nt1.num); //10

		NumberTest2 nt2 = new NumberTest2(3654);
		System.out.println("메소드 반환 값" + nt2.getNum()); //3654
		System.out.println("nt2.num:" + nt2.num); //3654
	}
}

사용자 정의 생성자를 매개변수를 가지는 형태로 구성

→ 매개변수 없이 호출 시 컴파일 에러 

---

실습076

---

1.  생성자 이름은 항상 예외 없이 클래스명과 동일해야 한다.  

 필요한 경우 인수를 받는 것이 가능하다.

 

2.  같은 이름의 메서드로 정의하는

 중복 정의가 가능하지만  리턴값은 가질 수 없다.

 

3.   생성자는 다른 일반 메서드처럼 호출될 수 없고,

 new 연산자를 이용하여 (객체를 생성하기 위해) 호출된다.

 

4.  각 클래스의 인스턴스를 생성한 후에   

생성된 객체의 멤버를 초기화시키는 작업을 수행한다.

 

5.  생성자 내부에서 다른 생성자 호출 가능.

단, 생성자 내부에서 가장 먼저 실행되어야 한다!! 

---

* 메서드 오버로딩 (면접 필수 질문!! 정확하게 대답할 수 있어야 하는 개념)
: 클래스 안에서 메서드 명은 식별자로 기능한다.
따라서 같은 클래스 안에 같은 이름의 메서드는 존재할 수 없다.
하지만 매개변수가 다르다면 구분 가능한 서로 다른 메서드로, '문법적 예외 허용'이다.  
- ex) 같은 기능을 하는데 매개변수에 따라 반환값이 다를 때 활용할 수 있다. 

 

 (cf. 메서드 오버라이딩) 

 메소드 오버라이딩

부모 클래스로부터 상속받은 메서드를 자식 메서드가 재정의 하는 것. 일반적인 클래스 상속 관계에서는 많이 사용되지 않고,  추상 메서드와 인터페이스에서 필수 사용되는 개념. 

 

 

class 선그리기
{
	선그리기(직선){}
	선그리기(점선){}
	선그리기(겹선){}
}

 

◆ 076 코드 블록

public class Test076
{
	int x;  // ^_^
	
	/*/------ 매개변수 없는 (사용자 정의)생성자 ------/*/
	Test076() 
	{	
		this(100);
		x = 10; 
		System.out.println("인자 없는 생성자!");
		System.out.println("Test076이 갖고 있는 x: " + x);
		// this(100); 재귀호출은 가장 최상단에서 실행해야 함.
	}

	/*/------- 정수형 매개변수를 넘겨받는 (사용자 정의) 생성자  -------/*/
	Test076(int x) // 
	{
		// x = x ;   둘 다 지역변수. -> 이럴 때 this 키워드 사용.
		this.x = x; // Test076 클래스의 x = x; (클래스명.x.. 라는 문법이 선점되어 this로 사용)  
					// this는 자신이 속한 class를 가르킨다. (== ^_^ ) 
		System.out.println("인자가 하나인 생성자!");
		System.out.println("Test076이 갖고 있는 x: " + this.x);
	}

	public static void main(String[] args)
	{	
		//Test076 클래스 기반 인스턴스 생성	

		Test076 ob1 = new Test076(); //출력: 인자 없는 생성자!
		Test076 ob2 = new Test076(100); //출력: 인자 없는 생성자!
		System.out.println();
		System.out.println("main 에서 ob1.x: " + ob1.x);
		System.out.println("main 에서 ob2.x: " + ob2.x);
	}
}

---

실습077

public class Test077
{
	int val1;
	double val2;

	Test077()
	{
		val1 = 0;
		val2 = 0;
		System.out.println("매개변수 없는 생성자...");
	}

	Test077(int x)
	{
		val1 = x;
		val2 = 0;
		System.out.println("int형 데이터를 매개변수로 받는 생성자...");
	}
	
	Test077(double y)
	{
		val1 = 0;
		val2 = y;
		System.out.println("double형 데이터를 매개변수로 받는 생성자...");
	}
	Test077(int x, double y)
	{
		val1 = x;
		val2 = y;
		System.out.println("int형 변수와 double형 변수를 매개변수로 받는 생성자...");
	}

	public static void main(String[] args)
	{
		Test077 ob1 = new Test077();
		System.out.println(ob1.val1 + ", " + ob1.val2); // 0, 0.0

		Test077 ob2 = new Test077(4); 
		System.out.println(ob2.val1 + ", " + ob2.val2); // 4, 0.0

		Test077 ob3 = new Test077(7.0);
		System.out.println(ob3.val1 + ", " + ob3.val2); // 0, 7.0

		Test077 ob4 = new Test077(4, 7.0); 
		System.out.println(ob4.val1 + ", "+ ob4.val2); // 4, 7.0
	}
}

/*
매개변수 없는 생성자...
0, 0.0
int형 데이터를 매개변수로 받는 생성자...
4, 0.0
double형 데이터를 매개변수로 받는 생성자...
0, 7.0
int형 변수와 double형 변수를 매개변수로 받는 생성자...
4, 7.0
계속하려면 아무 키나 누르십시오 . . .

*/

---

실습078

public class Test078
{	
	int n;    // 0으로 자동초기화 된 상태.
	int m;

	Test078()
	{	
		n = 100;
		m = 200;
		System.out.println("생성자 실행...");
	}
	{//--------------> 초기화 블럭 ! (구문 위치와 상관없이 먼저 실행한다. ) 
		n = 10; 
		m = 20; 
		System.out.println("초기화 블럭 실행...");
	}
	void write()// 멤버 출력 메소드 
	{
		System.out.println("n:" + n + ", m:" +m);
	}
	public static void main(String[] args)
	{	//Test078 인스턴스 생성 1
		Test078 ob1 = new Test078(); 
		ob1.write(); // n:10, m:20
	}
}
/*
초기화 블럭 실행...
생성자 실행...
n:100, m:200
*/

초기화 블록이 가장 먼저 실행되므로 값이 덮여 씌워진 것을 확인할 수 있다.

메서드 오버로딩 추가 ▼

public class Test078
{	
	int n;    // 0으로 자동초기화 된 상태.
	int m;
	Test078()
	{	
		n = 100;
		m = 200;
		System.out.println("생성자 실행...");
	}
	{//--------------> 초기화 블럭 ! (구문 위치와 상관없이 먼저 실행) 
		n = 10; 
		m = 20; 
		System.out.println("초기화 블럭 실행...");
	}	
	// 생성자 (Constructor) 
	Test078(int n, int m)
	{
		this.n = n;
		this.m = m;
		System.out.println("매개변수 있는 생성자 실행...");
	}
		
	// 멤버 출력 메소드 정의
	void write()
	{
		System.out.println("n:" + n + ", m:" +m);
	}

	public static void main(String[] args)
	{	//Test078 인스턴스 생성 1
		Test078 ob1 = new Test078(); 	
		ob1.write(); // n:10, m:20  -> n: 100, m: 200 

		//Test078 인스턴스 생성 2
		Test078 ob2 = new Test078(1234, 2345);
		ob2.write(); // n:1234, m:2345
	}
}

/*
초기화 블럭 실행...
생성자 실행...
n:100, m:200
초기화 블럭 실행...
매개변수 있는 생성자 실행...
n:1234, m:2345
*/

생성자, 초기화블럭, 메서드 오버로딩의 작동 방식을 확인할 수 있다. 

---

03.  배열 

 

- 배열의 선언과 초기화
1. 자바에서 배열이란 

: 크기와 성격이 같은 원소들이 모여 공동의 집합 구조를 갖는 자료 집합체.
동질적인 성격을 가진 자료들에 개별적으로 자료형(Data Type)을 부여하지 않고, 
하나의 이름으로 일괄적으로 처리할 목적으로 사용한다.

2. 자바의 배열은 다음과 같은 순서로 사용된다.

배열 선언 > 배열에 메모리 할당 > 배열 요소 접근(배열 요소의 사용)

3. 형식 및 구조
자료형 [] 변수명;
변수명 = new 자료형[요소크기];
변수명[인덱스] = 값; 

int[] arr;   // int형 자료가 모인 배열 선언
arr = new int[3];  
arr[0]...

---

실습 079

public class Test079
{
	public static void main(String[] args)
	{	
		int[] arr; // 배열 선언
		
		// 메모리 할당
		arr = new int[10]; // 데이터 10개 공간 확보(접근 전까지는 0으로 초기화)

		// 선언과 동시에 메모리 할당
		int[] arr2 = new int[10]; 

		int[] arr3 = {1,2,3,4,5,6,7,8,9,0}; // 권장
		int arr4[] = {1,2,3,4,5,6,7,8,9,0}; // 다른 표현 

		//배열 요소 접근(사용)
		arr[0] = 1; 
		arr[1] = 2; 
		arr[2] = 3; 	
		// 값을 할당하지 않은 나머지 배열 공간은 비어있지 않고 자동 초기화 값이 담긴다.
		
		int num = 10;
		System.out.println("num: " + num);
		System.out.println("arr: " + arr); // arr: [I@15db9742  - 해시코드

		// 배열을 일반 변수처럼 출력하면 알아볼 수 없는 코드가 출력된다.
		// 출력 값은 각 방의 데이터 값도, 메모리 주소값도 아니다!
        // (자바는 메모리접근 허용x)

		System.out.println("arr[0]" + arr[0]);
		System.out.println("arr[1]" + arr[1]);
		System.out.println("arr[2]" + arr[2]);

		System.out.println(arr[0] + ". "+  arr[1] + ", " + arr[2] + ". "+  arr[3] +", "+  
		arr[4] +", "+ arr[5]+ ", "+ arr[6] +", " + arr[6] +", "+ arr[7] +", "+ arr[8] +", "+ arr[9] );
		
		// 반복문 활용으로 배열 데이터 전체 출력
		for(int i =0 ; i<10; i++){
					System.out.println("i: " + i );
		}
	}
}
/*
num: 10
arr: [I@15db9742
arr[0]1
arr[1]2
arr[2]3
1. 2, 3. 0, 0, 0, 0, 0, 0, 0, 0
i: 0
i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
i: 8
i: 9
계속하려면 아무 키나 누르십시오 . . .
*/

---