Bibliothek

○ 메소드 오버로딩의 개요

   메소드 오버로딩(Overloading)이란 메소드가 처리하는 기능은 같고 메소드 괄호 속에 오는 인수(인자, 매개변수, 파라미터)의 갯수가 다르거나 자료형(Data Type)이 다른 경우 메소드의 이름을 동일한 이름으로 부여하여 메소드를 정의할 수 있도록 문법적으로 허용하게 되는데 이를 메소드 오버로딩(Method Overloading) 이라고 한다.

다음과 같이 같은 이름의 메소드를 3개 정의할 수 있다.

	// 선을 그리스 메소드 정의
	public static void drawLine()
	{
		System.out.println("====================");
	}
	
	// 선의 형태를 바꾸어 그리는 메소드 정의
	public static void drawLine(char c)
	{
		for (int i =0; i < 20; i++)
		{
			System.out.print(c);
		}
		System.out.println();
	}

	// 선의 형태와 길이를 바꾸어 그리는 메소드 정의ㅡ
	public static void drawLine(char c, int n)
	{
		for (int i = 0; i< n; i++)
		{
			System.out.print(c);
		}
		System.out.println();
	}

같은이름의 메소드들 중 인자의 갯수나 자료형이 일치되는 메소드를 호출하여 사용할 수 있다.  

public class Test106
{
	public static void main(String[] args)
	{
		drawLine();
		//--==>> ====================
		
		drawLine('+');
		//--==>> ++++++++++++++++++++
		
		drawLine('>');
		//--==>> >>>>>>>>>>>>>>>>>>>>

		drawLine('/', 50);
		//--==>> //////////////////////////////////////////////////
		
		drawLine('+', 30);
		//--==>> ++++++++++++++++++++++++++++++
		
	}
}    

※ 메소드 오버로딩이 가능한 형태 & 불가능한 형태

public class Test107
{
	public static void main(String[] args)
	{
		print('A');	

		double result = print(10, 0);
		print(10.0);
	}

	public static void print(){}
	public static void print(int i){}
	//public static void print(int j){}				//-- (Ⅹ)
	public static void print(char c){}				//-- 자동 형 변환 규칙 check~!!!
	public static void print(int i, int j){}
	//public static void print(double d){}				//-- 자동 형 변환 규칙 check~!!!
	//public static double print(double d){return 3.14;}		//-- (Ⅹ)
	//public static void print(double e){return 3.14;}		//-- 정의 불가


}

 ※ 1 ~ 3 사이의 난수를 발생시켜서
 가위, 바위, 보 게임 프로그램을 구현한다.
 단, 클래스의 개념을 활용하여 처리할 수 있도록 한다.
 또한, 배열을 활용하여 처리할 수 있도록 한다.
 최종적으로 RpsGame 클래스를 완성할 수 있도록 한다.

 ※ 기준 데이터 → 1:가위, 2:바위, 3:보

 실행 예)
 1:가위, 2:바위, 3:보 중 입력(1~3) : 4
 1:가위, 2:바위, 3:보 중 입력(1~3) : -2
 1:가위, 2:바위, 3:보 중 입력(1~3) : 2

 - 유저   : 바위
 - 컴퓨터 : 보

 >> 승부 최종 결과 : 컴퓨터가 이겼습니다~!!!
 계속하려면 아무 키나 누르세요...

/*=========================================================  
  ■■■ 클래스와 인스턴스 ■■■     
  - 클래스와 인스턴스 활용
  ========================================================*/

import java.util.Random;
import java.util.Scanner;

class RpsGame
{

	// ○ 주요 속성 구성(변수 선언)
	private int user;
	private int com;
	//pricate String resultStr;

	// ○ 주요 기능 구성(메소드 정의)
	//   - 사용자의 선택 내용을 입력받는 기능의 메소드
	public void input()
	{
		runCom();

		Scanner sc = new Scanner(System.in);

		do
		{
			System.out.print("1:가위, 2:바위, 3:보 중 입력(1~3) : ");
			user = sc.nextInt();
		}
		while (user < 1 || user > 3);

	}

