Java 정리 02

// 30억의 정수 리터럴은 4byte
// => 30억 정수상수를 담기위해선 8byte 리터럴이 필요
// 정수상수 뒤에 l, L을 붙임
long l = 3000000000l; 

// 0.5란 실수 리터럴은 8byte
// => float은 4byte이므로 8byte를 4byte로 줄여야 함
// 실수상수 뒤에 f, F를 붙임
float f = 0.5f;

/*
	기본형 데이터형(Primitive DataType)
	정수형 : byte, short, int, long
	실수형 : float, double
	문자형 : char
	논리형 : boolean
*/
class PrimitiveDataType {
	
	public static void main(String[] args) {
		// 정수형
		byte b = 10;
		short s = 20;
		int i = 30;
		// 할당되는 값이 4byte내 이므로 literal을 변환할 필요가 없다.
		long l = 40;
		
		b = -128; // byte : -128 ~ +127
		
		// 정수 literal은 4byte
		// 저장하려는 값은 8byte가 필요한 값이므로 
		// literal의 크기를 변경(형명시), 
		// 정수상수 뒤에 l이나 L을 붙인다
		long l2 = 2147483648L;
		
		System.out.println("byte : " + b + ", short : " 
		  + s + ", int : " + i + ", long : " + l + 
			", long2 : " + l2);

		/*
		  0  - 정수상수
		 '0' - 문자상수
		 "0" - 문자열상수
		*/

		// 문자형 : unicode 값 : \u0000
		// 할당은 unicode가 됨
		// char c = 'A';
		// char c2 = '0';
		// char c3 = '가';

		// 유니코드값을 바로 할당해도 같은 결과 출력
		char c = 65;
		char c2 = 48;
		char c3 = 44032;

		// 출력은 unicode에 대한 문자가 출력됨
		System.out.println("char : " + c +", " + c2 + ", " + c3);

		// 실수형 
		// float형은 4byte, 3.14란 실수 리터럴은 8byte
		// float형에 8byte 실수 리터럴을 담기위해
		// f 또는 F를 실수리터럴 뒤에 붙여 형명시
		float f = 3.14F;

		// double은 literal과 datatype의 크기가 같으므로
		// 형명시를 생략할 수 있다. (d, D)
		double d = 3.14;
		double d2 = 3.14D;

		System.out.println("float : " + f + ", double : "
			+ d + ", double2 : " + d2);

		// 불린형 
		boolean tu = true;
		boolean fa = false;

		// tu = 0; boolean은 true, false만 담을 수 있다. 
		// c처럼 1, 0을 사용하지 않는다.

		System.out.println("boolean : " + tu + ", boolean : " + fa);
	}// main 
}// class

byte b = 10; // byte 타입은 1byte를 넣을 수 있고 정수 literal은 4byte.
// 할당 안돼야 정상인데??

short s = 10; // short 타입은 2byte 얘한테도 할당안돼야 하는데??

// but, 자동형변환 때문에 가능

byte b1 = 10, b2 = 20, result = 0;

// error! - 자동형변환 때문에 에러발생
result = b1 + b2;

// byte와 byte 연산되고선 결과가 int로 발생
// result를 int형 변수로 선언해서 해결

byte b = 10;
short s = 20;

// b가 short타입으로 자동형변환 후 연산, 연산결과는 int
int i = b + c;  

// 작은바이트타입과 큰바이트타입이 연산되면 작은바이트타입이 
// 큰바이트타입으로 형변환 후 연산
// byte + byte = int
// byte + short = int , byte가 short으로 형변환된 후 연산
// int + int = int 
// int + long = long , int가 long으로 형변환된 후 연산
// char + char = int

// (변환할데이터형)변수명;

double d = 3.14;

// float f = dl; error!
float f = (float)d;

float f = 23;
int i  = (int)f;

// 강제형변환 하면 literal 크기를 변경하는 형명시 안해도 됨
float f2 = (float)3.1415;

