Java 기본 자료형(Primitive Data Type), 진법, 형변환

1. 자바의 기본 자료형(Primitive Data Type) -> 데이터 타입 심플!

총 8개

• 정수 타입: byte(1바이트), short(2바이트), int(4바이트), long(8바이트)
• 실수 타입: float(4바이트), double(8바이트)
• 문자 타입: char(2바이트)
• 논리 타입: boolean(1바이트)
  

**Primitivate Type - 기본타입 vs Reference Type (Objective Type) - 참조타입

  byte				클래스 타입 (ex: Scanner, String)
  short
  int 				배열 타입
  long
  float				enum 타입
  double
  char				인터페이스
  boolean			+ new 를 통해 생성되는 것들
  

-> reference 타입 변수는 ‘주소값’을 담고 있고 이는 4 byte 입니다. (32bit JVM 인 경우)

2. 진법 & 용량

(1) 진법

• 표현하는 기호가 10개인 숫자체계 : 10진법
• 기타 진법의 예 : 12진법(1년의 달, 12간지 등)

[진법 변환 연습]

(2) 용량

• 용량 : 더 많은 숫자의 범위를 표현할 수 있다!
• 10진법 4자리의 경우 : 0000 ~ 9999 ( 10의 4제곱 = 10000 개 표현 가능)
• 8진법 3자리의 경우 : 000 ~ 777 ( 8의 3제곱 = 512 개 표현 가능)
• 16진법 5자리의 경우 : 00000 ~ FFFFF ( 16의 5제곱 = 65536 개 표현 가능)
• 2진법 8자리의 경우 : 00000000 ~ 11111111 ( 2의 8제곱 = 256 개 표현 가능)

컴퓨터의 기본 용량 Byte 란

• 2진수 8자리를 컴퓨터의 최소한의 용량으로 정의

• 2진수 체제로 기억하고 연산하고, 저장하는 컴퓨터는 2진법 한자리를 1 bit 라 하고 가장 기본적인 데이터 단위로

• 2진수 8자리 즉 8 BIT 를 1 byte 란 단위를 붙여서 운영

  	1 Byte = 8 bit -> 2^8

  ex. 2 Byte -> 2^16

1 Byte의 크기?

• 1 Byte → 2의 8제곱만큼의 공간 (256가지 숫자 표현 가능)

  	      0       ~        255       (10진법)
  	0000 0000  ~ 1111 1111   (2진법 표기) 
     00       ~       FF     (16진법 표기)

• 2진법과 16진법은 대응됨
  2^4 = 16 (즉, 2진법 4글자가 16진법 1글자)

프로그래머는 2진법과 16진법을 ♥♥한다

• 2진법 4자리는 16진법 1자리
  16진법 자리수만 보면 몇 byte 용량인지 보임
• 2진법 8자리 → 1Byte
• 16진법 2자리 → 1Byte

Byte 단위

1 Byte = 8 Bit
1024 Byte = 1 KByte (kilo byte)
1024 KByte = 1 MByte (mega byte)
1024 MByte = 1 GByte (giga byte)
1024 GByte = 1 TByte (tera byte)
Peta , Exa, Zetta, Yotta ….

진법 (영어)

10진법 : Decimal notation
2진법 : Binary notation
8진법 : Octal notation
16진법 : Hexadecimal notation

진법 계산기 활용하기

• 윈도우스 등에 내장되어 있는 계산기를 활용 가능
  

2. 기본타입간의 자동 형변환 (Implicit Casting)

** 기본적으로
- 작은 크기 에서 → 큰 크기의 자료형으로는 자동형변환
- 정수타입 에서 → 실수 타입으로 자동형변환

[정수타입 변수 코드]

package com.lec.java.variable03;

public class Variable03Main {

