달거북씨의 코딩생활

오늘은 다른 반의 포트폴리오 발표를 참관했다.

하나의 홈페이지를 오롯이 만들어내고 구동시키는 걸 보면서 신기한 감정 반 저걸 어떻게 하지 우려 반이었다.

두근두근♥

1. 반복문

1-1. 반복문에서의 흐름제어

• break : 반복문 안에서 break; 키워드를 만나면 반복을 강제로 종료한다.
• continue : 실행흐름이 증감식으로 강제 이동된다

// 1 ~ 100까지 홀수의 합
// while, continue, break

int sum = 0;
int i = 0;

while(true){
	i++;
    
    if(i%2==0){
    	continue;	// 짝수일 경우 증감식으로 돌아간다.
    }
    
    if(i>100){
    	break;	// i가 100보다 커지면 반복문을 탈출한다.
    }
    
    sum += i;	// 짝수가 위에서 걸러지기 때문에 홀수만 더해진다.
}

2. 배열

• 배열 사용 전
• 프로그램에서 처리하는 값들이 많아질수록, 선언해야 하는 변수의 수가 증가하게 되어서 프로그램의 소스가 더 난해해진다.

• 예. 각 학생의 과목 평균 구하기
  int dooly_kor = 75;
  int dooly_eng = 82;
  int dooly_math = 91;
  System.out.println((dooly_kor+dooly_eng+dooly_math)/3);
  
  int dooly_kor = 75;
  int dooly_eng = 82;
  int dooly_math = 91;
  System.out.println((dooly_kor+dooly_eng+dooly_math)/3);
  
  int dooly_kor = 75;
  int dooly_eng = 82;
  int dooly_math = 91;
  System.out.println((dooly_kor+dooly_eng+dooly_math)/3);
  ▶ 소스가 많이 늘어남

2-1. 배열이란

• 변수를 그룹으로 묶은 형태의 한 종류로서, 사물함 같은 형태를 갖고 있다.
• 하나의 배열 안에는 같은 종류(데이터 형)의 값들만 저장될 수 있다.

2-2. 배열을 만드는 방법

• 배열의 선언
  데이터형[] 배열이름;
• 배열의 생성
  배열이름 = new 데이터형[크기]
• 배열 생성의 예 : 3개의 int형 변수를 저장할 수 있는 배열 생성
  int[] grade;   // 여러 개의 int형 변수를 저장할 수 있는 배열의 선언
  grade = new int[3];   // 배열의 칸을 3칸으로 할당

• 배열의 모양 : 생성된 배열은 사물함과 같이 각각의 칸에 값들이 저장되고, 각각의 칸은 0부터 일련번호가 지정된다(일련번호 = 배열의 인덱스)
• 배열의 선언과 크기 지정에 대한 일괄처리
  데이터형[] 배열이름 = new 데이터형[크기];
  int[] grade = new int[3];
  ▶ int grade[] = new int[3]; > 이렇게도 가능하지만 위 형태로 계속 사용할 예정!
  
  

2-3. 배열에 값을 저장하기

• 배열은 값을 저장할 수 있는 공간일뿐, 그 자체가 값은 아니다.
• 값이 대입되지 않은 경우, 숫자형은 0이 boolean형은 false가 자동으로 대입된다.
• 배열 안에 값을 저장하기 위해서는 인덱스 번호를 사용하여 각각의 칸에 직접 값을 대입해야 한다.
  배열이름[인덱스] = 값;
• 둘리의 점수를 배열로 표현한 예
  int[] grade = new int[3];
  grade[0] = 75;
  grade[1] = 82;
  grade[2] = 91;

2-4. 배열의 크기 설정과 값 할당에 대한 일괄처리

배열의 크기를 지정하면서 괄호{...} 안에 배열에 포함될 각 항목들을 콤마(,)로 나열하면, 배열의 생성과 값의 할당을 일괄처리 할 수 있다. 이 때는 배열의 크기를 별도로 지정하지 않으며, "new 데이터형[]" 부분은 생략 가능하다.
데이터형[] 배열이름 = new 데이터형[]{값1, 값2, 값3, ..., 값n};

                         또는

데이터형[] 배열이름 = {값1, 값2, 값3, ..., 값n};

2-5. 배열값 사용하기

• 배열 안에 저장되어 있는 값들을 사용하여 연산이나 출력 등의 처리를 위해서는 배열에 부여된 인덱스 값을 통해서 데이터에 접근해야 한다.
  배열이름[인덱스];
  grade[0];
• 둘리의 점수 출력하기
  System.out.println(grade[0]);   // 75
  System.out.println(grade[2]);   // 91
  System.out.println(grade[3]);   // error

2-6. 배열과 반복문

• 배열의 특성 : 0 ~ (배열의 크기 -1)만큼의 인덱스 값을 순차적으로 갖는다.
• 특성을 활용한 배열 데이터의 처리
  : 일정한 범위를 갖고 순차적으로 증가하는 인덱스 값의 특성을 활용하는 반복문 안에서 배열의 값을 할당하거나, 할당된 값을 읽어들이는 처리가 가능하다.
  int[] grade = new int[]{100, 100, 90};
  // 배열의 인덱스는 0부터 전체 길이 3보다 작은 2까지이다.([0], [1], [2])
  for(int i=0; i<3; i++){
           // i번째 배열값에 대한 출력 처리
           System.out.println(grade[i]);
  }
  
  

2-7. 배열의 크기(길이)

• 배열의 길이를 얻기 위해서는 "배열이름.length" 형식으로 접근한다.
• grade라는 배열을 생성한 경우 배열의 길이는
  int size = grade.length;
• 배열의 길이값은 주로 반복문의 조건식에서 반복의 범위를 지정하기 위하여 사용된다.
  int[] grade = new int[]{100, 100, 90, 95, 100, 65};
  // 배열의 크기(길이)는 변할 수 있기 때문에 특정 숫자로 지칭하기 보다 grade.length 사용
  for(int i=0; i<grade.length; i++){   
           // i번째 배열값에 대한 출력 처리
           System.out.println(grade[i]);
  }

2-8. 배열의 종류

• 1차 배열
  → 앞에서 살펴본 배열처럼 한 줄만 존재하는 사물함 같이 구성된 배열
  → 행에 대한 개념이 없고, 열에 대한 개념만 존재하기 때문에 "배열이름.length"는 몇 칸인지를 알아보는 기능이 된다.
