Java 2장(with 이것이 자바다)

변수(Variable)란

값을 저장할 수 있는 메모리의 공간
변수에는 복수 개의 값을 저장할 수 없고 하나의 값만 저장할 수 있다.

---

 

변수의 선언

• 어떤 타입의 데이터를 저장하고 이름이 무엇인지를 결정한다.

int age;                       //정수(int)값을 저장할 수 있는 age 변수를 선언
double value;             //실수(double)값을 저장할 수 있는 value 변수 선언

• 타입은 변수에 저장되는 값의 종류, 범위를 결정짓는 요소이다.
• 어떤값을 변수에 저장할 지 생각한 후 결정해야한다.

변수 이름은 메모리 주소에 붙여진 이름이다.

변수 이름은 자바 언어에서 정한 명명 규칙(naming convention)을 따라야 한다.

작성규칙	예
첫 번째 글자는 문자이거나 '$', '_'이어야 하고 숫자로 시작할 수 없다.	가능 : price, $price, _companyName 불가능 : 1v, @speed, $#value
영어 대소문가 구분된다(필수)	firstname과 firstName은 다른 변수
첫 문자는 영어 소문자로 시작하되 다른 단어가 붙을 경우 첫문자를 대문자로 한다.(관례)	maxSpeed, firstNmae, carBodyColor
문자 수(길이)의 제한은 없다.
자바 예약어는 사용할 수 없다.(필수)	아래 표 참조

 

---

 
 

자바의 예약어

예약어들로 변수 이름을 지정하면 컴파일 에러가 발생하기에 주의해야한다.

분류	예약어
기본 데이터 타입	boolean, byte, char, short, int, long, float, double
접근 지정자	private, protected, public
클래스와 관련된 것	class, abstract, interface, extends, implements, enum
객체와 관련된 것	new, instanceof, this, super, null
메소드와 관련된 것	void, return
제어문과 관련된 것	if, else, switch, case, default, for, do, while, break, continue
논리값	true, false
예외 처리와 관련된 것	try, catch, finally, throw, throws
기타	translent, volatile, package, import, synchronized, native, final, static, strictfp, asset

---

변수의 사용

변수를 사용한다는 것은 변수에 값을 저장하고 읽는 행위

 

• 변수에 값을 저장할 때 대입 연산자(=)를 사용한다.( 우측의 값을 좌측 변수에 저장한다는 의미)
• 변수를 선언하고 처음 값을 저장한 경우 이러한 값을 초기값이라 한다.

int score;                    //변수 선언
score = 90;                 //90을 score에 저장한다.

int score = 90;            //초기값은 변수를 선언함과 동시에 줄 수 있다.

 

1. 소스 코드 내에서 직접 입력된 값을 리터럴(literal)이라 한다.
2. 리터럴은 값의 종류에 따라 정수 리터럴, 실수 리터럴, 문자 리터럴, 논리 리터럴로 구분된다.
3. 정해진 표기법 대로 작성되어야 한다.
4. 리터럴은 상수(constant)와 같은 의미.

상수 : 값을 한 번 저장하면 변경할 수 없는 변수

 

정수리터럴

• 소수점이 없는 정수 리터럴은 10진수로 간주한다. (0, 75, -100 등)
• 0으로 시작되는 리터럴은 8진수로 간주한다. (02, -04 등)
• 0x 또는 0X로 시작하고 0~9숫자나 A, B, C, D, E, F 또는 a, b, c, d, e, f로 구성된 리터럴은 16진수로 간주한다.(0x5, 0xA, 0xB3, 0xAC08)

실수리터럴

• 소수점이 있는 리터럴은 10진수 실수로 간주한다.(0.25, -3.14 등)
• 실수 리터럴을 저장할 수 있는 타입은 float, double이 있다.
• 대문자 E 또는 소문자 e가 있는 리터럴은 10진수 지수와 가수로 간주한다.

문자리터럴

