0330 - 문자형 리터럴, 논리형 리터럴, 자료형 변환, 연산자

문자형(CharacterType) 리터럴 

: 문자 하나를 ' ' 안에 표현 

 

=> Java에서 문자형 리터럴은 기본적으로 2Byte(Character)로 표현
=> 문자형 리터럴은 일반문자 외에 회피문자(제어문자)가 존재 
 

-회피문자(Escape Character) : 프로그램에서 표현 불가능한 문자를 표현하기 위한 문자 ( \ 기호 사용 )
• '\n' : Enter

• '\t' : tab

• '\'' : '문자('을 문자로 표현하고 싶을 때)

• '\"' : " 문자

• '\\' : \문자

• '\0' : Null 문자

 

※ 문자형 리터럴은 내부적으로 약속된 정수값(0~65535)으로 표현 - 약속된 정수값 : 유니코드(Unicode) (전세계언어쓰기위해)
 => 'A' : 65, 'a' : 97 '0' : 48, '' : 32, '\n' : 13, '가' : 44032 - 완성형(이미 자음과 모음이 결합된 한글) 

 

System.out.println("문자값(2Byte) = " + 'A'); // A

System.out.println("문자값(2Byte) = " + '가'); //가

System.out.println("문자값(2Byte) = " + '\''); // '

System.out.println("문자값(2Byte) = " + '\\'); // \

 

* 문자값을 표현하기 위한 자료형 - char(2Byte)

char c1 = 'A'; //문자형 변수에는 문자값에 대한 약속된 정수값이 저장

char c2 = 65; //문자형 변수에는 문자값 대신 약속된 정수값 저장 가능

char c3 = 'a' - 32;

 

System.out.println("c1 = " + c1); //A

System.out.println("c2 = " + c2); //A

System.out.println("c3 = " + c3); //A

 

char c4 = 45000;

System.out.println("c4 = " + c4); //꿈

 

논리형(BooleanType) 리터럴 

: false(거짓),true(참) -> 연산이 불가 
 => Java에서 논리형 리터럴은 기본적으로 1Byte(BooleanType)로 표현 
  

- 관계 연산자 (비교 연산자)를 이용한 연산식의 결과값으로 논리형 리터럴 제공

System.out.println("논리값(1Byte) = " + ( 20 < 10)); //false

System.out.println("논리값(1Byte) = " + ( 20 > 10)); //true

 

-논리값을 표현하기 위한 자료형 - boolean(1byte)

boolean d1 = false;

boolean d2 = 20 > 10;

 

System.out.println("d1 = " + d1); //false

System.out.println("d2 = " + d2); //true

 

문자열(StringType) 리터럴 

: 문자들을 " " 안에 0개 이상의 문자들로 표현 - String 객체
 => 문자열은 원시형(기본형)이 아닌 참조형으로 String 클래스로 표현 

 

System.out.println("문자열 = " + "홍길동"); // 홍길동

System.out.println("문자열 = " + "유관순 열사가 \"대한독립 만세\"를 외쳤습니다."); // 유관순 열사가 "대한독립 만세"를 외쳤습니다.

 

 - 문자열을 표현하기 위한 자료형 : String 클래스

String name = "임꺽정";

System.out.println("이름 = " + name); //이름 = 임꺽정

 

 

자료형 변환(TypeCast) 

: 값의 자료형을 일시적으로 변환하여 사용하는 방법 
  => 자동 형변환(JVM실행할 때 해줌), 강제 형변환(프로그래머가 해줌)

-자동 형변환 : 자료형이 다른 값을 연산하기 위한 JVM(Java Virtual Machine : Java 프로그램을 실행하기 위한 가상의 플랫폼)이 
                      자료형을 일시적으로 변환
                      자동 형변환 통해 자료형이 서로 다른 값들이 연산 가능해짐 

  => 표현의 범위가 작은 자료형의 값이 큰 자료형의 값으로 형변환되어 연산 처리
     ( byte >> short >> char >> int >> long >> float >> double )

System.out.println("결과 = " + (3 + 1.5)); //3(int) + 1.5(double) >> 3.0(double) + 1.5(double) >> 4.5(double)

 

double su = 10; //10 >> 10.0

System.out.println("su = " + su); //10.0

 

System.out.println("결과 = " + (35 / 10)); //3 ( int/int = int이기 때문 )

System.out.println("결과 = " + (35.0 / 10.0)); //3.5 ( double/double >> double )

System.out.println("결과 = " + (35.0 / 10)); //3.5 ( double/int >> double/double(자동 형변환) >> double )

System.out.println("결과 = " + (35 / 10.)); //3.5 ( int/double >> double/double(자동 형변환) >> double )

-> 하나만 실수여도 자동 형변환 된다!

 

int kor = 95, eng = 90; //점수 입력

int tot = kor + eng; //총점

 

// double ave = tot / 2; //평균 - 연산 결과 값: 정수값(92) >> 실수값 (92.0)으로 변환되어 저장 (실행오류)

double ave = tot / 2.; //평균 - 연산 결과 값: 실수값 (92.5) (올바른 연산)

 

