39번
public class Test {
public static void main(String[] args) {
int a = 2;
int b = 2;
int c = 2;
System.out.println((a & b) > c ? 2.5 : 1);
}
}
1) int a = 2; int b= 2; int c = 2;
: 정수형 변수 a, b, c 선언하면서 각각 2로 초기화.
2) 계산
: 삼항연산자로, 앞에 조건이 참이면 2.5를, 거짓이면 1을 출력.
① a & b : a와 b를 비트 단위로 AND 연산. a = 10(2), b = 10(2)이고 AND 연산은 둘 다 1일 때 1을 출력하므로 a & b = 10(2) = 2(10)
② (a & b) > 2 : 2 > 2는 거짓이므로 1을 출력.
③ 하지만 여기서 잘 봐야 할 것은 출력할 때 실수 : 정수면 실수를 출력하게 됨. 따라서 1이 아닌 1.0을 출력
[출력]
1.040번
public class Spock {
public static void main(String[] args) {
int mask = 0;
int count = 0;
if(((5 < 7) || (++count < 10)) | mask ++ < 10) mask = mask + 1;
if((6 > 8) ^ false) mask = mask + 10;
if(!(mask > 1) && ++count > 1) mask = mask + 100;
System.out.println(mask + " " + count);
}
}
1) int mask = 0; int count = 0;
: 정수형 변수 mask, count 선언하면서 각각 0으로 초기화.
2) 조건문
① if(((5 < 7) || (++count < 10)) | mask ++ < 10) mask = mask + 1;
ⅰ. 5 < 7의 조건은 참(true)이므로 단락회로평가로 인해 ++count < 10은 계산하지 않음
ⅱ. | 연산은 단락회로평가를 수행하지 않으므로 mask++ < 10은 계산해야 함.
ⅲ. mask는 현재 0이므로 0 < 10은 참(true)이고 mask는 ++ 연산되어 mask = 1을 저장.
ⅳ. true | true는 true이므로 mask = mask + 1 = 1 + 1 = 2. 따라서 mask = 2.
② if((6 > 8) ^ false) mask = mask + 10;
ⅰ. 6 > 8의 조건은 거짓(false)이므로 거짓 ^ 거짓은 거짓을 의미.
ⅱ. 따라서 mask = mask + 10은 수행하지 않음
③ if(!(mask > 1) && ++count > 1) mask = mask + 100;
ⅰ. mask는 현재 2이므로 2 > 1 참(true)이고 !참은 참을 부정하므로 거짓을 의미.
ⅱ. 거짓(false) && ++count : 단락 회로 평가로 인해 계산하지 않음. 앞에 조건이 조것이기 때문.
ⅲ. 따라서 mask = mask + 100은 계산하지 않으므로 현재 mask = 2, count = 0을 출력.
1) 논리연산자 : true / false 조건 연산
① 논리곱(AND, &&) : 피연산자가 모두 true일 경우 결과는 true
② 논리합(OR, || ) : 피연산자 중 하나만 true이면 결과는 true
③ 논리부정(NOT, ! : 피 연산자의 논리값을 바꿈
2) 비트연산자 : 메모리에 저장된 0 / 1 비트 기준 연산
① 논리곱(AND, &) : 두 비트 모두 1일 경우 연산 결과는 1
② 논리합(OR, |) : 두 비트 중 하나만 1이면 연산 결과는 1
③ 배타적 논리합(XOR,, ^) : 두 비트 중 하나는 1이고, 다른 하나는 0일 경우 연산 결과는 1
④ 논리부정(NOT, ~) : NOT, 1이면 0으로, 0이면 1로 바꿈
논리연산자는 단락회로평가를 수행하지만 비트연산자는 단락회로평가를 수행하지 않음.
[출력]
2 041번
public class Test1 {
public static void main(String[] args) {
int a = 1, b = 2, c= 3, d= 4;
if((a == b) & (c++ != d) && (c++ < 6)) c++;
System.out.println(c);
}
}
1) int a = 1, b = 2, c= 3, d= 4;
: 정수형 변수 a, b, c, d 선언하면서 각각 값을 1, 2, 3, 4로 초기화.
2) if((a == b) & (c++ != d) && (c++ < 6)) c++;
① (a == b) : a와 b가 같은지 비교하는데 a = 1, b = 2이므로 조건은 거짓(0).
② (c++ != d) : & 연산자는 단락회로 평가를 수행하지 않으므로 c++ != d 조건 확인.
c++에서 ++ 되기 전 c는 3이고 d = 6이므로 3 != 6은 참(1)을 반환하면서 c = 4로 증가.
③ (a == b) & (c++ != d) : 1 & 1의 결과는 참(1)
④ ((a == b) & (c++ != d) && (c++ < 6)) : && 연산자는 단락회로 평가를 수행하므로 앞에 조건이 참이기 때문에 계산하지 않음.
3) 출력
: 따라서 c의 값을 출력하므로 c = 4를 출력함.
[출력]
442번
public class Test {
int f(int k[]) {
k[1] = k[1] + 4;
return k[1] * 3;
}
public static void main(String[] args) {
int s;
int a = 6;
int b[] = {1, 2, 3, 4, 5};
Test t = new Test();
s = b[1] + t.f(b);
System.out.println(s);
}
}
1) main 함수 먼저 보기.
① int s; : 정수형 변수 s 선언.
② int a = 6; : 정수형 변수 a 선언하면서 6으로 초기화.
③ int b[] = {1, 2, 3, 4, 5}; : 정수형 배열 b 선언하면서 초기화.
④ Test t = new Test(); : Test 클래스의 객체 t를 생성.
⑤ s = b[1] + t.f(b); : 변수 s에 b[1] + t.(b) 대입.
⊙ b[1] : 배열 b의 두 번째 요소를 나타내므로 2를 의미.
⊙ t.f(b) : Test 클래스의 메서드 f를 호출하며 배열 b를 매개변수로 전달
2) Test 클래스
: main 함수에서 t.f(b)는 매개변수로 전달된 배열 b를 받고 b = 1을 의미함. (메서드 내에서 k배열은 b배열을 가리킴)
k[1]은 배열 b의 두 번째 요소이므로 k[1] = 2 + 4 = 6을 의미. 그리고 return k[1] * 3 = 6 * 3 = 18을 반환함.
3) main 함수
: 따라서 변수 s는 b[1] = 2, t.f[b] = 18이므로 2 + 18 = 20을 저장.
4) System.out.println(s);
: s의 값을 출력하므로 20을 출력
[출력]
2043번
public class Wind {
public static void main(String[] args) {
foreach:
for(int j=0; j<5; j++) {
for(int k = 0; k<3; k++) {
System.out.print(" " + j);
if(j==3 && k==1) break foreach;
if(j==0 || j==2) break;
}
}
}
}
이 코드는 중첩된 반복문 사용하여 숫자 출력. 특정 조건에서 레이블 사용하여 외부 반복문 종료시킴.
1) 외부 for문 : j는 0부터 시작해서 하나씩 증가하여 4까지 반복.
2) 내부 for문 : k는 0부터 시작해서 하나씩 증가하여 2까지 반복.
3) for문 실행
① j = 0 일 때
ⅰ. k = 0 일 때
공백과 함께 j 값 출력(j = 0)하고, 첫 번째 if문 조건 확인. j == 3 && k == 1에서 j = 0으로 거짓(false).
두 번째 if문 조건 확인하면 j == 0 || j == 2이면 break이므로 안쪽 for문(k 반복문) 빠져나옴.
② j = 1 일 때
ⅰ. k = 0 일 때
공백과 함께 j 값 출력(j = 1)하고, 첫 번째 if문 조건 확인. j == 3 && k == 1에서 j = 1로 거짓(false).
두 번째 if문 조건 확인하면 j == 0 || j == 2이면 break이지만 현재 j는 1이므로 다시 반복.
ⅱ. k = 1 일 때
공백과 함께 j 값 출력(j = 1)하고, 첫 번째 if문 조건 확인. j == 3 && k == 1에서 j =1로 거짓(false).
두 번째 if문 조건 확인하면 j == 0 || j == 2이면 break이지만 현재 j는 1이므로 다시 반복.
ⅲ. k = 2일 때
공백과 함께 j 값 출력(j = 1)하고, 첫 번째 if문 조건 확인. j == 3 && k == 1에서 j = 1로 거짓(false).
두 번째 if문 조건 확인하면 j == 0 || j == 2이면 break이지만 현재 j는 1이므로 다시 반복.
ⅳ. k = 2일 때 조건이 맞지 않아 for문 빠져나옴.
③ j = 2 일 때
ⅰ. k = 0 일 때
공백과 함께 j 값 출력(j = 2)하고, 첫 번째 if문 조건 확인. j == 3 && k == 1에서 j = 2로 거짓(false).
두 번째 if문 조건 확인하면 j == 0 || j == 2이면 break이고, 현재 j = 2이므로 break 실행하여 안쪽 for문(k 반복문) 빠져나옴.
④ j = 3 일 때
ⅰ. k = 0 일 때
공백과 함께 j 값 출력(j = 3)하고, 첫 번째 if문 조건 확인. j == 3 && k == 1에서 j = 3이지만 k = 1이 아니므로 거짓(false).
(단락회로 평가를 생각할 수 있지만 여기에서 사용한 if문은 단순 조건 평가이며, 단락회로 평가는 논리연산자에서만 수행되는 것.
즉, break foreach 구문 자체는 단순히 조건이 참일 때 외부 루프를 종료하는 동작을 수행하는 것으로 단락회로 평가와는 상관이 없음.)
두 번째 if문 조건 확인하면 j == 0 || j == 2이면 break이고, 현재 j = 2이므로 break 실행하여 안쪽 for문(k 반복문) 빠져나옴.
ⅰ. k = 1 일 때
공백과 함께 j값 출력(j = 3)하고, 첫 번째 if문 조건 확인.
j == 3 && k == 1에서 j = 3에서 j = 3, k = 1이므로 break foreach가 수행되어 이중 for문 빠져나가 완전히 종료가 됨.
4) 출력
: j값들을 출력하면 0 1 1 1 2 3 3
[출력]
0 1 1 1 2 3 344번
public class Circles {
public static void main(String[] args) {
int[] ia = {1, 3, 5, 7, 9};
for(int x : ia) {
for(int j = 0; j < 3; j++) {
if(x > 4 && x < 8) continue;
System.out.print(" " + x);
if(j == 1) break;
continue;
}
continue;
}
}
}
1) int[] ia = {1, 3, 5, 7, 9};
: 정수형 배열 ia 선언하면서 초기화.
2) for - each문 : 배열 ia의 각 요소 x를 순차적으로 탐색. 여기서는 x의 값이 1, 3, 5, 7, 9 순으로 진행.
3) 내부 for문 ; j는 0부터 시작해서 하나씩 증가하여 2까지 반복.
4) if문 조건 : x > 4 && x < 8은 x가 4보다 크고, 8보다 작으니까 5, 6, 7일 때 조건을 만족.
5) for문 실행
① x = 1 일 때
ⅰ. j = 0 일 때
if문 실행하면, x > 4 && x < 8 일 때 continue 실행하지만 현재 x = 1이므로 조건은 거짓(false).
출력하면 공백화 함께 x값 출력하고 (x = 1), 다음 두 번째 if문 보면 j == 1 일 때 break 실행하지만 현재 j = 0이므로 다음 반복문 실행.
ⅱ. j = 1일 때
if문 실행하면, x > 4 && x < 8 일 때 continue 실행하는데 현재 x = 1이므로 조건은 거짓(false).
출력하면 공백가 함께 x값 출력하고 (x = 1),
다음 두 번째 if문 보면 j == 1 일 때 break 실행하고 현재 j = 1이므로 break 실행하여 내부 루프 종료.
② x = 3 일 때
ⅰ. j = 0 일 때
if문 실행하면, x > 4 && x < 8 일 때 continue 실행하지만 현재 x = 3이므로 조건은 거짓(false).
출력하면 공백과 함께 x값 출력하고 (x = 3), 다음 두 번째 if문 보면 j == 1일 때 break 실행하지만 현재 j = 0이므로 다음 반복문 실행.
ⅰ. j = 1일 때
if문 실행하면, x > 4 && x < 8 일 때 continue 실행하지만 현재 x = 3이므로 조건은 거짓(false).
출력하면 공백과 함께 x값 출력하고 (x = 3),
다음 두 번째 if문 보면 j == 1 일 때 break 실행하는데 현재 j = 1이므로 break 실행하여 내부 루프 종료.
③ x = 5 일 때
ⅰ. j = 0 일 때
if문 실행하면, x > 4 && x < 8 일 때 continue 실행하므로 아래문장 실행하지 않고 다음 반복문 실행.
ⅱ. j = 1, j = 2 일 때도 똑같이 반복되므로 출력할 거 없이 내부 루프 종료.
④ x = 7 일 때도 x = 5와 같이 반복되므로 출력할 게 없음.
⑤ x = 9 일 때
ⅰ. j = 0 일 때
if문 실행하면, x > 4 && x < 8 일 때 continue 실행하지만 현재 x = 9이므로 조건은 거짓(false).
출력하면 공백과 함께 x값 출력하고 (x = 9), 다음 두 번째 if문 보면 j == 1 일 때 break 실행하지만 현재 j = 0이므로 다음 반복문 실행.
ⅱ. j = 1 일 때
if문 실행하면, x > 4 && x < 8 일 때 continue 실행하지만 현재 x = 9이므로 조건은 거짓(false).
출력하면 공백과 함께 x값 출력하고 (x = 9),
다음 두 번째 if문 보면 j == 1 일 때 break 실행하는데 현재 j = 1 이므로 break 실행하여 내부 루프 종료.
6) 출력
: x 값들을 출력하면 1 1 3 3 9 9
1 1 3 3 9 9
[출력]
45번
public class Test {
public static void main(String[] args) {
int i, j, n = 0;
aaa:
for(i = 0; i < 3; i++) {
for(j = 0; j < 3; j++) {
System.out.print("abc" + " ");
continue aaa;
}
}
System.out.println("ccc");
}
}
1) int i, j, n = 0;
: 정수형 변수 i, j, n 선언하고 n은 0으로 초기화.
2) 외부 for문 : i는 0부터 시작해서 하나씩 증가하여 2까지 반복.
3) 내부 for문 : j는 0부터 시작해서 하나씩 증가하여 2까지 반복.
4) for문 실행
① i = 0 일 때
ⅰ. j = 0 일 때 abc와 함께 공백 출력(abc)하고 continue aaa가 실행되어 내부 루프 종료되고 외부 for문으로 이동.
② i = 1 일 때
ⅰ. j = 0 일 때 abc와 함께 공백 출력(abc)하고 continue aaa가 실행되어 내부 루프 종료되고 외부 for문으로 이동.
③ i = 2 일 때
ⅰ. j = 0 일 때 abc와 함께 공백 출력(abc)하고 continue aaa가 실행되어 내부 루프 종료되고 외부 for문으로 이동.
④ i = 3 일 때 조건이 맞지 않아 for문 종료. 외부 for문까지 종료 후 마지막 출력 문장 ccc를 출력 후 해당 코드 종료.
[출력]
abc abc abc ccc46번
public class Test {
public static void main(String[] args) {
int i = 1, j = 5;
do {
if(i > j) {
continue;
}
j--;
System.out.println("i = " + i+ " and j = " + j);
} while(++i < 3);
System.out.println("i = " +i+ " and j = " + j);
}
}
1) int i = 1, j = 5;
: 정수형 변수 i, j 선언하면서 i는 1, j는 5로 초기화.
2) do-while문장.
do - while 문장은 조건식을 검사하기 전에 무조건 중괄호 내부에 있는 실행문을 한 번 실행 후 조건 검사하여 반복 결정.
do {
① 실행문
} while (② 조건식)
for, while은 반복 횟수가 0 ~ n회이면 do - while은 반복 횟수가 1 ~ n회
① if(i > j) { continue;} :
먼저 중괄호 내부에 있는 if문 먼저 실행.
i = 1, j = 5이므로 1 > 5 조건은 거짓(false)이 되어 continue는 실행되지 않음
② j-- : -- 연산되어 j = 4로 감소.
③ System.out.println("i = " + i+ " and j = " + j) : 출력하면 i = 1 and j = 4.
④ ++i < 3 : 이제 조건식을 확인하여 반복 실행. ++i 하면 현재 i = 1이므로 ++ 연산되어 i = 2이고 2 < 3 조건은 참(true)이므로 실행.
⑤ if(i > j) { continue;} : i = 2, j = 4이므로 2 > 4 조건은 거짓(false)이 되어 continue는 실행되지 않음.
⑥ j-- : -- 연산되어 j = 3으로 감소.
⑦ System.out.println("i = " + i+ " and j = " + j) : 출력하면 i = 2 and j = 3.
⑧ ++i < 3 : 조건식 보면 ++i 하면 현재 i = 2이므로 ++ 연산되어 i = 3이고 3 < 3 조건은 거짓(false)이므로 루프 종료.
3) System.out.println("i = " +i+ " and j = " + j);
: 현재 i = 3, j = 3이므로 i = 3 and j = 3으로 출력.
[출력]
i = 1 and j = 4
i = 2 and j = 3
i = 3 and j = 3
47번
public class Testcount {
public static void main(String[] args) {
long charge = 5000;
String country1 = args[1];
String country2 = "Korea";
if (country1.equals(country2))
charge = 10000;
else
charge = 20000;
System.out.println(charge + "[" + args.length + "]");
}
}
실행 : C:\java Testcount Korea Germany
1) 실행 : C:\java Testcount Korea Germany
: 실행을 보면 Testcount는 실행할 Java 클래스 이름이고, Korea Germany는 명령줄 인수로 프로그램에 전달.
따라서 args[0] = "Korea", args[1] = "Germany"로 값들이 저장됨.
2) long charge = 5000;
: long 타입의 변수 charge 선언하면서 5000으로 초기화.
3) String country1 = args[1];
: country1에는 args[1]이 저장되므로 args[1]은 Germany가 저장되어 있기 때문에 country1 = "Germany"
4) String country2 = "Korea"
: country2에는 "Korea"가 저장.
5) country1.equals(country2)
: equals 메서드는 문자열 객체의 내용을 비교. 즉 두 문자열이 같은 문자들로 구성되어 있는지 확인.
따라서 country1 = "Germany", country2 = "Korea"로 두 문자열은 같지 않기 때문에 거짓(false)을 반환하므로 else문 실행.
else문 실행하면 charge = 20000;으로 변경.
6) System.out.println(charge + "[" + args.length + "]");
: charge는 20000으로 출력.
args.length는 args의 길이를 출력하는 것으로 2를 출력. 명령줄 인수로 "Korea", "Germany" 두 개가 전달되었기 때문.
[출력]
20000[2]48번
class A{}
class B extends A{}
class Test {
void dis(A a) {System.out.print("aaa" + " ");}
void dis(B b) {System.out.print("bbb" + " ");}
public static void main(String[] args) {
Test te = new Test();
A a = new A();
B b = new B();
A c = new B();
te.dis(a);
te.dis(c);
te.dis(b);
}
}
이 코드는 메서드 오버로딩과 다형성의 동작 방식 보여줌.
1) class A{ }, class B extends A { }
: 클래스 A와 B가 정의되고, B 클래스는 A 클래스를 상속 받음. B는 A의 자식 클래스임.
2) class Test
: Test 클래스 정의.
3) void dis (A a) : A 타입 객체를 인수로 받는 메서드.
4) void dis (B b) : B 타입 객체를 인수로 받는 메서드.
5) Test te = new Test(); → Test 객체 생성
6) A a = new A(); → A 타입 객체 변수 a 생성.
7) B b = new B(); → B 타입 객체 변수 b 생성.(A를 상속)
8) A c = new B(); → A 타입으로 변수 c 생성되고, 이 변수에 B객체 생성 (업캐스팅)
9) te.dis(a); → a는 A 타입 객체이므로, void dis(A a) 메서드 호출되어 "aaa" 출력.
10) te.dis(c) → c는 B 객체이지만 A 타입으로 선언된 변수. 메서드 호출 시 컴파일러는 참조타입(A)을 보고 dis(A a)를 호출하여 "aaa" 출력.
11) te.dis(b) → b는 B 타입 객체이므로, void dis(B b) 메서드 호출되어 "bbb" 출력.
메서드 오버로딩은 컴파일 시점에 결정되므로, 참조 변수 타입을 기준으로 호출할 메서드를 결정.
현재 상위클래스는 A, 하위클래스는 B이므로 A c = new B();이지만 그 반대인 B c = new A();는 불가능.
[출력]
aaa aaa bbb
! 강의 보며 혼자 공부한 것으로,
틀린 거 있을 시 댓글로 가르쳐 주시면 감사하겠습니다!
'Studying > 정보처리기사' 카테고리의 다른 글
| [정보처리기사 실기]_2020년 1회 (1) | 2024.10.04 |
|---|---|
| [정보처리기사 실기]_JAVA언어 특강(6) (3) | 2024.10.02 |
| [정보처리기사 실기]_C언어 특강(4) (3) | 2024.10.01 |
| [정보처리기사 실기]_C언어 특강(3) (4) | 2024.09.30 |
| [정보처리기사 실기]_C언어 특강(2) (2) | 2024.09.28 |
