(1) do ~ while문 : 선실행, 후조건, 최소 한번은 실행해야 하는 code

형식)

do {

실행문;

} while(조건식);

 

* while문과 비교

  • 0열 선택0열 다음에 열 추가
  • 1열 선택1열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가
  • 1행 선택1행 다음에 행 추가
  • 2행 선택2행 다음에 행 추가
  • 3행 선택3행 다음에 행 추가

셀 전체 선택

열 너비 조절

행 높이 조절

while

do ~ while

선조건, 후실행

선실행, 후조건

 

반복횟수가 0이어도, 조건에 상관없이 무조건 한번은 실행됨

사용자가 입력한 수의 팩토리얼을 구하는 프로그램

메뉴를 나타내어 사용자의 입력을 처리하는 프로그램

(사용자의 입력을 받은 후에 계속 루프를 돌 것인지 판단할 때 사용)

public class DoWhileTest{
	public static void main(String[] args) {
		int x = 0;
		do{
			x = (int )(Math.random() *3);
			System.out.println("x :" + x);
		}
		while (x!=0); //0이 되면 종료
	}
}

- 로또 do~while문으로 풀기

/*while문은 앞에 난수발생을 반복해서 써줘야 하지만, 
do ~ while문은 선실행, 후조건이기 때문에 앞에서 초기화값을 지정하지 않아도 ok~*/

public class Lotto2{
	public static void main(String[] args) {
		int gameCnt = 5;
		System.out.println("===== 금주의 예상번호 =====");
		int n1,n2,n3,n4,n5,n6;
		for (int i = 1;i <=gameCnt ;i++ ){
			n1 = (int) (Math.random() * 45 + 1);
			do{
				n2 = (int) (Math.random() * 45 + 1);
			}
			while (n1 == n2);
		
			do{
				n3 = (int) (Math.random() * 45 + 1);
			}
			while (n1 == n3 || n2 == n3);
		
			do{
				n4 = (int) (Math.random() * 45 + 1);
			}
			while (n1 == n4 || n2 == n4 || n3 == n4);
		
			do{
				n5 = (int) (Math.random() * 45 + 1);
			}
			while (n1 == n5 || n2 == n5 || n3 == n5 || n4 == n5);
			
			do{
				n6 = (int) (Math.random() * 45 + 1);
			}
			while (n1 == n6 || n2 == n6 || n3 == n6 || n4 == n6 || n5 == n6);
			
			System.out.println(i + "게임 : " + n1 + "  " + n2 + "  " + n3 + "  " + n4 + "  " + n5 + "  " + n6);
			}	 
		}
	}

- 숫자 야구게임 (1번과 2번까지만 배움... 추후에 완성시키는 걸로~~)

/*
1. 컴이 서로 다른 3자리수를 발생 
	- 첫자리는 0이 되면 안된다.
	- 나머지는 0~9중의 난수.
2. 내가 입력한 수를 3개로 분리 (유효성검사 - 입력값이 적절한지)
3. 컴과 내가 입력한 수를 비교
 3-1. 숫자와 자리까지 맞으면 strike
 3-2. 숫자만 맞고 자리가 틀렸으면 ball
4. 결과 출력
 4-1. strike가 3이면.. xxx는 정답입니다.
 4-2. strike가 3이 아니면... xxx는 x스트라이크 X볼입니다.
*/

public class BaseBallGame{
	public static void main(String[] args) {
		int myNum = 729;
		int c1, c2, c3;
		int m1 = (myNum /100);
		int m2 = (myNum % 100 /10);
		int m3 = (myNum % 10);
		
		do{
			c1 = (int) (Math.random()*10);
		}
		while (c1 == 0);

		do{
			c2 = (int) (Math.random()*10);
		}
		while (c1 == c2);

		do{
			c3 = (int) (Math.random()*10);
		}
		while (c1 == c3 || c2 == c3);

		System.out.println("컴 : " +c1 + " " +c2+ " " +c3);//컴 : x x x
		System.out.println("나 : "+m1 + " " +m2+ " " +m3);//컴 : 7 2 9
		
	}
}

 

(2) break문 : 반복문인 for, while, do~while문을 실행 중지시킬 때 사용 (if문과 사용)

: if문의 조건문이 true라면, 아예 반복문을 빠져나오도록 설정!!

 

public class BreakExample{
	public static void main(String[] args) {
		while(true) {
			int num = (int) (Math.random()*6)+1;
			System.out.println(num);
			
			if (num == 6){ //6이 나오면 멈추고 while문을 빠져나가 "프로그램 종료"를 출력하라.
				break;
			}
		}
		System.out.println("프로그램 종료");
	}
}

 

(3) continue문 : 반복문인 for, while, do~while문에서만 사용 (if문과 사용)

if문의 조건문이 true라면 continue 아래는 실행되지 않고, 위로 반복문을 찾아 올라간다.

- for문 : 증감식으로 이동

- while, do~while문 : 조건식으로 이동

 

//무한루프

public class EtcTest{
	public static void main(String[] args) {
		boolean b = true;
		while (b) {
			int x = (int) (Math.random() *5); // 0~4
			if (x == 0){
				b = false;
			} else {
				System.out.println("10 / x :" + 10 / x);
			}
		}
		System.out.println("---------------------");
		while (true){
			int x = (int) (Math.random() *5);
			if (x == 0){
				System.out.println("0이 나와서 종료합니다.");
				break; //반복문을 빠져나오는 break, 주로 if문이랑 같이 쓰임
			}
			System.out.println("10 / x :" + 10 / x);

		}

		System.out.println("---------------------");
		for (int i = 0;i<10 ;i++ ){
			int x = (int) (Math.random() *5);
			if (x == 0){
				System.out.println("0이 나와서 종료합니다.");
				break;
			}
			System.out.println(i + 1 + ". 10 / x :" + 10 / x);
		}

		System.out.println("---------------------");
		for (int i = 0;i<10 ;i++ ){
			int x = (int) (Math.random() *5);
			if (x == 0){
				System.out.println("0이 나와서 다음으로 진행합니다.");
				continue;
			}
			System.out.println(i + 1 + ". 10 / x :" + 10 / x);
		}
	}
}
---------- run ----------
---------------------
10 / x :10
10 / x :10
10 / x :2
10 / x :3
10 / x :3
0이 나와서 종료합니다.
---------------------
0이 나와서 종료합니다.
---------------------
1. 10 / x :3
0이 나와서 다음으로 진행합니다.
3. 10 / x :3
4. 10 / x :3
5. 10 / x :3
6. 10 / x :5
7. 10 / x :5
8. 10 / x :3
0이 나와서 다음으로 진행합니다.
10. 10 / x :5

 

