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 타입 난수를 리턴

​

​

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

🔅 단 하나의 조건식으로 많은 경우의 수를 처리할 수 있고 표현도 간결

수행 절차

• 조건식을 계산한다.
• 조건식의 결과와 일치하는 case문으로 이동
• 이후의 문장들을 수행
• break 문이나 switch문의 끝을 만나면 switch문 전체를 빠져나감

💡  POINT

     -  break문을 생락하면 case문 사이의 구분이 없어지므로 다른 break문을 만나거나 switch문 블럭 {} 끝을 만날 때까지 나오는 모든 문장들을 수행

    -  제약조건
       a. 조건식 결과는 정수 또는 문자열

       b. case문의 값은 정수 상수만 가능, 중복 X

    -  if문 처럼 중첩 가능

switch (조건식) {
    case 값1 :
        // 조건식의 결과가 값1과 같을 경우 수행될 문장들
        //...
        break;
    case 값2 :
        // 조건식의 결과가 값2과 같을 경우 수행될 문장들
        //...
        break;
    default :
        // 조건식의 결과와 일치하는 case 문이 없을 때 수행될 문장들
        //...
        break; // 생략가능.
}

​2. 반복문

💡 어떤 작업이 반복적으로 수행되도록 할 때 사용

💡 종류 ; for문, while문, do-while문

💡 조건식의 결과가 true이면 참, false면 거짓으로 간주

1) for문

✓ 반복 횟수를 알고 있을 때 적합

  👾  실수 사용 x 정수만 사용하기 ▶️ 계산이 부정확하기 때문

  👾  초기화, 조건식, 증감식 모두 생략 가능

            ▶️  조건식이 생략된 경우, 참으로 간주되어 무한 반복문이 된다.

            ▶️  대신 블럭{} 안에 if 문을 넣어서 특정 조건을 만족하면 for 문을 빠져 나오게 해야 한다.

for문의 구조

for (초기화; 조건식; 증감식) {
    // 조건식이 참일 때 수행될 문장들을 적는다.
}

for문 수행 순서

  📍  초기화 ▶️ 조건식 ▶️ 수행될 문장 ▶️ 증감식 ▶️ 조건식 ▶️ 수행될 문장 ▶️ 증감식 ...

public class MyFor_02 {
	public static void main(String[] args) {
		/* for문의 순서 */
		int sum = 0; // 총 합을 담을 변수. 초기화가 꼭 필요.
		// for (초기값; 조건식; 증감식)
		for (int i = 1; i > 0; i++) { //1부터 10까지의 합
			System.out.println("i = " + i + " sum = " + (sum += i));
			
			// 1) 초기값 실행
			// 2) 조건식 확인
			// 3) 조건식이 참이면 명령문 실행
			
			// 4) 증감식 실행
			// 5) 조건식 확인
			// 6) 조건식이 참이면 명령문 실행
			// 4) 5) 6) 반복
		}	
			// System.out.println(i); // i는 for문에서만 유효
		{ 
			int tmp = 12;
		    System.out.println(tmp);
		}    	
	}
}

2)  중첩 for문

별 출력

public class Ex_03_03 {
	public static void main(String[] args) {
		/* for문을 이용해서 다음과 같이 *를 출력하는 코드를 작성해보세요. 
		 * 
		 **
		 ***
		 ****
		 */
		
		for (int i=1; i<=4; i++) {
			
			for (int j=1; j<=i; j++) {
				System.out.print("*");
				
			}
			System.out.println();
		}
	}
}

구구단 출력

public class MyFor_11 {
	public static void main(String[] args) {
		/* 중첩 for문으로 구구단 출력
		 * for문은 또 다른 for문을 내포할 수 있는데, 이것을 중첩 for문이라고 함.
		 * 이 경우 바깥쪽 for문이 한 번 실핼할 때마다 중첩된 for문은 지정된 횟수만큼
		 * 반복해서 돌다가 다시 바깥쪽 for문이 돌아감.  */
		
		for(int dan = 2; dan <= 9; dan++) { // 바깥 쪽 for문. 8번 반복
			System.out.println("*** " + dan + "단 ***");
			
			for(int times = 1; times <= 9; times++) { // 중첩 for문. 9번 반복
			    System.out.println(dan + " X " + times + " = " + dan * times);
			}
			System.out.println(); // -> 각 단이 끝날 때 넣어줌.
		}
	}
}

주사위 게임

