핸드북 1,2일차

3:00 PM - 3:51 PM

증감 연산자 , 부호 연산자 , 형변환 연산자 , 자동 형변환 , 사칙 연산자 , 산술변환 , Math 클래스의 메소드 , 나머지 연산자(%) , 비교 연산자 , .equals() , 삼항 조건식 , 대입연산자

증감 연산자

public class test {
    public static void main(String[] args) {
        System.out.println("hello");
        int k=0, j=3;

        //1. 후위 형
        k = j++;
        /* 다르게 표현 가능
        k = j;
        j++;*/
        System.out.println("k = j++;, k = " + k);
        System.out.println("k = j++;, j = " + j);

        k = 0;
        j = 3;

        //2. 전위 형
        k = ++j;
        /* 다르게 표현 가능
        ++j;
        k = j;*/
        System.out.println("k = ++j;, k = " + k);
        System.out.println("k = ++j;, j = " + j);
    }
}

Result :

 

hello
k = j++;, k = 3
k = j++;, j = 4
k = ++j;, k = 4
k = ++j;, j = 4

 

 

부호 연산자

'-' 는 피연산자의 부호를 반대로 변경합니다.

'+'는 아무런 일도 하지 않습니다. (현업에서 미사용)

public class test {
    public static void main(String[] args) {
        int i = -10;
        i = + i;
        System.out.println("i = +i; = " + i);

        i = -10;
        i = -i;
        System.out.println("i = -i; = " + i);
    }
}

Result :

i = +i; = -10
i = -i; = 10

 

 

형변환 연산자

public class test {
    public static void main(String[] args) {
        int i = 65, num = 10;
        char ch = 'A';
        float f = 1.6f;

        System.out.println("(char)i = " + (char)i);
        System.out.println("(int)ch = " + (int)ch);
        System.out.println("(int)f = " + (int)f);
        System.out.println("(float)num = " + (float)num);
    }
}

Result :

(char)i = A
(int)ch = 65
(int)f = 1
(float)num = 10.0

 

 

자동 형변환

public class test {
    public static void main(String[] args) {
        // 큰 타입을 작은 타입에 저장!
        // int i = 3.14f; // Error 발생
        int i = (int)3.14f; // 형변환 필요!
        System.out.println("i = " + i);

        // 예외 경우 확인

        // 100 은 int 타입 따라서 아래 코드는 현재 큰 타입(int)을 작은 타입(byte)에 넣고 있음!
        // 컴퓨터는 byte의 범위가 -128 ~ 127 인 것을 알고 있다.
        // 따라서 100을 byte b 에 집어 넣어도 값 손실이 발생하지 않는 다는 것을 알기 때문에
        // 자동으로 형변환을 해준다.
        // byte b = (byte)100; -> 컴파일러가 자동 형변환
        byte b = 100; // OK
        System.out.println("b = " + b);

        // 위의 경우는 100 은 리터럴 즉, 상수이기 때문에 컴파일러가 값을 명확하게 알지만
        // 아래 num 은 변수, 따라서 확신할 수 없기 때문에 Error 발생
        int num = 100;
        // byte b2 = num; // Error 발생
        byte b2 = (byte) num; // byte 타입으로 형변환
        System.out.println("b2 = " + b2);

        //  byte b3 = 1000; // Error 발생, 범위를 넘어감
        byte b3 = (byte) 1000;
        // OK, 그러나 값 손실 발생, b3 에는 -24 가 저장됨
        // 즉, 상수여도 값 손실이 일어나면 자동 형변환 불가능!
        System.out.println("b3 = " + b3);
    }
}

Result :

i = 3
b = 100
b2 = 100
b3 = -24

 

 

사칙연산

public class test {
    public static void main(String[] args) {
        int a = 10, b = 4;

        // 덧셈 -> 10
        System.out.print("a + b = ");
        System.out.println(a + b);

        // 뺄셈 -> 6
        System.out.print("a - b = ");
        System.out.println(a - b);

        // 곱셈 -> 40
        System.out.print("a * b = ");
        System.out.println(a * b);

        // 나눗셈 -> 2
        // 소수점 이하는 버려진다.
        // b를 float으로 명시적 형변환을 할 시 소수점 아래까지 계산
        System.out.print("a / b = ");
        System.out.println(a / b);

        // 10 / 4.0f -> 10.0f / 4.0f -> 2.5
        System.out.print("a / (float)b = ");
        System.out.println(a / (float)b);
    }
}

Result :

a + b = 14
a - b = 6
a * b = 40
a / b = 2
a / (float)b = 2.5

 

산술변환

public class test {
    public static void main(String[] args) {
        char ch = '2';

        // 문자 '2' 는 숫자로 50, '0' 은 48
        // 따라서 int 타입으로 자동으로 변하기 때문에 50 - 48 = 2
        System.out.print("ch - '0' = ");
        System.out.println(ch - '0');

        int a = 1_000_000; // 1백만
        int b = 2_000_000; // 2백만

        // a * b = 2_000_000_000_000 -> 10^12
        // long 에 저장하려는 것은 맞지만 a * b 의 결과 타입이 int
        // 따라서 이미 계산을 할 때 오버플로우 발생! -> 따라서 계산을 할 때 형변환 필요!
        // long l = a * b; // -1454759936

        long l = (long)a * b;
        // long * int -> long * long => 1_000_000L * 2_000_000 -> 1_000_000L * 2_000_000L
        System.out.println("l = " + l);
    }
}

Result :

ch - '0' = 2
l = 2000000000000

 

 

 