(1) while문 : 횟수가 안 정해져 있을 때(for문과 차이점), only 조건만 참조,

조건을 만족 하지 않으면 한 번도 실행이 안 될 수도 있다!!!

형식)

while (조건식) {

실행문;

}

 

public class  WhileTest{
	public static void main(String[] args)  {
		System.out.println(" 1~10까지 출력!!!" ); //for문으로 쓰는 게 더 효율적
		int x = 1;
		while (x<=10){
			System.out.println(x++); //그냥 x만 하면 1씩 증가하지 않아, 1만 계속 출력됨
		}

		System.out.println(" 1~10까지 출력!!!(홀수만)" );
		 int a = 1;
		 while (a<=10) {
			 if (a%2==1) {
				System.out.println(a);
			 }
				a++; // a= a+1 or a+=2;
		 }

		 int y = 10;
		 int z = (int) (Math.random()*10); // 0-9
		 while (z !=0){ //어떤 숫자를 0으로 나눌 수 없기 때문에 이렇게 처리
			System.out.println(y + "/" + z + " = " + y / z);
			z = (int) (Math.random() * 10);
		 }
	}
}
---------- run ----------
 1~10까지 출력!!!
1
2
3
4
5
6
7
8
9
10
 1~10까지 출력!!!(홀수만)
1
3
5
7
9
10/4 = 2
10/5 = 2
10/1 = 10
10/3 = 3

- 로또 게임 (배열 사용 x)

/*
1. 1~45의 중복되지 않는 난수 6개
2. 1의 발생 숫자를 정렬 (나중에...)
3. 게임수 (5판)
결과>
1게임 : 5 10 13 26 85
2게임 :'
.
.
5게임 : 2 4 9 2 15 95
*/

//로또는 계속 반복되기 때문에 if문으로 하기에는 부적합. while로 처리하기.(횟수를 모르는 계속 반복되는 식)

public class  Lotto{
	public static void main(String[] args)  {
		int gameCnt = 5;
		System.out.println("===== 금주의 예상번호 =====");
		int l1,l2,l3,l4,l5,l6;
		for (int i=1;i<=gameCnt ;i++ ){
			
		 l1 = (int) (Math.random()*45)+1;
		 l2 = (int) (Math.random()*45)+1;
		 l3 = (int) (Math.random()*45)+1;
		 l4 =(int) (Math.random()*45)+1;
		 l5 =(int) (Math.random()*45)+1;
		 l6 =(int) (Math.random()*45)+1;
		
		while(l1==l2) { //중복제거
			l2 = (int) (Math.random()*45)+1;
		}
		while(l1==l3 || l2 == l3) {
			l3 = (int) (Math.random()*45)+1;
		}
		while(l1==l4 || l2 ==l4 || l3 == l4) { 
			l4 = (int) (Math.random()*45)+1;
		}
		while(l1==l5 || l2 == l5 || l3 == l5 || l4 == l5) { 
			l5 = (int) (Math.random()*45)+1;
		}
		while(l1==l6 || l2 == l6 || l3 == l6 || l4 == l6 || l5 == l6) { 
			l6 = (int) (Math.random()*45)+1;
		}
		System.out.println(i +"게임 : " +l1+ " " + l3 + " " + l4+ " " + l5+ " " + l6 );
		}			
	} 
}

- 구구단 소스 (while문)

public class  GugudanWhileTest{
	public static void main(String[] args)  {
		int dan = 2;
		int i = 1;
		while (dan<=9){ 
			while (i<=9){
				System.out.print(dan + " * " + i+ " =  " + dan*i + "  ");
				i++; 
			}
			i = 1;
			System.out.println();
			 dan++;
		} 
		
	}
}
---------- run ----------
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  
3 * 1 =  3  3 * 2 =  6  3 * 3 =  9  3 * 4 =  12  3 * 5 =  15  3 * 6 =  18  3 * 7 =  21  3 * 8 =  24  3 * 9 =  27  
4 * 1 =  4  4 * 2 =  8  4 * 3 =  12  4 * 4 =  16  4 * 5 =  20  4 * 6 =  24  4 * 7 =  28  4 * 8 =  32  4 * 9 =  36  
5 * 1 =  5  5 * 2 =  10  5 * 3 =  15  5 * 4 =  20  5 * 5 =  25  5 * 6 =  30  5 * 7 =  35  5 * 8 =  40  5 * 9 =  45  
6 * 1 =  6  6 * 2 =  12  6 * 3 =  18  6 * 4 =  24  6 * 5 =  30  6 * 6 =  36  6 * 7 =  42  6 * 8 =  48  6 * 9 =  54  
7 * 1 =  7  7 * 2 =  14  7 * 3 =  21  7 * 4 =  28  7 * 5 =  35  7 * 6 =  42  7 * 7 =  49  7 * 8 =  56  7 * 9 =  63  
8 * 1 =  8  8 * 2 =  16  8 * 3 =  24  8 * 4 =  32  8 * 5 =  40  8 * 6 =  48  8 * 7 =  56  8 * 8 =  64  8 * 9 =  72  
9 * 1 =  9  9 * 2 =  18  9 * 3 =  27  9 * 4 =  36  9 * 5 =  45  9 * 6 =  54  9 * 7 =  63  9 * 8 =  72  9 * 9 =  81  

- 두개의 주사위를 던졌을 때 나오는 눈을 (눈1, 눈2)로 출력하고, 눈의 합이 5가 아니면 계속 주사위를 던지고, 눈의 합이 5이면 실행을 멈추어라. (while문 사용)

public class  Example {
	public static void main(String[] args)  {
		/*int a = 3;
		int b = 3;
		while (a+b != 5){
			a = (int) (Math.random()*6)+1;
			b = (int) (Math.random()*6)+1;
			System.out.println ("(" + a + " , " + b + ")");
		} */

//while & break 사용
		while (true){
			int a = (int)(Math.random()*6)+1;
			int b = (int)(Math.random()*6)+1;
			System.out.println(" (" +a+", "+ b + " )");
			if (a+b ==5){
				break;
			}
		}
	}
}

- while & 증감연산자

