#include <stdio.h>
void main() {
int i, total = 0;
for (i = 0; i < 10; i++) {
if (!(i % 2)) continue;
total = total + i;
}
printf("%d\n", total);
}
출력값은 25이다. 짝수일 때 continue 로 건너뛰므로 홀수만 누적된다.
i%2 가 0(짝수)이면 !(i%2) 가 참이 되어 덧셈을 생략한다. 따라서 total = 1+3+5+7+9 이다.
- 20은 짝수 0~8의 합으로, 조건을 반대로 해석한 값이다.
- 45는 0~9 전체의 합으로, continue 를 무시한 값이다.
- 55는 1~10의 합으로, 반복 범위도 잘못 본 값이다.
#include <stdio.h>
int func() {
static int x = 10;
return x += 10;
}
void main() {
int x;
x = func();
x = func();
printf("a = %d\n", x);
}
#include <stdio.h>
int x = 10;
void func() {
x += 10;
}
void main() {
int x = 10;
func();
func();
printf("b = %d\n", x);
}
#include <stdio.h>
int x = 10;
void func() {
x += 10;
}
void main() {
func();
func();
printf("c = %d\n", x);
}
b = 30
c = 10
b = 30
c = 30
b = 10
c = 30
b = 30
c = 30
출력은 a = 30, b = 10, c = 30이다. 정적 지역 변수는 값이 유지되고, 지역 변수는 같은 이름의 전역 변수를 가린다.
프로그램 1의 static x 는 최초 1회만 10으로 초기화되어 호출마다 20, 30이 된다. 프로그램 2의 main 은 지역 x(10)를 출력하고 func() 는 전역 x 만 바꾼다. 프로그램 3은 전역 x 를 두 번 증가시켜 30이 된다.
- a = 10 으로 본 것은 static 변수가 호출마다 재초기화된다고 오해한 것이다.
- b = 30 으로 본 것은 func() 가 main 의 지역 x 를 바꾼다고 오해한 것이다.
- c = 10 으로 본 것은 전역 변수 갱신을 반영하지 않은 것이다.
A → aA | B
B → Bb | c
A → c
A → aAb | c
옳은 문법은 S → aSb | c이다. 재귀 규칙이 a 와 b 를 같은 개수로 짝지어 감싸고, n = 0 이면 c 만 생성된다.
S → aSb 를 n번 적용한 뒤 S → c 로 끝내면 이 정확히 만들어진다.
- S → aA, A → aA | B, B → Bb | c 는 a 의 개수와 b 의 개수를 서로 독립적으로 늘려 개수를 맞추지 못하며 c 단독도 만들 수 없다.
- S → aAb, A → c 는 acb 한 문자열만 생성한다.
- S → aAb, A → aAb | c 는 a 와 b 가 최소 하나씩 있어야 하므로 n = 0 인 c 를 생성하지 못한다.
class ClassA {
private static ClassA instance = new ClassA();
private ClassA() {
System.out.print("객체생성-");
}
public static ClassA getInstance() {
return instance;
}
}
public class Test {
public static void main(String[] args) {
ClassA obj1 = ClassA.getInstance();
ClassA obj2 = ClassA.getInstance();
if (obj1 == obj2) System.out.println("같다");
else System.out.println("다르다");
}
}출력은 객체생성-같다이다. 이 코드는 싱글톤(singleton) 패턴이다.
static 필드 instance 는 클래스가 로드될 때 한 번만 생성되므로 생성자 출력도 한 번뿐이다. getInstance() 는 항상 같은 객체를 반환하므로 obj1 == obj2 는 참이다.
- 생성자 출력이 두 번이라는 결과는 getInstance() 가 호출마다 객체를 새로 만든다고 오해한 것이다.
- 다르다는 결과는 두 참조가 같은 객체를 가리킨다는 점을 놓친 것이다.
#include <stdio.h>
void main() {
int a, b, c, r;
a = 4;
b = 2;
c = 3;
r = a++ - ++b * (c << 2);
printf("%d\n", r);
}
출력값은 -32이다. 후위 증가는 증가 전 값을, 전위 증가는 증가 후 값을 식에 쓴다.
a++ 는 4, ++b 는 3, c << 2 는 3을 왼쪽으로 2비트 이동한 12이다. 곱셈이 뺄셈보다 먼저 계산된다.
- -20은 ++b 를 증가 전 값 2로 계산한 값이다.
- 12는 곱셈 우선순위를 무시하고 a++ - ++b 를 먼저 계산한 값이다.
매개변수와 자동 변수는 스택(stack)에 저장된다. 함수 호출마다 활성화 레코드가 스택에 쌓이고 반환 시 제거된다.
자동 변수는 함수 실행 동안만 존재하므로 호출·반환 순서(LIFO)와 수명이 같은 스택 영역이 적합하다.
- 히프는 new 등으로 동적 할당한 객체가 저장되는 영역이다.
- 정적 데이터 구역은 전역 변수와 static 변수가 저장되는 영역이다.
- 프로세스 제어 블록은 운영체제가 프로세스 관리 정보를 보관하는 자료구조로, 프로그램 변수 저장 영역이 아니다.
class Mammal {
void mamma() {
System.out.println("mamma");
}
}
class Human extends Mammal {
void speak() {
System.out.println("speak");
}
}
class ReferenceCast {
public static void main(String args[]) {
Mammal mammal;
Human human;
mammal = new Mammal();
human = new Human();
㉠
}
}주어진 프로그램의 ㉠ 부분에 다음 <보기 1> 또는 <보기 2> 문장이 들어가는 경우에 대한 설명으로 옳은 것은?human = (Human)mammal;
human.mamma();
mammal = human;
mammal.speak();
하향 형변환은 컴파일은 되지만, 실제 객체가 Mammal 이면 실행 중 ClassCastException 이 발생합니다.
- <보기 1>:
(Human)mammal은 상속 관계의 명시적 형변환이라 컴파일러가 허용합니다. 그러나 mammal 이 가리키는 실제 객체는 Mammal 이므로 실행 시 예외가 나고, 다음 줄은 실행되지 않습니다. - <보기 2>:
mammal = human;은 상향 형변환이라 문제없이 컴파일됩니다. 오류는 다음 줄에서 납니다. 변수의 선언 타입인 Mammal 에 speak() 가 없어mammal.speak();가 컴파일 오류입니다.
import java.util.*;
class Test {
public static void main(String args[]) {
LinkedList<Integer> list =
new LinkedList<Integer>();
list.addLast(new Integer(20));
list.addLast(new Integer(10));
Iterator e = list.iterator();
while (e.hasNext()) {
Integer num = (Integer)e.next();
System.out.print(num + " ");
}
while (!list.isEmpty()) {
Integer num = list.removeLast();
System.out.print(num + " ");
}
}
}
출력은 20 10 10 20이다. 반복자는 앞에서부터 순회하고, removeLast() 는 뒤에서부터 꺼낸다.
addLast 로 20, 10 순서로 넣었으므로 리스트는 [20, 10]이다. 반복자 순회는 20 10, removeLast 반복은 10 20 을 출력한다.
- 10 20 으로 시작하는 결과는 addLast 를 앞에 삽입하는 것으로 오해한 것이다.
- 20 10 20 10 은 removeLast 를 앞에서 꺼내는 것으로 오해한 것이다.
#include <stdio.h>
int getnext(int a) {
return (a * 2 + 1);
}
void main() {
int i, j, k = 0;
for (i = 1; i < 10; i++)
for (j = 1; j < getnext(i); j++)
k++;
printf("k = %d\n", k);
}
출력은 k = 90이다. 안쪽 반복은 j 가 1부터 2i 까지이므로 i 마다 2i 회 실행된다.
getnext(i) = 2i+1 이고 조건이 j < 2i+1 이므로 반복 횟수는 2i 이다.
- 99는 i 마다 2i+1 회 반복한다고 계산한 값이다.
- 110은 i 를 10까지 포함해 2i 를 합한 값이다.
- 120은 i 를 10까지 포함하고 2i+1 회씩 센 값이다.
#include <stdio.h>
void main() {
int a[2][3] = {{-3, 14, 5}, {1, -10, 8}};
int *b[] = {a[0], a[1]};
int *p = b[1];
printf("%d, ", *b[1]);
printf("%d, ", *(--p - 2));
printf("%d\n", *(*(a + 1) + 1));
}
출력은 1, -3, -10이다. 2차원 배열은 메모리에 행 우선으로 연속 배치되므로 포인터 연산이 행 경계를 넘을 수 있다.
*b[1] 은 a[1][0] 인 1이다. p 는 &a[1][0] 이고 --p 는 a[0][2], 다시 2를 빼면 a[0][0] 이므로 -3이다. *(*(a+1)+1) 은 a[1][1] 인 -10이다.
- 첫 값을 -3으로 본 결과는 b[1] 을 첫 행으로 착각한 것이다.
- 둘째 값을 3으로 본 결과는 --p - 2 가 a[0][0] 을 가리킨다는 점을 놓친 것이다.
- 셋째 값을 8로 본 결과는 a[1][2] 를 가리킨다고 오해한 것이다.
#include <stdio.h>
( ㉠ ) // 배열의 원소 값을 두배로 하는 함수 정의
void main() {
int x[2][3] = {{1, 2, 3}, {4, 5, 6}};
( ㉡ ) // 함수 ㉠ 호출
}
void dubl(int ary[][], int row, int col) {
int i, j;
for (i = 0; i < row; i++)
for (j = 0; j < col; j++)
ary[i][j] *= 2;
}㉡ dubl(x, 2, 3);void dubl(int ary[], int size) {
int i;
for (i = 0; i < size; i++)
ary[i] *= 2;
}㉡ int i;for (i = 0; i < 2; i++) dubl(x[i], 3);
void dubl(int ary[], int size) {
int i;
for (i = 0; i < size; i++)
ary[i] *= 2;
}㉡ dubl(x[0], 6);void dubl(int *ary, int size) {
int i;
for (i = 0; i < size; i++)
*(ary + i) *= 2;
}㉡ dubl(x[0], 6);옳지 않은 것은 매개변수를 int ary[][] 로 선언한 경우이다. 2차원 배열 매개변수는 첫 차원을 제외한 크기를 반드시 명시해야 하므로 컴파일 오류가 된다.
컴파일러는 ary[i][j] 의 주소를 계산하려면 한 행의 원소 수(열 크기)를 알아야 한다. int ary[][3] 처럼 써야 한다.
- x[i] 를 1차원 배열로 넘겨 행마다 3개씩 두 배로 하는 방식은 올바르다.
- x[0] 과 크기 6을 1차원 배열 매개변수로 넘기는 방식은 원소가 연속 배치되어 있으므로 전체가 처리된다.
- 같은 인수를 포인터 매개변수와 *(ary+i) 로 처리하는 방식도 동일하게 동작한다.
#include <stdio.h>
void swap(int i, int *j) {
int tmp;
tmp = i;
i = *j;
*j = tmp;
}
void main() {
int i, j;
i = 10;
j = 9;
swap(i, &j);
printf("%d\n", i - 1);
}
출력값은 9이다. 첫 인자 i 는 값 전달이므로 함수 안에서 바꿔도 main 의 i 는 그대로 10이다.
swap 은 *j 에만 실제 변경을 반영하여 main 의 j 는 10이 되지만, 출력하는 것은 i - 1 이다.
- 8은 i 가 j 의 값 9로 바뀌었다고 오해한 값이다.
- 10은 i 자체를 출력한다고 본 값이다.
- 11은 i - 1 을 i + 1 로 잘못 본 값이다.
#include <stdio.h>
int m(int x) {
if (x == 1) return 3;
else return 2 * m(x - 1);
}
void main() {
printf("%d\n", m(5));
}
출력값은 48이다. m(x) 는 m(1) = 3 에서 시작해 재귀마다 2배가 된다.
- 12는 m(3) 의 값이다.
- 24는 m(4) 의 값이다.
- 72는 배수 관계를 잘못 적용한 값으로 m(5) 와 맞지 않는다.
class C {
int x = 10;
void show_me() {
System.out.println("상위클래스 C의 show_me() 메소드");
}
void write() {
this.show_me();
System.out.println("x 값은 : " + x);
}
}
class D extends C {
int x = 20;
void show_me() {
System.out.println("하위클래스 D의 show_me() 메소드");
}
}
class InheritThis {
public static void main(String args[]) {
D d = new D();
d.write();
}
}x 값은 : 10
x 값은 : 10
x 값은 : 20
x 값은 : 20
출력은 하위클래스 D의 show_me() 메소드와 x 값은 : 10이다. 메소드는 동적 바인딩되지만 필드는 오버라이딩되지 않는다.
this.show_me() 는 실제 객체 D 의 재정의 메소드를 호출한다. 반면 write() 는 C 에 정의되어 있어 x 는 C 의 필드로 정적으로 결정되며, D 의 x 는 C 의 x 를 가릴 뿐이다.
- 상위클래스 C의 메소드가 출력된다는 결과는 오버라이딩된 메소드의 동적 바인딩을 놓친 것이다.
- x 값이 20이라는 결과는 필드도 메소드처럼 재정의된다고 오해한 것이다.
옳지 않은 것은 protected 에 대한 설명이다. Java 의 protected 는 파생 클래스뿐 아니라 같은 패키지의 모든 클래스에서도 접근할 수 있다.
Java 의 접근 범위는 public > protected > default(지정자 없음) > private 순으로, protected 는 default 범위에 다른 패키지의 하위 클래스를 더한 것이다.
- public 메소드는 모든 클래스에서 접근 가능하다는 설명은 옳다.
- private 메소드는 자신이 속한 클래스 안에서만 접근 가능하다는 설명은 옳다.
- 접근지정자가 없으면 같은 패키지 안에서 접근 가능하다는 설명은 패키지 접근(default)으로 옳다.
class ThreadTest implements ( ㉠ ) {
public void run() {
System.out.println("쓰레드 실행부분....");
}
}
public class ImplOfThread {
public static void main(String[] args) {
Thread t = new Thread(new ThreadTest());
System.out.println("Before");
( ㉡ )
System.out.println("After");
}
}㉠ ㉡㉠은 Runnable, ㉡은 t.start();이다. Runnable 은 인터페이스라 implements 로 구현하며, 스레드는 start() 로 실행을 시작한다.
Thread 는 클래스이므로 implements 뒤에 올 수 없다. join() 은 이미 시작된 스레드의 종료를 기다리는 메소드라 시작되지 않은 스레드에 쓰면 run() 이 실행되지 않는다.
- Thread 를 implements 하는 조합은 클래스를 인터페이스처럼 구현하려는 것이라 컴파일 오류가 난다.
- Runnable 과 t.join() 조합은 스레드를 시작하지 않아 run() 이 실행되지 않으며, join() 이 던지는 검사 예외 InterruptedException 을 처리하지 않아 컴파일도 되지 않는다.
#include <stdio.h>
int fac(int n) {
if (n <= 1) return 1;
else return (n * fac(n - 1));
}
void main() {
int x;
x = fac(4);
}
저장할 필요가 없는 것은 정적 링크(static link)이다. C 는 함수 중첩 정의를 허용하지 않아 바깥 함수의 지역 변수를 참조할 일이 없다.
정적 링크는 정적 유효범위에서 외부 블록(정의 환경)의 활성화 레코드를 가리키는 포인터로, Pascal·Ada 처럼 중첩 함수가 있는 언어에서 필요하다. C 의 비지역 변수는 전역 변수뿐이라 고정 주소로 접근한다.
- 함수의 반환값은 n * fac(n-1) 계산 결과를 호출자에게 넘기기 위해 필요하다.
- 복귀 주소는 재귀 호출이 끝난 뒤 호출 지점으로 돌아가기 위해 필요하다.
- 매개 변수 n 의 값은 재귀 호출마다 달라 각 활성화 레코드에 따로 보관해야 한다.
abstract class Person {
int age;
protected String name;
abstract String job();
public int getAge() {
return age;
}
}
public class HumanResource {
public static void main(String[] args) {
Person p = new Person();
}
}오류 원인은 추상 클래스로부터 객체를 생성한 것이다. abstract 클래스는 new 로 인스턴스화할 수 없다.
추상 클래스는 하위 클래스가 추상 메소드를 구현한 뒤 그 하위 클래스 객체를 만들어 사용해야 한다.
- 접근지정자 없는 멤버변수는 패키지 접근으로 허용되므로 오류가 아니다.
- 추상 메소드 job() 에 몸체가 없는 것은 추상 메소드의 정상 형태이다.
- 추상 클래스도 몸체가 있는 일반 메소드를 가질 수 있으므로 getAge() 는 문제없다.
class Calc1 {
protected int a, b;
public Calc1() {
a = 1;
b = 2;
}
}
class Plus extends Calc1 {
void answer() {
System.out.println(a + "+" + b + "=" + (a + b));
}
void answer(int a, int b) {
System.out.println(a + "+" + b + "=" + (a + b));
}
}사용되지 않은 특성은 오버라이딩(overriding)이다. Plus 의 두 answer() 는 같은 클래스 안에서 매개변수만 다른 오버로딩이며, 상위 클래스 Calc1 에는 answer() 가 없어 재정의할 대상이 없다.
오버라이딩은 상위 클래스 메소드와 같은 시그니처로 하위 클래스에서 다시 정의하는 것이다.
- Plus 가 extends Calc1 로 필드 a, b 를 물려받으므로 상속이 사용되었다.
- 필드를 protected 로 선언해 외부 접근을 제한하므로 캡슐화가 사용되었다.
- 이름이 같고 매개변수 목록이 다른 answer() 두 개가 있으므로 오버로딩이 사용되었다.
class TestExcep {
static int a, b;
public static void div() {
try {
System.out.println("a를 b로 나눈 몫 = " + (a / b));
} catch(Exception e) {
System.out.println("Exception 처리 루틴2 : ");
} finally {
System.out.println("div()의 finally 블록 수행");
}
}
public static void main(String args[]) {
try {
a = 1;
b = 1;
div();
} catch(Exception e) {
System.out.println("Exception 처리 루틴1 : ");
} finally {
System.out.println("main()의 finally 블록 수행");
}
}
}div()의 finally 블록 수행
main()의 finally 블록 수행
div()의 finally 블록 수행
main()의 finally 블록 수행
출력은 몫 출력 뒤 div() 의 finally, main() 의 finally 가 차례로 이어진다. finally 블록은 예외 발생 여부와 관계없이 항상 실행된다.
b = 1 이므로 1/1 = 1 로 예외가 없어 catch 는 모두 건너뛴다. div() 가 끝나며 그 finally 가 먼저 실행되고, main 의 try 가 끝나며 main 의 finally 가 실행된다.
- 몫만 출력된다는 결과는 예외가 없으면 finally 가 생략된다고 오해한 것이다.
- div() 의 finally 까지만 출력된다는 결과는 main 의 finally 를 빠뜨린 것이다.
- main() 의 finally 만 출력된다는 결과는 div() 안의 finally 를 빠뜨린 것이다.