	public static void main(String[] args) {
		System.out.println("정수 타입 변수");
		
		// byte : 8bit , 256가지 표현 가능한 용량.  -128 ~ +127
		System.out.println("byte: " + Byte.MIN_VALUE + " ~ " + Byte.MAX_VALUE);
		byte num1 = -128;	// (대입연산자가) 4byte int 타입이었던 128을 byte로 변환 (자동현변환)
		byte num2 = 0;
		byte num3 = 123;
//		byte num4 = 128;	// 에러: byte가 저장할 수 있는 값의 범위를 넘어간 값 대입.
							// Type mismatch: cannot convert from int to byte (형변환이 안된 것. 즉 int->byte로 자동현변환 불가)
                            // 에러 인식 순서 : 1. literal 인식 2. 대입연산자를 통한 형변환 가능 여부 확인
		
		// short : 2byte, 16bit, 65536가지 표현 가능한 용량. -32768 ~ 32767
		System.out.println("short: " + Short.MIN_VALUE + " ~ " + Short.MAX_VALUE);
		short num5 = -12345;
		short num6 = 12345;
//		short num7 = 32768;
//		short num8 = -32769;
	
		// int: 4byte 32bit, -2147483648 ~ 2147483647
		// long: 8byte 64bit, -9223372036854775808 ~ 9223372036854775807
		System.out.println("int: " + Integer.MIN_VALUE + " ~ " + Integer.MAX_VALUE);
		System.out.println("long: " + Long.MIN_VALUE + " ~ " + Long.MAX_VALUE);
		
//		int num9 = 9876543210;		// The literal 9876543210 of type int is out of range (애시당초 literal을 인식하는데 문제)
//		long num10 = 9876543210;	// 으잉? The literal 9876543210 of type int is out of range -> int 타입으로 리터럴 인식하려는데 범위를 벗어났다는 의미
						// 에러 인식 순서 : 1. literal 인식 2. 대입연산자를 통한 형변환 가능 여부 확인
		
		// 리터럴(literal) : 코드에 직접 입력하는 값.
		// 리터럴도 타입이 있다.
		// 정수타입리터럴은 int 타입으로 인식하려 한다.
		// 실수타입리터럴은 double 타입으로 인식하려 한다.

		long num11 = 9876543210L;
		// 9876543210 이라는 숫자가 int 타입이 아니라 long 타입임을 명시하기 위해서
		// 숫자 뒤에 영문자 L을 붙여줌
		// 자바에서 정수 타입 변수의 기본은 int임.
		// 자바는 정수 숫자(리터럴)를 별도 표기 가 없으면 int라고 생각.
        	// 자바는 원래 동일한 타입만 대입 가능.

		long num12 = 12;	// 12 라는 int 를 long 타입에 저장
		long num13 = 12L;	// 12 라는 long 를 long 타입에 저장
		int num14 = 12;
		
		// 진법에 따른 정수 리터럴 표기
		int number1 = 11;	// 10진수(decimal)
		int number2 = 0xB;	// 16진수(hexadecimal) : 보통 0x로 시작
		int number3 = 013;	// 8진수(octal) : 0으로 시작
		int number4 = 0b1011;	// 2진수(binary) : 0b로 시작
		
		System.out.println("number1 = " + number1);
		System.out.println("number2 = " + number2);
		System.out.println("number3 = " + number3);
		System.out.println("number4 = " + number4);

	}

}

[실수타입 변수 코드]

package com.lec.java.variable04;

public class Variable04Main {

	public static void main(String[] args) {
		System.out.println("실수 타입");
		
		// 실수타입
		// float(4byte)
		// double(8byte)
		
		double number1 = 3.14;
//		float number2 = 3.14; -> cannot convert 에러
		
		// 별도의 표기가 없는 경우 소수점이 있는 리터럴은 double로 인식
		// 3.14는 double형. 이것을 작은 자료 타입인 float에 저장할 수 없다.
		float number3 = 3.14f;
		// 실수리터럴 뒤에 f를 붙여주면 float 리터럴로 인식된다.
		
		// 실수타입에서 최소, 최대값
		System.out.println("float: " + Float.MIN_VALUE + " ~ " + Float.MAX_VALUE);
		System.out.println("double: " + Double.MIN_VALUE + " ~ " + Double.MAX_VALUE);
		// 실수에서 말하는 최소값의 의미는 0~1 사이에서 얼마나 소수점 이하로 디테일하게 표현할 수 있는가
		// 최대값의 의미는 1이상의 값에서 얼마만큼 많은 숫자를 정밀하게 표현할 수 있는가
		// 따라서, 컴퓨에서 실수연산은 100% 정확하지 않다! 그래서 얼마나 정밀하게 표현할 수 있느냐가 실수타입의 의미

		float number4 = 1.23456789f;
		double number5 = 1.23456789;
		// 기본적으로 float은 소숫점 6자리 정도까지만 정확하게 표현함
		
		System.out.println("number4 = " + number4);
		System.out.println("number5 = " + number5);
		// float과 double은 저장할 수 있는 값의 크기만이 아니라
		// 소수점 이하 정밀도(precision)에서도 차이가 있다. 나머지는 근사값으로 표현

		// 실수표기법
		double number6 = 123;
		double number7 = 1.23e2;
		System.out.println(number6);
		System.out.println(number7);
        // 위의 2개 결과 모두 : 123.0
			
	}

}

