[Java] 변수, 형변환, 식별자

Part1 변수
1. 변수란? (variable)

- 값을 저장할 수 있는 공간
- 메모리에 값을 기록하기 위한 공간
- 변수명은, 각 저장공간의 구분을 위해 필요함

* 변수에 값을 기록하는 이유?
- 프로그램 실행 시 사용할 값(DATA)는 메모리에 기록되어야만 사용 가능함

2. 변수의 선언: 메모리에 데이터를 저장할 수 있는 공간을 할당하는 것
저장공간이 필요하다면 변수를 선언해야 함 (변수 선언 시, 저장공간 생성)
같은 데이터타입(자료형)의 변수는 동시 선언이 가능함

	int      coder;
 // 변수타입
 // (자료형)   변수명;
 
    int java, html, css;
    
 // 같은 타입(자료형) 변수는 동시선언 가능

3. 변수를 사용하는 이유
- 재사용성: 한번의 값 저장으로 필요시 재사용 가능
- 가독성: 값에 의미를 부여해줌
====> 유지보수 용이
4. 변수와 저장공간은 일대일 대응 / 중복저장시 마지막 저장값을 저장
변수=저장공간을 의미하므로, 하나의 변수(저장공간)에는 하나의 값만 저장 가능함

5. 변수의 초기화
- 초기화(initialization):변수 선언 후 처음으로 해당 변수에 값을 저장하는 것
* 초기값: 초기화를 통해 변수에 넣어준 값

6. 변수의 데이터타입:
- 테이터의 타입에 따라 저장공간의 크기, 형식을 정의한 것
- 변수에 어떠한 값을 저장하느냐에 따라 달라짐
(저장값/리터럴 의 타입에 따라 변수타입 결정)
- 변수 선언 시에는 저장값으 특성을 고려하여 가장 알맞는 변수 타입을 선택하여야 함


7. 상수와 리터럴
1) 상수(constant): 변수와 마찬가지, 저장공간
-> 변수와 달리 한 번 저장시 값 변경 불가
-> 변수 앞 final 선언시 사용가능
-> 한 번 선언하면, 상수의 값 변경 불가

final 데이터타입 변수명; // 상수형 변수명은 대문자로 선언!
                        // 여러 문자의 경우 underbar 구분

final double LAST_ONE = 1.112

2) 리터럴(literal): 변수에 저장되는 값 (수학적 개념의 상수)
- 리터럴 타입과 접미사
: 리터럴에도 타입이 있으며, 변수의 타입은 리터럴의 타입에 의해 결정

종류	리터럴	접미사
논리형	false, true	없음
정수형	123, 0b0101, 100L	L - long 타입 ( 생략불가, ~L) 없을시 - int (default값) byte, short - 별도 접미사 없음
실수형	3.14, 3.0, 1.4f	f - float 타입 (생략불가, ~f) d - double 타입 (default 값, 생략가능)
문자형	'a', '1', '\n'	없음	한 개 문자 ' - ' 로 감싸기 빈 문자 비허용 ( '-' 내부 반드시 존재)
문자열	"ABC", "123", "A", " ", "TRUE"	없음	두 개 이상 문자 " -- " 로 감싸기 빈 문자열 허용 (empty string)

* 자바 defalult 컴파일 값: 정수형 -> int, 실수형 ->double

3) 문자열 결합: 문자열 + 문자열
* "S"tring이 대문자인 이유가있어~
피연산자 중 한 쪽이 String일 시, 나머지 한 쪽을 String 변환 후 결합
어떤 타입도 String을 만나면 그 결과값이 문자열이 됨

문자열 + any type -> (문자열) + (문자열로 변환) -> 문자열 (결과)

 

8. 변수의 기본형과 참조형
1) 기본형(8개) : 실제 값(data)를 변수에 저장 (연산에 사용되는 변수는 모두 기본형)

<정수형>

데이터 타입	메모리의 크기	표현 가능 범위
byte	1 byte	-128 ~ 127
short	2 byte	-32,768 ~ 32,767
int	4 byte	-2,147,483,648~2,147,483,647
long	8 byte	-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807

* 정수형 리터럴 "," 역할 -> underbar
(예: 10000 -> 10_000)
<실수형>

float	4byte	±(1.40129846432481707e-45 ~ 3.40282346638528860e+38)
double	8byte	±(4.94065645841246544e-324d ~ 1.79769313486231570e+308d)

<문자>

char	2byte	모든 유니코드 문자
String *참조형	크기 미정 (길이에 제한 없음)	문자열

<논리형>

boolean

1byte

true / false

2) 참조형: 값이 저장되어 있는 메모리주소(memory address)를 저장 (참조형 변수간 연산 불가)
* 메모리 주소(객체주소): 메모리에 1byte단위로 붙어있는 일련번호


9. 오버플로우 : 연산과정에서 해당 타입이 표현가능한 최대 범위를 넘어서는 것
- 오버플로우가 되어도 에러는 발생하지 않지만, 예상 값을 얻을수 없음
1) 정수형의 오버플로우
최대값 + 1(오버플로우) => 최소값
최소값 - 1 (오버플로우) = 최대값