	// ○ 주요 기능 구성(메소드 정의)
	//   - 컴퓨터의 선택 내용을 입력받는 기능의 메소드
	private void runCom()
	{
		Random rd = new Random();
		com = rd.nextInt(3) + 1;	//-- +1 : 0 1 2 → 1 2 3
	}

	
	// ○ 주요 기능 구성(메소드 정의)
	//   - 중간 결과 출력
	public void middleCalc()
	{
		String[] str = {"가위", "바위", "보"};
		
		System.out.println();
		System.out.println("- 유저   : " + str[user - 1]);
		System.out.println("- 컴퓨터 : " + str[com - 1]);
		//-- "-1" : str[1] str[2] str[3] → str[0] str[1] str[2]
	}

	// ○ 주요 기능 구성(메소드 정의)
	//    - 승부에 대한 연산
	public String resultCalc()
	{
		String result = "무승부 상황입니다~!!!";
		
		// (유저 =="가위" && 컴=="보") (유저 == "바위" && 컴 == "가위") (유저 == "보" && 컴 == "바위")
		if ((user == 1 && com == 3)||(user == 2 && com == 1)||(user == 3 && com == 2))	// 당신이 승리한 상황
		{
			result = "당신이 승리했습니다~!!!";
		}

		//(유저 =="가위" && 컴=="바위") (유저 == "바위" && 컴 == "보") (유저 == "보" && 컴 == "가위")
		else if((user == 1 && com== 2)||(user == 2 && com == 3)||(user == 3 && com == 1)) // 컴퓨터가 승리한 상황
		{
			result = "컴퓨터가 승리했습니다~!!!";			
		}


		return result;
	}

	// ○ 주요 기능 구성(메소드 정의)
	//    - 최종 결과 출력
	public void print(String str)
	{
		System.out.printf("\n>> 승부 최종 결과 : %s\n",str);
	}
}

public class Test105
{
	public static void main(String[] args)
	{
		RpsGame ob = new RpsGame();
		
		ob.input();
		ob.middleCalc();
		String result = ob.resultCalc();
		ob.print(result);
	}
}

 학생별로 국어점수, 영어점수, 수학점수를 입력받아
 총점, 평균을 계산하는 프로그램을 구현한다.
 단, 클래스의 개념을 활용하여 작성할 수 있도록 한다.
 또한, 이 과정에서 배열을 적극적으로 활용할 수 있도록 한다.

 프로그램을 구성하는 클래스
 1. Record 클래스
    → 속성만 존재하는 클래스로 설계할 것~!!!

 2. Sungjuk 클래스
   → 인원 수를 입력받아, 입력받은 인원 수 만큼
  이름, 국어점수, 영어점수, 수학점수를 입력받고
  총점과 평균을 산출하는 클래스로 설계할 것~!!!
  * 속성 : 인원수, Record 형태의 배열
  * 기능 : 인원수 입력, 상세 데이터 입력, 총점 및 평균 연산, 결과 출력

 3. Test104 클래스
   → main() 메소드가 존재하는 외부 클래스로 설계할 것~!!!

 실행 예) 
 인원 수 입력(1~100) : 102 
 인원 수 입력(1~100) : -10
 인원 수 입력(1~100) : 3

 1번째 학생의 이름 입력 : 윤홍준
 국어 점수 : 90
 영어 점수 : 80
 수학 점수 : 70

 2번째 학생의 이름 입력 : 김승범
 국어 점수 : 82
 영어 점수 : 72
 수학 점수 : 62

 3번째 학생의 이름 입력 : 이예슬
 국어 점수 : 98
 영어 점수 : 88
 수학 점수 : 78

 윤홍준 90 80 70 xx xx 2
 김승범 82 72 62 xx xx 3
 이예슬 98 88 78 xx xx 1

