Java 1주차 문법 1-7,8,9 아스키코드, 변수타입(심화), 형변환

1-7. 아스키코드

숫자 -> 문자

// 숫자 -> 문자
// import : im(in) + port(항구) main.java 안쪽으로 외부에서 가져오는것
import java.util.Scanner; // 입력한 값을 저장한 것

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int asciiNumber = sc.nextInt();
        char ch = (char)asciiNumber; // 문자로 형변환을 해주면 숫자에 맞는 문자로 표현됩니다.

        System.out.println(ch); // *
    }

}

// *
// 97을 입력하면 a가 출력된다.
// 97이라는 값은 System.out.println(ch);에 의해 출력이 됐는데,
// sc.nextInt()로 인해서 읽어줘서 -> asciiNumber로 할당이 됨
// 97이라는 값이 asciNumber(변수명)으로 할당되었고
// char ch = (char)asciiNumber; 에 의해 입력된 값을 char 타입으로 바꿔줌.
// 97은 아스키코드에서 a이다.

 

문자->숫자

// 문자 -> 숫자

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        char letter = sc.nextLine().charAt(0); // 첫번째 글자만 받아오기위해 charAt(0) 메서드를 사용합니다.
        int asciiNumber = (int)letter; // 숫자로 형변환을 해주면 저장되어있던 아스키 숫자값으로 표현됩니다.

        System.out.println(asciiNumber); // *
    }

}

// *
// a를 입력하면 97이 출력됨.
// Scanner sc = new Scanner(System.in); -> sc 를 이용하여 입력하는 값을 저장.
// char letter = sc.nextLine().charAt(0); -> letter 라는 문자형 변수는 입력한 값의 첫번째 글자만 받아온 것. (0번째가 1번째.)
// int asciiNumber = (int)letter; -> asciiNumber라는 숫자형 변수 = 변수 letter를 숫자형으로 형변환한 것
// System.out.println(asciiNumber); -> asciiNumber를 출력한다.
// 문자형 변수 char letter로 입력한 값의 첫 글자만 따온 후 숫자형으로 형변환 하였음. 따라서 입력한 문자->숫자.
// 여기서 asciiNumber은 임의로 지은 "변수명"이기 때문에! 명령어가 아님. 다른 이름으로 지어도 상관없음~

 

 

1.8 변수타입 (심화)

선언 관점에서 차이점

 - 문자 (char) ''

char alphabet = 'A'; // 문자 하나를 저장

 

 -문자열 (String) ""

String message = "Hello World"; // 문자열을 저장

 

저장 관점에서 차이점

문자 (char)

 문자 뒤에 \0(널문자)가 없음 (1 byte 만 쓰기 때문에 끝을 알아서 데이터만 저장하면 됨)

문자열 (String)

문장의 끝에 \0(널문자)가 함께 저장이 됨 (몇개의 byte 를 쓸지 모르기 때문에 끝을 표시해야함)

 

또한, 문자(char)은 기본형, 문자열(String)은 참조형!

 

참조형

 - 참조 -> 복잡. 별도의 영역에 저장을 하여 그 주소값을 가져와서 사용.

 - 다른 기본형 변수는 실제 값을 저장하지만 참조형 변수는 실제값이 아닌 원본값의 주소값을 저장. -> 별도의 저장공간이 필요하다.

 

Stack 영역

 - 정적(ex : int->4byte)으로 할당된 메모리 영역

 - 기본형 변수를 저장

 - 크기가 정해져있는 참조형 변수의 주소값도 저장.

 

Heap 영역

 - 동적(크기를 알 수 없을 때)으로 할당된 메모리 영역

 - 크기가 계속 늘어날 수 있는 참조형 변수의 '원본'을 저장.

 

입력, 출력

 입력

  - java 프로그램에서는 기본적으로 Scanner.in 객채의 next() 명령을 사용해서 입력.

Scanner sc = new Scanner(System.in); // Scanner 객체를 new 명령어로 생성.
String input = sc.next();  // sc(Scanner)의 .next(); 를 실행하면 input 변수에 입력한 글자를 받을 수 있습니다.

 

 출력

  - java 프로그램에서는 기본적으로 System.out 객채의 println() 명령을 사용해서 출력 (sout)

