[ 연산자 ]
- 자료 가공을 위해 정해진 방식에 따라 계산하고 그 결과를 얻기 위한 행위를 의미하는 기호들의 총칭
1. 증감 연산자 : ++, --
|
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
|
package day01;
// 연산자 : 자료 가공을 위해 정해진 방식에 따라 계산하고 그 결과를 얻기 위한 행위를
// 의미하는 기호들의 총칭
// 1. 증감연산자 : ++, --
public class OperEx1 {
public static void main(String[] args) {
// a라는 이름의 int 크기의 공간을 선언
int a;
// a에 100 값을 할당
a = 100;
// b라는 이름의 int 크기의 공간 선언하면서 10 값을 할당
int b = 10;
// a, b를 화면에 출력
System.out.println("a : " + a);
System.out.println("b : " + b);
System.out.println("--------------");
a = a + 1; // 우항에 위치한 값을 왼쪽의 변수에 대입(할당)하라 : 연산자 2개 사용
// a, b를 화면에 출력
System.out.println("a : " + a);
System.out.println("b : " + b);
System.out.println("--------------");
++a;
// a++; // 자기 자신의 값을 1 증가시킴 : 연산자 1개 사용 > 권장
// a--; // 1 감소시킴
// a, b를 화면에 출력
System.out.println("a : " + a);
System.out.println("b : " + b);
System.out.println("==============================");
a = 100;
b = 10;
// 멀티 라인 주석 설정, 해제 단축키 : ctrl + /
// a = a + 1; // a <-- 101
// b = a; // a 변수의 값을 b 변수에 대입한다.
// b = ++a; // a를 먼저 증가시키고 b에 대입
// b = a;
// a = a + 1;
b = a++; // 대입한 뒤 증가
System.out.println("a : " + a);
System.out.println("b : " + b);
}
}
|
cs |
2. 산술 연산자 : +, -, *, /, %
|
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
|
package day02;
//2. 산술연산자
public class OperEx2 {
// main method
public static void main(String[] args) {
// int형 변수 a를 선언하고 10을 할당
int a = 10;
// int형 변수 b를 선언하고 20을 할당
int b = 20;
// +
// 1. 연결 연산자 : 문자열 뒤에 오면 +
// 2. 산술 연산자 : 숫자 + 숫자
// 표준 출력장치로 a + b : 30 형식으로 출력
// 연산자 우선 순위 () <--
System.out.println("a + b : " + ( a + b ));
System.out.println("a - b : " + ( a - b ));
System.out.println("a * b : " + ( a * b ));
System.out.println("a / b : " + ( a / b ));
// 연산 후 0.5지만 int 이하의 값은 연산하면 int가 되므로
// 실수 float이 될 수는 없다.
// 따라서 정수 부분인 0만 남는다.
// a/b의 나머지를 출력
System.out.println("a % b : " + ( a % b ));
// byte형 변수 b1을 선언하고 100을 값으로 할당
byte b1 = 100;
// byte형 변수 b2을 선언하고 30을 값으로 할당
byte b2 = 30;
//byte b3 = b1 + b2; //overflow <<
// byte : -128 ~ 127 : 최대.. 25
// int 이하의 자료형끼리 연산하면 결과는 int
// int형 변수 c를 선언하고 b1 + b2의 값을 할당
int c = b1 + b2;
System.out.println("c : " + c);
// double형 변수 d1을 선언하고 100.2 값을 할당
double d1 = 100.2;
// 두 변수 를 덧셈하려고 한다. 자료형은 무엇으로 하면 좋을까?
// 연산할 때 더 큰 자료형으로
double d2 = c + d1;
System.out.println("d2 : " + d2);
}
}
|
cs |
3. Shift 연산자
byte b = 10; 0000 1010
- b >> 2
| 0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 |
↓
| 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
: 10진수로 2
- b << 2
| 0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 |
↓
| 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 |
: 10진수로 40
|
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
|
package day02;
// 3. shift 연산자
public class OperEx3 {
public static void main(String[] args) {
byte b = 10; // 2^2 ==> 4
System.out.println("b >> 2 : " + (b >> 2)); // 나누기
System.out.println(b/4);
// 컴퓨터 입장에서 *, / 보다 >>, << 연산속도가 훨씬 빠르다.
// 게임과 같은 빠른 성능을 우선으로 하는 시스템 개발을 위해 shift 연산 사용
// web 개발에서는 잘 사용 X
System.out.println("b << 2 : " + (b << 2)); // 곱하기
System.out.println(b*4);
byte b2 = 20;
// >>> : 오른쪽으로 밀고 남는 자리는 부호자리 값으로 채움
// >> : 오른쪽으로 밀고 남는 자리는 0으로 채움
// << : 왼쪽으로 밀고 남는 자리는 0으로 채움
System.out.println("b2 >> 2 : " + (b2 >> 2)); // 5
System.out.println("b2 << 2 : " + (b2 << 2)); // 80
}
}
|
cs |
4. 비교 연산자 : >, <, >=, <=, ==(같다), !=(다르다)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package day02;
// 4. 비교 연산자
// >, <, >=, <=, ==(같다), !=(다르다)
// = : 이건 대입연산자, 할당연산자로 쓰임
public class OperEx4 {
//main method
public static void main(String[] args) {
//int형 변수 a에 100 대입
int a = 100;
//int형 변수 b에 20 대입
int b = 20;
// 비교식이 참인지 거짓인지 화면에 출력
System.out.println("a : " + a);
System.out.println("b : " + b);
System.out.println("a > b : " + (a>b));
System.out.println("a < b : " + (a<b));
System.out.println("a >= b : " + (a>=b));
System.out.println("a == b : " + (a==b));
System.out.println("a != b : " + (a!=b));
//System.out.println("a <> b : " + (a<>b));
}
}
|
cs |
5. 비트 연산자 : &, |
- 비트 단위로 연산
|
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
|
package day02;
// 5. 비트 연산자 : 비트 단위로 연산 (정수, 논리 연산 가능)
public class OperEx5 {
// 메인 메서드
public static void main(String[] args) {
// 1 ==> true, 0 ==> false
// false(0) and false(0) ==> false
// false and true ==> false
byte a = 10; // 2진수 0000 1010
byte b = 22; // 2진수 0001 0110
// and(&) 연산
// -----------------------------
// 0000 0010
// OR(|) 연산
// -----------------------------
// 0001 1110
System.out.println("a & b : " + (a & b));
System.out.println("a | b : " + (a | b));
byte k1 = 13; // 1101
byte k2 = 17; // 1 1101
// k1 & k2
// k1 | k2
System.out.println("k1 & k2 : " + (k1 & k2));
System.out.println("k1 | k2 : " + (k1 | k2));
// boolean형
boolean b1 = true;
boolean b2 = false;
System.out.println("b1 & b2 : " + (b1 & b2));
}
}
|
cs |
6. 논리 연산자 &&, ||
- 논리형만 사용 가능! 정수형은 사용 불가
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package day02;
// 6. 논리 연산자 : &&, ||
// boolean 타입만 연산, 때문에 정수형은 연산이 안된다.
public class OpenEx6 {
public static void main(String[] args) {
boolean b1 = true;
boolean b2 = false;
System.out.println("b1 && b2 : " + (b1 && b2));
System.out.println("b1 || b2 : " + (b1 || b2));
byte c1 = 10;
byte c2 = 20;
// System.out.println("c1 && c2 : " + (c1 && c2)); > 연산 안됨
}
}
|
cs |
7. 삼항 연산자 : (조건)? (참):거짓
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package day02;
// 단항연산자 : ++, --
// 이항연산자 : +, -
// 삼항연산자 : (조건) ? "참":"거짓"
public class OperEx7 {
public static void main(String[] args) {
int a = 10;
int b = 5;
// (조건) ? "참일 경우의 값":"거짓일 경우의 값"
System.out.println((a>b)?"참":"거짓");
}
}
|
cs |
8. 대입 연산자 : =, +=, -=, *=, /=
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package day02;
// 8. 대입 연산자
// =, +=, -=, *=, /=, %=
public class OperEx8 {
public static void main(String[] args) {
int a = 10;
// a = a + 1;
//a++;
//a에 2를 더하고 다시 a에 할당
//a = a + 2;
a += 2;
System.out.println("a : " + a);
}
}
|
cs |
* 연산자의 우선 순위
: 1(증감 연산자) → 2(산술 연산자) → 3(Shift 연산자) → 4(비교 연산자)
→ 5(비트 연산자) → 6(논리 연산자) → 7(삼항 연산자) → 8(대입 연산자)
# Java 구구단 출력 : println에 직접 입력해서
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package day02;
// ctrl + shift + f: 자동 정렬
public class StatementEx1 {
public static void main(String[] args) {
// ctrl + alt + 화살표 방향 아래키
// 구구단 3단 출력
System.out.println("3 * 1 = 3");
System.out.println("3 * 2 = 6");
System.out.println("3 * 3 = 9");
System.out.println("3 * 4 = 12");
System.out.println("3 * 5 = 15");
System.out.println("3 * 6 = 18");
System.out.println("3 * 7 = 21");
System.out.println("3 * 8 = 24");
System.out.println("3 * 9 = 27");
}
}
|
cs |
[ 반복문 ]
- 제어문 : 특정 문장을 만나면 문장이 실행흐름 변경
- 반복문 : 특정 구간을 반복해서 실행하게 하는 문장
> 제어문에 포함
* for문
- 횟수가 명확할 때 사용
for( 초기식; 조건식; 증감식) {
문장;
문장;
}
- 초기식 : for 문에서 사용될 변수의 초기값을 할당
- 조건식 : 조건식의 결과값은 논리값으로 true이면 {}안의 문장을 실행하고
false이면 {} 안을 완전히 빠져나간다.
- 증감식 : for문에서 사용될 변수를 증가, 감소 처리해준다.
# for문 시작 3단 출력
- 초기식 : int형 변수 i에 1을 할당
- 조건식 : i가 9보다 작거나 같을 때까지 반복문 실행
- 증감식 : i를 한번 반복할 때마다 1씩 증가해
for (int i =1;i <= 9;i++) {
System.out.println(i + " 3 * " + i + " = " + (3*i));
|
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
|
package day02;
// main method 상단에서 하단 방향으로 1줄씩 실행
// 특정 문장을 만나면 문장이 실행흐름 변경 : 제어문
// 특정 구간을 반복해서 실행하게 하는 문장 : 반복문
public class StatementEx2 {
public static void main(String[] args) {
// for( 초기식; 조건식; 증감식) {
// 문장;
// 문장;
// }
// 초기식 : for 문에서 사용될 변수의 초기값을 할당
// 조건식 : 조건식의 결과값은 논리값으로 true이면 {}안의 문장을 실행하고
// false이면 {} 안을 완전히 빠져나간다.
// 증감식 : for문에서 사용될 변수를 증가, 감소 처리해준다.
// for문 시작 3단 출력
// 초기식 : int형 변수 i에 1을 할당
// 조건식 : i가 9보다 작거나 같을 때까지 반복문 실행
// 증감식 : i를 한번 반복할 때마다 1씩 증가해
for (int i =1;i <= 9;i++) {
System.out.println(i + " 3 * " + i + " = " + (3*i));
}
}
}
|
cs |
# for 문으로 별( * ) 3줄 출력
|
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
|
package day02;
// main method 상단에서 하단 방향으로 1줄씩 실행
// 특정 문장을 만나면 문장이 실행흐름 변경 : 제어문
// 특정 구간을 반복해서 실행하게 하는 문장 : 반복문
public class StatementEx2 {
public static void main(String[] args) {
// for( 초기식; 조건식; 증감식) {
// 문장;
// 문장;
// }
// 초기식 : for 문에서 사용될 변수의 초기값을 할당
// 조건식 : 조건식의 결과값은 논리값으로 true이면 {}안의 문장을 실행하고
// false이면 {} 안을 완전히 빠져나간다.
// 증감식 : for문에서 사용될 변수를 증가, 감소 처리해준다.
// for문 시작 3단 출력
// 초기식 : int형 변수 i에 1을 할당
// 조건식 : i가 9보다 작거나 같을 때까지 반복문 실행
// 증감식 : i를 한번 반복할 때마다 1씩 증가해
for (int i =1;i <= 9;i++) {
System.out.println(i + " 3 * " + i + " = " + (3*i));
}
}
}
|
cs |
# for 문으로 1부터 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
|
package day02;
public class StatementTest2 {
public static void main(String[] args) {
// 1. 1부터 10까지 숫자를 화면에 출력
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
System.out.println(6);
System.out.println(7);
System.out.println(8);
System.out.println(9);
System.out.println(10);
System.out.println("---------------");
// 2. (반복문 사용)
for (int i = 1; i <= 10; i++) {
System.out.println(i);
}
}
}
|
cs |
# for 문으로 1111부터 5555까지 출력
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package day02;
public class StatementTest3 {
public static void main(String[] args) {
// 1111
// 2222
// 3333
// 4444
// 5555
for (int i=1; i<=5; i++) {
System.out.println("" + i + i + i + i);
}
}
}
|
cs |
# for 문으로 +++++, ----- 반복 출력
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package day02;
public class StatementTest4 {
public static void main(String[] args) {
/
/ +++++ // -----
// +++++
// -----
// +++++
// -----
for (int i=1; i<=3; i++) {
System.out.println("+++++");
System.out.println("-----");
}
}
}
|
cs |
# for 문으로 누적합 출력
|
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
|
package day02;
public class StatementTest5 {
public static void main(String[] args) {
// 1부터 5까지의 누적합을 출력
// 1 누적합: 1
// 2 누적합: 3
// 3 누적합: 6
// 4 누적합: 10
// 5 누적합: 15
// System.out.println("1 누적합 : 1");
// System.out.println("2 누적합 : 3");
// System.out.println("3 누적합 : 6");
// System.out.println("4 누적합 : 10");
// System.out.println("5 누적합 : 15");
for(int i=1, sum=0 ; i <= 5; i++) {
sum += i;
System.out.println(i + " 누적합 : " + sum);
}
System.out.println("-----------------");
int i = 1;
int sum = 0;
sum = i;
System.out.println(i + " 누적합 : " + sum);
i++; // i <== 2
// sum이라는 변수에 i를 누적
sum = sum + i;
System.out.println(i + " 누적합 : " + sum);
i++;
sum += i;
System.out.println(i + " 누적합 : " + sum);
i++;
sum += i;
System.out.println(i + " 누적합 : " + sum);
i++;
sum += i;
System.out.println(i + " 누적합 : " + sum);
// for (int i=1; i<=5; i++) {
// System.out.println(i+(i++));
// }
}
}
|
cs |
# for 문으로 1부터 100까지의 누적합 출력
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package day02;
public class StatementTest6 {
public static void main(String[] args) {
//1부터 100까지의 누적합을 출력
// for 초기식에서 선언된 변수는 for문 {} 안에서 존재하고 밖으로 빠져나오면 사라지는 변수
// 지역변수 <--> 전역변수
int sum=0; // 전역변수
for(int i = 1; i<=100;i++) {
sum+=i;
System.out.println("누적합 : "+ sum);
}
// System.out.println(i);
int i= 100;
System.out.println("1부터 100까지 누적합은 " +sum+ " 입니다");
}
}
|
cs |
# for 문으로 Hello java world 1부터 5까지 출력
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package day02;
public class StatementTest7 {
public static void main(String[] args) {
String str = "Hello java world ";
for (int i=1; i<=5; i++) {
System.out.println(str + i);
}
System.out.println("반복문 탈출");
}
}
|
cs |
# for 문으로 1부터 10 까지의 홀수만 출력
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package day02;
public class StatementTest8 {
public static void main(String[] args) {
// 1. 1부터 10까지 화면에 출력
// 2. 반복문으로
for (int i=1; i<=10; i++) {
System.out.println(i);
}
System.out.println("---------");
// 3. 1부터 10 사이의 홀수만 출력
// ????
for (int i=1; i<=10; i+=2) {
System.out.println(i);
}
}
}
|
cs |
# for 문을 활용한 String 반복문
|
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
|
package day02;
public class StatementTest9 {
public static void main(String[] args) {
// String을 사용해서 + 반복문
String str = "";
for(int i=1; i<=5; i++) {
str += "*";
System.out.println(str);
}
// str += "*";
// System.out.println(str);
// // *
// str += "*";
// System.out.println(str);
// // **
// str += "*";
// System.out.println(str);
// // ***
// str += "*";
// System.out.println(str);
// // ****
}
}
|
cs |
* while문과 do ~ while문
- 조건에 의해서 반복을 할 때
- while문 > 조건을 만족하면 반복
while(조건) {
문장1;
문장2;
}
- do ~ while문 > 여기에 있는 문장은 반드시 1번은 실행 된다.
do {
문장1;
문장2;
} while (조건);
|
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
|
package day02;
public class StatementTest10 {
public static void main(String[] args) {
// while(조건) {
// 문장1;
// 문장2;
// }
// 구구단 3단 출력
// 3 * 1 = 3 <== 9
int i = 1;
while(i<=9) { // 반복문을 잘못 쓰면 무한 반복
System.out.println("3 * " + i + " = " + i*3);
i++;
}
System.out.println("-----------------");
// do {
// 문장1;
// 문장2;
// } while (조건); <=== ;
// i, j, k, l, m, n 은 관습적으로 정수형 변수
int j = 1;
do {
// 문장
System.out.println("3 * " + j + " = " + j*3);
// j의 값을 1씩 증가
j++;
} while(j<=9);
}
}
|
cs |
| - Src : source Package는 폴더 - Src에 new 폴더 만들기 + 자바 파일을 자동으로 컴파일해서 바이너리 폴더에 저장함 |