Record 클래스 설계

public class Record
{
	// 학생 1명을 표현할 수 있는 속성들로 구성~!!!

	String name;
	int[] score= new int[3];
	int tot;
	double avg;
	int rank;
}

Sungjuk 클래스 설계

import java.util.Scanner;

public class Sungjuk
{
	// 주요 속성 구성(주요 변수 선언)
	int inwon;		//-- 인원 수
	Record[] rec;	//-- Record 배열(학생 한 명 당 배열 방 한 개 활용)
					//	 Record를 기반으로 생성된 객체만 담아낼 수 있는 배열

	// 주요 메소드 구성 기능(기능 구성 → 메소드 정의)
	// ① 인원 수 입력
	public void set()
	{
		Scanner sc = new Scanner(System.in);
		
		do
		{
			System.out.print("인원 수 입력(1~100) : ");
			inwon = sc.nextInt();
		}
		while (inwon < 1 || inwon > 100);

		// check~!!!
		// Record 클래스를 기반으로 생성된 객체(인스턴스)를 담을 수 있는
		// 배열방을 inwon 만큼 생성한 것이지
		// Record 클래스의 인스턴스를 생성한 것은 아니다.
		rec = new Record[inwon];
	}

	// 주요 메소드 구성 기능(기능 구성 → 메소드 정의)
	// ② 상세 데이터 입력 (이름, 국어점수, 영어점수, 수학점수 입력) + 총점, 평균 산출
	public void input()
	{
		Scanner sc = new Scanner(System.in);
		
		String[] title = {"국어 점수 : ", "영어 점수", "수학 점수"};

		// 인원 수 만큼 반복 → 인원 수에 기반하여 만들어진 배열의 길이만큼 반복
		for (int i = 0; i < inwon; i++) // for(int i = 0; i < rec.length; i++)
		{
			// check~!!!
			// Record 클래스 기반의 인스턴스 생성

			//Record ob = new Record();
			//rec[i] = ob
			rec[i] = new Record();

			//rec[i].name = "홍길동";
			System.out.printf("%d번째 학생의 이름 입력 : ", (i+1));
			rec[i].name = sc.next();
			
			/*
			System.out.print("국어 점수 : ");
			rec[i].kor = sc.nextInt();
			System.out.print("영어 점수 : ");
			rec[i].eng = sc.nextInt();
			System.out.print("수학 점수 : ");
			rec[i].mat = sc.nextInt();
			*/

			/*
			System.out.print("국어 점수 : ");
			rec[i].score[0] = sc.nextInt();
			System.out.print("영어 점수 : ");
			rec[i].score[1] = sc.nextInt();
			System.out.print("수학 점수 : ");
			rec[i].score[2] = sc.nextInt();
			*/

			for (int j = 0; j < title.length; j++)
			{
				// 안내 메세지 출력
				System.out.print(title[j]);

				// 사용자가 입력한 데이터를 스코어(score) 배열에 담아내기
				rec[i].score[j] = sc.nextInt(); // score[0] → 국어 점수
												// score[1] → 영어 점수
												// score[2] → 수학 점수

				// 국어, 영어, 수학 점수 데이터를 입력받는 동안
				// 총점 누적하기
				rec[i].tot += rec[i].score[j];
			}

			// 평균 산출하기
			rec[i].avg = rec[i].tot / 3.0;

		}
	}//end input()