public class While1{
	public static void main(String[] args) {
		int j=1, i=1, k=1;
		int sum1=0;
		int sum2=0;
		int sum3 = 0;

		while (j<=10){
			sum1 = sum1 +(j++); // 1~10까지 결과 : 55
		}

		while (i<=10){
			sum2 = sum2 +(++i); // 1~11까지 결과 : 65
		}

		while (k<10){
			sum3 = sum3 +(k++); // 1~9까지 결과 : 45
		}
		System.out.println(sum1);
		System.out.println(sum2);
		System.out.println(sum3);
	}
}

 

(1) 반복문

1. for문 : 규칙 반복시, 횟수가 정해진 경우 사용 (이중 , 삼중 for문이 가능하다!!!!)

형식)

for(초기화;조건식;증감식) {

// 초기화는 처음 한 번만 실행. 조건식: 참or거짓 --> 참이면 실행문 --> 증감식 --> 다시 조건식 --> 거짓이 나올 때까지 반복

실행문;

}

 

ex1)

1~10까지 출력하시오. >> 횟수 o, 규칙 o

for (int i = 1;i<11;i++) {

System.out.println(i);

}

 

ex2)

자연수 2 8 5 1 9를 출력하시오. >> 횟수 o, 규칙 x

public class ForTest {
	public static void main(String[] args) {
		System.out.println("1 ~ 10까지 출력!!!");
		for(int i=1;i<11;i++) {
			System.out.println(i);
		}
		System.out.println("1 ~ 10까지의 홀수만 출력!!!"); 
		//방법1
            for(int i=1;i<11;i++) { //10번 실행됨, 시간이 오래걸림
			if(i % 2 != 0) {
				System.out.println(i);
			}
		}
		System.out.println("---------------------------");
		//방법2
            for(int i=1;i<11;i+=2) { //5번 실행됨, 시간 절약, 더 효율적
			System.out.println(i);
		}
        //방법3
            for (int i=1;i<=10;i++){
                if (i%2==0){ //짝수라면 밑에 i에 대입이 안되고, i++로 올라감
				   continue;
                 } 
            System.out.println(i);
             }

		int dan = 7;
		System.out.println("*** " + dan + "단 ***");
		// 7 * 1 = 7
		// 7 * 2 = 14
		// .
		// 7 * 9 = 63
		for(int i=1;i<10;i++) {
			System.out.println(dan + " * " + i + " = " + dan * i);
		}
        
        //i가 5일때, 줄바꾸기 (for문 안에 if문 쓰기)
		for(int i=1;i<10;i++) {
			System.out.print(dan + " * " + i + " = " + dan * i + "  ");
			if(i == 5) {
				//System.out.print("\n");
				System.out.println();
			}
		}

		System.out.println("1 ~ 100까지 출력!!(10자리마다 줄바꿈)");
		for(int i=1;i<101;i++) {
			System.out.print(i);
			if(i % 10 != 0) { //10이 아닐 경우를 먼저 하는 게 효율적
				System.out.print("  "); 
			} else {
				System.out.print("\n");//10인 경우 줄을 바꿈
			}
		}
	}
}
---------- run ----------
1~10까지 출력!!!
1
2
3
4
5
6
7
8
9
10
1~10까지의 홀수만 출력!!!
1
3
5
7
9
***7단 ***
7*1=7
7*2=14
7*3=21
7*4=28
7*5=35
7*6=42
7*7=49
7*8=56
7*9=63
7*1=7  7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49  7*8=56  7*9=63  7*1=7  7*2=14  7*3=21  7*4=28  7*5=35  
7*6=42  7*7=49  7*8=56  7*9=63  1~100까지 출력!!(10자리마다 줄바꿈)
1  2  3  4  5  6  7  8  9  10
11  12  13  14  15  16  17  18  19  20
21  22  23  24  25  26  27  28  29  30
31  32  33  34  35  36  37  38  39  40
41  42  43  44  45  46  47  48  49  50
51  52  53  54  55  56  57  58  59  60
61  62  63  64  65  66  67  68  69  70
71  72  73  74  75  76  77  78  79  80
81  82  83  84  85  86  87  88  89  90
91  92  93  94  95  96  97  98  99  100

 

 

**<구구단 만들기>

 

- 단별로 세로로 출력

public class Gugudan1 {
	public static void main(String[] args) {
		System.out.println("*** 구구단 ***");
		for(int dan=2;dan<10;dan++) { //2단일때, 밑에 for문에서 1~9까지 실행
			for(int i=1;i<10;i++) {
				System.out.print(dan + " * " + i + " = " + dan * i + "  ");
			}
			System.out.println();
		}
	}
}
---------- run ----------
 *** 구구단 *** 
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   
3 * 1 = 3  3 * 2 = 6  3 * 3 = 9  3 * 4 = 12  3 * 5 = 15  3 * 6 = 18  3 * 7 = 21  3 * 8 = 24  3 * 9 = 27   
4 * 1 = 4  4 * 2 = 8  4 * 3 = 12  4 * 4 = 16  4 * 5 = 20  4 * 6 = 24  4 * 7 = 28  4 * 8 = 32  4 * 9 = 36   
5 * 1 = 5  5 * 2 = 10  5 * 3 = 15  5 * 4 = 20  5 * 5 = 25  5 * 6 = 30  5 * 7 = 35  5 * 8 = 40  5 * 9 = 45   
6 * 1 = 6  6 * 2 = 12  6 * 3 = 18  6 * 4 = 24  6 * 5 = 30  6 * 6 = 36  6 * 7 = 42  6 * 8 = 48  6 * 9 = 54   
7 * 1 = 7  7 * 2 = 14  7 * 3 = 21  7 * 4 = 28  7 * 5 = 35  7 * 6 = 42  7 * 7 = 49  7 * 8 = 56  7 * 9 = 63   
8 * 1 = 8  8 * 2 = 16  8 * 3 = 24  8 * 4 = 32  8 * 5 = 40  8 * 6 = 48  8 * 7 = 56  8 * 8 = 64  8 * 9 = 72   
9 * 1 = 9  9 * 2 = 18  9 * 3 = 27  9 * 4 = 36  9 * 5 = 45  9 * 6 = 54  9 * 7 = 63  9 * 8 = 72  9 * 9 = 81   

- 단별로 가로로 출력

