Bibliothek

○ 생성자(Constructor)의 역할

1. 메모리 할당
2. 초기화

○ 생성자(Constructor)의 특징

1. 생성자는 메소드이지만, 일반 메소드처럼 호출될 수 없으며, 반환 자료형을 가질 수 없다.
2. 생성자는 클래스와 동일한 이름을 가져야 한다.
   (대소문자 까지도 명확히 구분하여 동일한 이름으로 구성)
3. 생성자는 객체를 생성하는 과정에서 "new 생성자();"의 형태로 호출된다. 
   (인스턴스 생성 시 단 한 번만 호출)
4. 인스턴스 생성 시에만 단 한 번 호출된다는 특징으로 인해 생성자 내부에서 final 변수의 초기화가 가능하다.

class NumberTest
{
	int num;

	// default 생성자
	//-- 컴파일 과정에서 자동으로 삽입되는(생성되는) 이 생성자는
	//	 사용자 정의 생성자가 존재하지 않을 경우에만 만들어진다.
	
	//NumberTest()
	//{
	//	 텅 비어있는 상태	
	//}
	
	
	// 사용자 정의 생성자
	NumberTest()
	{
		num = 10;
		System.out.println("사용자 정의 생성자 호출~!!!");
	}

	int getNum()
	{
		return num;
	}
}

// ※ 모든 클래스에는 생성자가 존재한다
//    (사용자 정의 생성자를 별도로 정의하지 않았을 경우...
//     컴파일 과정에서 default 생성자가 자동으로 삽입된다.)

public class Test076
{
	public static void main(String[] args)
	{
		// NumberTest 클래스 기반의 인스턴스 생성
		NumberTest nt1 = new NumberTest();
		//-- 인스턴스가 생성되는 시점에서
		//   이와 동시에 선택의 여지 없이 생성자 호출이 이루어 진다.
		//								  ------
		//								NumberTest()

		
		//NumberTest nt1 = new NumberTest
		//						 +
		//				     NumberTest();
		

		//nt1.NumberTest();
		//--==>> 에러 발생(컴파일 에러)

		int result = nt1.getNum();
		System.out.println(result);
		//--==>> 10


		nt1.num = 100;
		System.out.println(nt1.getNum());
		//--==>> 100

		NumberTest nt2 = new NumberTest();

		int result2 = nt2.getNum();
		System.out.println(result2);
	
		
	}
}

실행 결과

// 실행 결과
/*
사용자 정의 생성자 호출~!!!
10
100
계속하려면 아무 키나 누르십시오 . . .
*/

※ 사용자로부터 임의의 두 정수와 연산자를 입력받아 사칙연산을 수행하는 프로그램을 구현한다.
 단, 클래스와 인스턴스의 개념을 활용하여 작성할 수 있도록 한다.

 실행 예)
 임의의 두 정수 입력(공백 구분) : 10 5
 임의의 연산자 입력( + - * / )  : +
 >> 10 + 5 = 15
 계속하려면 아무 키나 누르세요...

import java.util.Scanner;
import java.io.IOException;

class Calculate
{
	char op;
	int n1,n2;

	/*
	// 생성자 → 사용자 정의 생성자가 없으면 디폴트 생성자가 삽입된다
	Calculate()
	{
		// 텅 비어 있는 상태
	}
	*/
	// 입력받을 메소드
	void input() throws IOException
	{
		Scanner sc = new Scanner(System.in);

		System.out.print("임의의 두 정수 입력(공백 구분) : ");
		n1 = sc.nextInt();
		n2 = sc.nextInt();
		
		System.out.print("임의의 연산자 입력( + - * / )  : ");
		op = sc.next().charAt(0);
		//op = (char)System.in.read();

	}

	// 연산을 수행할 메소드
	int cal()
	{
		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.print("잘못된 연산자 입력\n");
			return 0;
		}
		return result;
	}

	void print(int result)
	{
		System.out.printf(">> %d %c %d = %d", n1, op, n2, result);
	}
}

public class Test075
{
	public static void main(String[] args) throws IOException
	{
		// Calculate 인스턴스 생성
		Calculate cc = new Calculate();

		// 입력 메소드 호출
		cc.input();

		// 연산 메소드 호출
		int result = cc.cal();

		// 결과 출력 메소드 호출
		cc.print(result);


	}
}

실행 결과

// 실행 결과
/*
임의의 두 정수 입력(공백 구분) : 10 5 
임의의 연산자 입력( + - * / )  : + 
>> 10 + 5 = 15 
계속하려면 아무 키나 누르세요...
*/

※ 사용자로부터 임의의 정수를 입력받아 1부터 입력받은 수 까지의 합을 연산하여 결과값을 출력하는 프로그램을 구현한다.

 단, 클래스와 인스턴스의 개념을 활용하여  처리할 수 있도록 한다. 또한, 입력 처리 과정에서 BufferedReader 를 사용하며, 입력 데이터가 1 보다 작거나 1000 보다 큰 경우 다시 입력받을 수 있는 처리를 포함하여 프로그램을 구현할 수 있도록 한다.

 실행 예)
 임의의 정수 입력(1~1000) : 1022
 임의의 정수 입력(1~1000) : -23
 임의의 정수 입력(1~1000) : 100
 >> 1 ~ 100 까지의 합 : 5050
 계속하려면 아무 키나 누르세요...

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