	// 주요 메소드 구성 기능(기능 구성 → 메소드 정의)
	// ③ 결과 출력
	// 윤홍준 90 80 70 xx xx 2
	// 김승범 82 72 62 xx xx 3
	// 이예슬 98 88 78 xx xx 1
	public void print()
	{
		// 석차 산출 메소드 호출~!!! (구문 추가)
		ranking();

		System.out.println();	// 개행

		// 학생 한 명 당 반복 출력 구문 구성
		for (int i = 0; i < inwon; i++)
		{
			// 이름 출력
			System.out.printf("%5s", rec[i].name);

			// 성적(국어, 영어, 수학) 반복 출력
			for (int j = 0; j < 3; j++)
			{
				System.out.printf("%4d", rec[i].score[j]);
			}

			// 총점, 평균 출력
			System.out.printf("%5d", rec[i].tot);
			System.out.printf("%6.2f", rec[i].avg);
			// 석차 출력구문 추가~!!! (구문 추가)
			System.out.printf("%5d\n", rec[i].rank);

		}
	}

	
	// ④ 석차 산출 메소드 추가~!!!
	// - Record 배열의 rank 속성 초기화를 수행하는 기능 → 반환 자료형 void
	// - 클래스 내부에서 활용할 메소드로 정의
	//   즉, 외부에 노출할 메소드가 아닌 형태로 정의 → 접근제어 지시자 private
	//   → 외부에서 접근(호출) 불가

	private void ranking()
	{
		int i,j;		//-- 루프 변수

		// 모든 학생들의 등수(석차, rank)를 1로 초기화
		for (i = 0; i < inwon; i++)
			rec[i].rank = 1;

		// 등수 산출
		for (i = 0; i < inwon - 1; i++)			// 비교 기준	0	  1	  2	   3
		{
			for (j = i + 1; j < inwon; j++)		// 비교 대상	1234  234 34   4
			{
				// 기준의 평균이 대상의 평균보다 크다면...
				if (rec[i].avg > rec[j].avg)
				{
					// 대상의 rank 를 1만큼 증가
					rec[j].rank++;
				}
				else
				{	
					// 기준의 rank 를 1만큼 증가
					rec[i].rank++;
				}

			}
		}

	}
}

main 클래스

public class Test104
{
	public static void main(String[] args)
	{
		Sungjuk ob = new Sungjuk();
		
		ob.set();
		ob.input();
		ob.print();

		/*
		Sungjuk sj = new Sungjuk();
		
		// 실행
		sj.print();
		*/
	}
}

실행 결과

// 실행 결과
/*
인원 수 입력(1~100) : 3
1번째 학생의 이름 입력 : 윤홍준
국어 점수 : 90
영어 점수 : 80
수학 점수 : 70
2번째 학생의 이름 입력 : 김승범
국어 점수 : 92
영어 점수 : 82
수학 점수 : 72
3번째 학생의 이름 입력 : 이예슬
국어 점수 : 99
영어 점수 : 88
수학 점수 : 77

  윤홍준  90  80  70  240 80.00    3
  김승범  92  82  72  246 82.00    2
  이예슬  99  88  77  264 88.00    1
계속하려면 아무 키나 누르십시오 . . .
*/

/*=========================================================  
  ■■■ 클래스와 인스턴스 ■■■     
  - 클래스 변수(static 변수)와 클래스 메소드(static 메소드)
  ========================================================*/

// ※ 실습 편의상 접근제어지시자 생략

public class Test103
{
	// ※ 클래스 변수 또는 클래스 메소드는
	//    클래스 정보라 로딩되는 순간 메모리 할당이 이루어지며
	//    클래스 이름 또는 객체(인스턴스)를 통해 접근할 수 있다.
	//    즉, "new" 연산자를 통해 메모리 할당을 받지 않아도
	//    사용이 가능하다는 것이다.
	static int a = 10;		//-- static 변수 / 클래스 변수 / class 변수 / 정적 변수

	// ※ 인스턴스 변수 또는 인스턴스 메소드는 
	//    동일한 클래스의 메소드에서는 바로 접근하는 것이 가능하지만
	//    클래스 메소드에서는 접근할 수 없다.
	int b = 20;				//-- non-static 변수 / 인스턴스 변수 / instance 변수


	void write()			//-- non-static 메소드 / 인스턴스 메소드 / instance 메소드
	{
		System.out.println("클래스 변수 a : " + a);
		System.out.println("인스턴스 변수 b : " + b);
	}