• 2차 배열
  → 1차 배열의 각 칸에 새로운 배열을 넣는 형태
  → 1차 배열의 각 칸은 행이 되고, 각각의 칸에 추가된 개별적인 배열이 "열"의 개념이 되어"행렬"을 구성하게 된다.
     (▶ 한 마디로 1차 배열이 여러 개 모인 형태)

2-9. 2차원 배열의 생성 방법

• 데이터 타입의 이름 뒤에 대괄호 "[]"를 행과 열에 대하여 각각 지정한다.
  데이터형[][] 배열이름;
• 2차원 배열의 크기 할당
  → 행과 열에 대한 크기를 명시한다
      배열이름 = new 데이터형[행][열];
  → 2차원 배열의 선언과 할당의 일괄처리
      데이터형[][] 배열이름 = new 데이터형[행][열];

// 둘리, 도우너, 코치의 성적 배열로 생성하기

// 배열의 선언과 크기 지정 및 값의 할당에 대한 개별 처리
int[] dooly;
dooly[0] = 75;
dooly[1] = 82;
dooly[2] = 91;

// 배열의 선언과 크기 지정의 일괄처리
int[] douneo = new int[3];
douneo[0] = 88;
douneo[1] = 64;
douneo[2] = 50;

// 배열 생성의 일괄처리
int[] ddochy = new int[]{100, 100, 90};

// 배열 활용
// 각 배열 요소의 값에 대한 합계 구하기
// 합을 할당할 변수 선언
int sum1 = 0, sum2 = 0, sum3 = 0;	// 같은 종류의 변수들은 콤마로 구별하여 한 번에 선언 가능함

// sum1 dooly 합계 반복문
for(int i=0; i<dooly.length; i++){
	sum1 += dooly[i];
}
System.out.println(sum1);

// sum2 douneo 합계 반복문
for(int i=0; i<douneo.length; i++){
	sum2 += douneo[i];
}
System.out.println(sum2);

// sum3 ddoch 합계 반복문 생성 및 출력
for(int i=0; i<ddochy.length; i++){
	sum3 += ddochy[i];
}
System.out.println(sum2);

// 각 과목의 평균 구하기
System.out.println("dooly 평균 : " + sum1/dooly.length);
System.out.println("douneo 평균 : " + sum2/douneo.length);
System.out.println("ddochy 평균 : " + sum3/ddochy.length);

1. 반복문

1-1. for문

• for문은 사람이 직접 처리하기에 부담스러운 반복적인 작업을 처리하기에 매우 용이하다.

• (1) 최초로 초기식을 설정한다.
  (2) 초기식을 설정한 다음에는 조건식을 판단한다.
  (3) 만약 조건식이 참이라면 반복적으로 동작할 구문을 1회 수행한다.
  (4) 반복구문을 수행한 후, 증감식으로 이동한다.
  (5) 증감식을 수행한 후, 다시 조건식으로 이동한다. 여전히 조건식이 참이라면 반복수행을 처리하고,
      그렇지 않다면 for문을 종료한다.

// for문
// 1 ~ 5까지 합
// 1 + 2 + 3 + 4 + 5 = 15

int sum = 0;

// i의 값이 1부터 5까지 증가하는 동안 i의 값을 sum에 누적한다.
for(int i=1; i<=5; i++){
    sum += i;
}
System.out.println(sum);

// 구구단 7단

int multiply = 0;

for(int i=1; i<=9; i++){
	multiply = 7*i;
	System.out.println("7 x " + i + " = " + multiply);
}

1-2. while문

• while문 역시 for문과 마찬가지로 반복적인 처리를 수행하는 문법이다.
• for문은 초기식, 조건식, 증감식을 모두 내장하는 반면, while문은 조건식만을 내장하기 때문에 초기식과 증감식을 외부에 따로 정의해 주어야 한다.

// while문
// 1 ~ 5까지 합

int sum = 0;

int i = 1;
while(i<=5){
	sum += i;
	i++;
}
System.out.println(sum);

// 구구단 7단

int multiply = 0;

int i = 1;
while(i<=9){
	multiply = 7*i;
	System.out.println("7 x " + i + " = " + multiply);
	i++;
}

1-3. do ~ while문

• 조건의 판별을 나중에 수행하는 반복문 형태
• 초기식을 설정한 후 do{...} 안의 문장을 우선적으로 1회 실행하고 조건을 판별하므로, 조건이 참이 아니더라도 최소 1회는 실행된다.

// do ~ while문
// 1 ~ 5까지의 합

int sum = 0;

int i = 1;
do{
	sum += i;
	i++;
} while(i<=5);
System.out.println(sum)

// 구구단 7단

int multiply = 0;

int i = 1;
do{
	multiply = 7*i;
	System.out.println("7 x " + i + " = " + multiply);
	i++;
} while(i<=9);

// while문과 do ~ while문 비교

int max = 100;

while(max>100){
	System.out.println("while문");
}

do{
	System.out.println("do ~ while문");
} while(max>100);



// 콘솔창 출력
do ~ while문

// int max는 100으로 "max는 100보다 크다"는 조건식을 충족하지 않지만, 
   do ~ while문은 일단 한 번 실행하므로 "do ~ while문"이 출력됨

1-4. 무한루프

• 증감식이 설정되지 않거나, 증감식이 수행되더라도 조건식이 거짓이 되지 않는 형태
• (버그 중에서 제일 발생하면 안되는 버그라고 라고라고...)
• 조건식이 항상 참이므로, 반복문이 종료되지 않는다.
• 프로그램이 PC의 자원을 매우 많이 사용하게 되므로, 시스템 다운을 발생시킬 수 있다.
• while문의 무한루프 예
  while(true){
           System.out.println("Hello");
  }
  ▶ 조건식이 항상 참(true)이기 때문에 무한 반복된다.
• for문의 무한루프 예
  for(int i=0; i<10; i--){
           System.out.println("Hello");
           System.out.println(i);
  }
  ▶ i가 0에서 계속 마이너스 되기 때문에 조건식 "i는 10보다 작다"는 항상 참(true)이다. = 무한반복

// for문
// 문제1. 1~50까지 숫자의 합
int sum = 0;
for(int i = 1; i<=50; i++) {
	sum += i;
}
System.out.println(sum);
		