Scanner sc = new Scanner(System.in);
String input = sc.next();  

System.out.println("입력값 : " + input);  // 입력한 글자를 출력.

// 실행 결과
{입력}
입력값 : {입력}

 

-

1-9 형변환

명시적인 형변환

 실수 -> 정수

public class Main {

    public static void main(String[] args) {
        // double형 or float형 -> int
        // 실수 -> 정수(0.xxx -> 0)
        double doubleNumber = 10.101010;
        float floatNumber = 10.1010f;

        // 변환(int)
        int intNumber;
        intNumber = (int)doubleNumber; // double -> int
        System.out.println("Double Type => " + doubleNumber); // 10.10101
        System.out.println("Int Type =>" + intNumber); // 10

        intNumber = (int)floatNumber;
        System.out.println("Float Type => " + floatNumber); // 10.101
        System.out.println("Int Type =>" + intNumber); // 10
    }
}

 

 정수 -> 실수

public class Main {

    public static void main(String[] args) {
        // 정수 -> 실수
        int intNumber = 10;

        double doubleNumber = (double)intNumber;
        float floatNumber = (float)intNumber;

        System.out.println("intNumber => " + intNumber); // 10
        System.out.println("doubleNumber => " + doubleNumber); // 10.0
        System.out.println("floatNumber => " + floatNumber); // 10.0
    }
}

 

암시적인 형변환

 작은 타입에서 큰 타입으로 저장될 때 자동으로 타입 변환!

public class Main {

    public static void main(String[] args) {
        // 변수 타입별 크기 순서
        // byte(1) -> short(2) -> int(4) -> long(8) -> float(4) : 부동소수점, 표현식이 더 많음 -> double(8)
        // 작은 타입에서 큰 타입으로 저장될때 자동으로 타입 변환된다. -> ex : (int)byteNumber X  / byteNumber O

        // (1) byte -> int
        byte byteNumber = 10;
        int intNumber = byteNumber; // (int)byteNumber이라고 안해도됨
        System.out.println(intNumber); // 10

        // (2) char(1 byte) -> int(4) 형변환
        char charAlphabet = 'A';
        intNumber = charAlphabet; // char -> int로 자동 형변환
        System.out.println(intNumber); // 65로 출력. char인 'A'의 아스키코드가 65이기 때문.

        // (3) int -> long number 형변환
        intNumber = 100;
        long longNumber = intNumber;
        System.out.println(longNumber); // 100

        // (4) int -> double 형 변환
        intNumber = 200;
        double doubleNumber = intNumber;
        System.out.println(doubleNumber); // 200.0
    }
}

public class Main {

    public static void main(String[] args) {
        // 작은 크기의 타입이 큰 크기의 타입과 '계산'될 때,
        // 자동으로 큰 크기의 타입으로 형 변환이 된다!
        int intNumber = 10;
        double doubleNumber = 5.5;
        double result = intNumber + doubleNumber;

        System.out.println(result); // 15.5

        // 1) 정수로 나누기
        int iResult = intNumber / 4; // 2.5
        // 2) 실수로 나누기
        double dResult = intNumber / 4.0;

        System.out.println(iResult + " / " + dResult); // 2 / 2.5

        // 저장을 int로 하면 기본적으로 소수점 아래의 0.5는 버리고 2만 저장했음
        // double로 저장하면 소수점까지 온전히 2.5로 저장
    }
}

 

작은 타입 -> 큰타입 형변환시 (자동 형변환)

 - 더 큰 표현범위를 가진 타입으로 변환되는 것이라 값의 손실이 X

 - 값의 손실 없이 변환이 가능하기 때문에 컴파일러가 자동으로 형변환을 해줌.

 

큰 타입 -> 작은 타입 형변환시 (강제 형변환 = 캐스팅)

 - 더 작은 표현범위를 가진 타입으로 변환되는 것이라 값의 손실이 생긴다.

 - 값의 손실이 생기기 때문에 자동으로 형변환을 해주지 않고 개발자가 선택하여 형변환을 한다.