System.out.println("총점 = " + tot + " , 평균 = " + ave); //총점 = 185 , 평균 = 92.5

 

- int 자료형보다 작은 자료형의 값은 무조건 int 자료형으로 형변환되어 연산 처리

byte su1 = 10, su2 = 20;

// byte su3 = su1 + su2; //byte + byte >> int + int >> int (따라서, byte 변수에 저장 불가능)

 

int su3 = su1 + su2;

 

System.out.println("su3 = " + su3); //30

 

* 강제 형변환 

: 프로그래머가 Cast 연산자를 사용하여 원하는 자료형의 값으로 일시적으로 변환하여 명령을 작성하는 방법 - Cast 연산자 : 자료형(값)

 

int num = (int)12.3; // (int)12.3 >> 12

System.out.println("num = " + num); //num = 12

 

int num1 = 95, num2 = 10;

 

//double num3 = num1 / num2; //연산결과 : 9.0

double num3 = (double)num1 / num2; //연산결과 : 9.5

 

System.out.println("num3 = " + num3);

 

-정수값에 대한 연산 결과값 표현 범위 4Byte -> 8Byte

//큰 정수값은 _ 기호를 사용하여 표현 가능

int num4 = 100_000_000, num5 = 30;

//정수값에 대한 연산결과값은 4Byte(-2147483648~2147483647)로만 표현 가능

//문제점) 정수값에 대한 연산 결과값이 4Byte로 표현 가능한 범위를 벗어난 경우 쓰레기값 발생

// => 변수에 쓰레기값이 저장되어 잘못된 결과값 출력 - 실행 오류

//int num6 = num4 * num5;

//해결법) 정수값에 대한 연산 결과값이 8Byte로 표현될 수 있도록 강제 형변환

long num6 = (long)num4* num5;

System.out.println("num6 = " + num6); //num6 = 3000000000

 

 

 

-소숫점 2자리 위치까지만 출력되도록 명령 작성

 

double number = 1.23456789;

System.out.println("number = " + number); //number = 1.23456789

 

System.out.println("number(내림) = " + (int)(number * 100) / 100.0); //number(내림) = 1.23

System.out.println("number(반올림) = " + (int)(number * 100 + 0.5) / 100.0); //number(반올림) = 1.23

System.out.println("number(올림) = " + (int)(number * 100 + 0.9) / 100.0); //number(올림) = 1.24

 

 

 

연산자(Operator) 

: 계산을 목적으로 제공되는 기호 또는 키워드
 => 피연산자 : 연산자에 의해 계산되는 값을 의미 
 => 단항연산자(피연산자 : 1개), 이항연산자(피연산자 : 2개), 삼항연산자(피연산자 : 3개) 

 

*최우선연산자 

 : 무조건 가장 먼저 연산 처리되는 연산자  

      -> () : 우선 처리 연산자   /  [] : 배열 연산자   /   : 객체 연산자 

 

System.out.println("10 + 20 * 3 = " + (10 + 20 * 3)); //70

System.out.println("10 + 20 * 3 = " + ((10 + 20) * 3)); //90

 

*단항 연산자 

: 피연산자가 갯수가 1개인 연산자 

 

 + : 양수화 연산자 - 피연산자에 +1를 곱하는 연산자 

 - : 음수화 연산자(2의 보수 연산자) - 피연산자에 -1을 곱하는 연산자  

 

※ 음수화 연산자는  변수값이 바뀌는 것이 아니라, 변수값을 음수화

변수값을 바꾸지 않아도 유일하게 변수값을 바꿀 수 있는 연산자 -> ++ , --

 

int a1 = 10;

System.out.println("a1 = " + a1); //10

System.out.println("a1 = " + (-a1)); //-10

 ! : Not 연산자 : false(거짓)와 true(참)을 반대로 변환하는 연산자 

System.out.println("20 > 10 = " + (20 > 10)); //true

System.out.println("20 > 10 = " + !(20 > 10)); //false

 ++ : 1 증가 연산자 - 피연산자를 변수로 설정하고 변수값을 1 증가하여 저장하는 연산자
-- : 1 감소 연산자 - 피연산자를 변수로 설정하고 변수값을 1 감소하여 저장하는 연산자  

 

int a2 = 10, a3 = 10;

System.out.println("a2 = " + a2 + ", a3 =" + a3); //a2 = 10, a3 =10

 

//++a2; // a2 = a2 + 1; -> 결과는 같으나 과정은 다름

//--a3; // a3 = a3 -1; -> 결과는 같으나 과정은 다름

 

** ++ 연산자와 -- 연산자는 피연선자 뒤에 작성 가능

    하나의 연산식으로 구현된 단일 명령인 경우, 연산자의 위치는 연산 결과에 영향을 미치지 않는다

a2++;

a3--;

 

System.out.println("a2 = " + a2 + ", a3 =" + a3); //a2 = 11, a3 =9

 

** ++연산자와 --연산자로만 구성된 단일 명령이 아닌 경우, 연산자의 위치는 연산 결과에 영향을 미친다

 

