⚒️  객체지향 이론 기본 개념 : 실제 세계는 사물(객체)로 이루어져 있으며, 발생하는 모든 사건들은 사물간의 상호작용.

  ⚒️  발전 단계 : 기본자료형  →  배열  →  구조체  →  클래스

• 구조체는 서로 다른 타입도 하나에 묶을 수 있도록 함
• 구조체가 발전된 형태(함수까지 포함)가 클래스

70년대 -  C, 변수와 함수, 구조체
80년대 -  C++, 변수와 함수, 구조체, 클래스
90년대 -  Java, only 클래스만… 하지만 클래스안에 변수와 메서드가 있음

​  ⚒️  주요특징

    1.  캡슐화 Encapsulation

        -  객체의 데이터(필드), 동작(메소드)을 하나로 묶고 실제 구현 내용을 외부에 감추는 것

        -  외부 객체는 객체 내부의 구조를 알지 못하며 객체가 노출해서 제공하는 필드와 메소드만 이용할 수 있다

        -  외부의 잘못된 사용으로 인해 객체가 손상되지 않도록 하는 데 의의가 있다

        -  자바 언어는 접근 제한자를 사용하여 캡슐화된 멤버를 노출시킬 것인지 숨길 것인지 결정

    2.  상속 Inheritance

-  부모 객체가 자기가 가지고 있는 필드와 메소드를 자식 객체에게 물려줌

-  코드의 재사용성을 높여준다

-  유지 보수 시간을 최소화 시켜 준다

    3.  다형성 Polymorphism

-  사용 방법은 동일하지만 실행 결과가 다양하게 나오는 성질을 말함

-  자동 타입 변환과 재정의 기술이 필요함  ➡️  상속과 인터페이스 구현을 통해 얻어짐

2)  객체와 클래스

🚀  클래스 Class  -  객체를 생성하기 위한 설계도

• 클래스로부터 생성된 객체를 해당 클래스의 '인스턴스 instance' 라고 부른다
• 클래스로부터 객체를 만드는 과정을 인스턴스화라고 함
• 동일한 클래스로부터 여러 개의 인스턴스를 만드는 것 = 동일한 설계도로 여러 대의 자동차를 만드는 것

​

 ⚒️  ​객체는 모든 인스턴스를 대표하는 포괄적인 의미를 갖고 있으며,  인스턴스는 어떤 클래스로부터 만들어진 것인지를 강조하는 구체적인 의미를 갖고 있다.

​

3)  객체 생성과 클래스 변수 

 🚀  클래스로부터 객체를 생성하려면 객체 생성 연산자인 'new' 가 필요

 🚀  new 연산자 뒤에는 생성자 호출 코드가 오는데, 클래스() 형태를 가진다.

 🚀  객체를 생성시킨 후 객체의 주소를 리턴하기 때문에 클래스 변수에 다음과 같이 대입할 수 있다.

클래스 변수 = new 클래스();

사용 예제

• Student 클래스를 선언하고 StudentExample 클래스의 main() 메소드에서 Student 객체를 생성

public class Student {}

public class StudentExample {
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println("s1 변수가 Student 객체를 참조합니다.");
        
        Student s2 = new Student();
        System.out.println("s2 변수가 또 다른 Student 객체를 참조합니다.");
    }
}

💡  클래스의 두 가지 용도
      - 라이브러리(library) 클래스 : 실행할 수 없으며 다른 클래스에서 이용하는 클래스
      - 실행 클래스 : main() 메소드를 가지고 있는 실행 가능한 클래스
      - Student는 라이브러리 클래스이고 StudentExample은 실행 클래스라고 볼 수 있음. 일반적으로 자바 프로그램은 하나의 실행 클래스와 여러 개의 라이브러리 클래스들로 구성된다. 

 4)  클래스의 구성 멤버