/*
    강제형변환 (Casting)
    - 변수의 데이터형을 일시적으로 변환하여 사용하는 것
*/

class UseCasting{

    public static void main(String[] args) {

        byte b1=10, b2=20;        // 자동형변환
        
        // 연산의 결과를 int로 자동형변환, error!
        // byte result = b1+b2;    

        // 강제형변환!
        // 가로는 +보다 연산의 우선순위가 빠름
        // 때문에 연산을 먼저 묶음
        byte result = (byte)(b1+b2);

        System.out.println(b1 + " + " + b2 + " = " + result);

        double d = 11.14;
        float f = (float)d;

        System.out.println("double : " + d + ", float : " + f);
        
        // 상수에 사용가능, literal 자체는 바뀌지 않음
        float f1 = (float)2018.11;
        System.out.println("float : " + f1);

        // error!
        // 상수값이 literal보다 크면 casting을 실행하기 전에 error 발생
        // long l = (long)2147483648;
        
        // int와 float은 byte 수는 같아도 값을 담는 형태가 달라 할당 안됨
        // 값손실 발생(실수부의 값이 모두 사라져 할당)
        int i = (int)f1;

        System.out.println("int : " + i + ", float : " + f1);       

        char c = 'A';
        System.out.println(c + "의 unicode(ASCII code)값 " + (int)c);

        // 형이(기본형 <-> 참조형) 다르면 강제형변환이 되지 않는다.
        // error!
        String str = "11";    // String은 참조형 데이터타입
        int i2 = str;        // int는 기본형 데이터타입

        // boolean형은 boolean형 끼리만 변환가능
        // error!
        // boolean b=true;
        // int i3=(int)b;

        boolean b = true;
        boolean b3 = (boolean)b; // 의미없는 강제형변환..

        System.out.println("boolean : " + b3);
    }// main
}// class

// 정수는 그냥 int로 변수를 생성하면 걱정없음.. 
// 메모리 마구마구 쓰세요~
// 메모리를 절약하기 위해 형변환을 여러번 하는 것보다 
// int로 연산하는게 더 빠르다! 

// 작성법
public static final 데이터형 상수명 = 값;

// 사용법
// 정의한 클래스안에서 사용
// - 상수명 또는 클래스명.상수명
// 다른 클래스에 있는 상수
// - 클래스명.상수명
// '.'은 그 안을 의미.. ex) 내.너

/*
	Constant(변수를 상수처럼 사용하는 것: 상수)의 사용
	선언 : class field에서만 선언
*/
class Constant {

	// Constant 선언
	// 상수는 method내에서 선언할 수 없다
	public static final int MAX_SCORE=100;
	public static final int MIN_SCORE=0;

	public static void main(String[] args) {
		
		// 상수의 사용
		System.out.println(MAX_SCORE + " / " + MIN_SCORE);	
		System.out.println(Constant.MAX_SCORE + 
												" / " + Constant.MIN_SCORE);

		int my_score=83;
		// MAX_SCORE=90; 상수는 값할당이 되지 않는다.

		System.out.println("점수의 최고점은 "+Constant.MAX_SCORE+
			"점이고, 최저점은 :"+Constant.MIN_SCORE+
			"입니다. 획득점수는 "+my_score+
			"이고, 최고점과 획득점수의 차이는 "+
			(MAX_SCORE-my_score)+"입니다.");

	}// main
}// class

/*
	다른 클래스에 있는 상수를 사용해보기위한 클래스
*/
class UseConstant{

	public static void main(String[] args){

		// 다른클래스에 존재하는 상수를 참조할 땐 
		// 클래스명.상수명 의 형식을 가진다
		// System.out.println(MAX_SCORE);
		System.out.println(Constant.MAX_SCORE+" / "+Constant.MIN_SCORE);
	}
}

// 클래스 field 사용해보기
System.out.println("long의 최댓값 : "+Long.MAX_VALUE+", long의 최소값 : "+Long.MIN_VALUE);
// 못 외우면 java api doc 찾으면서 사용