public class Gugudan2 {
	public static void main(String[] args) {
		System.out.println("*** 구구단 ***");
		for(int i=1;i<10;i++) {
			for(int dan=2;dan<10;dan++) {
				System.out.print(dan + " * " + i + " = " + dan * i + "  ");
			}
			System.out.println();
		}
	}
}
---------- run ----------
*** 구구단 ***
2 * 1 = 2  3 * 1 = 3  4 * 1 = 4  5 * 1 = 5  6 * 1 = 6  7 * 1 = 7  8 * 1 = 8  9 * 1 = 9  
2 * 2 = 4  3 * 2 = 6  4 * 2 = 8  5 * 2 = 10  6 * 2 = 12  7 * 2 = 14  8 * 2 = 16  9 * 2 = 18  
2 * 3 = 6  3 * 3 = 9  4 * 3 = 12  5 * 3 = 15  6 * 3 = 18  7 * 3 = 21  8 * 3 = 24  9 * 3 = 27  
2 * 4 = 8  3 * 4 = 12  4 * 4 = 16  5 * 4 = 20  6 * 4 = 24  7 * 4 = 28  8 * 4 = 32  9 * 4 = 36  
2 * 5 = 10  3 * 5 = 15  4 * 5 = 20  5 * 5 = 25  6 * 5 = 30  7 * 5 = 35  8 * 5 = 40  9 * 5 = 45  
2 * 6 = 12  3 * 6 = 18  4 * 6 = 24  5 * 6 = 30  6 * 6 = 36  7 * 6 = 42  8 * 6 = 48  9 * 6 = 54  
2 * 7 = 14  3 * 7 = 21  4 * 7 = 28  5 * 7 = 35  6 * 7 = 42  7 * 7 = 49  8 * 7 = 56  9 * 7 = 63  
2 * 8 = 16  3 * 8 = 24  4 * 8 = 32  5 * 8 = 40  6 * 8 = 48  7 * 8 = 56  8 * 8 = 64  9 * 8 = 72  
2 * 9 = 18  3 * 9 = 27  4 * 9 = 36  5 * 9 = 45  6 * 9 = 54  7 * 9 = 63  8 * 9 = 72  9 * 9 = 81  
public class ForExample{
	public static void main(String[] args) {
		System.out.println("1부터 100까지 더하라");
		int sum = 0;

		for (int i =1;i<=100 ;i++ ){
			sum += i;
		}
		System.out.println(sum);	
	}
}
---------- run ----------
1부터 100까지 더하라
5050

 

- 중첩 for문 사용

ex) 4x + 5y = 60의 모든 해를 구해서 (x,y)형태로 출력하시오. x와 y는 10이하의 자연수입니다.

public class Exercise05{
	public static void main(String[] args) {
	
		for (int x=1;x<=10 ;x++ ){
			for (int y=1;y<=10 ;y++ ){
			
				if (4*x+5*y == 60){
					System.out.println("(" +x+" , " + y + ")");
				}
			}
		}
	}
}
---------- run ----------
(5 , 8)
(10 , 4)

 

- for문 이용 삼각형 출력

/*
*
**
***
****
*****
삼각형 출력하기
*/

public class Exercise06{
	public static void main(String[] args) {
	
		int a = 5;
		for (int i=1;i<=a ;i++ ){
			for (int j=1;j<=i ;j++ ){
				System.out.print("*");
			if (i==j){ //i가 1번 실행되면 j는 * 1개, i가 2번 실행되면 j는 * 2개, i=j랑 같을 때 개행 
				System.out.println();
			}	
			}
		}
	}
}

 

 

 

 

(1) eclipse.exe 실행

 

- workspace : 이클립스에서 생성한 프로젝트가 기본적으로 저장되는 디렉토리

Q. 저장 위치 변경하고 싶다면? file - switch workspace - other

 

- perspective : 개발 프로젝트 종류별로 유용한 view들을 묶어 놓은 것

 

- window탭에서 open perspective - java 클릭

 

(2) 프로젝트 생성

 

1. file - new - java project 클릭

2. project name : chap01 입력

3. next - finish

 

(3) 소스 파일 생성과 컴파일

 

1. 왼쪽 package explorer에서 chap01 - src - 마우스 오른쪽 버튼 클릭 - new - class 선택

2. package 이름 지우기

3. name : Hello 입력

4. finish

5. main method 작성

public class Hello {
	public static void main (String args[]) {
		System.out.println("Hello,welcome to the Java World");
	}
}

 

6. 저장 (자동 compile)

7. 실행

 

(4) 글꼴 변경하기

 

window - preferences - general - appearance - colors and fonts - basic - text font 클릭 후 edit

 

(5) 라인 번호 생성

 

작업창에서 마우스 오른쪽 버튼 누르면 show line numbers 클릭

 

(6) 패키지 생성

java project chap02 생성 - chap02 src 오른쪽 마우스 클릭 후 - new - package - name : sec01 - finish

서브패키지 생성 : sec01에서 오른쪽 마우스 클릭 후 new package - name : sec01.exam01_variable - finish

서브패키지에 오른쪽 마우스 클릭 후 class 선택 - name : VariableExample - finish

package sec01.exam01_variable;
public class VariableExample {
	public static void main(String args[]) {
		int value = 10;
		int result = value + 10;
		System.out.println(result);
	}
}
20

 

 

 

(1) ascii code 값 외우기

'0' = 48번

'1 = 49번

'2' = 50번

'A' = 65번

'a' = 97번

 

(2) **타입변환

자동(묵시적) 타입 변환 : Promotion

강제(명시적) 타입 변환 : Casting

 

- 자동 타입 변환 : 프로그램 실행 도중에 작은 타입은 큰 타입으로 자동 타입 변환이 된다

byte(1) < short(2) < int(4) < long(8) < float(4) < double(8)

 

- 강제 타입 변환 : 작은크기타입 = (작은크기타입) 큰크기타입

(원래 값이 보존될 것인지, 손실될 것인지 if문으로 검사!!)

 

package sec03.exam02_casting;

public class CheckValueBeforeCasing {

	public static void main(String[] args) {

		/*int i = 128;
		byte b = (byte) i;//byte가 -128~127까지만 가능, 결과 : -128
		System.out.println(b);*/
		
		int i = 128;
		if(i<-128 || i>127) { // 둘 중 하나라도 true면 true
        //or if(i<Byte.MIN_VALUE || i>Byte.MAX_VALUE)
			System.out.println("byte 타입으로 변환할 수 없습니다.");
			System.out.println("값을 다시 확인해 주세요.");
		} else {
			byte b = (byte) i; 
			System.out.println(b);
		}
	}
}
byte 타입으로 변환할 수 없습니다.
값을 다시 확인해 주세요.

ex)