int result1 = ++a4; //전처리 : ++a4 연산식이 실행된 후 result1 = a4 연산식 실행

int result2 = a5++; //후처리 : result2 = a5 연산식이 실행된 후 a5++ 연산식 실행

 

System.out.println("a4 = " + a4 + ", a5 =" + a5); //a4 = 11, a5 =11

System.out.println("result1 = " + result1 + ", result2 =" + result2); //result1 = 11, result2 =10

int a6, a7 = 10;
int a8 = (++a6) + a7++;
System.out.println(a8); //21

*이항 연산자 

: 피연산자의 갯수가 2개인 연산자 
 => 산술 연산자, 이동 연산자, 비교 연산자, 논리 연산자, 대입 연산자 

     

산술 연산자 

: *(곱), /(나눔), %(나머지), +(합 또는 문자열 결합), -(차)

int b1 = 20, b2 = 10;

System.out.println(b1 + " * " + b2 + " = " + (b1 * b2)); //20 * 10 = 200

System.out.println(b1 + " / " + b2 + " = " + (b1 / b2)); //20 / 10 = 2

System.out.println(b1 + " % " + b2 + " = " + (b1 % b2)); //20 % 10 = 0

System.out.println(b1 + " + " + b2 + " = " + (b1 + b2)); //20 + 10 = 30

System.out.println(b1 + " - " + b2 + " = " + (b1 - b2)); //20 - 10 = 10

 

이동 연산자 

:  << (왼쪽 이동 연산자),   >> (오른쪽 이동 연산자),   >>> (오른쪽 이동 연산자) 

50(10) - 4Byte >> 00000000 00000000 00000000 00110010 

 50 << 3 (50이라는 정수값을 왼쪽으로 3bit 이동 시키시오) 
         : 00000000 00000000 00000001 10010000 - 400(10)  

 50 >> 3 : 00000000 00000000 00000000 00000110 - 6(10)  

  
 -50(10) - 4Byte : 11111111 11111111 11111111 11001110 

 -50 >> 3 : 11111111 11111111 11111111 11111001 
 -50 >>> 3 : 00011111 11111111 11111111 11111001

 

비교(관계) 연산자 : 값을 비교하여 false 또는 true 중 하나의 결과를 제공하는 연산자 
:   > , < , >=, <=, ==, != , instanceof : 객체 비교 연산자

System.out.println("20 > 10 = " + (20 > 10)); //true

System.out.println("20 < 10 = " + (20 < 10)); //false

System.out.println("20 == 10 = " + (20 == 10)); //false

System.out.println("20 != 10 = " + (20 != 10)); //true

논리 연산자 : Bit 논리 연산자, 일반 논리 연산자 
 - Bit 논리 연산자 : 두 피연산자의 정수값을 Bit 단위로 계산하기 위한 연산자 
                      -> &(논리곱), ^(배타적 논리합), |(논리합)
 - 일반 논리 연산자 : 두 개의 비교 연산식을 연결하기 위한 연산자 
                      -> &&(And), ||(Or)

int c = -20;

 

System.out.println("c = " + c);

//첫번째 비교식이 거짓인 경우 두번째 조건식은 미실행

System.out.println("c >= 10 && c <= 30 = " + (c >= 10 && c <= 30)); //false

// || 연산자는 첫번째 비교식이 참인 경우 두번째 조건식 미실행

System.out.println("c < 10 || c > 30 = " + (c < 10 || c > 30)); //true

 

삼항 연산자 : 피연산자의 갯수가 3개인 연산자  
               
형식) 조건식 ? 참값 : 거짓값 

=> 조건식의 결과값이 true인 경우  참값을 제공하고 false인 경우 거짓값을 제공하는 연산자 
    (조건식 : false 또는 true 중 하나의 결과값을 제공하는 연산식)

 

int d1 = 20, d2 = 10;

System.out.println("큰 값 = " + (d1 > d2 ? d1 : d2)); //큰 값 = 20

 

응용) 홀수 짝수

 

int d3 = 11;

 

System.out.println(d3 + " = " + (d3 % 2 == 0 ? "짝수" : "홀수")); //홀수

 

대입 연산자 : 왼쪽 피연산자(변수)에 값을 저장하기 위한 연산자 
 - 무조건 마지막에 실행되는 연산자 
 - 순수 대입 연산자 : 변수에 값을 저장 ( = )
 - 계산 대입 연산자 : 변수에 저장된 값을 계산한 후에 변수에 다시 저장 ( *=, /= , %= , += , -=, <<= , >>=, >>>-, &=, ^=, |= )

 

int e = 10;

System.out.println("e = " + e); //10

 

e += 20; // e = e + 20

System.out.println("e = " + e); //30

 

 

 

※ 일반적으로 연산식은 왼쪽에서 오른쪽 방향으로 처리되지만

   단항 연산자와 대입 연산자를 사용한 연산식은 오른쪽에서 왼쪽 방향으로 처리된다 

ex) A + B + C           A = B = C
   ----------->          <-----------