Math 클래스의 내장 메소드

• round() : 실수를 소수점 첫 째자리에서 반올림한 정수를 반환합니다.

• ceil() : 올림값을 double 형으로 반환합니다.ceil() : 올림값을 double 형으로 반환합니다.

•  

  floor() : 내림값을 double 형으로 반환합니다.

• abs() : int, double 기본형 모두 사용 가능하며 절대값을 얻습니다.

public class test {
    public static void main(String[] args) {
        long result = Math.round(3.645678);
        System.out.println("result = " + result);

        // 소수점 4째 자리에서 반올림한 값을 구하라!
        double pi = 3.141592;
        // pi * 1000 = 3141.592
        // Math.round(3141.592) = 3142
        // 3142 / 1000.0 = 3.142
        double shortPi = Math.round(pi * 1000) / 1000.0;
        System.out.println(shortPi); // 3.142

        // 3.141 구하기!
        double pi2 = 3.141592;
        // pi2 * 1000 = 3141.592
        // (int)3141.592
        System.out.println("(int)(pi2 * 1000) = " + (int) (pi2 * 1000));
        System.out.println("(int)(pi2 * 1000) / 1000.0  = " + (int) (pi2 * 1000) / 1000.0);
    }
}

Result :

result = 4
3.142
(int)(pi2 * 1000) = 3141
(int)(pi2 * 1000) / 1000.0  = 3.141

 

public class test {
    public static void main(String[] args) {
        double num = 3.14;

        System.out.println("반올림 : " + Math.round(num)); // 반올림 : 3
        System.out.println("올림 : " + Math.ceil(num)); // 올림 : 4.0
        System.out.println("내림 : " + Math.floor(num)); // 내림 : 3.0
        System.out.println("절대값 : " + Math.abs(num*-1)); // 절대값 : 3.14
    }
}

Result :

반올림 : 3
올림 : 4.0
내림 : 3.0
절대값 : 3.14

 

나머지 연산자

public class test {
    public static void main(String[] args) {
        int x = 10;
        int y = 8;

        System.out.print("x를 y로 나눈 몫 = ");
        System.out.println(x / y);

        System.out.print("x를 y로 나눈 나머지 = ");
        System.out.println(x % y);

        // 부호 무시 확인
        int n = 3;
        int z = -3;
        System.out.println("x % n = " + x % n);
        System.out.println("x % z = " + x % z);
    }
}

Result :

x를 y로 나눈 몫 = 1
x를 y로 나눈 나머지 = 2
x % n = 1
x % z = 1

 

 

 

비교 연산자

public class test {
    public static void main(String[] args) {
        int n1 = 10, n2 = 6;
        char c1 = 'A', c2 = 'B';

        System.out.print("n1 >= n2 = " ); // true
        System.out.println(n1 >= n2);
        System.out.print("n1 <= n2 = " ); // false
        System.out.println(n1 <= n2);

        System.out.print("n1 == n2 = " ); // false
        System.out.println(n1 == n2);
        System.out.print("n1 != n2 = " ); // true
        System.out.println(n1 != n2);

        // 산술변환 규칙에 의해서 char 타입이 int 타입으로 변환되어 연산됨
        System.out.print("c1 < c2 = "); // true
        System.out.println(c1 < c2); // 65 < 66
        System.out.print("c1 > c2 = "); // false
        System.out.println(c1 > c2); // 65 > 66
    }
}

Result :

n1 >= n2 = true
n1 <= n2 = false
n1 == n2 = false
n1 != n2 = true
c1 < c2 = true
c1 > c2 = false

 

문자열 일치 확인

*자바에서 문자열의 일치 여부 확인은 ==가 아닌 .equals() 를 사용해야 한다.

equals : 비교하고자 하는 두 피연산자의 값 자체를 비교합니다.

== : 비교하고자 하는 두 피연산자의 주소값을 비교합니다.

public class test {
    public static void main(String[] args) {
        String s1 = "사랑";
        String s2 = "사랑";

        System.out.print("s1 == s2 = "); // true
        System.out.println(s1 == s2);
        System.out.println("s1.equals(s2) = " + s1.equals(s2)); // true

        // 하지만!
        String s3 = new String("사랑");
        System.out.print("s1 == s3 = "); // false
        System.out.println(s1 == s3);
        System.out.println("s1.equals(s3) = " + s1.equals(s3)); // true
    }
}

Result :

s1 == s2 = true
s1.equals(s2) = true
s1 == s3 = false
s1.equals(s3) = true

 

 

삼항 조건식

public class test {
    public static void main(String[] args) {
        int num1 = 5, num2 = 7;
        int result;

        result = num1 - num2 > 0 ? num1 : num2;

        System.out.println("두 정수 중 더 큰 수는 " + result + "입니다."); // 7
    }
}

Result :

두 정수 중 더 큰 수는 7입니다.

 

 

대입연산자

public class test {
    public static void main(String[] args) {
        int num1 = 7, num2 = 7, num3 = 7;

        num1 = num1 - 3;
        num2 -= 3;
        num3 =- 3;

        System.out.println("- 연산자에 의한 결과 : "+ num1); // 4
        System.out.println("-= 연산자에 의한 결과 : "+ num2); // 4

        // = 위치를 주의하셔야 합니다.
        // num3 =- 3; 는 num3 = -3 입니다.
        System.out.println("=- 연산자에 의한 결과 : "+ num3); // -3
    }
}

Result :

- 연산자에 의한 결과 : 4
-= 연산자에 의한 결과 : 4
=- 연산자에 의한 결과 : -3