[실기][10장 프로그래밍 언어 활용] 오답 정리

[연산자 우선순위]

단항 연산자	단항 연산자	! ~ ++ - -  size of	<-
이항 연산자	산술 연산자	* / % + -	->
	시프트 연산자	<< >>
	관계 연산자	<  <=  >=  >  ==  !=
	비트 연산자	& (AND) ^ (XOR) | (OR)
	논리 연산자	&& (AND) ||  (OR)
삼항 연산자	조건 연산자	?  :	->
대입 연산자	대입 연산자	=  +=  -=  *=  /=  %=  <<=  >>=	<-

 

[연산자 우선순위 문제]

#include <stdio.h>
main(){
	int a = 12, b = 8, c = 2, d = 3;
        a /= b++ - c * d;
        printf("%d", a);
}

1) a /= b++ - c * d   
2) a /= b++ - 6
3) a /= 2
>> 6
# b++ 는 후치 연산으로, 연산에 참여한 후 1 증가한다. 
# a = 6, b = 9, c = 2, d = 3

public class Problem{
	public static void main(String [] args){
    	int a, b, c, hap;
        a = b = c = 2;
        hap = ++a | b-- & c--;
        System.out.printf("%d %d %d %d", hap, a, b, c, d)
    }
}

1) hap = ++a | b-- & c- -;
2) hap = 3 | 2 & 2;  
3) hap = 3 | 2;
4) 3 = 0000 0011, 2 = 0000 0010 / 0000 0011 
>> 3 3 1 1 