public class Ex_03_01 {
	public static void main(String[] args) {
		/* 2개의 주사위를 던지는 게임이 있다고 가정하자.
		 * 중첩 for문을 이용하여 2개의 주사위의 합이 6이 되는 경우를 출력하는 코드 작성.
		   (1,5) (2,4) (3,3) (4,2) (5,1) */
		
		for (int i = 1; i <= 6; i++) {
			
			for ( int j = 1; j <= 6; j++) {
				if (i+j == 6)
				System.out.println("(" + i + ", " + j + ")");
				// 변수 통상적으로 i 다음에 j 씀.
			}
		}
	}
}

3)  float 타입 카운터 변수

  ✓  for문을 작성할 때 주의할 점은 초기화 식에서 루프 카운터 변수를 선언할 때 부동 소수점을 쓰는 float 타입을 사용 x
         ➡️  0.1은 float 타입으로 정확하게 표현할 수 없기 때문에 x에 더해지는 값이 0.1보다 약간 커서, 루프는 9번 실행
         ➡️  float과 double은 계산이 부정확
  ✓  대안으로 정수로 변환 후 계산 결과 값을 실수로 변환 or 자바에서는 정확한 실수 계산을 위해 Decimal 클래스를 제공

public class MyFor_05 {
	public static void main(String[] args) {
		
		for (float x = 0.1f; x <= 1.0f; x += 0.1f) {
			System.out.println(x);
			/* 0.1
			 * 0.2
			 * 0.3
			 * 0.4
			 * 0.5
			 * 0.6
			 * 0.70000005
			 * 0.8000001
			 * 0.9000001 */
		}
	}
}

4)  for문 동작 시간 구하기

  📍  프로그램의 동작 시간을 구하는 방법은 프로그램 시작 위의 부분에서 시작시간을 구하고, 프로그램이 끝나는 부분에서 종료시간을 구한후 종료시간에서 시작시간을 빼면 프로그램이 동작한 시간을 구할 수 있음

public class MyFor_04 {
	public static void main(String[] args) {
		
	     long startTime = System.currentTimeMillis(); // 시작시간
	     for(int i = 0; i < 1000000000; i++) { // 10억번 반복
	    	 ; // 빈문장 실행
	     }
	     long endTime = System.currentTimeMillis(); // 종료시간
	     
	     System.out.println("시작시간 : " + startTime);
	     System.out.println("종료시간 : " + endTime);
	     System.out.println("소요시간 : " + (endTime - startTime));

	}
}

2) if - else 문

'else' 그 밖의 다른 이라는 뜻이므로 조건식의 결과가 참이 아닐 때, 즉 거짓일 때 else 블럭의 문장을 수행하라는 뜻

실행할 명령문이 간단하면 삼항연산자로 변경 가능

public static void main(String[] args) {
		
    int age = 15;
		
	if (age > 19) {
	    System.out.println("성인입니다");
		System.out.println("성인요금이 적용됩니다");
	} else { // 위의 조건이 거짓일 때만 실행
	    System.out.println("청소년입니다.");
		System.out.println("청소년요금이 적용됩니다.");
	}
	System.out.println("결제를 진행해 주세요.");
}

public static void main(String[] args) {
		
    Scanner scanner = new Scanner(System.in);
	int age;
		
	System.out.println("나이를 입력해주세요.");
    age = scanner.nextInt();
        
    /* 놀이공원의 요금 나이 기준
     * 성인 : 20세 이상
     * 청소년 : 14 ~ 19
     * 어린이 : 9 ~ 13
     * 유아 : 0 ~ 8
     */
        
    // 첫번째 조건에 해당 되지 않으면 다음 조건으로 넘어감.
    // 그렇기 때문에 두번째 조건에서 첫번째 조건과 겹치는 범위는 적지 않아도 됨.
        
    if (age <= 8) { // 0~8
        System.out.println("유아입니다.");
        System.out.println("유아요금이 적용됩니다.");
    }
    else if (age <= 13) { // 9 ~ 13
        System.out.println("어린이입니다.");
        System.out.println("어린이요금이 적용됩니다.");
    }
    else if (age <= 19) { // 14 ~ 19
        System.out.println("청소년입니다.");
        System.out.println("청소년요금이 적용됩니다.");
    }
    else { // 20 ~
        System.out.println("성인입니다.");
        System.out.println("성인요금이 적용됩니다.");
    }
        
    System.out.println("결제를 진행해주세요."); 
        
    // 삼항 연산자를 중첩해서 사용하면 동일한 기능 가능.
    System.out.println(age <= 8 ? "유아입니다. \n유아요금이 적용됩니다." :
        age <= 13 ? "어린이입니다. \n어린이요금이 적용됩니다." :
        age <= 19 ? "청소년입니다. \n청소년요금이 적용됩니다." :
         "성인입니다. \n성인요금이 적용됩니다.");
    
    scanner.close();
}