🚀  클래스 선언에는 객체 초기화 역할을 담당하는 생성자와 객체에 포함될 필드와 메소드를 선언하는 코드가 포함된다. 

  1.  필드 field 

     -  선언 형태는 변수 선언과 비슷하지만 쓰임새는 다름

  2. 생성자 constructor 

     -  new 연산자로 객체를 생성할 때 객체의 초기화 역할을 담당.

     -  선언 형태는 메소드와 비슷하지만, 리턴 타입이 없고 이름은 클래스 이름과 동일

  3. 메소드 method

     -  다른 프로그램 언어에서는 함수라고 하기도 하는데, 객체 내부의 함수는 메소드라고 부름

     -  메소드는 객체와 객체간의 상호 작용을 위해 호출

2)  힙(heap)

• 인스턴스가 생성되는 공간.

​3)  호출스택(call stack 또는 execution stack)

• 메서드의 작업에 필요한 메모리 공간을 제공한다. 메서드가 호출되면, 호출된 메서드를 위한 메모리가 할당되며 이 메모리는 메서드가작업을 수행하는 동안 지역변수들과 연산의 중간결과 등을 저장하는데 사용된다.
• 메서드가 작업을 마치면 할당되었던 메모리공간은 반환되어 비워진다.
• 각 메서드를 위한 메모리상의 작업공간은 서로 구별되며, 첫 번째로 호출된 메서드를 위한 작업공간이 호출스택의 맨 밑에 마련되고, 첫 번째 메서드 수행 중에 다른 메서드를 호출하면 첫 번째 메서드의 바로 위에 두 번째로 호출된 메서드를 위한 공간이 마련된다.

💡  후입선출 구조 (LIFO : Last-in, First-out)
     -  제일 상위에 위치하는 메서드가 현재 실행중인 메서드 
     -  이 메서드가 끝나야 먼저 호출된 메서드가 다시 실행하게 됨
     -  반환타입이 있는 메서드는 종료되면서 결과값을 자신을 호출한 메서드(caller)에게 반환한다
     -  caller는 넘겨받은 반환값으로 수행을 계속 진행하게 된다

​

public class MyMethod_08 {

	// main() -> firstMethod() -> secondMethod()
	// 메모리 구조상 secondMethod가 가장 위에 쌓이고, main이 가장 아래에 깔린다고 생각하면 됨.

	public static void main(String[] args) {
	     System.out.println("main(String[] args)이 시작되었음."); //1
	     firstMethod(); // 이 메서드를 호출함. 리턴 값이 있든 없든 이 메서드가 끝나야지 다음 줄로 넘어감.
	     System.out.println("main(String[] args)이 끝났음.");//6
	}
	
    static void firstMethod() {
    	System.out.println("firstMethod()이 시작되었음."); //2
        secondMethod(); // 이 메서드가 끝나야지 다음 줄로 넘어감.
        System.out.println("firstMethod()이 끝났음.");//5
    }
    
    static void secondMethod() {
    	System.out.println("secondMethod()이 시작되었음."); //3
    	System.out.println("secondMethod()이 끝났음."); //4
    }
}

장점

• 메서드의 이름만 보고도 같은 기능을 하겠다는 예측을 쉽게 할 수 있다.
• 메서드의 이름을 절약할 수 있음   ➡️  하나의 이름으로 여러개의 메서드를 정의할 수 있어 이름 짓는데 고민이 줄고, 동시에 사용되었어야 할 메서드 이름을 다른 메서드의 이름으로 사용할 수 있다.

public class MyMethod_06 {

	public static void main(String[] args) {
		
		printGreet(); // 안녕하세요
		printGreet("안녕~!"); // 안녕~!
		printGreet("한수", "잘 지내셨나요?"); // 한수님! 잘 지내셨나요?
		printGreet(3); // 안녕하세요. 3번째 보는거네요.
	}
	
	public static void printGreet() {
		System.out.println("printGreet() 메서드가 실행됩니다.");
		System.out.println("안녕하세요.");
	}
	
	public static void printGreet(String greeting) {
		// 같은 이름의 메서드가 있으나 매개변수가 없음
		System.out.println("printGreet(String greeting) 메서드가 실행됩니다.");
	    System.out.println(greeting);
	}
	