[char, boolean, String 타입 변수 코드]

package com.lec.java.variable05;

public class Variable05Main {

	public static void main(String[] args) {
		System.out.println("변수 : char, boolean, String");
		
		// char: 문자 하나를 저장하기 위한 자료 타입(2바이트)
		// char 는 문자의 코드값(정수)가 담긴다 (2byte)

		char ch1 = 'A';
		// 문자열(String)은 큰따옴표("")로 묶어 줌.   (String literal)
		// 문자 하나(char)는 작은따옴표('')로 묶어 줌.   (char literal)
//		char ch2 = "A";
		
		System.out.println("ch1: " + ch1);
		
		char ch2 = '한';
		char ch3 = '글';
		
		System.out.println("ch2: " + ch2);
		System.out.println("ch3: " + ch3);

		char ch4 = 0xAE01; //16진수 2자리 -> 2 byte
		System.out.println("ch4: " + ch4);
		char ch5 = 1234;
		System.out.println("ch5: " + ch5);
		
		char ch6 = '!';
		char ch7 = 33;
		System.out.println("ch6: " + ch6);
		System.out.println("ch7: " + ch7);
		System.out.println("ch7: " + (int)ch7);
		
		// 1. "bible"
		// 2. "cable"
		// 3. "able"		
		// 오름차순 정렬하면?
		// 3 > 1 > 2
		
		// 1. "aaAA"
		// 2. "AaAa"
		// 3. "aAaA"
		// 4. "AAaa"
		// 4 > 2 > 3 > 1

		char ch8 = 'A';
		char ch9 = 'a';
		System.out.println("'A' : " + (int)ch8);	// 65
		System.out.println("'A' : " + (int)ch9);	// 97
		
		
		// boolean (논리형) : 참(true), 거짓(false) , 용량 1byte
		boolean b1 = true;
		boolean b2 = false;
		System.out.println("b1: " + b1);
		System.out.println("b2: " + b2);
		System.out.println(10 < 20);
		System.out.println(10 > 20);
		
		boolean b3 = 10 <20;
		System.out.println("b3: " + b3);
		
		
		// String 타입 (문자열) - 객체
		// ※ String은 primitive 타입은 아닙니다
		String name = "Hong";
		String nick = "thunder";
		System.out.println("이름은: " + name + "\n별명은:" + nick);
		
	}

}

3. 암묵적 형변환 (Implicit Casting)

• 암묵적 형변환(Implicit casting): 자바 언어가 자동으로 해주는 형변환
  • primitive type 에서 implicit casting 방향

• 명시적 형변환(Explicit casting): 프로그래머가 직접 타입을 변환하는 것
  • (변환하고자 하는 타입명)변수/값

public class CastingMain {

	public static void main(String[] args) {
		System.out.println("형변환(Casting)");

		// 암묵적 형변환
		byte num1 = 123;	// byte <- int
		short s1 = 123;		// short <- int
		int n1 = s1;		// int <- short
		
		char ch1 = 'A';
		//s1 = ch1;		// char -> short 불가능
		n1 = ch1;		// int <- char
		
		
		// 명시적 형변환
		byte num5 = (byte)513;	// 4byte 에서 상위 3byte 를 잘라내어 byte 변환
		System.out.println("num5 = " + num5);	// 1 출력 - 주의! (상위 바이트가 사라자기 때문) 자료손실 발생할 수 있다!
		
		
		byte num6 = 10;
		int n2 = 10;
//		byte num7 = n2;	// int '변수' -> byte 는 implicit casting 안됨. (비록 용량 범위 안이 숫자라 하더라도)
		byte num7 = (byte)n2;

🎇TIPs!

• 프로그래밍을 잘 학습할 수 있는 법 : 프로젝트 진행, 타인에게 표현 및 설명하기(블로그)
• ASCII 코드 : https://blog.sweetchip.kr/271 (참조사이트)