public class CastingTest {
  public static void main(String[] args) {
    double d = 123.56;
      System.out.println("d:" + d);

//int x = d; double은 8byte고, int는 4byte라서 오류!!

int x = (int) d; // casting 연산 (강제형변환) - 기본형은 기본형끼리, 참조형은 참조형끼리만 변환
      System.out.println("x:" + x);

   d = x; // (자동형변환 - 작은 값을 큰 값에 집어넣는 거니까 오류x)
      System.out.println("d:" + d);
  /*boolean b = true;
   int y = b;
  */ // 값은 타입만 형 변환 가능하기 때문에 오류

   char c = 'a';
   int y = c;
      System.out.println("y:" + y); // ascii 코드 값을 가지기 때문에 ok

   c = (char)y; // (강제형변환)
      System.out.println("c:" + c);
 } 
}
---------- run ----------
d:123.56
x:123
d:123.0
y:97
c:a

ex)

package sec01.exam01_variable;

public class VariableExample {
	public static void main(String args[]) {
		byte var1 = 10;
	    //var1 = var1 + 1; //산술연산은 int 값으로 나오기 때문에 byte 변수 var1에 대입할 수 x
        var1 ++; // or var1 = (byte) (var1 + 1); or int intvar1 = var1 + 1;
		System.out.println(var1);

        int intValue1 = 10;
		int intValue2 = intValue1 / 4; // 정수 / 정수
		System.out.println(intValue2); // 값 : 2 정수로 계산됨
		
		int intValue3 = 10;
		//int intValue4 = 10 / 4.0; (산술연산이지만 실수값이 들어갔기 때문에 double로 자동 변환)
		double doubleValue = intValue3 / 4.0; // 정수 / 실수 = 실수
		System.out.println(doubleValue); //값 : 2.5
	}
}

 

** ex1)

/*

가위 바위 보

1. 가위(0), 바위(1), 보(2)

2. 컴퓨터는 0,1,2중 하나의 난수 발생

3. 나는 0,1,2 중 하나의 수를 입력

4. logic

5. 결과 >> 나 : 바위, 컴 : 가위, 결과 : 이겼다.

*/

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

public class GBB {
    public static void main(String[] args) {
        //double d = Math.random();//0.0<= Math.random() < 1.0
        //System.out.println(d);
        int com = (int) (Math.random() * 3);//0 1 2
        int my = 1;
        int result = (my - com + 2) % 3;

        String myStr;
        String comStr;
        String resultStr;
        if(my == 0) {
            myStr = "가위";
        } else if(my == 1) {
            myStr = "바위";
        } else {
            myStr = "보";
        }

        switch(com) {
            case 0 : comStr = "가위"; break;
            case 1 : comStr = "바위"; break;
            default : comStr = "보";
        }

        if(result == 0) {
            resultStr = "이겼다.";
        } else if(result == 1) {
            resultStr = "졌다.";
        } else {
            resultStr = "비겼다.";
        }    

        System.out.println("나 : " + myStr + ", 컴 : " + comStr + ", 결과 : " + resultStr);//나 : 바위, 컴 : 가위, 결과 : 이겼다.
    }
}

ex2) 주사위 던지기

public class  IfDiceExample{
	public static void main(String[] args)  {
		int num = (int) (Math.random() * 6) +1; // 1부터 나오게 하려면 +1, 0부터 나오게 하려면 그냥 *만!!

		if (num == 1)	{
			System.out.println ("1번이 나왔습니다.");
		} else if (num ==2)	{
			System.out.println ("1번이 나왔습니다.");
		} else if (num ==3)	{
			System.out.println ("3번이 나왔습니다.");
		}else if (num ==4)	{
			System.out.println ("4번이 나왔습니다.");
		}else if (num ==5)	{
			System.out.println ("5번이 나왔습니다.");
		}else {
			System.out.println ("6번이 나왔습니다.");
		}

		}
	}

public class SwitchExample{
	public static void main(String[] args) {
		int num = (int) (Math.random()*6)+1; // 1~6까지 나온다.
		
		switch (num){
		case 1: System.out.println("1번이 나왔습니다.");break;
		case 2: System.out.println("2번이 나왔습니다.");break;
		case 3: System.out.println("3번이 나왔습니다.");break;
		case 4: System.out.println("4번이 나왔습니다.");break;
		case 5: System.out.println("5번이 나왔습니다.");break;
		default: System.out.println("6번이 나왔습니다.");
		
		}

	}
}

 

** 제어문 : 조건문, 반복문

 

* 조건문

1. if문

형식)

if (조건문) {

실행문1;

}

실행문2;

결과)

조건문 true : 실행문1 --> 실행문2

false : 실행문2

 

ex)

public class IfTest {
  public static void main(String[] args) {
    int x; //선언
    x = 19; //값을 할당
    if(x > 10) {
      System.out.println(x + "는 10보다 큽니다.");
    }

   int jumin = 1;
   /*if ( jumin % 2 == 0) {
      System.out.println("주민번호가 " + jumin + "인 사람의 성별 : 여자");
   }
   if ( jumin % 2 == 1)
     System.out.println("주민번호가 " + jumin + "인 사람의 성별 : 남자");*/

//(더 간단한 코드)
   String gender = "남자";
   if ( jumin % 2 == 0) {
     gender = "여자";
   }
   System.out.println("주민번호가 " + jumin + "인 사람의 성별 : " + gender);
   System.out.println("프로그램 종료!!!!");
  }
}
---------- run ----------
19는 10보다 큽니다.
주민번호가 1인 사람의 성별 : 남자
프로그램 종료!!!!

---------- run ---------- 1910보다 큽니다. 주민번호가 1인 사람의 성별 : 남자 프로그램 종료!!!!

 

 

2. if ~ else 문 : ~라면 ~가 아니라면

형식)

if (조건문) {

실행문1;

} else {

실행문2;

}

실행문3;

결과)

조건문 true : 실행문1 --> 실행문3;

false : 실행문2 --> 실행문3;

 

 

ex1)

public class IfElseTest {
  public static void main(String[] args) {
    int x =19;
    if (x>10) {
      System.out.println(x + "는 10보다 큽니다.");
    } else {
      System.out.println(x + "는 10보다 작습니다.");
    }

    int jumin = 2;
    String gender = null; 
//아직 만들지 않은 값 (String에만 들어갈 수 있다, boolean, int 등에는 null이 들어갈 수 없다)
    if ( jumin % 2 == 0) {
      gender = "여자";
    } else {
      gender = "남자";
    }
      System.out.println("주민번호가 " + jumin + "인 사람의 성별 : " + gender);
    System.out.println("프로그램 종료!!!");
  }
}

 