// 문제2. 구구단 2단
// 2 * 1 = 2
// 2 * 2 = 4
// 2 * 3 = 6
// 2 * 4 = 8
// 2 * 5 = 10
// 2 * 6 = 12
// 2 * 7 = 14
// 2 * 8 = 16
// 2 * 9 = 18
int multiply = 0;
for(int i=1; i<10; i++) {
	multiply = 2*i;
	System.out.println("2 * " + i + " = " + multiply);
}
	
    
    
// while문
// 문제1. 10번 찍어 안 넘어 가는 나무 없다.
// 나무를 1번 찍었습니다.
// 나무를 2번 찍었습니다.
// ...
// 나무를 10번 찍었습니다.
// 나무 넘어갑니다.
int i=1;
while(i<=10) {
	System.out.println("나무를 " + i + "번 찍었습니다.");
	i++;
}
System.out.println("나무 넘어갑니다.");
	
// 문제1 강사님 풀이		
int treeHit = 0;
while(treeHit<10) {
	treeHit++;
	System.out.println("나무를 " + treeHit + "번 찍었습니다.");
			
	if(treeHit==10) {
		System.out.println("나무 넘어갑니다.");
	}
}

1-5. 중첩반복문

// 문제1. 1 ~ 10까지 홀수 값의 합

int sum = 0;

for(int odd=1; odd<=10; odd++) {
	if(odd%2!=0) {
		sum += odd;
	} 
}
System.out.println(sum);
		
		
        
// 문제2. 1 ~ 10까지 짝수 값의 합

int sum1 = 0;

for(int even=1; even<=10; even++) {
	if(even%2==0) {
		sum1 += even;
	} 
}
System.out.println(sum1);



/*
 * 문제3.
 * ★★★★★★★★
   ★★★★★★★★
   ★★★★★★★★
   ★★★★★★★★
   ★★★★★★★★
   ★★★★★★★★
   ★★★★★★★★
   ★★★★★★★★
 */
 
for(int i=0; i<8; i++) {
	for(int j=0; j<8; j++) {
		System.out.print("★");
	}
	System.out.println();
}
		
		
      
/*
 * 문제4. 
 * ★★★★★★★★
   ★★★★★★★
   ★★★★★★
   ★★★★★
   ★★★★
   ★★★
   ★★
   ★
 */
		
for (int i = 0; i < 8; i++) {
	for (int j = i; j < 8; j++) {
		System.out.print("★");
	}
	System.out.println();
}
			


/*
 * 문제5.
   ★
   ★★
   ★★★
   ★★★★
   ★★★★★
   ★★★★★★
   ★★★★★★★
   ★★★★★★★★
 */

for (int i = 8; i > 0; i--) {
	for (int j = i; j <= 8; j++) {
		System.out.print("★");
	}
	System.out.println();
}
		


// 문제6. 2단 ~ 9단까지 구구단 출력(2중 for문, 2중 while문)

int multiply = 0;

for(int i=2; i<=9; i++) {
	System.out.println(i + "단");
	for(int j=1; j<=9; j++) {
		multiply = i*j;
		System.out.println(i + "x" + j + "=" + multiply);
	}
	System.out.println();
}
		
int i = 2;
while(i<=9) {
	System.out.println(i + "단");
	
	int j = 1;
	while(j<=9) {
		multiply = i*j;
		System.out.println(i + "x" + j + "=" + multiply);
		j++;
	}
	System.out.println();
	i++;
}

2. 변수의 범위(=변수의 스코프)

2-1. 자신보다 하위 블록으로는 침투할 수 있다.

• 예제1
  int num = 100;
  if(num == 100){
           System.out.println(num);   // 사용가능
  }
• 예제2
  int num = 100;
  for(int i=0; i<10; i++;){
           System.out.println(num + i);   // 사용가능
  }

2-2. 자신이 선언된 블록 밖으로는 빠져나갈 수 없다.

• 예제1
  int num = 100;
  if(num == 100){
           int result = num + 100;
  }
  System.out.println(result);   // error > 변수 result가 if 블록 안에서 생성되었으므로 사용불가
• 예제2
  for(int i=0; i<10; i++){
           ...
  }
  System.out.println(i);   // error > 변수 i가 for문을 위한 괄호 안에서 사용되었으므로 사용불가

2-3. 블록 안에서 선언된 변수는 블록 밖에 존재하는 동일한 이름의 변수와는 이름만 동일할 분, 다른 값으로 인식된다.

• 예제
  int target = 100;
  if(target == 100){
           int num = target + 100;
  } else{
           int num = target - 100;   // 사용가능
  }

1. 연산자

1-1. 논리연산자

두 개 이상의 비교 연산자의 결과나 boolean 값에 대해 추가로 "AND"나 "OR" 연산을 수행하여 결과를 얻는다.

1-2. AND(&&)

• && 연산자는 두 개의 boolean 값을 비교하여 모두 true인 경우만 결과값이 true이다.

• boolean result 1 = true&&true   // true
  boolean result 2 = true&&false   // false
  boolean result 3 = false&&true   // false
  boolean result 4 = false&&false   // false

int num1 = 100;
int num2 = 200;
(num1 <= num2) && (num1 != num2)	// true && true		//true

1-3. OR(||)

• Shift키를 누른 채 원화(또는 백슬래시)키를 두 번 누르면 된다.
• || 연산자는 두 개의 boolean 값을 비교하여 둘 중 하나라도 true이면 결과값도 true이다.

• boolean result 1 = true||true   // true
  boolean result 2 = true||false   // true
  boolean result 3 = false||true   // true
  boolean result 4 = false||false   // false

!true	// F	// 앞에 붙는 느낌표(!)는 not의 의미
!false	// T

int num1 = 100;
int num2 = 200; 

(num1 > num2)	// F
!(num1 > num2)	// T
(num1 != num2) || (num1 >= num2)	// T||F	// T
!(num1 != num2) || (num1 >= num2)	// F||F	// F

int a = 100;
int b = 200;
int x = 5;
int y = 3;
		
boolean result1 = a != b || a == b;	// true || false	// true
boolean result2 = a < b || x > y;	// true || true		// true
boolean result3 = a < b || x < y;	// true || false	// true
boolean result4 = a > b || x > y;	// false || ture	// true 
boolean result5 = a > b || x < y;	// false || false	// false
		
System.out.println("-----------------------------------------------");
		
boolean r1 = a >= b;	// false
boolean r2 = x >= y;	// true
boolean result6 = r1 && r2;	// false && true	// false
boolean result7 = r1 || r2;	// false || ture	// true
		
System.out.println("-----------------------------------------------");
		