10. 결과값 타입 간 변환방법
1) 숫자->문자로 : 숫자 + '0'
2) 문자->숫자로: 문자-'0'
3) 숫자=>문자열로: 3 + " "
4) 문자열=>숫자로: Integer.parseInt() or Double.parseDouble()
5) 문자열=>문자로: charAt(3)
6) 문자=>문자열로: +" "



Part2. 형변환
1. 형변환(casting)이란?:
- 서로 다른 타입간 연산 수행을 위해서는 연산 전 연산하고자 하는 값들의 타입을 일치시키는 것이 원칙
- 형변환: 변수나 리터럴(상수)의 타입을 다른 타입으로 변환하는 것

(타입) 피연산자
() : 캐스트연산자, 형변환 연산자

2.  형변환의 종류

1) 자동 형변환 (promotion)
- 컴파일러 자동 형변환 (

https://s3.ap-northeast-2.amazonaws.com/opentutorials-user-file/module/516/1822.gif

                    

 

2. 강제 형변환(force casting) :자동형변환이 이루어지지 않을 경우 진행
     큰타입 => 작은타입으로 변환 (프로그래머 책임 하에, (캐스팅연산자)를 통해 진행, 형변환 명시)
      ===> 값 손실 발생가능. 신중하게
    

ex) byte b = 10000; (에러)
- 좁은그릇-> 넓은그릇 : O (값 손실 없음, 자동형변환)
1 Byte 2 Byte 4 Byte 8 Byte 4 Byte 8 Byte

* 기본값을 최대한 보존할 수 있는 타입으로 자동형변환됨

 

3. 산술변환:
1) 이항연산자는 두 피연산자의 타입이 일치해야 연산 가능함
2) 피연산자 타입이 다를시 형변환 연산자를 통해 타입 일치시켜야함
===> 컴파일러가 자동으로 형변환하는 것을 "산술변환", "일반산술변환"이라 함
* 산술변환 규칙
(1) 더 큰 그릇 타입으로 일치
*(2) 피연산자 타입이 int보다 작을 시 int로 변환
( char, short의 경우 표현범위가 좁아서 오버플로우 발생 가능성이 높음)
*(3) 정수 + 실수 형변환시, 실수로 변환
( 8byte 정수 (long) 보다 4byte 실수(float)형이 더 범위가 큼)

long + int -> long + long -> long
float + int -> float + float -> float
double + float -> double + double -> double
byte + short -> int + int -> int
char + short -> int + int -> int
char + char -> int + int ->int // char형이 int로 변할때에는 대응되는 아스키코드 값으로 변환됨
long + float -> float + float ->float

 

// 자동형변환: 작->큰
	 public void autoCasting() {
	// 1. int(4byte, 정수) -> double(8byte, 실수)
	    int i1 =10;
		System.out.println(i1);
		double d1 = /*double*/i1;
		System.out.println(d1);
		// 자동형변환 완료 (int -> double 타입으로) 
		// d1 =10->10.0
		
	  // 2. int(4byte, 정수)-> long (8byte, 실수)
          int i2 = 1200000;
          long l3 =i2;
         System.out.println(l3);    // 1200000
         
      // 특이케이스 1. long (8byte, 정수) -> float(4byte)
      // 정수 -> 실수 변환시, 큰 정수가 작은 실수에 대입 가능
      // => 4byte float 형이 8byte long형보다 담을 수 있는 값의 범위가 더 크기 때문
         
        long l4 = 1000000L;
        float f5 = l4;
        System.out.println("f5출력: " +f5); //  f5출력: 1000000.0  	
         
       // 특이케이스 2. char(2Byte) <-> int (4Byte) 
       // 아스키코드표 
         char ch = 98; // 아스키코드, 숫자 - 알파벳 대응
         char ch2 = 'b';
         System.out.println(ch+"는"+ch2+"?"); // b는b? 
         //char + string + char ==> String + String +String으로 인식

         
         int num = ch; // int<->char 간의 형변환
         System.out.println(num);
         
         System.out.println('b');  //b 
         System.out.println((int) 'b'); // ->98
         System.out.println('b'+2);//  -> char + int => int ( 98+2 =100)
         System.out.println('b'+(char)'2'); //-> 100 
         System.out.println((char)2); // 
         
         
         
         System.out.println((char)2+(char)'2'); // char형 '2'를 int형으로 변환시,이에 대응되는 아스키값인 50이 출력됨
         // 작은 자료형, 큰 자료형 연산시 작은 자료형을 큰 자료형으로 변환하여 연산, 위의 경우 모두 int 형으로 변환,int50 + int2 이 되어 int 52가됨 (502아님)

 

// 특이케이스 5. byte, short간의 연산
         // -128~127
         byte b1 = 126;
         byte b2 = 2;       
         System.out.println(b1+b2);
         // 결과값이 int 형 => cpu가 값을 처리하는 기본크기가 int형의 크기 (4byte)         
         // byte b3 = (byte)128;  // byte 범위를 넘는 값을 byte에 넣었음, 오버플로우 발생
         System.out.println(b3);
         
         // 강제형변환 : 큰 바이트 -> 작은바이트
	 }
         public void forceCasting() {              //여기 오류 다시보기 
        	 // 명시적 형변환이라고도 함 
        	 // (바꿀자료형) 값
        	 // 1. double (8byte) -> float(4byte)
        	 
        	 double d2= 8.0;
        	 float f1 = (float)d2;
        	 
        	 System.out.println(f1);
    
         
         double d3= 10.123123;
         int i4 = (int)d3;
         System.out.println(i4);
          // 0.123123소수점 뒷부분 절삭 -> 데이터 손실 
         
         int iNum=10;
         double dNum=1.56;
         double dNum2 = 0.57;
         
         // BigDecimal
         
         System.out.println(iNum+dNum); // 11.56
         System.out.println(dNum+dNum2);//2.13
         System.out.println((int)(dNum+dNum2));//2
         
         
         
         char ch = 98; // 아스키코드, 숫자 - 알파벳 대응
         char ch2 = 'b';
         System.out.println(ch+"는"+ch2+"?");
         
         int num = ch; // int<->char 간의 형변환
         System.out.println(num);
         
         System.out.println('b');
         System.out.println((int) 'b'); // ->98
         System.out.println('b'+2);//  -> 100
         System.out.println('b'+(char)2); //-> 문자+문자는 자바가 컴파일 할 수 없는 코드임
                                          //-> 자바가 강제로 int+int로 변환함
         
         System.out.println((char)2); // 숫자를 문자형에 넣으면 인식이 불가!
         System.out.println((char)2+(char)'2'); 
         // char형 + char형 = int형 
         // char형 '2'를 int형으로 변환시,이에 대응되는 아스키값인 50이 출력됨
         // 작은 자료형, 큰 자료형 연산시 작은 자료형을 큰 자료형으로 변환하여 연산, 위의 경우 모두 int 형으로 변환,int50 + int2 이 되어 int 52가됨 (502아님)
         
      
         }