class Hap
{
	// 주요 변수 선언(속성 구성)
	//-- 사용자의 입력값을 담아둘 변수
	int su;

	// 주요 메소드 정의(기능 정의)
	//-- 입력 기능을 수행할 메소드
	void input() throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		do
		{
			System.out.print("임의의 정수 입력 : ");
			su = Integer.parseInt(br.readLine());

		}
		while (su < 1 || su > 1000);


	}
			
	

	// 주요 메소드 정의(기능 정의)
	//-- 연산 처리 기능을 수행할 메소드
	int calculate()
	{
		int result = 0;
		
		for(int i=1;i<=su;i++)
		{
			result += i;
		}

		return result;
	}

	// 주요 메소드 정의(기능 정의)
	//-- 결과 출력 기능을 수행할 메소드
	void print(int sum)
	{
		System.out.printf(">> 1 ~ %d 까지의 합 : %d\n", su, sum);
	}

}


public class Test074
{
	public static void main(String[] args) throws IOException
	{
		// Hap 클래스를 기반으로 한 인스턴스 생성
		Hap ob = new Hap();
		
		// 생성한 인스턴스를 통해 입력 메소드 호출
		ob.input();

		// 생성한 인스턴스를 통해 연산 메소드 호출
		int s = ob.calculate();

		// 생성한 인스턴스를 통해 출력 메소드 호출
		ob.print(s);

	}
}

실행 결과

// 실행 결과
/*
임의의 정수 입력 : 100
>> 1 ~ 100 까지의 합 : 5050
계속하려면 아무 키나 누르십시오 . . .
*/

※

원의 넓이와 둘레 구하기 원의 넓이와 둘레를 구할 수 있는 클래스를 설계한다. (클래스명 : CircleTest) → CircleTest.java

 원의 넓이 = 반지름 * 반지름 * 3.141592
 원의 넓이 = 반지름 * 2 * 3.141592

 실행 예)
 반지름 입력 : xx

 반지름이 xx인 원의
 넓이 : xxx.xx
 둘레 : xxx.xx
 계속하려면 아무 키나 누르세요...

클래스 설계

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class CircleTest
{
	// 멤버 변수 → 주요 속성
	int r;						//-- 반지름
	final double PI = 3.141592; //-- 원주율(변수의 상수화)

	// 반지름 입력 기능 → 메소드 정의
	void input() throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		System.out.print("반지름 입력 : ");
		r = Integer.parseInt(br.readLine());

	}

	// 넓이 계산 기능 → 메소드 정의
	double calArea()
	{
		double result = 0;
		
		result = r * r * PI;
		
		return result;

	}
	// 둘레 계산 기능 → 메소드 정의
	double calLength()
	{
		double result = 0;

		result = r * 2 * PI;

		return result;
	}
	// 결과 출력 기능 → 메소드 정의
	void print(double a, double l)
	{
		// 반지름이 xx인 원의
		// 넓이 : xxx.xx
		// 둘레 : xxx.xx
		System.out.printf("반지름이 %d인 원의\n", r);
		System.out.printf("넓이 : %d\n", a);
		System.out.printf("둘레 : %d\n", l);
	}
}

인스턴스 생성 및 메소드 호출

import java.io.IOException;

public class Test073
{
	public static void main(String[] args) throws IOException
	{
		/*
		// 넓이과 둘레를 저장할 변수 선언
		double a,l;

		// CircleTest 인스턴스 생성
		CircleTest ct = new CircleTest();
		
		// 반지름 입력
		ct.input();

		// 넓이 계산
		a = ct.calArea();

		// 둘레 계산
		l = ct.calLength();

		// 결과 출력
		ct.print(a,l);
		*/

		CircleTest ct = new CircleTest();

		ct.input();
		double a = ct.calArea();
		double l = ct.calLength();
		ct.print(a, l);
	}
}

 클래스, 객체, 인스턴스의 개념

클래스(Class) 란

• 객체를 만들어 내기 위한 설계도 혹은 틀
• 연관되어 있는 변수와 메소드의 집합

객체(Object) 란

• 소프트웨어 세계에 구현할 대상
• 클래스에 선언된 모양 그대로 생성된 실체
• 클래스의 인스턴스(Instance)라고도 부른다.
• 객체는 모든 인스턴스를 대표하는 포괄적인 의미를 갖는다.
• OOP(객체지향프로그래밍)의 관점에서 클래스의 타입으로 선언되었을 때 '객체' 라고 부른다.

인스턴스(Instance)란