boolean success = true;		// true
boolean fail = !success;	// !true	// false

2. 형변환(Casting)

2-1. 형변환

• 변수의 자료형이 변환되는 것을 의미한다.
• 특정 자료형의 값을 다른 자료형읜 변수에 대입할 수 있다.
• 암묵적 형변환과 명시적 형변호나 두 종류가 있다.

2-2. 암묵적 형변환

• 서로 다른 자료형을 연산 혹은 대입하는 경우, java 컴파일러가 자료형을 통일한다. 이 과정에서 발생하는 형변환을 암묵적 형변환이라 한다.
  → long a =100;   // 정수형
  → float b = a;   // 정수형을 실수형에 대입
• 암묵적 형변환은 어떤 변수가 더 큰 범위의 변수로 대입 가능함을 의미한다.
• 암묵적 형변환이 허용되는 범위
  → 암묵적 형변환은 데이터의 손실이 발생하지 않는 범위 내에서만 이루어진다.
  → double형 데이터 20.5를 int에 대입하는 경우에는 0.5에 대한 데이터 손실이 불가피하므로, 에러가 발생된다.

▶ 암묵적 형변환은 작은 그릇에 든 물을 더 큰 그릇으로 옮기는 행위이다. 여기서 물의 손실은 일어나지 않는다.

▶ 정수 long은 8byte, 실수 float은 4byte로 long의 그릇이 더 커보이지만, 기본적으로 실수는 정수보다 더 큰 그릇이다.

▶ 실수의 소수점 자리를 정수가 받아줄 수 없기 때문이다.

short s = 100;	// 100
int i = s;	// 100
long l = i;	// 100
float f = l;	// 100.0
double d = f;	// 100.0

int myage1 = 20;	// 20
double myage2 = myage1;	// 20.0	

// 아무런 에러 없이 형변환이 일어난다.

2-3. 명시적 형변환

• 데이터의 손실을 감수하더라도, 강제로 형변환시키는 형태
  → 자료형 b = (변환할 자료형)a;
• 실수형을 정수형으로 변환하는 경우 소수점 이하 자리는 버려진다.
  → double a = 3.14D;
  → int i = (int)a;   // 3

long ll = 100L;		// 100
// int i = l;		// Type mismatch error > 명시적 형변환 필요
int i = (int)l;		// 100
short s = (shsor)i;	//100

double pi1 = 3.14D;	// 3.14
// int pi2 = pi1;	// Type mismatch error
int pi2 = (int)pi1;	// 3

double a = 10.5D;
float b = 20.5f;

// a+b를 하면 형이 어떻게 바뀔까?
// 1. float 2. double 3. float, double

float f = a + b;	// type mismatch error
/*
* 큰 범위의 변수와 작은 범위의 변수가 연산을 수행하면, 
* 작은 범위의 변수가 큰 범위의 데이터 형으로 암묵적 형변환을 수행한다.
* 그러므로 a+b는 double형의 변수가 되므로, float형의 값에 대입하는 것은 에러가 난다.
*/

float f = (float)a+b;
// 또는
doulbe d = a + b;

3. 조건문

3-1. 조건문이란?

무조건 실행되는 것이 아니라, 특정 조건을 충족할 경우에만 실행되는 구문

3-2. 조건문의 종류

• if문 : 주어진 '조건'이 참(true)일 경우에만 실행된다.
• if ~ else문 : 주어진 '조건'이 참(true)일 경우 if문이 실행되고, 그렇지 않을 경우 else문잉 실행된다.
• if ~ else if ~ else문 : '조건'을 여러 개로 세분화하여 사용하는 if문이다.
• switch문 : 하나의 '값'에 대하여 여러 가지 경우의 수로 나누어 분기한다.
  ▶ 분기점의 그 '분기'다. 분기하다라는 뜻을 찾아보면 '나뉘어 갈라지다'라는 뜻.

3-3. if문

• if문에서 주어진 조건이 참일 경우에 지정된 구문이 실행된다.
  → if(조건){
           ...실행할 구문...
           ...실행할 구문...
           ...실행할 구문...
      }
• 실행할 구문이 한 줄만 있을 경우 괄호{}는 생략가능하다.
  → if(조건)
           ...실행할 구문...
• if문의 조건식
  → 비교식(비교연산자)
  → 논리식(논리연산자)
  → boolean값

// 비교연산자
int myage = 19;

if(myaage == 19){	// true > 실행
	system.out.println("19살 입니다.")	// 19살 입니다.
}
if(myaage != 20){	// true > 실행
	system.out.println("20살이 아닙니다.")	// 20살이 아닙니다.
}
if(myaage > 19){	// false > 실행되지 않음
	system.out.println("성인 입니다.")
}
if(myaage <= 19){	// true > 실행
	system.out.println("학생 입니다.")	// 학생 입니다.
}

// 논리연산자
int point = 75;

/*
* point가 70보다 크고, 80이하이면 "C학점입니다." 출력,
* point가 70이하이고, 80보다 크면 "범위를 벗어났습니다." 출력
*/

// AND(&&) > 두 조건이 모두 참이어야 전제가 참
if(70<point && point<=80){	// true > 실행
	system.out.println("C학점입니다.")	// C학점입니다.
}

// OR(||) > 두 조건 중 하나라도 참이면 전제도 참
if(point<=70 || 80<point){	// false > 실행되지 않음
	system.out.println("범위를 벗어났습니다.")
}

// boolean값
boolean is_korean = false;

if(is_korean == true);{		// false == true	// false
	System.out.println("한국사람입니다.");
}
if(is_korean == false);{	// false == false	// true
	System.out.println("한국사람이 아닙니다.")	// 한국사람이 아닙니다.
}