• 작은 따옴표(')로 묶은 텍스트는 하나의 문자 리터럴로 간주한다.('A', '한', '\t', '\n' 등)
• 문자 리터럴은 저장할 수 있는 타입은 char 하나뿐이다.

역슬래쉬가 붙은 문자 리터럴은 이스케이프(escape) 문자라 한다.

문자열 리터럴

• 큰따옴표(")로 묶은 텍스트는 문자열 리터럴로 간주한다.("대한민국", "탭 만큼 \t 합니다.", "한줄 내려쓰기 \n 합니다")
• 큰따옴표 안에 텍스트가 없어도 문자열 리터럴로 간주한다.
• 문자열 리터럴 내부에서도 이스케이프 문자를 사용할 수 있다.
• 문자열 리터럴을 저장할 수 있는 타입은 String 하나뿐이다.

논리 리터럴

• ture와 false는 논리 리터럴로 간주한다.
• 논리 리터럴을 저장할 수 있는 타입은 boolean 하나 뿐이다.

---

변수값 읽기

변수는 초기화가 되어야 읽을 수 있다.

int value;                                                      //변수 value 선언(초기화 x)
int result = value + 10;                                 // 변수 value 값을 읽고 10을 더한 결과값을 변수 result 에 저장

//변수 value가 선언되었으나 초기화가 되지않아 value + 10에서 사용할 수 없다. (컴파일 에러가 발생)

int value; = 30;                                             //변수 value가 30으로 초기화 됨.
int result = value + 10;                                  //변수 value 값을 읽고 10을 더한 결과값 40을 변수 result에 저장

---

public class VariableExample{
   public static void main(String[] args){
        int value = 10;                                                 //10을 변수 value의 초기값으로 저장
        int result = value + 10;                                    //변수 value의 10을 더하고 result의 초기값으로 저장

     System.out.println(result);                                   // result 변수의 값은 20
        }
}

---

변수의 사용 범위

변수는 중괄호 { } 블록 내에서 선언되고 사용된다.
중괄호 블록을 사용하는 곳은 클래스, 생성자, 메소드

 

1. 메소드 블록 내에서 선언된 변수를 로컬 변수(local variable)이라 한다.
2. 로컬 변수는 메소드 실행이 끝나면 메모리에서 자동으로 멀어진다.

변수는 메소드 블록 내 어디에서든 선언할 수 있으나 변수 사용은 제한이 있다.
(변수는 선언된 블록에서만 사용이 가능)

---

• 메소드 블록 내에서 조건문if ( ) { }, 반복문 for ( ) { }, While ( ) { }등이 중괄호를 가질수 있다. (제어문이라 한다)
• 제어문 블록에서 선언된 변수는 해당 제어문 블록 내에서만 사용이 가능하다.(밖에서 사용x)

public static void main(String[] agrs){
    int var1;                                             //메소드 블록에서 선언

   if ( ) {
      int var2;                                            // if 블록에서 선언
      //var1, var2 사용가능
      }
   for ( ) {
       int var3;                                           // for 블록에서 선언
      //var1, var3 사용가능
      //var2는 사용 불가
     }
      //var1 사용가능
      //var2, var3 사용 불가
}

---

변수를 선언할 때 변수가 어떤 범위에서 사용될 것인지를 생각하여 선언위치를 결정한다.
메소드 블록에서 어떤위치건 사용한다면 메소드 블록 첫머리에 사용
제어문내에서 잠깐 사용한다면 제어문 내에서 사용

public calss VariableScoreExample{
   public static void main(Stiring[] args){
     int v1 = 15;
     if(v1>10){
       int v2 = v1 - 10;
     }
       int v3 = v1 + v2 + 5;                                   //if 블록내 v2를 사용할 수 없어 컴파일 에러가 생긴다.
   }
} 

---

데이터 타입

1. 모든 변수에는 타입(type : 형)이 있다.
2. 타입에 따라 값의 종류와 범위가 달라진다.
3. 변수를 선언할 때 주어진 타입은 변수를 사용하는 도중 변경할 수 없다.
4. 변수를 선언할 때 어떤 타입을 사용할 지 충분히 고려해야한다.

---

기본(원시 : primitive) 타입이란

정수, 실수, 문자, 논리 리터럴을 직접 저장하는 타입

 

• 정수 타입 : byte, char, short, int, long
• 실수 타입 : float, double
• 논리 타입 : boolean

기본	byte	bit
byte (정수)	1byte	8bit
char (정수)	2byte	16bit
short (정수)	2byte	16bit
int (정수)	4byte	32bit
long (정수)	8byte	64bit
float (실수)	4byte	32bit
double (실수)	8byte	64bit
boolean (논리)	1byte	8bit

 

1. 메모리에는 0과 1을 저장하는 최소 기억 단위인 비트(bit) 가 있다.
2. 이 비트를 8개 묶은것이 바이트(byte)라 한다.
3. 기본 타입은 정해진 메모리 사용 크기(바이트 크기)로 값을 저장한다.
4. 바이트 크기가 클수록 표현하는 값의 범위도 크다.

---

정수 타입(byte, char, short long)

정수타입	byte	char	short	int	long
바이트 수	1	2	2	4	8

 

• 자바는 기본적으로 정수 연산을 int 타입으로 수행한다.
• 저장하려는 값이 정수 리터럴이라면 int타입 변수에 저장하는 것이 좋다.

 

byte타입

1. 색상 정보 및 파일 또는 이미지 등의 이진(바이너리) 데이터를 처리할 때 주로 사용된다.
2. byte 타입은 정수 타입 중 가장 작은 범위의 수를 저장한다. 표현 할 수있는 값의 범위 : -128~127
3. 값이 초과할 경우 컴파일 에러가 발생한다 (Type mismatch : cannot convert from int to byte)

최상위 비트(MSB: Most Significant Bit)

• 정수값의 부호를 결정한다.
• 차상위 비트가 0이면 양의 정수, 1이면 음의 정수를 뜻한다.
• byte타입보다 크기가 큰 타입도 동일한 원리로 작동한다.

public class ByteExample{
   public static void main(String[] args){
    byte var 1= -128;
    byte var 2 = -30;
    byte var 3 = 0;
    byte var 4 = 30
    byte var 5 = 127;
    // byte var 6 = 128; 은 에러가 나온다.

   System.out.println(var1);    //-128
   System.out.println(var2);    //-30
   System.out.println(var3);    //0
   System.out.println(var4);    //30
   System.out.println(var5);    //127
   }
}

---

• 실행 중에 저장할 수 있는 값의 범위를 초과하면 최소값부터 다시 반복 저장된다.
• byte일 경우 -128~127을 넘으면 -128부터 시작한다.
• shot, int, long도 마찬가지이다.
• 저장할 수 있는 값의 범위를 초과하여 저장될 경우 쓰레기 값이라 한다.

public class GarbageValueExample{
  public static void main(String[] args){
    byte var = 125;
     int var = 125;
    for(int i = 0; i<5; i++){
      var 1++;
      var 2++;
      System.out.println("var1:" + var1 + "\t" + "var 2 :" + var2);
       }
   }
}  // var 1은 127이 넘어가면 -128부터 돌아가고 var2는 int 타입의 변수는 정상적으로 작동한다.

---

char 타입

자바는 모든 문자를 유니코드(Unicode)로 처리한다.

유니코드는 세계 각국의 문자들을 코드값으로 매핑한 국제 표준규약이다.

1. 유니코드는 0~65535 범위의 2byte 크기를 가진 정수값이다.
2. 자바는 하나의 유니코드를 저장하기 위해 2byte 크기인 char 타입을 제공한다.
3. 유니코드는 음수가 없기에 char타입의 변수에 음수값을 저장할 수 없다.
4. char 타입에 저장할 수 있는 값은 0~65535이다.
5. char 타입에 변수 작은 따옴표(')로 감싼 문자를 대입하면 해당 문자의 유니코드가 저장된다.

char var1 = 'A';     //유니코드 : 0x0041   -> 이진수 : 00000000 01000001
char var2 = 'B';     //유니코드 : 0x0042   -> 이진수 : 00000000 01000010
char var3 = '가';    //유니코드 : 0xAC00  -> 이진수 : 10101100 00000000
char var4 = '각';    //유니코드 : 0xAC01  -> 이진수 : 10101100 00000001

---

char 변수에 작은 따옴표 (')로 감싼 문자가 아니라 직접 유니코드 정수값을 저장할 수 있다.
특정문자의 유니코드를 안다면 10진수 또는 16진수로 저장하면된다.

char c = 65;
char c = '\u0041'; 
char c = 'A';

int uniCode = c;                     //A는 유니코드로 \u0041, c 는 10진수로 65이다.

---

public class CharExample{
  public static void main(String[] args){
    char c1 = 'A';                    //문자를 직접 저장
    char c2 = 65;                    //10진수로  저장
    char c3 = '\u0041';            // 16진수로 저장

    char c4 = '가';                   //문자를 직접저장
    char c5 = 44032               //10진수로 저장
    char c6 = '\uac00';            //16진수로 저장

    int uniCode = c1               // c1의 유니코드 얻기

   System.out.println(c1);        //A
   System.out.println(c2);        //A
   System.out.println(c3);        //A
   System.out.println(c4);        //가
   System.out.println(c5);        //가
   System.out.println(c6);        //가
   System.out.println(c7);        //65
   } 
}

---

문자열을 저장하고 싶을 경우 String 타입을 사용해야한다.
큰 따옴표로 감싼(" ")문자열 리터럴을 대입하면된다.

EX) String name = "김형석";

• Sring은 기본타입이 아니다
• String은 클래스 타입이고 String 변수는 참조 변수이다.
• String 변수에 대입 -> String 객체 생성 -> String변수는 String객체의 번지를 참조하게된다.
• Stirng변수는 큰따옴표("") 두개를 연달아 붙인 빈 문자를 대입해도 괜찮다.

---

Short 타입

Short 타입은 2byte(16bit)로 표현되는 정수값을 저장할 수 있는 데이터이다.
저장할 수 있는 값의 범위는 -32,768~32,767이다

C언어와의 호환을 위해 사용되며 자바에서는 잘 사용되지 않는 타입

---

int 타입

int 타입은 4byte(32bit)로 표현되는 정수값을 저장할 수 있는 데이터 타입이다.
저장할 수 있는 값의 범위는 -2,147,483,658~2,147,483,647이다.

int타입은 자바에서 정수연산을 하기위한 기본 타입이다.

public class IntExample{
   public static void main(Stiring[] args){
     int var1 = 10;                                       //10진수
     int var2 = 012;                                     //8진수 -> 앞에 0을 붙이면된다.
     int var3 = 0xA;                                     // 16진수 -> 앞에 0x를 붙이면된다.

    System.out.println(var1);
    System.out.println(var2);
    System.out.println(var3);
   }                                                            //결과는 다 10으로 출력된다.
}

---

long 타입

long타입은 8byte(64bit)로 표현되는 정수값을 저장할 수 있는 데이터 타입이다.
저장할 수 있는 값의 범위는 -9,223,372,036,854,775,808~9,223,372,036,854,775,807이다

수치가 큰 데이터를 다루는 프로그램에서 long타입이 필수적으로 사용된다.

• long 타입의 변수를 초기화 할때 정수값 뒤에 소문자 'l' 또는 대문자 'L'을 붙일 수 있다.
• int 타입의 저장 범위를 넘어서는 큰 정수는 반드시 'l' 또는 'L'을 붙여야한다.

---

public class LongExample{
  public static void main(String[] args){
   long var 1 =10;
   long var 2 = 20L;
   //long var3 = 10000000000000; //컴파일에러 (int 타입의 저장범위를 넘어서는 정수리터럴에 L을 붙이지 않아서)
   long var4 = 1000000000000L;

  System.out.println(var1);   //10
  System.out.println(var2);   //20
  System.out.println(var4);   //1000000000000 가 나온다.
    }
}

---

실수 타입(float, double)

실수 타입은 소수점이 있는 실수 데이터를 저장할 수 있는 타입이다.
메모리 사용 크기에 따라 float과 double이 있다.

 

실수 타입	float	double
바이트 수	4	8

 

• 실수는 정수와 달리 부동 소수점(floating -point)방식으로 저장된다.
• float타입과 double 타입은 가수와 지수를 저장하기 위해 전체 bit를 나누어 사용한다.

float : 부호(1bit) + 지수(8bit) + 가수(23bit) = 32bit = 4byte

double : 부호(1bit) + 지수(11bit) + 가수(52bit) = 64bit= 8yte

 

• 가수를 표현하는데 있어 float에 비해 double이 약 두배 자릿수가 배정되어 있다.
• float보다 double이 더 정밀한 값을 저장할 수 있기에 높은 정밀도를 요구하는 계산에서 double을 사용해야한다.
• 자바는 실수 리터럴의 기본 타입을 double로 간주한다.
• 실수 리터럴을 float타입 변수에 저장하려면 리터럴 뒤에 소문자 'f' 또는 대문자'F'를 붙여야한다.

double var = 3.14;
float var2 = 3.14;        //에러 
float var3 = 3.14F;

---

정수 리터럴에 10의 지수를 나타내는 E 또는 e를 포함하고 있으면 정수 타입 변수에 저장할 수 없다.
실수타입 변수에 저장해야한다.

int var6 = 3000000;    //3000000
double var7 = 3e6;     //3000000
float var8 = 3e6f;        //3000000
double var9 = 2e-3;    //0.002

public class FloatDoubleExample{
   public static void main(Sting[] args) {
    //실수값 저장
    double var1 = 3.14;
    //float var2 = 3.14;    //에러 뒤에 F 또는 f를 붙여야한다.
    float var3 = 3.14F;

    //정밀도 테스트
    double var4 = 0.1234567890123456789
    float var5 = 0.1234567890123456789F;

   System.out.println("var1: " + var1);   //3.14
   System.out.println("var3: " + var3);   //3.14
   System.out.println("var4: " + var4);   //0.1234567890123456789
   System.out.println("var5: " + var5);   //0.12345679

  //e 사용하기
  int var6 = 3000000;
  double var7 = 3e6;
  float var8 = 3e6F;
  double var9 = 2e-3;

  System.out.println("var6 : " + var6);   //3000000
  System.out.println("var7 : " + var7);   //3000000.0
  System.out.println("var8 : " + var8);   //3000000.0
  System.out.println("var9 : " + var9);   //0.002
   }
}

---

논리타입(boolean)

boolean 타입은 1byte(8bit)로 표현되는 논리값(true/false)을 저장할 수 있는 데이터 타입이다.
두가지 상태값을 저장할 필요성이 있을 경우 사용된다.

상태값에 따라 조건문과 제어문의 실행흐름을 변경하는데 주로 이용된다.

public class BooleanExample{
  public static void main(String[] args){
    boolean stop = true;                               // true이면 중지합니다, false이면 시작합니다 가 출력된다.
     if(stop) {
      System.out.println("중지합니다.");
}    else{
       System.out.println("시작합니다.");
        }
     }
 }

---

타입변환이란

데이터 타입을 다른 데이터 타입으로 변환하는 것을 말한다.
byte를 int로(자동, 묵시적) int를 byte로(강제, 명시적) 변환하는 행위

---

자동타입 변환

자동타입 변환(Promotion)은 프로그램 실행 도중 자동적으로 타입변환이 일어나는 것을 말한다.
작은 크기를 가진 타입이 큰크기를 가지는 타입에 저장될 때 발생.

 

byte(1) < short(2) < int(4) < long(8) < float(4) < double(8)

• float이 long보다 큰 이유는 표시할 수 있는 범위가 더 넓다.(소수점 = 실수)

---

자동 타입 변환이 발생되면 변환 이전의 값과 변환 이후의 값은 동일하다.
정수 타입이 실수 타입으로 변환하는 것은 무조건 자동 타입 변환이 된다.

int intValue = 200;
double doubleValue = intValue;    //200.0으로 변환

//char 타입의 경우 int 타입으로 자동 변환되며 유니코드 같이 int 타입에 저장된다.

char charValue = 'A';
int intValue = charvalue;                //65가 저장

//char타입은 2byte의 크기를 가지고 0~65535이므로 음수가 저장될 수 없다.

---

 public class PromotionExampleple{
   public static void main(String[] args){
     byte byteValue = 10;
     int intValue = byteValue;                      //int가 더 크므로 자동변환하여
     System.out.println(intValue);               //10이 출력된다. 

     char charValue = '가';
     intValue = charValue;
     System.out.println("가의 유니코드=" + intValue);      // int로 자동 변환하여 16진수 44032가 나온다

    intValue = 500;
    long longValue = intValue;
    System.out.println(longValue);     //long으로 자동변환 하여 500이 나온다

    intValue = 200;
    double doubleValue = intValue;    //double로 자동변환하여 실수로 변경,200.0이 나온다.
    System.out.println(doubleValue);
       }
}

---

강제 타입 변환 (캐스팅: Casting)

큰 크기의 타입에서 작은 타입으로 자동 타입 변환이 될 수 없다.
 int타입을 4개의 byte로 나누어 1byte만 저장할 수 있게할 수 있는 것을 의미한다.

int intValue = 103029770;
byte byteValue = (byte) intValue;      //강제 타입 변환 예시

//int 103029770를 byte로 나누어 표현 00000110(1byte) 00100100(1byte) 00011100(1byte) 00001010(1byte)
 앞의 3byte를 지워 나머지 00001010만 남으며 원래값은 보존되지 않는다.
//즉 결과는 10이 출력된다.

//변환 이후 다시 int로 변환 할 경우 00000000 00000000 00000000 00001010로 변환되어 똑같이 10이 나온다.

long long Value = 300;
int intValue =(int) longValue;         //intValue는 그대로 저장된다. 충분히 표현할 수 있으므로 300이 출력된다.


int intValue = 'A';
char charValue = (char) intValue;
System.out.println(charValue);       //강제 형변환을 사용하여 출력시 유니코드에 해당하는 문자가 출력된다.


double doubleValude = 3.14;
int intValue = (int)doubleValue;      //intValue는 정수이므로 3만 출력된다.

---

public class CastingExample{
   public static void main(String[] args){
     int intValue = 44032;
     char charValue = (char) intValue;
     System.out.println(charValue);        //결과는 '가' 출력된다. 

     long longValue = 500;
     intValue = (int) longValue;
     System.out.println(intValue);            //500이 출력된다.

     double doubleValue = 3.14;
     intValue = (int) doubleValue;
     System.out.println(intValue);           //3이 출력된다.
    }
}

---

강제 타입 변환에서 주의할 점

사용자로부터 입력받은 값을 변환할 때 값의 손실이 발생하면 안된다.
정수 타입을 실수 타입으로 변환할 때 정밀도 손실을 피해야한다.

public class ChackValueBeforCasting{
   public static void main(String[] args){
      int i = 128;

    if((i<Byte.MIN_VALUE)||(i>Byte.MAX_VALUE)) {                    //byte = -128~127 
      System.out.println("byte값으로 변환할 수 없습니다.");          // i 는 최소값과 최대값에 적용될 수 없어서
      System.out.println("값을 다시 확인해 주세요");                      // 결과는 true값으로 출력된다.
}   else {
     byte b= (byte) i;
     System.out.println(b)
      }
   }
}

기본 타입	최대값 상수	최소값 상수
byte	Byte.MAX_VALUE	Byte.MIN_VALUE
short	Short.MAX_VALUE	Short.MIN_VALUE
int	Integer.MAX_VALUE	Integer.MIN_VALUE
long	Long.MAX_VALUE	Long.MIN_VALUE
float	Float.MAX_VALUE	Float.MIN_VALUE
double	Double.MAX_VALUE	Double.MIN_VALUE

---

public class FromIntToFloat{
   public static void main(String[] args) {
    int num1 = 123456780;
    int num2 = 123456780;

    float num3 = num2;
    num 2 = (int) num3;

    int result = num1 -num2;
    System.out.println(result);   //결과는 0이 나오지 않았다.
        }
}                                               //int num2를 float으로 형변환 하면서 문제가 발생했기 때문이다
                                                //float : 부호(1비트) + 지수(8비트) + 가수(23비트)

 

1. 위 결과에서 123456780은 float의 가수 23비트로 표현할 수 없는 값으로 근사치로 변환되었다.(정밀도 손상)
2. float이 아닌 double로 변환하게 되면 결과 값은 0으로 출력이 된다.

---

public class FromIntTodouble{
   public static void main(String[] args){
     int num1 = 123456780;
     int num2 = 123456780;

    double num3 = num2;
    num2 = (int) num3;

    int result = num1 - num2;
    System.out.println(result);  //결과 값은 0으로 출력이된다.
    } 
}

---

연산식에서 자동 타입 변환

서로 다른 타입의 피연산자가 있을 경우 두연산자 중 크기가 큰 타입으로 자동 변환 되어 연산을 수행한다.

 

int intValue = 10;
double doubleValue = 5.5
double result = intValue + doubleValue;        // double로 자동 변환되어 15.5가 출력이된다.

int intValue = 10
double doubleValue = 5.5;
int result = intValue + (int)doubleValue;        //double이 int보다 크므로 강제 변환시켜 5로 변환, 15가 출력된다.

---

char 타입의 경우
char ai = 'A';
int result = ai + 1;             //A의 값을 int값으로 자동 변환되어 유니코드가 저장되고 +1을 하면 
char na = (char) result;    // B가 출력이 된다.

// 자바는 피연산자를 4byte단위로 저장하기 때문이다. 그래서 int보다 작은 단위도 int로 자동 변환되어 수행된다.

 

• 피연산자가 long일 경우 다른 피연산자도 long으로 자동 타입 변환 되어 long타입이 된다.
• 피연산자가 float일 경우 float타입으로 연산하면 float타입으로 나오지만 실수리터럴, double 타입이 있다면 double타입으로 자동 타입 변환 된다,

---

public class OperationsPromotionExample{
   public static void main(String[] args) {
     byte byteValue1 = 10;
     byte byteValue2 = 20;
     //byte byteValue3 = byteValue1 + byteValue2;            //컴파일에러가 나온다. 
     int intValue1 = byteValue1 + byteValue2;                    // int로 타입변환 
     System.out.println(intValue1);                                      //30으로 정상 출력된다

    char charValue1 = 'A';
    char charValue2 = 1;
    //char charValue3 = charValue1+charValue2;     
    //컴파일에러가 나온다.int로 변환시켜 유니코드로 출력시켜야한다.
    int intValue2 = charValue1+ charValue2;
    System.out.println("유니코드 = " + intValue2);           //유니코드 = 66
    System.out.println("출력문자 = " (char)intValue2);     //출력문자 = B

    int intValue3 = 10;
    int intValue4 = intValue3/4;                          //intValue3을 4로 나눈다.
    System.out.println(intValue4);                     //int는 정수값만 출력이 되므로 2.5가아닌 2가 나온다.

    int intValue5 = 10;
    //int intValue6 = 10 / 4.0;                              //컴파일 에러, 실수이므로
    double doubleValue = intValue5 /4.0;          //int를 double로 자동 타입 변환이 된다.
    System.out.println(doubleValue);                // 실수값이 출력되어 2.5가 나온다.
     }
}