	public static void printGreet(String name, String greeting) {
		// 매개변수가 문자열인 메서드가 있으나 갯수가 다름
		System.out.println("printGreet(String name, String greeting) 메서드가 실행됩니다.");
	    System.out.println(name + "님! "+ greeting);
	}
	
    public static void printGreet(int cont) {
    	// 매개변수가 하나인 메서드가 있으나 데이터 타입이 다름
        System.out.println("printGreet(int cont) 메서드가 실행됩니다.");
        System.out.println("안녕하세요. " + cont + "번째 보는거네요.");
    }
}

Method  =  함수(function) 

👩🏻‍💻  특정 작업을 수행하는 일련의 문장들을 하나로 묶은 것

👩🏻‍💻  기본적으로 수학의 함수와 유사하며, 어떤 값을 입력하면 이 값으로 작업을 수행해서 결과를 반환

👩🏻‍💻  main 메서드는 '규칙'. 이 메서드 안에 실행되기를 기다리는 로직을 위치시켜야 한다. 

​

1)  메서드의 장점과 작성지침

  · 반복적인 코드를 줄이고 코드의 관리가 용이.

  · 반복적으로 수행되는 여러 문장을 메서드로 작성.

  · 하나의 기능을 위해 작성한 여러 코드를 하나의 단어로 표현할 수 있음. (추상화)

  · 하나의 메서드는 한 가지 기능만 수행하도록 작성하는 것이 좋음.

  · 메서드는 특정 동작을 하는 코드이기 때문에 이름을 동사로 시작   ex. getAge ()

​

2)  메서드 용어

  · 인수 (argument) : 메서드에 전달할 입력(input)을 의미

  · 매개변수 (parameter) : 인수를 받아서 저장하는 변수를 의미

  · 반환값 (return) : 메서드의 출력(output)을 의미. 

      ⚡️  return의 기능 1) 값을 반환  2) 함수를 종료 (반복문의 break와 비슷) 

  · 메서드 호출 : 메서드를 실제로 사용하는 것을 의미

사용 예제

   📍  3명의 신장, 체중, 나이의 최대값을 구해서 표시
         ✔️  메서드를 만들면 1) 소스가 줄어들어서 main 메서드의 기본 로직을 읽기 쉽고 2) 재사용을 할 수 있다

public class MyMethod_01 {

    static Scanner scanner = new Scanner(System.in);
    static int getMax(int a, int b, int c) { // a,b,c의 최대값을 반환
    	int max = a;
    	if(b > max) max = b;
    	if(c > max) max = c;
    	return max;
    }
    
    static void inputData(int[] height, int[] weight, int[] age) {
    	  for (int i = 0; i < 3; i++) {
  	    	System.out.print("[" + (i+1) + "] ");
  	    	System.out.print("신장: ");  height[i] = scanner.nextInt();
  	    	System.out.print("   체중: "); weight[i] = scanner.nextInt();
  	        System.out.print("   나이: ");  age[i]  = scanner.nextInt();
  	    }
    }

	public static void main(String[] args) {
		
		// 3명의 신장, 체중, 나이의 최대값을 구해서 표시.
		int[] height = new int[3];  // 신장
		int[] weight = new int[3];  // 체중
		int[] age = new int[3];     // 나이
		
		inputData(height, weight, age);
	    
/*	    // 신장의 최대값을 구한다
	    int maxHeight = height[0];
	    if (height[1] > maxHeight) maxHeight = height[1];
	    if (height[2] > maxHeight) maxHeight = height[2];
	    
	    // 체중의 최대값을 구한다
	    int maxWeight = weight[0];
	    if (weight[1] > maxWeight) maxWeight = weight[1];
	    if (weight[2] > maxWeight) maxWeight = weight[2];
	    
	    // 나이의 최대값을 구한다
	    int maxAge = age[0];
	    if (age[1] > maxAge) maxAge = age[1];
	    if (age[2] > maxAge) maxAge = age[2]; */
	    
	    int maxHeight = getMax(height[0], height[1], height[2]);  // 신장의 최대값
	    int maxWeight = getMax(weight[0], weight[1], weight[2]);  // 체중의 최대값
	    int maxAge = getMax(age[0], age[1], age[2]);  // 나이의 최대
	    
	    System.out.println("신장의 최대값은 " + maxHeight + "입니다." );
	    System.out.println("체중의 최대값은 " + maxWeight + "입니다." );
	    System.out.println("나이의 최대값은 " + maxAge + "입니다." );		

	}
}

