Bibliothek

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

 프로그램을 구성하는 클래스
 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
		//		계속하려면 아무 키나 누르십시오 . . .

	}
}

 ※ 배열 변수의 복사에는 데이터 복사, 주소값 복수 두 가지 형태가 존재한다.
   주소값 복사 → 얕은 복사 → 원본을 수정하면 복사본에 영향을 미치게 되는 복사 방법.
   (배열 뿐 아니라 모든 참조형 데이터에 해당하는 방법)
 

※ 데이터 복사 → 깊은 복사 → 실제 요소가 들어있는 값에 대한 복사로
   원본을 수정해도 복사본에 영향을 미치지 않는 복사 방법.

주소값 복사의 예)

// Test100.java 파일과 비교~!!!

// 주소값 복사

public class Test099
{
	public static void main(String[] args)
	{
		int[] nums = {10, 20, 30, 40, 50};	//-- 배열의 원본
		int[] copys;						//-- 복사본으로 만들 배열

		int temp;							//-- 실습 진행(테스트)을 위한 임시 변수
		
		//check~!!!
		copys = nums;						//-- 복사~!!!

		temp = nums[0];						//-- temp = 10

		nums[0] = 1000;						//-- nums = {1000, 20, 30, 40, 50}

		//copys 배열의 전체 요소 출력
		for (int i = 0; i < nums.length; i++)
			System.out.print(copys[i] + " ");
		System.out.println();
		//--==>> 1000 20 30 40 50

		System.out.println("temp : " + temp);
	
	}
}

데이터 복사의 예)

// 데이터 복사
//-- int형 배열에 대한 깊은 의미의 복사를 처리하는
//   메소드를 정의하는 형태로 실습을 진행한다.


public class Test100
{
	public static void main(String[] args)
	{
		int[] nums = {10, 20, 30, 40, 50};		//-- 배열 원본

		int[] copys1 = nums;					//-- 얕은 의미의 배열 복사 수행
												//   (주소값 복사)
		int[] copys2 = copyArray(nums);			//-- 깊은 의미의 배열 복사 수행
												//   (사용자 정의 메소드 호출)
		int[] copys3 = (int[])nums.clone();		//-- 깊은 의미의 배열 복사 수행
												//   (자바 제공 → clone() 메소드 호출)

		// 원본 배열 요소의 수정~!!!
		nums[1] = 2;

		for (int i = 0; i < copys1.length; i++)
			System.out.print(copys1[i] + " ");
		System.out.println();
		//--==>> copys1 : 10 2 30 40 50

		for (int i = 0; i < copys2.length; i++)
			System.out.print(copys2[i] + " ");
		System.out.println();
		//--==>> copys2 : 10 2 30 40 50

		for (int i = 0; i < copys3.length; i++)
			System.out.print(copys3[i] + " ");
		System.out.println();
		//--==>> copys3	 : 10 2 30 40 50

		
	}

	// 매개변수로 int 배열 타입을 넘겨받아
	// 이를 복사한 후
	// 복사한 배열을 결과값으로 반환하는 기능을 가진 메소드 정의
	public static int[] copyArray(int[] os)	// {10, 20, 30, 40, 50}
	{
		// 매개변수로 넘겨받은 배열(os)
		// 즉, 원본 배열 만큼의 배열방(메모리 공간, 길이)을 확보한
		// 복사할 배열방 생성
		int[] result = new int[os.length];	// int[] result = new int[5];
	
		// 각각의 원본 배열(os)에 담겨있는 각각의 요소들을 복사 배열(result)에 담아내기
		for (int i = 0; i < os.length; i++)
		{
			result[i] = os[i];
		}

		// 보가한 배열(result) 반환
		return result;



	}
}

 ※ Random 클래스 활용

 사용자로부터 임의의 정수를 입력받아 그 정수의 갯수만큼 난수(1~100)를 발생시켜서 배열에 담아내고
 배열에 담겨있는 데이터들 중 가장 큰 값과 가장 작은 값을 선택하여 결과를 출력하는 프로그램을 구현한다.

 실행 예)
 발생시킬 난수의 갯수 입력 : 6
 (53 17 69 45 10 55 → 무작위로 발생한 정수 형태의 난수들...)
 (int[] arr = {53, 17, 69, 45, 10, 55}; → 배열에 담아내기)
 가장 큰 값 : 69, 가장 작은 값 : 10
 계속하려면 아무키나 누르세요...

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

public class Test098
{
	public static void main(String[] args)
	{
		// Scanner 인스턴스 생성
		Scanner sc = new Scanner(System.in);

		// 안내 메세지 출력
		System.out.print("발생시킬 난수의 갯수 입력 : ");
		int size = sc.nextInt();

		// size 변수에 담아낸 수 만큼의 배열방 만들기
		// (배열 선언 및 메모리 할당)
		int[] arr = new int[size];

		// 무작위 숫자(난수)를 발생시키기 위해서는
		// 난수 발생 전용 객체 필요하다.
		// → "java.util.Random"
		Random rd = new Random();

		// ※ Random 클래스의 "nextInt(int n)" 메소드 
		//-- 0 ~ 매개변수로 넘겨받은 정수  n-1 까지의 수 중
		//	 무작위 정수(난수) 1개를 발생시킨다.

		// 테스트(확인)
		//System.out.println("발생한 난수 : " + rd.nextInt(10));
		// 0 ~ 9 까지의 무작위 정수 1개~!!!

		// 배열 구성(초기화) → 발생한 난수로 배열방에 값을 담아내기
		for (int i = 0; i < size; i++)
		{
			arr[i] = rd.nextInt(100);
			//-- 0 ~ 99 무작위 정수 한 개 발생
			arr[i] = rd.nextInt(100) + 1;
			//-- 1 ~ 100 무작위 정수 한 개 발생
		}
		
		// 테스트(확인) → 구성된 배열의 전체 요소 출력
		/*
		for (int i = 0; i < arr.length; i++)
			System.out.print(arr[i] + " ");
		System.out.println();
		//--==>> 발생시킬 난수의 갯수 입력 : 10
		//		 80 68 31 9 25 40 89 44 93 18
		//		 계속하려면 아무 키나 누르십시오 . . .
		*/

		// 가장 큰 값, 가장 작은 값 확인
		int max, min;		//-- 최대값, 최소값
		max = min = arr[0];	//-- max = min = 80;

		for (int i = 1; i < arr.length; i++)
		{
			if(max < arr[i])
				max = arr[i];	//-- max=93;
			if(min > arr[i])
				min = arr[i];	//-- min 9;
		}

		// 최종 결과 출력
		System.out.printf("가장 큰 값 : %d, 가장 작은 값 : %d\n", max,min);
	}
}

실행 결과

// 실행 결과
/*
발생시킬 난수의 갯수 입력 : 10
가장 큰 값 : 96, 가장 작은 값 : 7
계속하려면 아무 키나 누르십시오 . . .
*/