4. 식별자(identifier)
- 클래스명, 메소드명, 변수명 등 사용자가 만들어서 이용하는 고유의 이름
1) 식별자 생성 규칙
- 대소문자 구분, 길이제한 없음
- 포함가능: 문자, 숫자, underbar, $ 포함가능
- 사용가능: 문자, underbar, $ (숫자로 시작불가)
- 공백 포함불가
- 예약어(키워드, 보라색으로 표기되는 void, public등)은 식별자로 사용할 수 없음

2) 식별자 명명 규칙(암묵적 약속)
(1) 클래스/인터페이스:
- 명사, 형용사를 서술적으로 연결하여 사용
- 첫글자는 대문자
- 연결된 단어들의 첫글자도 대문자
(ex_HelloWorld)
(2) 변수:
- 명사적 의미
- 첫글자는 소문자
- 연결된 단어들의 첫글자는 대문자 표기
(ex_lunchMenu)

(3) 메소드:
- 동사적 의미
- 첫글자는 소문자
- 연결된 단어들의 첫글자는 대문자 표기
- 메서드명명부분 바로 뒤엔 항상 ()가 붙음
- 메소드명은 일반적으로 underbar를 사용하지 않음
(ex_goHome() )

(4) 상수:
- 모든 문자를 대문자 표기
- 연결된 단어 사이 underbar 삽입



5. 출력문
print: 출력 후 줄바꿈 x
println: 출력후 줄바꿈o
printf: 출력 후 줄바꿈 x, 원하는 format을 지정하여 출력가능

%b	boolean
%d	정수
%o	8진수 정수
%x ,%X	16진수
%f	소수점 (.Af -> A+1자리에서 반올림하여 소수점A자리의 실수반환)
%c	문자형 (C: 대문자반환)
%s	문자열 (S: 전체문자열 대문자반환)
%n	줄바꿈
%e %E	지수

 

-> 결과

6. 화면에서 입력받기 (Scanner)

화면에서 입력받기 순서:
1) Scanner 객체생성 (임의 변수선언, 초기값 System.in)
2) java.util.* 임포트 ( ctrl + shift + o)
3) 콘솔창 직접입력 이전 화면에 뜰 출력문 입력
4) 변수선언 = Scanner 변수. Scanner메소드호출
5) 출력

Scanner 클래스 메서드

- next(): String타입, 입력값 문자열 반환
- nextLine(): String타입, 개행문자(\n)를 포함하는 문자열 line 반환, \n은 반환하지 않음
- nextByte() : byte 타입, byte 타입 입력 및 반환
- nextInt() : int 타입, int타입 입력 및 반환
- nextShort() : short 타입, short타입 입력 및 반환
- nextLong() : long 타입, long타입 입력 및 반환
- nextDouble()
- Scanner매개변수.close() : Scanner 메서드 사용 종료

*next.charAt(index넘버): char 타입,
String타입 입력값 중 (index넘버+1)에 해당하는 자리의 문자를 char 타입으로 반환