public class MyMethod_03 {
	
	static int getMax(int a, int b) { // a,b의 최대값을 반환
		// return이 여러번 나와도 된다.
	    System.out.println("함수 시작");
	    if(a>b) 
	    	return a;
	    else
	    	return b;
	    // System.out.println("함수 종료") -> return 때문에 함수가 종료되기 때문에 출력되지 않음.
	}

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		System.out.print("정수 a : ");
		int a = scanner.nextInt();
		System.out.print("정수 b : ");
		int b = scanner.nextInt();
		
		System.out.println("최대값은 " + getMax(a,b) + "입니다.");
	    scanner.close();
	}
}

 3)  메서드의 선언과 구현

  🚀  메서드는 크게 두 부분 '선언부(header, 머리)'와 '구현부(body, 몸통)'로 이루어져 있다.

반환타입 메서드이름 (타입 변수명, 타입 변수명, ...)
{
  // 메서드 호출시 수행될 코드
}

​

public class ExMethod_02 {

	public int add(int a, int b) {
		int c = a + b;
		return c;
		// return 다음에 위치하는 데이터는 반드시 메서드의 리턴 타입과 일치해야 함.
		// return 3.5; // 리턴 타입과 다른 데이터형을 반환하면 오류가 발생. (자동 형변환은 가능)
	}

	public static void main(String[] args) {
	     int numb1 = 10;
	     int numb2 = 20;
	     int result = 0;
	     
	     ExMethod_02 method = new ExMethod_02();
	     result = method.add(numb1, numb2);
	     System.out.println("두수의 합은 " + result); // 메서드의 반환 값을 저장해서 출력.
	     System.out.println("두수의 합은 " + method.add(numb1, numb2)); // 메서드의 반환 값을 바로 출력
		
	}
}

int result = add(1,2,3);    // 에러. 메서드에 선언된 매개변수의 개수가 다름 
int result = add(1.5, 2.3); // 에러. 메서드에 선언된 매개변수의 타입이 다름

    - 인자의 개수와 순서는 호출된 메서드에 선언된 매개변수와 일치해야 한다.

    - 인자는 메서드가 호출되면서 매개변수에 대입되므로, 인자의 타입은 매개변수의 타입과 일치하거나 자동형변환이 가능한 것이어야 함.

메서드의 실행흐름

• main 메서드에서 메서드 getAge를 호출
• 호출시 지정한 인자들이 메서드 getAge의 매개변수 a,b에 각각 복사(대입) 
• 메서드 getAge의 괄호 {} 안에 있는 문장들이 순서대로 수행
• 메서드 getAge의 모든 문장이 실행되거나 return문을 만나면, 호출한 메서드(main메서드)로 되돌아와서 이후의 문장들을 실행

⚒️   메서드 호출방식

  A.  값에 의한 호출

• 값에 의한 메서드 호출 방식은 메서드 호출 시에 값이 복사되어 전달
• 메서드의 매개변수 타입이 '기본형 데이터'​ 일 때 값에 의한 호출을 함.

💡  값 형식 (Value Type)

     -  변수가 값을 담은 데이터 형식, 스택 메모리 영역과 관련.

     -  코드 블록 안에서 생성된 모든 값 형식의 변수들은 프로그램 실행이 중괄호 "}"를 만나면 메모리에서 제거

public class CallByValue {

    static public int increase(int n) {
    	++n;
    	return n;
    }

