Math

Math는 수학과 관련된 메서드를 가지고 있는 클래스이다.

메서드는 '특정한 기능을 수행하기 위해 코드로 작성된 단위!;

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

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

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

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

class Operator5_1 {
    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);
    }
}

class Operator5_2 {
    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
    }
}

나머지 연산자 %

오른쪽 피연산자로 나누고 남은 나머지를 반환

나누는 피연산자는 0이 아닌 정수만 허용

부호는 무시

class Operator5_3 {
    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);
    }
}

사칙 연산자

덧셈(+) 뺄셈(-) 곱셈() 나눗셈(/)*

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

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

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

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

        // 나눗셈
        // 소수점 이하는 버려진다.
        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);
    }
}

산술변환

연산 전에 피연산자의 타입을 일치시키는 것을 의미한다.

1. 두 피연산자의 타입을 같게 일치시킨다.(보다 큰 타입으로 일치)

long + int -> long + long => long

float + int -> float + float => float

double + float -> double + double => double

2. 피연산자의 타입이 int 보다 작은 타입 이면 int 로 변환된다.

byte + short -> int + int => int

char + short -> int + int => int

int 보다 작은 타입이 계산을 통해 쉽게 범위가 넘어갈 수 있기 때문에 오버플로우가 발생해 정확한 계산값을 가져오지 못할 수 있어서 미리 큰 범위인 int 타입으로 변환시킨 후 계산하는 것이다.

class Operator4_2 {
    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);
    }
}

형변환 연산자

형변환이란?
변수 또는 상수의 타입을 다른 타입으로 변환하는 것을 의미한다.(타입)피연산자

변환 수식 결과

class Operator3_1 {
    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);
    }
}

자동 형변환

float f = 1234; => int 타입의 값을 float타입의 변수에 저장!

상대적으로 int 타입이 float 타입 보다 크기가 작기 때문에 가능함.

float f = (float)1234; => 사실 변수와 리터럴의 타입을 일치 시켜줘야 합니다.

우리가 보는 코드에는 형변환이 생략되어 있었습니다. 즉, 컴파일러에 의해 자동으로 형변환된다.

int i = 3.14f;

이렇게 큰 타입을 작은 타입에 저장할 때 Error 가 발생한다.

3.14f 가 int 타입으로 변환될 때 소수점이 사라지면서 원래 값이 달라집니다. 즉, 값 손실이 발생하는데 이런 경우, 컴파일러가 자동으로 형변환을 안해줌

int i = (int)3.14f; => 이렇게 직접 수동으로 형변환을 시켜줘야 합니다.

"기존의 값을 최대한 보존할 수 있는 타입으로 자동 형변환된다."
형변환을 하는 이유는 주로 서로 다른 두 타입을 일치시키기 위해서인데, 형변환을 생략 하려면 컴파일러가 알아서 자동으로 형변환을 해야한다.따라서 표현범위가 좁은 타입에서 넓은 타입으로 형변환하는 경우에는 값 손실이 없음으로 두 타입 중에서 표현 범위가 더 넓은 쪽으로 형변환된다.

class Operator3_2 {
    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);
    }
}