1.연산자 우선 순위 확인 (++, -- > & > | > =
2. 전치 연산, 후치 연산 확인하기 

 

[비트 연산 문제]

public class Problem{
	public static void main(String[] args){
    	byte a = 15, b = 19;
        System.out.printf("%d\n", ~a);
        System.out.printf("%d\n", a^b);
        System.out.printf("%d\n", a&b);
        System.out.printf("%d\n", a|b);
    }
}

java byte = 8 bit
15 = 0000 1111 , 19 = 0001 0011
~a = 1111 0000 
- java는 C와 같이 2의 보수를 사용하므로 맨 왼쪽 비트는 부호 비트이다. (0이면 양수, 1이면 음수)
- 원래 값을 알기 위해 2의 보수를 구한다. 
- 0000 1111 > 0001 0000 > 16, 부호 비트가 1이였으므로, > - 16 
a ^ b = 0001 1100 > 16 + 8 + 4 > 28 (1 ^ 0 = 1, 나머지는 0 )
a & b = 0000 0011 > 2 + 1 > 3 (1 & 1 = 1, 나머지는 0)
a | b = 0001 1111 > 16 + 8 + 4 + 2 + 1 > 31 (0 | 0 = 0, 나머지는 1)

[2의 보수 구하는 방법]
1. 1의 보수를 구한다. (비트 0과 1을 반전시킨다. )
2. 1의 보수에서 1을 더한다. 
3. 10진수로 변환 후, 부호를 붙여준다. 

#include <stdio.h>
main(){
	int a = 2, b = 3, c = 4, d, e;
    d = a & b & ~b;
    e = a | b & c;
    printf("%d %d", d, e);
}

d = a & b & ~b; > b와 ~b는 0과 1이 반대이다. 그래서 AND 비트 연산 시 모두 0 이 됨. 
e = a | b & c; > &연산이 |연산보다 우선 순위가 높으므로, a | (b & c) 순서로 연산
- b = 0000 0011 & c = 0000 0100 > 0000 0000
- a = 0000 0010 & 0000 0000 > 0000 0010 > 2
>>  0 2

 

[시프트 연산 문제]

a, c = 32, -3
b = a << 2
a >>= 3
c = c << 2
print(a, b, c)

a = 0010 0000 (32)
b = a << 2 
- a를 왼쪽으로 2번 시프트 해준다. 0100 0000 > 1000 0000 > 10진수로 변환하면 128 
a >> = 3 (a = a >> 3 축약)
- a를 오른쪽으로 3번 시프트 해준다. 0001 0000 > 0000 1000 > 0000 0100 > 10진수로 변환하면 4
c = c << 2
- c를 2진수로 표현하면,  0000 0011 > 1111 1100 > 1111 1101 
- c = -3 -> 음수이므로, 2진수 변환하려면 3을 2진수로 표현하고 2의 보수를 구한다. 
- 시프트 연산 : 1111 1010 > 1111 0100 
- 다시 10진수로 변환하려면 2의 보수를 구해준다. 
- 0000 1011 > 0000 1100 > 12 , 부호비트가 음수였으므로, -12 가 된다. 
>> 출력: 4 128 -12 

음수인 10진수를 2진수로 변환할 때, 
1. 양수를 2진수로 변환한다. 
2. 1의 보수를 구한다. (0과 1을 반전시킨다. )
3. 2의 보수를 구한다. (1의 보수에서 1을 더한다. )

시프트 연산 
* 맨 왼쪽의 부호 비트를 제외하고 시프트 해준다. 
* 음수일 때 시프트 연산 시, 빈자리(패딩비트)에 왼쪽 시프트일 때는 0, 오른쪽 시프트일 때는 1을 채워넣는다. 

 

[String 문제]

public class Problem{
	public static void main(String[] args){
    	String str = "Information!";
        int n = str.length();
        char[] st = new char [n];
        n--;
        for(int k = n; k >= 0; k--){
        	st[n-k] = str.charAt(k);  //1
        }
        for(char c:st){  //2
        System.out.printf("%c", c);
        }
    }
}

>> !noitamrofnI

#1 - str.charAt(k)
- charAt 메소드는 문자열에서 지정된 위치의 문자를 읽어온다.
(문자열 변수 str에서 K번째 위치의 문자를 읽어온다.) 
#2 - for (char c:st) 
- st 배열의 요수 수만큼 반복 수행한다. 
- char c: 문자열 st의 각 요소가 할당될 변수를 선언한다. 
- st: 문자열 변수의 이름을 적어준다. 문자열 변수가 12개의 요소를 가지므로 각 요소를 c에 할당하면서 printf를 12회 수행한다. 

public class Problem{
	public static void main(String [] args){
    	String str;
        str = "Power overwhelming!";
        System.out.printf("%8.4s\n", str);
   	}
}

"%8.4s\n"
- 8자리를 확보한 다음 str에 저장된 문자열 중 앞의 4글자를 오른쪽에서부터 출력 
>> "_ _ _ _ Powe" 앞에 공백이 4칸 있는 문자열 출력 

public class Test{
	public static void main(String[] args){
    	String str1 = "Programming";
        String str2 = "Programming";
        String str3 = new String("Programming");
        System.out.println(str1==str2);
        System.out.println(str1==str3);
        System.out.println(str1.equals(str3));
        System.out.println(str2.equals(str3));
    }
}

A.equal(B)
- A 문자열과 B 문자열을 비교하여 두 데이터가 같으면 참, 아니면 거짓을 반환한다. 

- str1 과 str2 문자열을 저장한 주소가 같다. 
- new String("Programming") < 새로운 메모리 공간을 할당하여 문자열 저장/str1, str2 주소와는 다른 주소

>>
True
False
True
True

 

[반복문 문제]

#include <stdio.h>
main(){
	int a, hap = 0;
    for (a = 0; a < 10; ++a, hap += a);
    printf("%d %d\n", a, hap);
}

for (식 1; 식 2; 식3;) 
- 식 1: 초기값; 식 2: 최종값; 식 3: 증가값;
- 증가값 부분에 수식 2개가 콤마로 나열 >> 나열된 두 식을 차례로 수행한 후, 식 2를 확인한다. 

*주의할 점
- 전치 연산이므로, a가 10보다 작을 동안에는 반복문을 수행하고
- a가 1 증가하여 10이 되었을 때, hap += a 수행한 후 반복문을 탈출한다. 

public class Problem{
	public static void main(String[] args){
    	int i, j = 0;
        for (i = 0; i < 8; i++){
        	j += i;
        }
     	System.out.printf("%d, %d\n", i, j);
    }
}

[반복문 수행 순서]
- i = 0 > j += i > i++ 후 i < 8 이면 반복문 실행, 아니면 반복문 탈출 
>> 8, 28 (7까지 더한 수) 

public class Problem{
	public static void main(String [] args){
    	int i = 0, hap = 0;
        do{
        	++i;
            hap += i;
        } while(i<5);
        System.out.printf("%d, %d\n", i, hap);
    }
}

do while 문 
- do { 조건에 따라 이 부분을 반복 실행 } while (조건) 
- i = 1,2,3,4,5 / hap 에 더한 후, i < 5 조건을 만족하지 않아 반복문을 탈출한다. 
>> 5, 15 (입출력 조건 제대로 확인하기 - 콤마, 줄바꿈 같은 것들) 

a = [[1, 1, 0, 1, 0], [1, 0, 1, 0]]
tot, totsu = 0, 0
for i in a:
	for j in i:
    	tot += j
    totsu = totsu + len(i)
print(totsu, tot)

i = [1, 1, 0, 1, 0] , [1, 0, 1, 0] 
j = 1, 1, 0, 1, 0 / 1, 0, 1, 0 
tot = 3, totsu = 5
tot = 5, totsu = 9 
>> 5 9 # for문 안에서 tot, totsu 값을 초기화하지 않으므로 누적해서 더해준 값을 출력한다.

 

[구현 문제]

class Static{
	public int a = 20;
    	static int b = 0;  // 1
}
public class Test{
	public static void main(String[] args){
    	int a = 10;
        Static.b = a;  // 0
        Static st = new Static();   // 2
        System.out.println(Static.b++);  // 3
        System.out.println(st.b);
        System.out.println(a);
        System.out.println(st.a);
    }
}

# 0
a의 값을 Static.b에 저장
# 1 
- static으로 선언된 변수는 main() 메소드가 시작되기 전에 메모리의 static 영역에 할당된다. 
- static으로 선언된 변수는 객체 변수 선언 없이 사용할 수 있으므로 클래스를 이름을 통해 (Static.b) 접근 가능함. 
# 2
- 객체 변수 st 선언
- 객체 변수를 선언한다는 것은 클래스의 정의부를 바탕으로 새로운 인스턴스를 생성하고 메모리를 배정하고 그 메모리의 주소를 변수명 st에 연결하는 것을 의미 
- Static.b와 st.b는 static 메모리 영역의 한 공간을 공유한다. 
# 3
- Static.b++ 후치 연산이므로, 출력 후 값을 + 1 해준다. 
>> 출력
System.out.println(Static.b++); >> 10
System.out.println(st.b); >> 11
System.out.println(a); >>10
System.out.println(st.a);  >> 20 

class SuperObject{
	public void paint(){
    	draw();
   	}
    public void draw(){  // 6
    	draw();  // 7
        System.out.println("Super Object");  // 10
    }
}
class SubObject extends SuperObject{  // 3
	public void paint(){  // 4
    	super.draw();  // 5
    }
    public void draw(){  // 8
    	System.out.println("Sub Object");  // 9
   	}
}
public class Test{
	public static void main(String[] args){
    	SuperObject a = new SubObject();  // 1
        a.paint();  // 2
    } 
}

class A extends B
A 클래스를 선언하면서 B 클래스에서 상속 받음으로써 B 클래스의 변수 및 메소드를 사용할 수 있다. 

메소드 재정의 (오버라이딩)
SubObject 에 있는 paint(), draw() 메소드는 부모 클래스의 메소드와 이름은 같지만 실행코드는 다르다. 
ㄴ 부모 클래스에서 정의한 메소드를 자식 클래스에서 다르게 정의해서 사용하는 것 

[부모 클래스명] [객체 변수명] = new [자식 클래스 생성자 ( )]
부모 클래스의 객체 변수를 선언하면서 자식 클래스의 생성자를 사용하면 형변환이 발생한다. 
형변환 발생 시, 부모 클래스와 자식 클래스에 동일한 속성이나 메소드가 있으면 자식 클래스의 속성이나 메소드로 재정의된다. 

# 1: 부모 클래스의 객체 변수를 선언하면서 자식 클래스의 생성자를 사용해서 형변환 발생 
# 2: 형변환으로 자식 클래스에서 메소드 재정의 >> SubObject 클래스로 이동 
# 3: SuperObject 클래스를 상속받음으로써 SuperObject 클래스의 변수 및 메소드를 사용할 수 있음
# 4: #2 과정에서 호출한 매개변수가 없는 메소드 
# 5: super.draw( ) - 부모 클래스의 draw 메소드를 호출
# 6: SuperObject 클래스의 draw 메소드로 이동 
# 7: draw( ) 는 자식 클래스에서 재정의 되었음 >> 자식 클래스의 같은 메소드로 이동
# 8: 재정의된 자식 클래스의 draw로 이동 
# 9: Sub Object 출력 (println 이므로 개행 문자 포함) 
# 10: 함수 실행 코드가 끝났으므로 다음 코드를 실행 >> Super Object 출력 
>> 출력
Sub Object
Super Object