	public static void main(String[] args) {
		int var1 = 100;
		int result = increase(var1);
		System.out.println("var1: " + var1 + ", result: " + result);		
	}
}

 

• 메서드 increase() 호출 시에 n이라는 매개변수가 메모리에 생성되어 var1의 값인 100 이 복사되어 처리
• 메서드 실행이 종료되면 매개변수 n은 메모리에서 소멸
• 이 처럼 값에 의한 호출은 호출시 매개변수로 전달되는 값이 복사되어 전달. 따라서 var1의 값은 변하지 않음

 

B.  참조에 의한 호출

• 매개변수의 타입이 참조형 타입일 때 사용, 참조에 의한 호출은 메서드 호출 시 참조 데이터의 위치가 매개변수에 전달
• 값에 의한 호출은 메모리에 동일한 값을 복사 후 사용하지만 참조에 의한 호출은 메모리의 주소를 넘기기 때문에 값을 복사하지 않음

💡  참조 형식 Reference Type

       - 변수가 값 대신 값이 있는 곳의 위치(참조)를 담는 데이터 형식, 힙 메모리 영역과 관련

       - 힙 영역에 데이터를 저장하고, 스택 영역에는 데이터가 저장된 힙 메모리의 주소를 저장

       - 가비지 컬렉터가 프로그램 뒤에 숨어 동작하면서 힙에 더 이상 사용하지 않는 객체가 있으면 그 객체를 쓰레기로 간주하고 수거하는 기능을 함

          ex. class, interface, delegate, object, string

public class CallByRef {
	
	public static void increase(int[] array) {
		/* 배열을 매개변수로 받아서, 원래 저장된 값보다 1이 증가한 값으로 업데이트 */
		for(int i = 0; i < array.length; i++) {
			array[i]++;
		}
	}

	public static void main(String[] args) {
		int[] refArray = {100, 800, 1000}; // 배열 선언 및 초기화. 배열은 참조형 데이터
		
	    System.out.println("메서드 호출 전");
	    for(int i = 0; i < refArray.length; i++) {
	    	System.out.println("refArray[" + i + "]: " + refArray[i]);
	    }
	    
	    increase(refArray); // 리턴이 없음.
	    
	    System.out.println();
	    System.out.println("메서드 호출 후");
	    // 배열은 참조형이라 메서드 호출 후 값이 변경.
	    for(int i = 0; i < refArray.length; i++) {
	    	System.out.println("refArray[" + i + "]: " + refArray[i]);
	    }
	}
}

 

 

  C.  문자열에 의한 호출

• 예외적으로 문자열을 전달하려면 참조형 데이터라도 값에 의한 호출을 함. 값에 의한 호출이기 때문에 값을 변경할려면 변경된 문자열을 리턴하고 호출한 쪽에서 값을 저장하면 됨

public class CallByString {

    public static String setAddress(String addr) {
    	addr = "경기도 수원시 장안구";
    	return addr;
    }
	
	public static void main(String[] args) {
	    String address = " 서울시 강남구 논현동";
	    
	    System.out.println("메서드 호출 전");
	    System.out.println("address: " + address); // address: 서울시 강남구 논현동
	    
	    address = setAddress(address);
	    
	    System.out.println("메서드 호출 후");
	    System.out.println("address: " + address); // address: 경기도 수원시 장안구
		
	}
}

 

 값 복사  VS  참조 복사

public class MyMethod_04 {

	public static void main(String[] args) {
		/* 깊은 복사. 값 복사. 기본형 변수
		 * deep copy
		 * 데이터 자체가 복사된다.
		 * 복사된 두 객체는 완전히 독립적인 메모리를 차지.
		 */
		int a = 1;
		int b = a;
		b++;
		
		System.out.println("a: " + a + ", b: " + b); // a: 1, b: 2
		
		/* 얕은 복사. 참조 복사. 참조형 변수
		 * shallow copy
		 * 값 자체를 복사하는 것이 아니라 주소값을 복사하여 같은 메모리를 가리키기 때문.
		 */
		int[] nums_01 = new int[1];
		nums_01[0] = 1;
		
		int[] nums_02 = nums_01;
		nums_02[0] = 2;
		
		System.out.println("nums_01[0]: " + nums_01[0] + ", nums_02[0]:" + nums_02[0]);
		// nums_01[0]: 2, nums_02[0]:2

	}
}

 

 