** ex2)

/*
주민번호의 7번째 숫자
1,2 : 1900년도 사람
3,4 : 2000년도 사람
1,3 : 남자
2,4 : 여자

샘플데이터
주민번호 :  3                      2
결과     : 3은 2000년대 남자입니다. 2는 1900년대 여자입니다.

만약에 주민번호가 5이상이면 5는 외국인입니다.
*/

public class IfElseTest2 {
	public static void main(String[] args) {
		int jumin = 5;
		if(jumin < 5) {
			int year;
			String gender;
			if(jumin < 3) {
				year = 1900;
			} else {
				year = 2000;
			}

			if(jumin % 2 == 0) {
				gender = "여자";
			} else {
				gender = "남자";
			}
			System.out.println(jumin + "은 " + year + "년대 " + gender);
		} else {
			System.out.println(jumin + "은 외국인입니다.");
		}
	}
}
---------- run ----------
1은1900년대남자입니다.

 

 

 

ex3)

public class Test0 { 
   public static void main(String[] args) {
     int x = 3;
     int y = 2;
     System.out.println(x!=y);

     int money = 2000;
     if (money >=3000) {
     System.out.println("택시를 타고 가라"); 
     } else {
     System.out.println ("걸어가라");
     }
  }
}
---------- run ----------
true
걸어가라

 

ex4)

/*

시험점수 : 89 score

학점 : 90점 이상 A grade

80점 이상 B

70점 이상 C

F

결과 : 89점은 B학점입니다.

*/

public class IfElseTest3{
   public static void main(String[] args) {
     int score = 89;
     char grade; //계속 바뀌는 값이니까
     if (score >= 90){
       grade = 'A';
     } else {
       if (score >= 80){
        grade = 'B';
       } else {
          if (score >= 70){
           grade = 'C';
          } else {
             grade = 'F';
            }
          }
       }
System.out.println(score + "점은" + grade + " 학점입니다.");
 }
}
---------- run ----------
89점은B 학점입니다.

 

 

 

 

3. if ~ else if ~ else 문 : ~라면 ~라면 ~라면 ~가 아니라면

형식)

if (조건문1) {

실행문1;

} else if (조건문2) {

실행문2;

} else {

실행문3;

}

실행문4;

결과)

조건문 1 true : 실행문1 --> 실행문4

false : 조건문2 true : 실행문2 --> 실행문4;

false : 실행문3 --> 실행문4;

 

ex1)

/*

시험점수 : 89 score

학점 : 90점 이상 A grade

80점 이상 B

70점 이상 C

F

학점은 X5점이상이면 X+

 

결과 : 89점은 B학점입니다.

*/

public class IfElseIfTest {
    public static void main(String[] args) {
        int score = 100;
        String grade; //Q.char가 안되는 이유는?
        if(score >= 90) {
            grade = "A";
        } else if(score >= 80){
            grade = "B";
        } else if(score >= 70) {
            grade = "C";
        } else {
            grade = "F";
        }

        if(score == 100 || score % 10 >= 5 && score >= 70) {
            grade += "+"; // grade = grade + "+" (grade에 +를 붙이겠다!!)
        }

        System.out.println(score + "점은 " + grade + "학점입니다.");
    }
}
---------- run ----------
100점은 A+학점입니다.

 

ex2)

if문 중첩

public class IfTest1{
	public static void main(String[] args) {
		int score = 75;
		String grade = " ";

		if (score >=90)	{
			if (score >= 95){
				grade = "A+";
			} else {
				grade = "A";
			}
		} else {
		if (score >=85)	{
				grade = "B+";
			} else {
				grade = "B";
			}
		}
			System.out.println(score + "는" + grade+ "학점입니다.");
	}
}

 

 

4. switch ~ case문 // equal 비교일 때만 사용

(단, JDK6까지는 값에 정수만 가능했지만, JDK7부터는 "문자열"도 가능)

(정수 : byte short int long char)

형식)

switch(값) {

case 값1 : 실행문1; break;

case 값2 : 실행문2; break;

 

ex1)

public class  SwitchCaseTest1 {
    public static void main(String[] args) {
            int x = 1;
            switch(x) {
                    case 0 :     System.out.println("x는 0입니다.");break;
                    case 1 :     System.out.println("x는 1입니다.");break;
                    case 2 :    System.out.println("x는 2입니다.");break;
                    default :    System.out.println("x는 0, 1, 2 모두 아닙니다.");
            }
     /*
                ASCII : 모든 문자는 숫자값
                '0' = 48번 (0~9 총 10개)
                'A' = 65번
                'a' = 97번
                */

                char c = 'b';
                //System.out.println((int)c);
            switch(c) {
                    case 'a' :     System.out.println("x는 a입니다.");break;
                    case 'b' :     System.out.println("x는 b입니다.");break;
                    case 'c' :    System.out.println("x는 c입니다.");break;
                    default :    System.out.println("x는 a b, c 모두 아닙니다.");
        }

                    String s = "java";
            switch(s) {
                    case  "java" :     System.out.println ("s는 java입니다.");break;
                    case  "oracle"  :     System.out.println ("s는 oracle입니다."); break;
                    case "spring" :    System.out.println ("s는 spring입니다."); break;
                    default :    System.out.println ("s는  java oracle,spring 모두 아닙니다.");
        }
    }
}
---------- run ----------
x는 1입니다.
x는 b입니다.
s는 java입니다.

 

ex2)

/*

시험점수 : 89 score

학점 : 90점 이상 A grade

80점 이상 B

70점 이상 C

F

학점은 X5점이상이면 X+

 

결과 : 89점은 B학점입니다.

*/

public class  SwitchCaseTest2 {
    public static void main(String[] args) {
            int score = 100;
            String grade;
            switch (score/10)    { //동등비교밖에 안되니까 10으로 나눠주기
            case 10 : case 9 : grade = "A"; break;
            case  8 : grade = "B"; break;
            case  7 : grade = "C"; break;
            default : grade = "F";
    }
     if(score == 100 || score % 10 >= 5 && score >= 70) { //범위비교가 필요(switch문 x)
            grade += "+"; // grade = grade + "+" (grade에 +를 붙이겠다!!)
        }

        System.out.println(score + "점은 " + grade + "학점입니다.");
    }
}
---------- run ----------
100점은 A+학점입니다.

ex3)

한번에 처리하기