• 설계도를 바탕으로 소프트웨어 세계에 구현된 구체적인 실체
• 즉, 객체를 소프트웨어에 실체화 하면 그것을 '인스턴스'라고 부른다.
• 실체화된 인스턴스는 메모리에 할당한다.
• 인스턴스는 객체에 포함된다고 볼 수 있다.
• OOP의 관점에서 객체가 메모리에 할당되어 실제 사용될 때 '인스턴스'라고 부른다.
• 즉, 인스턴스라는 용어는 반드시 클래스와 객체 사이의 관계로 한정지어서 사용할 필요는 없다.
• 인스턴스는 어떤 원본(추상적인 개념)으로부터 '생성된 복제본'을 의미한다.

※ 실습) 직사각형의 넓이와 둘레 계산, 클래스로 표현

직사각형의 넓이와 둘레 계산, 클래스로 표현

클래스의 정체성 → 직사각형
클래스의 속성   → 가로, 세로, (, 넓이, 둘레, 부피, 무게, 재질, 색깔, ....)
클래스의 기능 → 넓이 계산, 둘레 계산, 가로세로 입력, 결과 출력, ...)
 
객체를 구성 → 데이터(속성, 상태, 값) + 기능(행위, 동작) → 객체 생성
    ↓                         ↓                           ↓                  ||
클래스 설계 →           변수             +        메소드     → 인스턴스 생성

class 직사각형
{
   // 데이터(속성, 상태) → 변수
   int 가로, 세로

   // 기능(동작, 행위)   → 메소드
   가로세로 입력()
   {
   }

   둘레 계산()
   {  
   }

   넓이 계산()
   {
   }

   결과 출력()
   {
   }
}

 참고) 하나의 자바 파일(.java)에 여러 개의 클래스(class)를 만들 수 있다. 하지만, "public class"는 하나만 올 수 있다. 파일을 저장할 때의 이름은 이 "public class"의 이름으로 지정해야 한다. 일반적으로는 하나의 파일에 하나의 클래스를 설계한다. 또한, 여러 개의 클래스가 설계된 파일을 컴파일하게 되면 내부에 설계된 클래스의 수 만큼 클래스 파일(.class)이 파생된다.

직사각형 클래스 설계

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

class Rect // 직사각형 클래스 설계
{
	// 데이터(속성, 상태) → 변수
	int w, h;

	// 기능(동작, 행위)	  → 메소드
	void input() throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));


		System.out.print("가로 입력 : ");
		w = Integer.parseInt(br.readLine());

		System.out.print("세로 입력 : ");
		h = Integer.parseInt(br.readLine());
	}

	int calLength()				// 둘레 계산
	{
		int result = 0;
		
		result = (w + h) * 2;

		return result;
	}

	int calArea()				// 넓이 계산
	{
		int result = 0;

		result = w * h;

		return result;
	}

	void print(int a, int l)	// 결과 출력
	{
		// 가로 : 10
		// 세로 : 20
		// 넓이 : xxx
		// 둘레 : xx

		System.out.println("가로 : " + w);
		System.out.println("세로 : " + h);
		System.out.println("넓이 : " + a);
		System.out.println("둘레 : " + l);
	}
}

public class Test072
{
	public static void main(String[] args)
	{
		// Rect 인스턴스 생성
		Rect ob = new Rect();

		// 입력 메소드 호출(생성된 인스턴스의 참조변수명을 통해 접근)
		ob.input();

		// 넓이를 연산하는 메소드 호출
		int area = ob.calArea();
		
		// 둘레를 연산하는 메소드 호출
		int length = ob.calLength();

		// 출력 기능을 수행하는 메소드 호출 
		ob.print(area,length);


	}

}

전역변수(Global variable)와 지역변수(Local variables)

※ 지역 변수는 초기화 과정을 거치지 않으면 사용할 수 없다.

   (→ 자바가 자동으로 초기화를 수행해 주거나 하지 않는다.)

// Test071.java 와 비교~!!!

public class Test070
{
	public static void main(String[] args)
	{
		// 지역 변수 n
		int n;
		//-- 선언 후 초기화 과정을 거치지 않은 상태.
		
		System.out.println("n : " + n);
		//--==>> 에러 발생(컴파일 에러)
		//variable n might not have been initialized
		//-- 지역 변수 n 에 접근하여 그 값을 출력하고자 하는 구문
	}


	// 다른 메소드
	/*
	메소드1()
	{
		
	}

	메소드2()
	{
		
	}

	메소드3()
	{
		
	}
	*/
}

// Test070.java 와 비교~!!!


public class Test071
{
	// 전역 변수 a 선언
	int a;
	double b;
	float c;
	char d;
	String[] e;
	boolean f;

	//-- 자동으로 0으로 초기화 지원
	
	public static void main(String[] args) 
	{
		//System.out.println("a : " + a);
	    
		// Test071 인스턴스 생성
		Test071 ob = new Test071();

		System.out.println("ob.a : " + ob.a);
		//--==>>
		
		System.out.println("ob.b : " + ob.b);
		//
		
		System.out.println("ob.c : " + ob.c);
		//
		
		System.out.println("ob.d : " + ob.d);
		//
		
		System.out.println("ob.e : " + ob.e);
		System.out.println("ob.f : " + ob.f);


	}
}