// 값 자체가 boolean타입이므로 성립된다.
if(is_korean);{		// false
	System.out.println("한국사람입니다.");
}
if(!is_korean);{	// !false	// true
	System.out.println("한국사람이 아닙니다.)	// 한국사람이 아닙니다.
}

3-4. if ~ else문

• 그렇지 않으면?
• if문이 조건이 참일 경우에 실행되는 구문이라면, if문의 조건과 반대되는 경우에 실행되는 구문이 else문이다.
• else문은 독립적으로 실행될 수 없고, 반드시 if문의 뒤에 위치해야 한다.
• → if(조건){
           ...실행할 구문...
      } else{
           ...반대 경우에 실행할 구문...
      }

boolean is_korean = true;

if(is_korean == true){	// if(is_korean)으로만 써도 문제 없다. boolean 타입 true가 조건에 오기 때문에
	System.out.println("한국사람입니다.");
 } else {
 	System.out.println("한국사람이 아닙니다.");
 }

3-5. if ~ else if ~ else문

• 여러 가지 경우의 수를 분기
• if문과 else문 사이에 else if 문으로 두번째 조건, 세번째 조건, …, n번째 조건을 나열할 수 있다.
• else if문은 필요한 만큼 나열할 수 있으며, 필요치 않은 경우 else문은 생략 가능하다.
• → if(1차 조건){
           ...실행할 구문...
  } else if(2차 조건){
           ...실행할 구문...
  } else if(2차 조건){
           ...실행할 구문...
  } else if(n차 조건){
           ...실행할 구문...
  } else{
           ...실행할 구문...
  }

int point = 87;

if(90<point && point<=100){
	System.out.println("A");
} else if(80<point && point<=90){
	System.out.println("B");
} else if(70<point && point<=80){
	System.out.println("C");
} else{
	System.out.println("F");
}

3-6. switch문

• 변수 값에 대한 경우의 수를 처리하는 switch문
• switch문은 하나의 변수(기준값)에 대한 여러가지 case를 정의하는 구문이다.
• if문은 조건식(비교식, 부등식)이 사용될 수 있지만, switch문은 분기 조건이 반드시 일치하는 "값"에 대해서만 처리 가능하다.
• → switch(기준값){
  case 값1 :
           ...실행할 구문...
           break;
  case 값2 :
           ...실행할 구문...
           break;
  case 값 n :
           ...실행할 구문...
           break;
  default :
           ...모든 경우에 충족되지 않을 경우 실행될 기본 구문...
           break;
  }

char grade = 'D';

switch(grade){
case 'A':
	System.out.println("91~100점 사이 입니다.");
    break;
case 'B':
	System.out.println("81~90점 사이 입니다.");
    break;
case 'C':
	System.out.println("71~80점 사이 입니다.");
    break;
default:
	System.out.println("70점 이하입니다.");
    break;
}

// 콘솔창 출력
70점 이하입니다.

// break;이 없는 경우

char grade = 'B';
		
switch (grade) {
case 'A':
	System.out.println("91~100점 사이입니다.");
case 'B':
	System.out.println("81~90점 사이입니다.");
case 'C':
	System.out.println("71~80점 사이입니다.");
default :
	System.out.println("70점 이하입니다.");
}

// 콘솔창 출력
81~90점 사이입니다.
71~80점 사이입니다.
70점 이하입니다.

// break;이 없으면 switch문을 탈출하지 못해 해당 분기부터 switch문 끝까지 다 출력된다.

// char grade 선언, 등급은 A, B, C가 있다.
// A or B or C : Pass 한 번 출력
// A, B, C를 제외한 다른 등급이 올 경우, Not-Pass 한 번 출력

char grade = 'A';

switch(grade){
case 'A':
case 'B':
case 'C':
	System.out.println("Pass");
    break;
default:
	System.out.println("Not-Pass");
    break;
}

//////////////////////////////// if문 사용 /////////////////////////////////////

/*
 * 문제1. 만약 3000원 이상의 돈을 가지고 있으면 택시를 타고 그렇지 않으면 걸어가라.
 */
 
int money = 5000;

if(isMoney >= 3000){
	System.out.println("택시를 타세요.");
} else{
	System.out.println("걸어가세요.");
}
 
 
 
/*
 * 문제2. 만약 3000원 이상 있거나, 카드가 있다면 택시를 타고 그렇지 않으면 걸어가라.
 */
 
int isMoney = 2000;
boolean isCard = true

if(isMoney>=3000 || isCard){
	System.out.println("택시를 타고 가세요.");
} else{
 	System.out.println("걸어가세요.");
 }
 
 
 
/*
 * 문제3. 어떤 특정 정수값 a가 짝수이면 "짝수", 홀수이면 "홀수"를 출력하라.
 */
 
int a = 5

if(a%2==0){
	System.out.println(a + " : 짝수");
} else{
	System.out.println(a + " : 홀수");
}
 
 

/*
 * 문제4. 특정 정수값 a2, b2, c2의 최대값을 구하여라 
 */
 
int a2=21, b2=8, c2=33;
int max = 0;

if(a2>b2 && a2>c2){
	a2 = max;
} else if(b2>c2){
	b2 = max;
} else{
	c2 = max;
}
System.out.println("최대값 : " + max);
 
 
 
/*
 * 문제5-1. 국어, 영어, 수학 점수의 평균이 95점 이상이면 장학생을 출력하여라.
 * 문제5-2. 그리고 국어점수가 70점 이상이면 "국어 합격" 그렇지 않으면 "국어 불합격"을 출력하여라. 
 * 문제5-3. 수학점수가 90점 이상이면 "A학점", 80점 이상이면 "B학점", 70점 이상이면 "C학점", 
 * 		   60점 이상이면 "D학점", 나머지 "F학점"을 출력
 */ 
 
int kor=85, eng=100, math=70;
int avr = (kor+eng+math)/3;

if(math>=95){
	System.out.println("장학생");
}

if(kor>=70){
	System.out.println("국어 합격");
} else{
	System.out.println("국어 불합격");
}

if(math>=90){
	System.out.println("A학점");
} else if(math>=80){
	System.out.println("B학점");
} else if(math>=70){
	System.out.println("C학점");
} else if(math>=60){
	System.out.println("D학점");
} else{
	System.out.println("F학점");
}
 
 

///////////////////////////// switch-case문 사용 //////////////////////////////////

/*
 * 문제1. 1은 "축구", 2는 "농구", 3은 "야구", 4는 "배구", 그 외는 "배트민턴"을 출력
 */
 
 int answer = 4;
 
 switch(answer){
 	case 1:
    	System.out.println("축구");
        break;
    case 2:
    	System.out.println("농구");
        break;
    case 3:
    	System.out.println("야구");
        break;
    case 4:
    	System.out.println("배구");
        break;
    default:
    	System.out.println("배드민턴");
        break;
 }
 
 
 
/*
 * 문제2. 숫자가 3이면 "안녕"이 세줄, 숫자가 2이면 "안녕"이 두줄, 숫자가 1이면 "안녕"이 한줄,
 * 		 그 외는 "잘가"를 출력
 */
 
 int num = 3;
 
 switch(num){
 	case 3:
    	System.out.println("안녕");
    case 2:
    	System.out.println("안녕");
    case 1:
    	System.out.println("안녕");
        break;
    default:
    	System.out.println("잘가");
 }

앞으로 우선 국비수업 들은 거 정리하고 자바 기초 수업 들었던 거 정리할 예정!

1. 변수

1-1. 문자열 데이터

• 참조변수 : 프로그램 코드에서 "문장"을 표현하기 위해 사용되는 데이터 값

1-2. String

• 문자열을 표현하기 위한 자료형(S첫글자 대문자 주의!)
• 글자 수에 상관없이 쌍따옴표("")로 묶인 내용을 할당할 수 있다.
• 숫자값의 경우 쌍따옴표로 묶이게 되면 문자열로 취급되므로, 숫자와 문자열을 분명하게 구별해야 한다.

1-3. 변수의 사용방법

• 변수를 사용하는 방법은 "선언"과 "할당"의 두 영역으로 구분된다.
• 변수의 선언 : 선언은 데이터형과 사용하고자 하는 변수의 이름을 지정한 후, 세미콜론(;)으로 한 라인을 종료한다.
  → 데이터형 변수이름;
  → int num1;
• 변수의 할당 : 선언된 변수에 원하는 값을 대입하는 과정을 의미한다. 값의 대입은 대입연산자(=)를 사용하여, 우변에서 좌변으로 대입된다.
  → 변수 이름 = 값;
  → num1 = 100;
• 선언과 할당의 통합
  → 데이터형 변수이름 = 값;
  → int num1 = 100;

// 변수의 선언
int num1;

// 변수의 할당
num1 = 100;
System.out.println("num1 : " + num1);	// num1 : 100

// 변수의 재할당
num1 = 200;
System.out.println("num1 : " + num1);	// num1 : 200

int num2 = 200;
System.out.println("num2 : " + num2);	// num2 : 200

1-4. 문자열 데이터

• String형의 변수를 선언하고, 쌍따옴표로 묶인 값을 대입한다.
• 빈 문자열이나 공백도 문자열 데이터이다.
  → String msg = "안녕하세요 자바";   // 문장을 표현, 공백 포함
  → String blank = "";   // 빈 문자열 값 가능
  → String age = "25";   // 숫자값이 쌍다옴표로 묶였다면 문자열이다.
• 문자열 데이터의 덧셈 : 문자열 + 문자열은 두 문장을 하나로 합쳐준다.
  → String language = "JAVA";   // JAVA
  → String language = "JA" + "VA"   // JAVA
• 문자열 + 기본 자료형 : 기본 자료형의 데이터가 문자열로 변환되고, 두 문장이 합쳐진다.
  → int age = 20;
  → String name = "자바학생";
  → String result = name + age   // 자바학생20

1-5. 변수 명명 규칙

• 변수 이름은 영문, 숫자, "_", "$"만 사용 가능하다.
• 변수 이름의 첫 글자는 숫자로 시작될 수 없다.
• 대/소문자를 엄격하게 구별하므로 오타에 주의해야 한다.
• 자바에서 사용하는 예약어(키워드)를 사용할 수 없다.

• ex. myName, my_name, my_phone, userInput, userPassword 직관적이어야 한다★★★
• 클래스 명명 규칙도 변수 이름의 규칙과 동일하다.

1-6. 값의 할당 방법

• boolean은 true(참), false(거짓) 중 한 가지만 갖는다.
  → boolean isKorean = true;
  → boolean isJapanes = false;
• char는 홀따옴표('')로 감싸진 한 글자만 대입할 수 있다.
  → char first = '냥';
• long, float, double은 다른 데이터 형과의 구별을 위해 값 뒤에 데이터 형의 첫 글자를 접미사로 가질 수 있다. 접미사는 대/소문자를 가리지 않지만 가급적 대문자로 사용하는 것이 좋다.
  → long money = 50000000000L;
  → float PI = 3.14F;
  → double lat = 128.32452D;
• 생성된 변수는 다른 변수에 대입될 수 있다.
  → int num1 = 100;
  → int num2 = num1;

// 선언 + 할당 + 접미사의 사용
long num3 = 1234567890000000L;
double num4 = 128.D;
float num5 = 3.14F;

// 다음과 같이 출력하기
// num3 : 1234567890000000
// num4 : 128.
// num5 : 3.14
System.out.println("num3 : " + num3);
System.out.println("num4 : " + num4);
System.out.println("num5 : " + num5);

byte t = 100;
short s = 250;
char c = '가';
boolean b = true;
System.out.println("t : " + t);	// t : 100
System.out.println("s : " + s); // s : 250
System.out.println("c : " + c);	// c : 가
System.out.println("b : " + b);	// b : true

1-7. 변수 사용의 제약

• 반복하여 다른 값이 할당될 수 있지만, 선언은 중복불가
  → int num1 = 100;
  → num1 = 200;
  → num1 = 300;
  → int num1 = 400;   // error > 이미 선언된 변수를 다시 선언할 수 없다.
• 선언되지 않은 변수는 사용할 수 없다.
  → num2 = 300;   // error > 변수를 선언할 땐 타입을 붙여주어야 한다. int num2 = 300;
• 값이 대입되지 않은 변수는 다른 변수에 대입하거나 출력할 수 없다.
  → int num1;
  → int num2 = num1;   // error > 할당되지 않은 변수를 대입할 수 없다.
  → system.out.println(num1);   // error > 할당되지 않은 변수를 출력할 수 없다.

1-8. 상수

• 변하지 않는 수
• 변수와 마찬가지로 메모리상에 존재하지만, 값이 변경될 수 없는 데이터
• final 키워드를 사용하여 선언된 변수는 상수로 생성된다. > 다른 값을 재할당할 수 없다.
  → final int age = 20;
  → final long money = 12000000L;
  → final float PI + 3.14F;
• 메모리 상에 접근은 가능하지만, 할당한 값을 변경할 수는 없다.(읽기 전용)

// 일반 변수
int width = 100;

// 상수
final double PI = 3.14D;

System.out.println("width : " + width);	// width : 100
System.out.println("PI : " + PI);	// PI : 3.14

// 값의 변경
width = 200;
// PI = 3.141582D;	// error > 상수에 다른 값을 재할당 할 수 없음
System.out.println("width : " + width);	// width : 200
System.out.println("PI : " + PI);	// PI : 3.14

2. 연산자

2-1. 연산자란?

프로그램에서 연산을 수행하기 위하여 사용되는 특수기호들

2-2. 연산자의 종류

• 대입연산자(=) : 변수에 숫자나 문자열 등의 자료를 입력하거나 연산 결과를 다른 변수에 할당한다.
• 사칙연산자 : 더하기(+), 빼기(-), 곱하기(*), 나누기(/), 나머지(%)
• 단항연산자 : 변수에 대한 연산 결과를 다시 자기 자신에게 적용하는 경우 사용한다.
• 증감연산자 : 특정 변수에 저장되어 있는 값을 1씩 증가, 감소시킬 경우 사용한다.
• 비교연산자 : 두 개의 변수값 간의 관계를 비교하고 참(true), 거짓(false)의 결과를 반환한다.
• 논리연산자 : 좌변과 우변을 논리연산하고 참일 때는 true, 거짓일 때는 false 값을 반환한다.

2-3. 사칙연산자

• 일반적인 덧셈(+), 뺄셈(-), 곱셈(*), 나눗셈(/, %)을 수행한다.
• 사칙연산의 결과는 대입연산자를 통하여 다른 변수에 대입될 수 있다.
  → int num1 = 10-5;
• 정수(byte, short, int, long)와 실수(float, double)의 연산시에는 정수가 실수의 형태로 자동 변환되어 처리되기 때문에, 결과는 실수가 된다.
• 나눗셈 주의사항 : 10 나누기 3을 할 때, 몫3, 나머지가1 계산되어짐에 따라, 나눗셈은 두 개의 연산자로 구분된다.
  → 10/3 = 나눗셈의 몫만을 취하여 결과값은 "3"
  → 10%3 = 나눗셈의 나머지만을 취하여 결과값은 "1"이 된다.
• 연산자의 우선 순위 : 곱셈(*), 나눗셈(/, %)은 덧셈(+), 뺄셈(-)보다 우선한다. 여러 연산자를 복합적으로 사용할 경우, 괄호로 묶여 있는 곳이 우선한다.
  → 3 + 5 / (10 - 5)
  → 3 + 5 / 5
  → 3 + 1
  → 4 

int num1 = 12;
int num2 = 8;

// +
int result1 = num1 + num2;

// -
int result2 = num1 - num2;

// *
int result3 = num1 * num2;

// /
int result4 = num1 / num2;

// %
int result5 = num1 % num2;

System.out.println("result1 : " + result1);	// 20
System.out.println("result2 : " + result2);	// 4
System.out.println("result3 : " + result3);	// 96
System.out.println("result4 : " + result4);	// 1
System.out.println("result5 : " + result5);	// 4

// 나눗셈 - 0으로 나누기
int num = 100;
int zero = 0;
int result6 = num / zero;

System.out.println(result6);	// error > 0으로는 나눌 수 없다.

2-4. 단항연산자

• 어떤 변수(x)의 값에 대한 계산 결과를 다시 자기 자신에게 대입하고자 하는 경우의 약식 표현이다.
  → int x = 100;
  → x = x + 5; > 단항연산자 > x += 5;
• 단항연산자는 모든 사칙연산자에 표현 가능하다 : +=, -=, /=, %=

int source = 100;

source += 100;	// source = source + 100;	// 100 + 100 = 200
source -= 50;	// source = source - 50;	// 200 - 50 = 150
source *= 2;	// source = source * 2;		// 150 * 2 = 300
source /= 100;	// source = source / 100;	// 300 / 100 = 3
source %= 2;	// source = source % 2;		// 3 % 2 = 1

System.out.println("source : " + source);	// source : 1

2-5. 증감연산자

• 단항연산자로 표현할 수 있는 식에서 계산 대상 값이 1인 경우, 덧셈과 뺄셈에 대해서는 다시 한 번 축약할 수 있다.
• 덧셈의 경우
  → x = x + 1;
  → x += 1;
  → x++;
  → ++x;
• 뺄셈의 경우
  → x = x - 1;
  → x -= 1;
  → x--;
  → --x;
• x++와 ++x의 차이 : 증감연산자는 그 자체가 다른 연산식의 피연산자로 사용될 수 있다. 이 때, 증감연산자의 표시 위치에 따라 결과가 서로 다르게 적용된다.
• x++ : 증감연산자가 뒤에 표시되는 경우, 현재 x의 값을 먼저 수식에 적용하고, 나중에 x에 대한 1 증가 처리를 한다.
  → int a = 100;
  → int x = 1;
  → int y = a + ++x;
  → y=101, x=2
• ++x : 증감연산자가 앞에 표시되는 경우, 먼저 현재 x의 값을 1 증가시킨 후, 그 결과를 수식에 적용한다.
  → int a = 100;
  → int x = 1;
  → int y = a + x++;
  → y=102, x=2

int plus_num = 1;
plus_num = plus_num + 1;
plus_num += 1;
plus_num++;
++plus_num;
		
System.out.println("plus_num : " + plus_num);	// plus_num : 5
		
// //////////////////////////////////////////
System.out.println("-----------------------");
		
int minus_num = 5;
minus_num = plus_num - 1;
minus_num -= 1;
minus_num--;
--minus_num;
		
System.out.println("minus_num : " + minus_num);	// minus_num : 1

2-6. 비교연산자

• 같다, 다르다, 크다(초과), 크거나 같다(이상), 작다(미만), 작거나 같다(이하)에 대한 비교를 수행하는 연산자
  → 같다 ==
  → 다르다 != > 프로그래밍에서 느낌표(!)는 부정의 의미 not을 뜻한다.
  → 초과 >
  → 이상 >=
  → 미만 <
  → 이하 <=
• 주어진 식이 참인지 거짓인지만 판별 가능하므로, 연산 결과는 boolean 값으로 생성된다.
  → int x = 100;
  → int y = 1;
  → boolean result = x != y;   // true

int num1 = 123;
int num2 = 456;

boolean result1 = num1 == num2;
boolean result2 = num1 != num2;
boolean result3 = num1 > num2;
boolean result4 = num1 <= num2;

System.out.println(result1);	// false
System.out.println(result2);	// true
System.out.println(result3);	// false
System.out.println(result4);	// true

포스팅 발행 순서가 약간 이상한데, 여튼 오늘 첫 국비 수업을 들었다.

5개월 동안 java로 시작해 dbms, html, css, javascript, jQuery, jsp, SpringBoot, C언어까지 배운다고 한다.

대학 학부 과정을 5개월 안에 때려넣다 보니 이것저것 많은데, 모든 것에 시간을 공평히 할애할 수 없어 중점으로 배우는 것과 상대적으로 약하게 다루는 것이 있을 수 밖에 없다.

java, jsp, SpringBoot가 매우 중요하고 상세히 다룰 예정인 것 같았다.

최대한 프로젝트와 발표를 많이 하게끔 하신다고 하셨는데, 일단 예정된 프로젝트는 아래와 같다.

java 개인 프로젝트, jsp 팀 프로젝트, SpringBoot 팀 프로젝트

먼저 이 길을 가고 있는 친구 왈 java 프로젝트를  팀플로 했을 때도 힘들었다고... 그래 뭐 안되면 밤 새서 하면 되지^^

1. 프로그래밍 언어

1-1. 프로그래밍 언어란?

프로그래밍 언어란 주어진 어떤 문제를 해결하기 위해 인간과 컴퓨터 사이에서 의사소통을 가능케 하는 인공적인 언어이다.

이 언어를 통해 사용자는 컴퓨터에게 일련의 일을 시키는 명령어들의 집합체인 프로그램을 작성할 수 있다.

1-2. 프로그래밍 언어의 종류

• 기계어 : 컴퓨터가 이해하는 언어로서 2진수의 집합으로 구성되어 있다.
• 고급언어 : 사람이 이해할 수 있는 수준의 언어. 기계어로 변환되어야만 프로그램 형태로 실행하는 것이 가능하다.(C, C++, JAVA 등)

1-3. JAVA

• 운영체제에 독립적 : JVM이 설치된 환경이라면 어디서든지 실행 가능함
• 객체지향 언어 : 상속, 캡슐화, 다형성 / 코드의 재사용 및 유지보수에 용이함
• 자동 메모리 관리 : Garbage Collector가 자동으로 메모리를 관리해 준다.
• 네트워크, 분산처리, 멀티스레드 : 시스템과 관계없이 네트워크, 분산처리, 멀티스레드 구현을 위한 손쉬운 API 제공

(운영체제에 독립적, 객제지향 언어, 자동 메모리 관리는 기술면접에 많이 나오는 내용)

용어가 어렵기는 하나 나중에는 다 이해할 수 있을 거라 하셨다!

1-4. JVM

• 자바 가상 머신(Java Virtual Machine)
• 컴파일된 자바 바이트 코드를 실행시켜주는 소프트웨어
• 자바 프로그램은 JVM이 설치된 환경이라면 운영체제나 하드웨어에 종속되지 않고 실행이 가능하다.
• 운영체제로부터 독립적

1-5. JAVA 설치

• 자바 설치 여부 확인
  - window + R → cmd → java -version : 명령 프롬프트에서 java 버전 확인
• 자바 1.8 버전 설치
  https://turtlemoon.tistory.com/14
  

(그 외 알아두면 좋을 거 : window + R →  notepad 메모장, clac 계산기)

1-6. JRE

• 자바 실행환경(Java Runtime Environment) →개발 되어있는 것을 실행하는 것
• JRE = JVM + Library classes
• JRE는 JVM이 자바 프로그램을 동작시킬 때 필요한 라이브러리 파일들과 기타 파일들을 가지고 있다.
• JRE는 JVM의 실행환경을 구현했다고 할 수 있다.

1-7. JDK

• 자바 개발도구(Java Development Kit) → 개발도 할 수 있고 실행도 할 수 있음
• JDK = JRE + Development Tools
• JDK는 JRE + 개발을 위해 필요한 도구(javac, java 등)들을 포함한다.

1-8. Eclipse

• 통합개발환경(IDE; Integrated Development Environment)의 하나
• 코딩, 컴파일, 배포, 디버그 등 프로그램 개발에 관련된 모든 작업을 하나의 프로그램 안에서 처리할 수 있도록 환경을 제공하는 소프트웨어이다.
• Eclipse외에도 IntelliJ, VScode 등이 있음

2. 주석

2-1. 주석문이란?

• 프로그램 소스코드 안에서 개발자의 필요에 따라 명시하는 설명문
• 주석은 프로그램으로 컴파일되지 않는다.
• 특정 명령문이 실행되지 않도록 차단하는 용도로 사용할 수 있다.

2-2. 주석문의 종류

• 한 줄만 처리하는 주석문 : // 가 앞에 명시된 라인은 주석으로 인식된다.
• 여러 줄을 처리하는 주석문 :
  /*
  이 블록 안에서는 여러 라인을 주석으로 처리할 수 있다.
  */

3. 단축키

• Ctrl + Shift + + : 글자크기 크게
• Ctrl + Shift + - : 글자크기 작게(숫자키패드 쪽 - 눌러야 함)
• Ctrl + Space bar : 소스 자동완성
• sysout + Ctrl + Space bar : System.out.prinln() 자동완성
• Ctrl + M : 소스 코드 화면 확대/축소
• Ctrl + D : 소스 코드 한 줄 삭제
• Ctrl + Shift + F : 소스의 줄 맞춤과 들여쓰기를 자동으로 처리
• Ctrl + Z : 기존 소스코드로 역방향 원상복구
• Ctrl + Y : 기존 소스코드로 정방향 원상복구
• Ctrl + Alt + 아랫방향키 : 소스코드 복사
• Alt + 아랫방향키 : 소스코드 이동

4. 변수

Java에서도 다양한 종류의 자료를 표현할 수 있는 값을 변수라고 부르며, 일반적으로 웹페이지에서 처리하고자 하는 "데이터"에 해당한다.

4-1. 자료형(data type)

• 프로그래밍 언어에서 변수의 종류를 구별하기 위해 사용되는 키워드
• 자바에서 제공되는 자료형의 종류에는 총 8가지가 있으며, 이를 기본 자료형(Privitice Data Type)이라 한다.

4-2. 자료형이 가지는 의미

• 모든 변수는 컴퓨터의 메모리 영역에 생성된다.
• 일반적으로 메모리란, PC에서 설치하는 RAM을 의미한다.
• 4byte의 크기를 갖는 변수값 하나를 생성할 경우, PC의 RAM에서 해당 용량만큼 사용하게 된다.
• 변수는 RAM의 크기를 넘지 않는 범위 안에서만 생성할 수 있다. (용량을 넘어서는 경우 OutOfMemory 에러 발생)

실습