int month = Calendar.getInstance().get(Calendar.MONTH) + 1;
        String season = "";
        
        //case문을 한번에 사용하면 더 짧게 코드를 짤 수 있습니다.
        switch(month) {
            case 1:
            case 2:
            case 12:
                season = "겨울";
                break;
            case 3:
            case 4:
            case 5:
                season = "봄";
                break;
            case 6:
            case 7:
            case 8:
                season = "여름";
                break;
            case 9:
            case 10:
            case 11:
                season = "가을";
                break;
        }
        System.out.println("지금은 " + month + "월이고, " + season + "입니다.");
    }

 

 

 

(1) 문자열 연결 연산자 '+' : '+'는 oracle 에서 '||' 와 같다!!

public class VarTest1 {
  public static void main(String args[]) {
    int age;
    age = 25;
      System .out.println("age : " + age);

    char c;
    c='a';
      System.out.println("c:"+c);

    boolean flag = true; // boolean에는 true or false만 저장 가능 합니다.
      System.out.println("flag : " + flag);

//byte b = -129; //byte의 범위는 -128 ~ 127까지만 저장 가능하기 때문에 오류

/*
여
러
줄
*/

  }
}
---------- run ----------
age : 25
c:a
flag : true

 

( //한 줄 주석 달기)

( /* 여러줄 주석 달기 */)

 

 

(2) **연산자 (operator)

1. 증감 연산자 : ++, -- >> 1 증가(감소) 연산자

변수를 기준으로 했을 때 변수 ++(--) : 선실행 후증감

++(--) 변수 : 선증감 후실행

ex)

int x = 10; 출력값 실제값

S.o.p(x); // 10

S.o.p(++x); // 11 11

S.o.p(x++); // 11 12

S.o.p(--x); // 11 11

S.o.p(x--); // 11 10

S.o.p(x--); // 10 9

S.o.p(++x); // 10 10

S.o.p(--x); // 9 9

S.o.p(x++); // 9 10

S.o.p(++x); // 11 11

S.o.p(x--); // 11 10

S.o.p(x); // 10

 

2. 산술연산자 : + , -, *, /, %(나머지연산자)

 

public class OperTest2
{
public static void main(String[] args)
{
int x = 15;
int y = 8;
int z = 0;
System.out.println(" x : " + x + " \ty : " + y + " \tz : " +z);

z = x + y; // z에 x+y를 대입하라
System.out.println(" z : " + z); 

z = x - y;
System.out.println("z : " +z);

z = x / y;
System.out.println("z:" +z);

z = x * y;
System.out.println("z:" +z);

z = x % y;
System.out.println("z:" +z);
}
}
---------- run ----------
x : 15  y : 8  z : 0
z : 23
z : 7
z : 120
z : 1
z : 7

 

 

3. 비교연산자 : <, <=, >, >=, ==, !=

ex) 위에 이어서~

System.out.println( x > y); //true
System.out.println(z > y); //false
System.out.println(x > y && z > y); //false
System.out.println(x > y || z > y); //true (x>y에서 끝~ z>y는 볼 필요도 x)

 

* 문자열(String)은 비교연산자를 사용할 수 없다.

equals() 메소드를 사용해야 한다!!

ex) boolean result = str1.equals(str2);

 

4. 논리연산자 : &&(and), ||(or), !(not)

 

 

5. 대입연산자 : =, +=, -=, *=, /=, %=

ex)

int x = 10;

S.o.p(x);

x +=5; // x= x+5;

S.o.p(x); //15

 

Q. int x = 10;일때 x의 값을 1증가 시키는 방법을 아는대로 쓰시오.

++x, x++, x= x+1;, x+1;

 

6. 조건연산자(삼항연산자)

형식) 조건? 값1: 값2;

결과) 조건이 true면 값1

false면 값2

 

ex)

int x = 10;

int y = x < 10 ? 5 : 15;

S.o.p(y); //15

 

* 연산자 우선순위

( ) 최우선순위 연산 (어떤 것이 먼저인지 모르겠으면, ( )넣기)

대입연산자 최후위 연산

 

ex1)

/*
점수가 90점 이상이면 A등급
       80점 이상이면 B등급
       그 이하는     C등급
*/

public class ConditionalOperationExample {
	public static void main(String[] args) {
		int score = 60;
		char grade = (score >= 90)? 'A' : (score >= 80)? 'B' : 'C';
		System.out.println(score + "점은" + grade + "등급입니다.");
	}
}

 

 

ex2)

int jumin = 2;
String gender = (jumin ==1 || jumin ==3) ? "남자" : "여자" ;
System.out.println("주민번호가 " + jumin + "인 사람의 성별 : " + gender);

OR

int jumin = 2;
String gender = (jumin % 2 == 1) ? "남자" : "여자" ; //홀수면 남자, 짝수면 여자
System.out.println("주민번호가 " + jumin + "인 사람의 성별 : " + gender);

 

ex3)

/*
물건가격 : 3670원
투입금액 : 10000원
거스름돈 : 6330원
------------------------------
5000원 : 1장
1000원 : 1장
500원 : 0개
100원 : 3개
50원 : 0개
10원 : 3개
*/

public class VendingMachine {
  public static void main(String[] args) {
   int price = 3670;
   int myMoney = 10000;
   int change = myMoney - price;
    System.out.println("물건가격 : " + price + "원" );
    System.out.println("투입금액 : " + myMoney + "원");
    System.out.println("거스름돈 : " + change + "원");
   int c5000 = change /5000; //숫자로 시작할 수 없기에 c5000으로~
   int c1000 = (change %5000) / 1000; //change%5000 = change - 5000 *c5000
   int c500 = (change%1000) / 500;
   int c100 = (change%500) / 100;
   int c50 = (change%100) / 50;
   int c10 = (change%50) / 10;
    System.out.println( "-------------------------------------------");
    System.out.println( "5000원 :" + c5000 + "장");
    System.out.println("1000원 : " + c1000 + "장");
    System.out.println("500원 : " + c500 + "개");
    System.out.println("100원 : " + c100 + "개");
    System.out.println("50원 : " + c50 + "개");
    System.out.println("10원 : " + c10 + "개");
  }
}
---------- run ----------
물건가격 : 3670원
투입금액 : 10000원
거스름돈 : 6330원
----------------------------
5000권 : 1장
1000권 : 1장
500원 : 0개
100원 : 3개
50원 : 0개
10원 : 3개

 

(1) 변수 (variable) : 하나의 값을 저장하는 공간 (memory에 할당)

: 마음대로 지을 수 있음 (but, 몇 가지 규칙이 있다,)

 

int a;

String b;

(a,b가 변수)

 