	static void print()		//-- static 메소드 / 클래스 메소드 / class 메소드 / 정적 메소드
	{
		System.out.println("클래스 변수 a : " + a);
		//System.out.println("인스턴스 변수 b : " + b);
		//-- 에러 발생(컴파일 에러)
	}

	public static void main(String[] args)
	{
		System.out.println("main() → 클래스 변수 a : " + Test103.a);
		//-- 클래스 변수에 접근하기 위해서는
		//   "클래스명.변수명"의 형태로
		// 클래스의 이름을 통해 접근하는 것이 가능하다.
		//--==>> main() → 클래스 변수 a : 10

		System.out.println("main() → 클래스 변수 a : " + a);
		//--==>> main() → 클래스 변수 a : 10
		//-- 같은 클래스(Test103) 내부에 존재하기 때문에
		//   클래스의 이름을 생략하는 것이 가능하다.
		
		print();
		//--==>> 클래스 변수 a : 10		
		//		 클래스 변수 a : 10
		//-- 클래스 메소드에서 메소드의 호출은 가능하며,
		//   "클래스명.메소드명()"의 형태로 접근하여 호풀하는 것이 가능하다.
		//    또한, 지금은 같은 클래스 내부에 존재하고 있는 상황이기 때문에
		//    클래스의 이름을 생략하는 것이 가능하다.
		
		//System.out.println("main() → 인스턴스 변수 b : " + b);
		//System.out.println("main() → 인스턴스 변수 b : " + Test10.b);
		//--==>> 에러 발생(컴파일 에러)

		//Test103.write();
		//write();
		//--==>> 에러 발생(컴파일 에러)

		

		// Test103 클래스 기반 인스턴스 생성
		Test103 ob = new Test103();

		//System.out.println("main() → 인스턴스 변수 b : " + b);
		
		// 생성된 인스턴스를 통해 인스턴스 변수에 접근하는 방법
		System.out.println("main() → 클래스 변수 b : " + ob.b);
		//--==>> "main() → 클래스 변수 b : 20

		// 생성된 인스턴스를 통해 인스턴스 메소드 접근(호출)
		ob.write();
		//--==>>클래스 변수 a : 10
		//	    인스턴스 변수 b : 20
		

		// 생성된 인스턴스를 통해 클래스 변수에 접근 
		System.out.println("main() → 클래스 변수 a : " + ob.a);
		//--==>> main() → 클래스 변수 a : 10
		

		// 생성된 인스턴스를 통해 클래스 메소드 접근(호출)
		ob.print();
		//--==>> 클래스 변수 a : 10


		// ※ 클래스 변수나 클래스 메소드는
		//	  "생성된인스턴스명.변수명", "생성된인스턴스명.메소드명()"
		//	  의 형태로도 접근(호출)이 가능하지만
		//    "클래스명.변수명", "클래스명.메소드명()"
		//    의 형태로 접근(호출) 하는것이 일반적이다.

		
		System.out.println("main() → 클래스 변수 a : " + a);
		System.out.println("main() → 클래스 변수 a : " + Test103.a);
		System.out.println("main() → 클래스 변수 a : " + ob.a);
		//--==>> main() →  클래스 변수 a : 10
		//		 main() →  클래스 변수 a : 10
		//		 main() →  클래스 변수 a : 10


		System.out.println();

		// Test103 클래스 기반 인스턴스 생성
		Test103 ob2 = new Test103();

		ob2.a = 10000;		//-- 클래스 변수 초기화
		ob2.b = 20000;		//-- 인스턴스 변수 초기화

		System.out.println("ob2 확인---------------------------");
		ob2.write();
		//--==>>ob2 확인---------------------------
		//		클래스 변수 a : 10000
		//		인스턴스 변수 b : 20000

		System.out.println("ob 확인---------------------------");
		ob.write();
		//--==>>ob 확인---------------------------
		//		클래스 변수 a : 10000
		//		인스턴스 변수 b : 20


	}
}