​

5)  return 문

• 현재 실행중인 메서드를 종료하고 호출한 메서드로 되돌아간다.
• 반환타입이 void 인 경우, return문 없어도 문제가 되지 않는다  ➡️  컴파일러가 메서드의 마지막에 자동적으로 추가해주기 때문
• 결과로 사용되는 유형 : void, 기본자료형, 클래스형 등

public class ExMethod {

	public void print() {
	    System.out.println("메서드를 호출한다");
	    // 리턴 타입이 없더라도 return을 사용할 수 있음.
	    // 다만 return 다음에 값이 없어야 함.
	    // return의 의미는 이 부분에서 메서드 실행을 종료하고 복귀한다는 의미.
	    // return;
	}
	
	public static void main(String[] args) {
    
	    // 사용할 메서드가 있는 클래스의 인스턴스 선언
		ExMethod method = new ExMethod();
		method.print();
		method.print();
		method.print();

	}
}

  -  반환값으로 주로 변수가 오긴 하지만 위의 코드처럼 'x+y' 수식이 올 수 있다. (수식의 결과가 반환됨)

  -  간단한 메서드의 경우 if문 대신 조건연산자(ex. 삼항연산자)를 사용하기도 함.

매개변수의 유효성 검사

  -  메서드의 구현부{}를 작성할 때, 제일 먼저 해야 하는 일이 매개변수의 값이 적절한 것인지 확인하는 것

       ➡️  타입만 맞으면 어떤 값도 매개변수를 통해 넘어올 수 있기 때문.

  -  적절하지 않은 값이 매개변수를 통해 넘어온다면 매개변수의 값을 보정하던가, 보정하는 것이 불가능하다면 return문을 사용해서 작업을 중단하고 호출한 메서드로 되돌아가야 한다.

​

예제 문제

  📍 밑변이 30, 높이가 10인 사각형의 넓이를 출력하세요
        * 단 메서드 calculator()를 호출해서 출력하세요

public class Ex_01_01 {
	public static void main(String[] args) {
		
		int width = 30;
		int height = 10;
		System.out.println("밑변이 "+ width + " 높이가 " + height + "인 사각형의 넓이는 " + calculator(width,height) + "입니다.");
	
    }
	
	static int calculator(int a, int b) {
    	System.out.println("계산을 시작합니다.");
        int area = a * b; // 밑변 * 높이 = 사각형의 높이
        return area;
	}
}

매개변수는 없는데, 반환 값이 있는 경우

public class MyArray_05 {

	public static void main(String[] args) {
		int[] number = new int[10];
		
		for(int i = 0; i < number.length; i++) {
			number[i] = i; // 배열을 0 ~ 9의 숫자로 초기화한다.
		    System.out.print(number[i] + " "); // 0 1 2 3 4 5 6 7 8 9
		}
		System.out.println();
		
		for(int i = 0; i < 10000; i++) {
			int n = (int)(Math.random() * 10); // 0~9중의 한 값을 임의로 얻는다.
			
			// swap
			int temp = number[0];
			number[0] = number[n];
			number[n] = temp;
		}

		for (int i = 0; i < number.length; i++) {
			System.out.print(number[i] + " ");  // 2 4 8 7 6 0 5 9 1 3 
		}
	}
}

public class MyArray_05_01 {

	public static void main(String[] args) {
		int[] number = new int[45];
		
		for(int i = 0; i < number.length; i++) {
			number[i] = i+1; 
		    System.out.print(number[i] + " "); 
		}
	    
        System.out.println();
	    for(int i =0; i < 10000; i++) {
	    	int n = (int)(Math.random() * 45);
	    	
	    	// swap
	    	int temp = number[0];
	    	number[0] = number[n];
	    	number[n] = temp;
	    }

	    for (int i = 0; i < 6; i++) {
	    	System.out.print(number[i] + " ");
	    }
	}
}