(2) DataType (자료형) : 변수 앞에 위치한 것, 프로그래밍을 할 때 쓰이는 숫자, 문자 등 자료 형태로

사용하는 모든 것

a) 기본형 (primitive) DataType (8개)

- 논리형 boolean 1byte true, false (0,1 저장 x)

조건문,제어문 등의 실행 흐름 변경시 사용

두가지 상태값을 가질 경우 (맞냐?안맞냐?/ 시작?아직시작x?)

- 문자형 char 2byte 'a', '1', 'ab' (x, 문자열(String)이라 안됨 한글자만 ok) * 특수문자(escape문자) 5개 : \n (new line 줄바꿈), \t (tab), \' ('), \" ("), \\ (\)

- 숫자형

- 정수형 byte 1byte -128 ~ 127까지만 저장 가능( 1 byte = 8 bit)

실행중 범위가 초과한다면 128이 아니라 -128로 돌아간다.

short 2byte

int 4byte 가장 많이 사용

long 8byte

 

- 실수형 float 4byte

double 8byte 금융권에서 사용(소수점까지)

* 빈(empty) 문자 처리

- char c = ''; // 컴파일 에러

- char c = ' '; // 공백 가능

- String str = ""; // 가능

 

b) 참조형 (reference) DataType

- class (Object)

- array

 

(3) ** 접근제어자( access modifier) : private < default < protected < public 순으로 광범위

① private : 자기 클래스 안에서만 사용 가능.

② default : 생략, private (자기 클래스 안에서 사용 가능) + 같은 package에 있는 클래스간 사용 가능

③ protected : private(자기 클래스 안에서 사용 가능) + default (같은 package에 있는 클래스간 사용

가능) + package가 다르더라도 두 클래스가 상속 관계일 경우 사용 가능

(* package : 자바 클래스가 위치하고 있는 디렉터리명과 일치한다. 즉, 파일명이 동일하더라도 다른 패키지라면

동일한 클래스명 사용 가능)

④ public : 어떠한 제약 없이 사용 가능

 

(4) ** 명명 규칙

ⓐ 알파벳 대소문자, 숫자, 한글 가능 (단, 숫자로 시작할 순 X (int 1st; X))

ⓑ 특수문자 X (예외 : _, $ 사용 가능 but, $는 일반적으로 사용하지 x)

ⓒ 클래스는 대문자로 , 메소드나 변수는 소문자로 시작

합성어의 경우 다음 단어의 첫번째 문자는 대문자로~ >> camel case (낙타 표기법)

ex ) class : SportsCar

method : speedUp()

variable : carName, maxSpeed, firstName

constance (상수:절대바뀌지않는수) : CAR_MAKER

ⓓ 클래스나 변수는 명사, 메소드는 동사.

ⓔ 자바 예약어(keyword)는 변수명으로 사용 X

<자바 키워드>

  • 0열 선택0열 다음에 열 추가
  • 1열 선택1열 다음에 열 추가
  • 2열 선택2열 다음에 열 추가
  • 3열 선택3열 다음에 열 추가
  • 4열 선택4열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가
  • 1행 선택1행 다음에 행 추가
  • 2행 선택2행 다음에 행 추가
  • 3행 선택3행 다음에 행 추가
  • 4행 선택4행 다음에 행 추가
  • 5행 선택5행 다음에 행 추가
  • 6행 선택6행 다음에 행 추가
  • 7행 선택7행 다음에 행 추가
  • 8행 선택8행 다음에 행 추가
  • 9행 선택9행 다음에 행 추가

셀 전체 선택

열 너비 조절

행 높이 조절

abstract

continue

for

new

switch

assert

default

goto

package

synchronized

boolean

do

if

private

this

break

double

implements

protected

throw

byte

else

import

public

throws

case

enum

instanceof

return

transient

catch

extends

int

short

try

char

final

interface

static

void

class

finally

long

strictfp

volatile

const

float

native

super

while

  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

 

-(5) 기본형 DataType 사용

a) 변수 선언 (메모리 할당x)

형식) 접근제어자 기본형DataType 변수명;

ex)

public int age;

char c;

private boolean flag; 현재 클래스 안에서만 쓸 수 있는 참/거짓

 

b) 사용 (메모리 할당o) : 값 할당.

형식) 변수명 = 값; (변수에 해당 값을 대입)

ex)

age = 25;

c = 'a';

flag = true;

 

* 선언과 동시에 값 대입을 한번에도 가능

접근제어자 기본 datatype의 변수명 = 값;

ex)

public int age = 25;

char c = 'a';

private boolean flag = true;

 

(6) 변수는 선언된 블록{ } 내에서만 사용이 가능하다.

메소드 블록 내에서 선언된 변수는 전체 사용 가능

if 조건문 블록 내에서 선언된 변수는 if문 안에서만 사용 가능

for 반복문 블록 내에서 선언된 변수는 for문 안에서만 사용 가능

 

 

Q. 초기화란 ?

선언 후 값 대입까지 된 상태 ! 선언만 되어 있다면 초기화가 되지 않았기 때문에 컴파일 에러가 발생한다.

ex) int value = 30;

int result = value + 10; //초기화가 되었기 때문에 result변수에 대한 값으로 사용이 가능하다.

 

Q. 매번 cmd창에 입력하는 게 불편하다면?

EditPlus 설정 해주기~

도구 기본설정 - 사용자 도구 - 추가1 - 프로그램 (메뉴제목 : compile

명령 : C:\Program Files\Java\jdk1.8.0_221\bin\javac.exe

인수 : 옆에 밑에 화살표 눌러보면 파일이름 클릭

디렉토리 : 파일 디렉토리

추가2 - 프로그램 (메뉴제목 : run

명령 : C:\Program Files\Java\jdk1.8.0_221\bin\java.exe

인수 : 옆에 밑에 화살표 눌러보면 확장자를 뺀 파일이름

디렉토리 : 파일 디렉토리

 

ctrl + 숫자1 : compile

ctrl + 숫자 2 : run

(cmd창에서 자동으로 출력)

 

Q. 더 편리해지고 싶다면?

도구 기본설정 - 사용자 도구

 

동작에서 출력내용 캡처 선택해주기

(EditPlus 밑에 출력내용 나온다)

 

- Editplus에 메모장에 저장해 놓았던 main mathod 불러오기

도구 - 기본설정 - 파일 문서 탬플릿 - Java 클릭 - 파일이름(메모장 저장 파일 찾아서 열기) - 확인

 

+ Recent posts