※ 사용자로부터 년, 월, 일을 입력받아 해당 날짜의 요일을 출력하는 프로그램을 구현한다.                            

   단, 달력 클래스(Calendar)는 사용하지 않는다.                                 
   

   또한, 클래스의 개념을 활용하여 작성할 수 있도록 한다. (WeekDay 클래스 설계) 그리고, 배열의 개념도 적용시켜 작     성할 수 있도록 한다.      

   접근제어지시자의 개념도 확인하여 작성할 수 있도록 한다. 최종적으로 WeekDay 클래스의 설계를 통해 Test102           클래스의 main() 메소드가 정상적으로 프로그램을 실행될 수 있도록 한다.
                                                                             
  실행 예)                                                                     
  년 월 일 입력[공백 입력] : 2020 8 19                                         
                                                                             
  2020년 8월 19일 → 수요일                                                     
  계속하려면 아무 키나 누르세요...                                             
                                                                             
  ※ 1년 1월 1일 → 월요일                                                       
  ※ 윤년 vs 평년, 윤달 vs 평달                                                 
                                                                             
  ※ 윤년의 판별 조건                                                           
    연도가 4의 배수이면서 100의 배수가 아니거나                                
    400의 배수이면 윤년~!!!                                                    
    그렇지 않으면 평년~!!!                                                     
                                                                             
  2013년 12월 12일은 날수로는 735,214          

WeekDay 클래스 설계    

import java.util.Scanner;

class WeekDay
{
	// 주요 변수 선언
	int y, m, d;		//-- 사용자가 입력한 년, 월, 일을 담아낼 변수
	
	// 메소드 정의 → 입력받기
	public void input()
	{
		Scanner sc = new Scanner(System.in);

		System.out.print("년 월 일 입력[공백 입력] : ");	// 2020 8 19
		y = sc.nextInt();
		m = sc.nextInt();
		d = sc.nextInt();
	}