​

로또 중복값 제거

​

 2)  배열의 길이와 인덱스

  🚀  생성된 배열의 각 저장공간을 '배열의 요소(element)'라고 하며, '배열이름[인덱스]'의 형식으로 배열의 요소에 접근한다.

  🚀  인덱스(index)는 배열의 요소마다 붙여진 일련번호

         ➡️  인덱스의 범위는 0부터 '배열길이 -1'까지

         ➡️  인덱스로 상수 대신 변수나 수식도 사용할 수 있다

​score[0] = 0 ;
score[1] = 10;
score[2] = 20;
score[3] = 30;
score[4] = 40;

​* [0],[1],[2],[3],..  : '인덱스'(위치를 알려주는 원리)

int[] score = new int[0];     // 길이가 0인 배열
int[] score = new int[]{};    // 길이가 0인 배열
int[] score = {};             // 길이가 0인 배열, new int [ ] 가 생략됨

public class Ex_01_Array_03 {

	public static void main(String[] args) {
		
        Scanner scanner = new Scanner(System.in);
		
        boolean run = true;  // 반복문의 조건으로 사용 -> 값이 false가 된다면 반복문이 종료
        int studentNum = 0;  // 학생수
        int[] scores = null; // 점수를 입력 받을 빈 배열 생성. 사용자에게 입력받은 학생수를 기준으로 배열 생성.
        
        
        while (run) {
        
            System.out.println("-----------------------------------------------------");
            System.out.println("1.학생수 | 2.점수입력 | 3.점수리스트 | 4.분석 | 5.종료");
            System.out.println("-----------------------------------------------------");
            System.out.print("선택> ");
           
            int selectNo = scanner.nextInt();
          
            if (selectNo == 1) { // 학생수를 입력 받아서 배열 생성 
     
                System.out.print("학생수> ");
                studentNum = scanner.nextInt();
                scores = new int[studentNum];
                
                System.out.println(Arrays.toString(scores));
                
            } else if (selectNo == 2) { // 생성된 배열의 갯수 만큼 점수 입력
            	
                for(int i = 0; i < scores.length; i++) {
                	System.out.print("scores["+i+"] : ");
                	scores[i] = scanner.nextInt();
                }
            	
            } else if (selectNo == 3) { // 입력받은 배열의 값을 출력

            	for(int i = 0; i < scores.length; i++) {
                    System.out.println("score["+i+"] : " + scores[i]);
            	}
            	
            } else if (selectNo == 4) { // 최고 점수, 평균 점수 출력
                
            	int max = 0;
            	int sum = 0;
            	double avg = 0;
            	
            	for(int i = 0; i < scores.length; i++) {
            		max = (max < scores[i]) ? scores[i] : max;
            		sum += scores[i];
        		}
                
        		avg = (double) sum / studentNum; // 평균
        		System.out.println("최고 점수: " + max);
            	System.out.println("평균 점수: " + avg);
            	
            } else if (selectNo == 5) { // run 값 변경
                run = false;
            }
        }
        System.out.println("프로그램 종료");
        scanner.close();
    }
}

public class Exam023 {

	public static void main(String[] args) {
		/* do~while문은 조건이 거짓이라도 적어도 한번은 문장이 출력된다. */
		int num = 100;
		do {
			System.out.println("적어도 한번은 출력되는 문장");
		} while(num < 10);

	}
}

📄   Random random = new Random();

  -  Random 클래스의 인스턴스를 생성하여 random이라는 변수에 저장하는 코드

  -  Random : Java에서 무작위 숫자를 생성하기 위한 클래스로, java.util 패키지에 포함되어 있다. 이 클래스는 난수를 생성하는 다양한 메서드를 제공함.

​  -  random() 메소드는 0.0과 1.0 사이의 double 타입 난수를 리턴

​

​

[ 출처 ; 학원 강의 및 자바의 정석 책 ]