	// 메소드 정의 → 요일 산출하기
	public String week()
	{
		// 각 월의 마지막 날짜(각 월의 최대값)를 배열 형태로 구성
		int[] months = {31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

		// 테스트
		//System.out.println(months.length);
		//--==>> 12

		// 요일 이름에 대한 배열 구성
		String[] weekNames = {"일", "월", "화", "수", "목", "금", "토"};

		// 날 수를 종합할 변수
		int nalsu;

		// 윤년에 따른 2월의 날 수 계산
		// 입력 년도가 윤년이라면... 2월의 마지막 날짜를 29일로 설정
		// 입년 년도가 평년이라면... 2월의 마지막 날짜를 28일로 설정
		if (y % 4 == 0 && y % 100 != 0 || y % 400 == 0) //-- 윤년이라면...
		{
			// 2월의 마지막 날짜를 29일로 설정
			months[1] = 29;
		}
		else											//-- 윤년이 아니라면... (평년이라면...)
		{
			// 2월의 마지막 날짜를 28일로 설정
			months[1] = 28;
		}
		
		// ① 1년 1월 1일 ~ 입력받은 년도의 이전 년도 12월 31일까지의 날 수 계산
		//					-------------
		//						  y
		//					-------------------------
		//                             y-1
		//입력이전년도 * 365 + 입력이전년도 / 4 - 입력이전년도 / 100	+ 입력이전년도 / 400
		nalsu = (y - 1) * 365 + (y - 1) / 4 - (y - 1) / 100 + (y - 1) / 400;
		
		// 테스트(확인)
		//System.out.println("날 수 : " + nalsu);
		// --==>>날 수 : 737424 (2020 8 19 입력 기준)
		// 1. 1. 1 ~ 2019. 12. 31 의 총 날 수

		// ② 입력받은 월의 이전 월 까지의 날 수 계산 후
		//	  이 계산 결과를 1번 결과에 누적하는(더하는) 연산
		for (int i = 0; i < (m - 1); i++)
		{
			nalsu += months[i];
		}
		// 737424 + 31 + 29 + 31 + 30 + 31 + 30 + 31

		// 테스트(확인)
		//System.out.println("날 수 : " + nalsu);
		//--==>> 날 수 : 737637
		// 1. 1. 1 ~ 2020. 7. 31 의 총 날 수

		// ③ 입력받은 일의 날짜만큼 날 수 계산 후
		//    2번 결과에 누적하는(더하는) 연산
		nalsu += d;

		// 테스트(확인)
		//System.out.println("날 수 : " + nalsu);
		//--==>> 날 수 : 737656
		// 1. 1. 1 ~ 2020. 8. 19 의 총 날 수 

		//----------------------- 여기까지 수행하면 날 수 연산 끝~!!!

		
		// 무슨 요일인지 확인하기 위한 연산
		int w = nalsu % 7;		// 전체날수 % 7 == 0 → 일요일
								// 전체날수 % 7 == 0 → 일요일
								// 전체날수 % 7 == 0 → 일요일
								//			  :
		// 테스트
		//System.out.println("요일 : " + w);


		return weekNames[w];
		// 0 → "일"
		// 1 → "월"
		//  :



	}

	//메소드 정의 → 결과 출력하기
	public void print(String day)
	{
		System.out.printf("%d년 %d월 %d일 → %s요일\n", y, m, d, day);
	}
}

main클래스

public class Test102
{
	public static void main(String[] args)
	{
		// WeekDay 기반 인스턴스 생성
		WeekDay wd = new WeekDay();
	
		// 입력 메소드 호출
		wd.input();
		
		// 요일 산출 메소드 호출 및 결과 확인
		String result = wd.week();

		// 출력 메소드 호출
		wd.print(result);
	}

}

// 실행 결과
/*
년 월 일 입력[공백 입력] : 2020 1 13
2020년 1월 13일 → 월요일
계속하려면 아무 키나 누르십시오 . . .
*/

○ 접근제어 지시자

==================================================
지시자   클래스 내부   동일 패키지   상속받은 클래스   이외의 영역
==================================================
private          ○               X                  X                    X
-------------------------------------------------------------------------------
default          ○              ○                  X                    X
-------------------------------------------------------------------------------
protected      ○               ○                 ○                   X
-------------------------------------------------------------------------------
public           ○               ○                 ○                  ○
-------------------------------------------------------------------------------

※ public > protected > default > private

   private 지정자를 쓰면 메소드로만 접근가능

import java.util.Scanner;

class CircleTest2
{	
	// 정보 은닉(Information Hiding)
	// 멤버 변수, 인스턴스 변수, 전역 변수
	// "private" 이라는 접근제어지시자의 선언은
	// 클래스 내부에서만 접근 및 참조가 가능하게 하겠다는 의미
	// int 형 변수 0으로 초기화 지원
	private int r;
	
	//int r;
/*
	// getter / setter 구성

	int getR()
	{
		return r;
	}

	void setR(int r)
	{
		this.r = r;
	}
*/

	void input()
	{
		Scanner sc = new Scanner(System.in);

		System.out.print("반지름 입력 : ");
		r = sc.nextInt();
	}

	double calArea()
	{
		return r * r * 3.141592;
	}
	void write(double a)
	{
		System.out.println("반지름 : " + r);
		System.out.println("넓이 : " + calArea());
	}

}

public class Test101
{
	public static void main(String[] args)
	{
		CircleTest2 ob = new CircleTest2();
		
		//ob.r = 10;
		//System.out.println("원의 반지름 : " + ob.r);
		
		//ob.setR(100);
		//System.out.println("원의 반지름 : " + ob.getR());

		ob.input();

		double result = ob.calArea();
		ob.write(result);
		//--==>>반지름 입력 : 2000
		//		반지름 : 2000
		//		넓이 : 1.2566368E7
		//		계속하려면 아무 키나 누르십시오 . . .

	}
}