[java] 4. 변수(Variable)와 연산자(Operator)

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

1. 리터럴(Literal)의 개념

basic > VariableApp.java

• 리터럴이란 프로그램에서 사용하기 위해 표현하는 값(Value)
• 소스코드에서 프로그래머에 의해 직접 입력된 값
• 값이므로 절대 변하지 않음!!!
• 리터럴 중 자바가 정수로 인식하는 정수형리터럴은 2진수 8진수 10진수 16진수 (혼공자바 p60 참고)
• ex. 문자값 = 문자리터럴 |  정수값 = 정수리터럴

 

 

 

2. 변수(Variable)의 개념 및 선언 형식

1) 변수의 개념

• 값(=리터럴(Literal)) 을 저장하기 위해 메모리(Memory , 주기억장치 , RAM)에 부여된 이름
  VS 보조기억장치 (하드디스크: HDD, SDD)
• 변수에 값을 저장하면 처리, 출력이 가능해짐!! 그러려면 먼저 변수 선언이 필요!!!!!!!
• 변수(메모리에 부여된 이름) = 그릇 → 불변
• 값(리터럴) = 음식 → 변함
• 변수 선언없이 사용 가능한 언어있음ex.자바스크립트
• 그렇지만 변수 안에 값이 저장되어 있어야 변수의 가치를 가짐

 

2) 변수 선언의 형식

자료형 변수명;

2-1. 자료형(DataType) : 변수에 저장될 값에 대한 형태

• 자료형은 값의 형태를 표현하기 위한 키워드나 식별자임
• 즉 약속된 단어, 만들어진 단어 둘 다 가능함
• 자료형의 종류 : 
  • 원시형/기본형(PrimitiveType) : 키워드로 구성됨
  • 참조형(ReferenceType) : 식별자로 구성됨

2-2. 변수명 : 값을 저장하기 위해 메모리를 구분하기 위해 사용되는 식별자

• 변수명은 우리가 만들어서 사용함
• 식별자는 중복 불가능(식별!!! - 구분가능하다!!!)

 

 

 

 

 

3. 식별자 작성 규칙 및 표기법

1) Java의 식별자 작성 규칙

• 영문자, 숫자, 특수문자(_ 또는 $만 가능)를 조합하여 작성하기
  자바에서는 한글을 식별자로 사용도 가능 , but 한글은 권장하지 않음
• 숫자로 시작되도록 작성 불가능
• 영문자는 대소문자를 구분하여 작성
• 기존에 사용된 단어(키워드 도는 식별자)를 식별자로 사용 불가능
  회사마다 식별자 작성 규칙이 있음 ex. ~~~App : 프로그램을 동작하게 하는 클래스

 

2) Java의 식별자 작성 표기법

• 영문자의 소문자를 기본으로 식별자 작성,  but 때에 따라 대문자 표기하는 경우도 있음

파스칼 표기법(PascalCase)

• 조합된 단어의 첫문자를 대문자로 표현하여 식별자 작성
• 클래스명, 인터페이스명 작성할 때 사용

ex. VariableApp.java

 

카멜 표기법(CamelCase)

• 첫번째 단어를 제외한 조합된 단어의 첫문자를 대문자로 표현하여 식별자 작성
• 자바에서 기본적으로 가장 많이 작성함!!
• 변수명, 메소드명 작성할 때 사용

ex.
메소드명 : main(String[] args){}에서 main
메소드명 : getSum(){}
변수명 : int su;

 

 

스네이크 표기법(SnakeCase)

• 단어와 단어를 _로 구분하여 식별자 작성
• 상수 작성할 때 사용
• 자바에서는 상수를 소문자로 절대 사용 안하기 때문에
  대문자로만 쓰면 단어와 단어를 구분하지 못하므로 스네이크 표기법 사용
• 참고) 기본적으로 sql은 스네이크 표기법, 자바는 카멜표기법

ex.
FLAG_BRIDGES

 

 

 

 

4. 값 출력법

1) 변수에 담긴 값만 출력

System.out.println(su); //변수에 저장된 값을 화면에 출력해줌
                        //결과값: su변수의 데이터타입(int)

// 20

2) 변수값 + "문자열" 결합해 출력

• + 연산자이용 (문자열결합연산자)
• 하위는 모두 문자열과 값(혹은 변수에 담아서)의 결합을 의미
  • 변수 + "문자열"
  • "문자열" + 변수
  • 값 + "문자열"
  • "문자열" + 값

System.out.println("num = " + num); //결과값: String
// num = 10

System.out.println("올해는 " + 2 + 0 + 2 + 2 + "년 입니다."); //결과값: String
//올해는 2022년 입니다.

3) 숫자형 + “문자열” 결합해 출력

• 결과값은 String

System.out.println("올해는 " + 2 + 0 + 2 + 2 + "년 입니다.");
//올해는 2022년 입니다.

System.out.println(2+0+2+2+"년은 호랑이띠 해입니다."); //잘못된 결과 발생 - 실행오류
//6년은 호랑이띠 해입니다.

//"" : 문자가 하나도 없는 문자열 - NullString
System.out.println(""+2+0+2+2+"년은 호랑이띠 해입니다.");
//2022년은 호랑이띠 해입니다.

4) ( ) 연산자 이용해 출력

int num1 = 100 , num2 = 200;

System.out.println("연산결과= " + num1 + num2); //잘못된 결과 발생 - 실행오류
//연산결과= 100200

//()연산자를 사용하여 무조건 먼저 실행되도록 설정 가능
System.out.println("연산결과= " + (num1 + num2));
//연산결과= 300
System.out.println("연산결과= " + num1 * num2);
//연산결과= 20000
System.out.println("연산결과= " + (num1 * num2));
//연산결과= 20000

 

 

5. 값 출력 시 주의사항

1)연산결과는 변수에 저장해서 변수로 출력하기!

• 값을 직접적으로 사용하는 경우는 없음!
• 변수에 저장하고 사용하기 권장
• 변경하지 않을 변수는 상수로 저장하기!!

int kor = 88, eng = 90;
int tot = kor + eng; //연산 결과를 변수에 저장
System.out.println("점수합계= " + tot);
//점수합계= 178

int tot = 88 + 99; //권장하지 않음

 

2) 변수에 값을 저장 안하고 출력하면 error

int count;
System.out.println("count =" + count); //error

• 변수 초기화지 않았어!

Exception in thread "main" java.lang.Error: Unresolved compilation problem: The local variable count may not have been initialized at basic.VariableApp.main(VariableApp.java:76)

 

3) 변수에 저장 불가능한 값을 저장할 경우 error

• (c언어는 가능)
• 자바는 자료형에 예민!!!!안돼!!!

int count = 10.0; //error
System.out.println("count = " + count); //error

• 자료형이 안맞아!

Exception in thread "main" java.lang.Error: Unresolved compilation problem: Type mismatch: cannot convert from double to intat basic.VariableApp.main(VariableApp.java:80)

 

 

 

 

 

6. 변수를 이용한 예제

example > VariableExample.java

 

1) 가로의 길이가 7이고 세로의 길이가 10인 사각형의 넓이를 계산하여 출력하세요.

🚩my answer

int width1 = 7;
int height1 = 10;
int area1 = width1 * height1;

System.out.println("사각형의 넓이 = " + area1);
//사각형의 넓이 = 70

 

2) 높이가 9이고 밑변의 길이가 7인 삼각형의 넓이를 계산하여 출력하세요.

🚩my answer

int height2 = 9;
int width2 = 7;
double area2 = ((double)height2 * width2) / 2;

System.out.println("삼각형의 넓이 = " + area2);
//삼각형의 넓이 = 31.5

 

3) 10명의 전체 몸무게가 759Kg인 경우 평균 몸무게를 계산하여 출력하세요.

🚩my answer

int whloe = 759;
int peopleNum = 10;
double average = whloe / (double)peopleNum;

System.out.println("평균몸무게 = " + average);
//평균몸무게 = 75.9

4) 이름이 [홍길동]인 학생이 국어점수 89점, 영어점수 93점, 수학점수 95점을 받은 경우 총점과 평균을 계산하여 이름, 총점, 평균을 출력하세요.

(단, 평균은 소숫점 한자리까지만 출력하고 나머지는 절삭 처리 하세요.)

🚩my answer

String name = "홍길동";
int kor = 89, eng = 93, math = 95;
int tot = kor + eng + math;
double ave = tot / 3.;
double newAve = (int)(ave * 10) / 10.;

System.out.println("이름=" + name + " 총점="+ tot + " 평균="+ newAve );
//이름=홍길동 총점=277 평균=92.3

 

 

 

 

 

7. 자료형변환(TypeCast)

basic > TypeCastApp.java

 

1) 자료형변환(TypeCast)이란?

• 값의 자료형을 일시적으로 변환하여 사용하는 방법
• 영구적으로 바뀌는 것이 아님

 

2) 자동형변환 (JVM이 필요에 의해 자동으로 변환해줌)

• 나누기할 때만 신경쓰기!!
• 자료형이 다른 값을 연산하기 위해 JVM이 자료형을 일시적으로 변환
• 표현의 범위가 작은 자료형의 값이 커다란 자료형의 값으로 형변환되어 연산
• int 자료형보다 작은 자료형은 무조건 int 자료형으로 형변환되어 연산 처리 ex. byte, short, char
• 데이터 크기 순서 : byte < short < char < int < long < float < double
• char - 부호비트 없음, only 양수

🍈자동형변환 예시

//1.
//자료형이 다르지만 자동 형변환
System.out.println("결과 = "+ (3 + 1.5));//결과 = 4.5
//3(int) + 1.5(double) => 3.0(double) + 1.5(double) = 4.5(double)

//2.
double su = 10; //저장할 때 (double)10.0로 자동 형변환
System.out.println(su);//10.0

//3.
//byte + byte => int + int 로 자동형변환
//byte + short + char
//JVM이 바꿔줌
//int 변수에 저장하기
byte su1 = 10, su2 = 20;

//10(byte) + 20(byte) == 10(int) + 20(int) == 30(int) : byte 변수에 저장이 error
byte su3 = su1 + su2; //error
int su3 = su1 + su2; //ok
System.out.println("su3= " + su3); //su3= 30

//4.
//int & double의 사칙연산 시 자동형변환 발생 - 값손실주의!!
//JVM자동형변환에 의해 값손실 발생 가능하니 형변환 필요
//=> double/int >> double/double == double
System.out.println("결과 = " + (95/10)); //정수/정수 >> 정수
//결과 = 9
System.out.println("결과 = " + (95.0/10.0)); //실수/실수 >> 실수
//결과 = 9.5
System.out.println("결과 = " + (95.0/10)); //실수/정수 >> 실수(자동 형변환)
//결과 = 9.5
System.out.println("결과 = " + (95/10.0)); //정수/실수 >> 실수(자동 형변환)
System.out.println("결과 = " + (95/10.)); //정수/실수 >> 실수(자동 형변환)
//결과 = 9.5

//5.
//평균값 계산 예시 : 2개의 피연산 중 하나를 실수로 변경하기
int kor = 95, eng = 90; //점수 입력
int tot = kor + eng; //총점 계산
//double ave=tot/2;//평균 계산 - 연산 결과 : 정수값 >> 변수값 : 92.0
double ave=tot/2.;//평균 계산 - 연산 결과 : 실수값 >> 변수값 : 92.5
System.out.println("총점 = "+tot+", 평균 = "+ave);
//총점 = 185 , 평균 = 92.0 (정숫값이 double형으로 표현)
//총점 = 185 , 평균 = 92.5 (실숫값이 double형으로 표현)

 

3) 강제형변환 (프로그래머가 직접 변환해줌)

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

 

🍈강제형변환 예시

//1. (int)값
int num = (int)12.3; 
System.out.println(num); //12

//2. (double)값
int num1 = 95, num2 = 10;
double num3 = num1 / num2;
System.out.println(num3); //9.0
double num3 = num1 / (double)num2;
System.out.println(num3); //9.5

 

 

😱 error 없이 쓰레기값이 출력되는 유일한 경우 😱

//문제점)
//=> 4Byte 정수값들을 연산한 결과가 4Byte 범위의 정수값 표현 범위를 벗어난 경우 쓰레기값이 발생되어 변수에 저장
//=> 4Byte 정수값들을 연산한 결과는 4Byte 범위의 정수값(-2147483648 ~ 2147483647)만 표현 가능

int num4 = 100_000_000, num5 = 30; //커다란 정수값은 _기호를 사용하여 표현가능

//1. int 자료형변수 이용해도 실행오류
int num6 = num4 * num5;
System.out.println("num6=" + num6); //num6=-1294967296 , 실행오류

//2. long 자료형변수 이용해도 실행오류
long num6 = num4 * num5;
System.out.println("num6=" + num6); // num6=-1294967296 , 실행오류

//해결법) 정수값에 대한 연산결과가 4Byte 범위의 정수값 표현 범위를 벗어난 경우 (long)으로 강제 형변환하여 연산 처리
long num6 = (long)num4 * num5;
System.out.println("num6=" + num6); //num6=3000000000 , 해결완료

 

4) 강제형변환 + 자동형변환

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

//강제형변환 + 자동형변환을 이용한 간단한 알고리즘 - 소숫점 2자리 위치까지만 출력되도록 명령 작성
//=> 사실 Math클래스 이용하면 간단히 구현 가능! ex. Math.floor()
System.out.println("number(내림) ="+ (int)(number * 100)/100.); //number(내림) =1.23
System.out.println("number(반올림)=" + (int)(number * 100 + 0.5)/100.); //number(반올림)=1.23
System.out.println("number(올림)=" + (int)(number * 100 + 0.9)/100.); //number(올림)=1.24

 

5) char자료형은 연산 시 int로 변경되는 것 주의

char a = 'A';
char b = 'A' + 1;
System.out.println(b);//B

//char + char => int + int = int
char a = 'A';
char b = 1;
char c = a + b; //error

//해결책) 연산 값을 char로 강제형변환해주기
char a = 'A';
char b = 1;
char c = (char)(a + b);
System.out.println(c);//B

//만약 int변수에 담으면?
char a = 'A';
char b = 1;
int c = a + b;
System.out.println(c); //66

 

6) example > VariableExample.java

• 이름이 [홍길동]인 학생이 국어점수 89점, 영어점수 93점, 수학점수 95점을 받은 경우 총점과 평균을 계산하여 이름, 총점, 평균을 출력하세요. (단, 평균은 소숫점 한자리까지만 출력하고 나머지는 절삭 처리 하세요.)

String name = "홍길동";
int kor = 89, eng = 93, math = 95;
int tot = kor + eng + math;

double ave = tot / 3.;
//조건에 맞는 평균을 구하기 위해 새 변수 생성했음!
double newAve = (int)(ave * 10) / 10.;
// 다시 10으로 나눌때 double로 바꿔주는거 잊지말자!!!

System.out.println("이름=" + name + " 총점="+ tot + " 평균="+ newAve );

 

 

 

 

 

 

 

8. 연산자(Operator)

basic > OperatorApp.java

 

1) 연산자(Operator)의 개념

• 계산을 목적으로 제공되는 기호 또는 키워드
• 피연산자 : 연산자에 의해 계산될 값을 의미
  • 단항연산자(피연산자:1개) lst
  • 이항연산자(피연산자:2개) 2nd
  • 삼항연산자(피연산자:3개) 3rd 의 우선순위로 계산처리
• 일반적으로 연산자는 (왼쪽에서 오른쪽으로) 처리되지만,
• 단항연산자와 대입연산자는 (오른쪽에서 왼쪽으로) 처리

ex) 10 + 20 + 30
------------> 방향
ex) a = b = c
<-------------- 방향

 

---

2) 최우선 연산자

() : 우선 처리 연산자

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

 

[] : 배열연산자

• 배열선언할 때, 배열요소표현할 때 사용

 

. : 객체연산자

• 객체 혹은 클래스가 가진 요소에 접근할 때 사용
• 객체요소접근할 때 사용

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

 

 

---

3) 단항연산자

• 피연산자의 갯수가 1개인 연산자

+ : 양수화 연산자

• 피연산자에 +1을 곱하는 연산자 (양수값을 표현하는 기호라고 생각하기)

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

 

 

 

- : 음수화 연산자

• 2의 보수 연산자
• 2의 보수 연산자란? 양수를 음수화처리하는 것, 피연산자에 -1을 곱하는 연산자

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

 

 

 

~ : Bit Not 연산자

• 1의 보수 연산자, 틸트연산자
• 정수값으로 표현된 Bit 값을 반대로 반환하는 연산자
• 비트단위로 연산할 때 사용, 자바에서는 안씀(기본단위Byte)

//		~X (1의 보수) + 1 =2의 보수 =
//
//				~50 = -(50+1)
//		~00110010 >> 11001101(-값) 값을 알려면 2의보수화처리해야함

 

 

! : Not 연산자(논리부정연산자)

• false(거짓) 또는 true(참)을 반대로 변환하는 연산자
• 즉, boolean 타입에만 사용 가능 , 논리값을 반대로 바꿔줄 때만 사용가능

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

!20 //error
//다른 언어에서는 0을 제외한 나머지 값들은 참이라고 봄.. 자바는 아님.. error
// 다른 언어에서는 true or false = 0 or 1로 표현하지만, 자바는 안돼!!

 

 

 

 

++ (1증가 연산자) / -- (1감소 연산자)

• ++ : 피연산자가 반드시 변수로 변수값을 1증가 시키는 연산자
• - : 피연산자가 반드시 변수로 변수값을 1감소 시키는 연산자
• 주의 ++값 으로 못씀 ex. ++10 x

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

• ++a는 [a = a+1]와 같다 & --a는 [a = a-1]와 같다
  • ++a는 자동형변환이 일어나지 않음
  • byte, short, char 연산할 때도 int로 자동형변환 되지 않음
  • a = a+1은 연산식으로서 자동형변환이 되어 error나오거나 잘못된 결과를 가져올 수 있음
  • 따라서 상황에 따라++a를 사용해야 하는 경우가 있음

int a2 = 10, a3 = 10;
++a2; //a2 = a2+1과 같은 뜻이지만, 권장하지 않음
--a3; //a3 = a3-1과 같은 뜻이지만, 권장하지 않음
System.out.println("a2=" + a2 + " a3=" + a3); //a2=11 a3=9

• a++와 a--도 존재 : 연산식으로만 구현된 단일 명령일 경우 연산자의 위치는 연산결과에 영향x

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

• 연산결과에 영향을 미치는 [a++] vs [++a] , [a--] vs [--a]
  • +연산자와 -연산자로만 구성된 단일 명령이 아닌 경우 연산자의 위치는 연산결과에 영향미침
  • 전처리 : [++a] , [--a]
  • 후처리 : [a++] , [a--]
• 자바에서는 알고리즘하지 않는 이상 전처리, 후처리 사용할 일이 거의 없음

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

//전처리 : 이기적, 내가 먼저야!!!!!!!! 다른 명령은 나중에~
// ++a4 연산식 실행 후 result1=a4 연산식 실행
int result1 = ++a4;

//후처리: 이타적, 다른 명령들 먼저해~~~
//result2 =a5 연산식 실행 후 a5++ 연산식 실행
int result2 = a5++;

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

 

 

 

(자료형) : 강제 형변환 연산자 (cast연산자)

• 값의 자료형을 일시적으로 변환하는 연산자
• (byte) (short) (char) (int) (long) (float) (double)

 

 

new : 객체생성연산자

• 클래스의 생성자를 호출하여 객체를 생성하기 위한 연산자

 

---

4) 이항연산자

• 피연산자의 갯수가 2개인 연산자

 

산술연산자

• (곱)
• /(나눔)
• %(나머지)
  • 배수처리할 때 많이 사용, 범위처리할 때 사용
  • 다양한 형태의 값을 만들 때 사용 , 나머지는 항상 0 ~9 중 하나로 나오니 이를 잘 활용하자!!
• +(합 or 문자열결합)
• (차)

int b1=20, b2=10;
System.out.println("b1 * b2 = " + (b1*b2)); //b1 * b2 = 200
System.out.println("b1 / b2 = " + (b1/b2)); //b1 / b2 = 2
System.out.println("b1 % b2 = " + (b1%b2)); //b1 % b2 = 0
System.out.println("b1 + b2 = " + (b1+b2)); //b1 + b2 = 30
System.out.println("b1 - b2 = " + (b1-b2)); //b1 - b2 = 10

 

 

 

이동연산자(쉬프트연산자)

• 정수값을 원하는 방향으로 Bit수만큼 이동하는 연산자
• 자바에서는 BIT단위를 쓸 일이 거의 없음
• <<(왼쪽 이동 연산자)
• >>(오른쪽 이동 연산자)
• >>>(오른쪽 이동 연산자)

  //50(10진수) = 110010 (2진수) = (4Byte)로 표현하면? 00000000 00000000 00000000 00110010 (4Byte)
  //50 << 3 - 00000 00000000 00000000 00110010 (앞에 3개 오버플로우 발생해 없어짐)
  //50 << 3 - 00000000 00000000 00000001 10010000 : 400 (400=256 + 128 + 16)
  // 50 곱하기 2의 3승과 결과가 똑같음 즉, 크기가 2의 n승 만큼 커짐 (50 * 2의3승)

  //50 >> 3 -    00000000 00000000 00000000 00110 010(뒤의 3개 언더플로우 되어서 버리고 부호비트와 같은 값을 채움)
  //50 >> 3 -    00000000 00000000 00000000 00000110 (50 나누기 2의 3승 = 6.xx지만 그냥 6)

  //-50(10) -4Byte : 11111111 11111111 11111111 11001110
  //-50 >> 3 - 11111111 11111111 11111111 11111001:-7(10진수) (부호비트와 같은 값으로 채움)
  //-50 >>> 3 - 00011111 11111111 11111111 11111001 (무조건 0으로 채움)

  // 단순한 계산식에서 쓸 일은 없음
  //원하는 비트 값만 필터링할 수 있음 (c언어에서 비트값을 필터링할 때 씀)
  //자바에서는 메서드가지고 사용
  System.out.println(-50>>3); //-7

 

 

 

 

비교(관계)연산자

• 값(객체)를 비교하여 false(거짓) 혹은 true(참) 중 하난의 결과를 제공
• > , < 1st
• >= , <= 1st
• ==(같다) , !=(같지않다) 2nd
• instanceof(객체비교연산자) - 객체공부, 상속공부 후 다룰예정.. 1st

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

 

 

논리연산자

• Bit논리 연산자
  • 정수값을 Bit 단위로 계산하기 위한 연산자
  • 같은 위치에 있는 비트끼리 연산
  • &(논리곱) :
  • ^(배타적 논리합) : 다르면 좋아해서 1 반환, 같으면 싫어해서 0 반환
  • |(논리합) : 1개라도 1이 있으면 1 반환

  //		  00111110			00111110			00111110
  //		& 11110000		  ^ 11110000		  | 11110000
  //		----------	      ----------          ----------
  //		  00110000          11001110            11111110
  

• 일반논리 연산자
  • 비교 연산식을 연결하기 위한 연산자
  • &&(And)
  • ||(Or)

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

int c = -20;
System.out.println("c = "+c); //c = -20
System.out.println("c >= 10 && c <= 30 = "+(c >= 10 && c <= 30)); //c >= 10 && c <= 30 = false
System.out.println("c < 10 || c > 30 = "+(c < 10 || c > 30)); //c < 10 || c > 30 = true

            		//앞이 false여도 굳이 뒤에까지 연산함(효율적이지 않음)
System.out.println("c >= 10 && c <= 30 = "+(c >= 10 & c <= 30));
            		//앞이 true여도 굳이 뒤에까지 연산함
System.out.println("c < 10 || c > 30 = "+(c < 10 | c > 30));

 

 

 

대입연산자

• 왼쪽 피연산자(= 변수) 에 값을 저장하기 위한 연산자
• 무조건 맨마지막에 실행
• why? 그래야 마지막에 저장할 수 있으니까!!!
• 순수대입 연산자 : 값을 변수에 저장함
  • =
• 복합대입 연산자 : 변수값을 계산하여 변수에 저장함
  • = /= %= += = <<= >>= >>>= &= ^= |=

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

//가독성을 위해 사용, 그리고 형변환이 일어나지않음, byte끼리 연산해도 byte!
d += 20; //d=d+20;
System.out.println("d = " + d); //d = 30

 

---

 

5) 삼항연산자

• 피연산자의 갯수가 3개인 연산자
• 형태 : 조건식 ? 참값 : 거짓값
• 조건식의 결과가 true인 경우 참값을 사용, false인 경우 거짓값을 사용
  • 조건식 : false 또는 true 중 하나의 결과값을 제공하는 연산식 (즉, 관계연산자나 논리연산자 이용)

삼항연산자는 언제 이용?

//1.
//변수값이 바껴도 결과값은 바뀌고 싶지 않을때 조건을 걸자!
int e1 = 10,  e2 = 20;
System.out.println("큰 값 = "+ (e1 > e2 ? e1 : e2)); //큰 값 = 20 (변하지 않음)
int e1 = 20, e2 = 10;
System.out.println("큰 값 = "+ (e1 > e2 ? e1 : e2)); //큰 값 = 20


//2.
//결과값이 조건에 따라 바꾸면 좋을 것 같을 때 사용하자!
int e3 = 10;
System.out.println(e3 + " >> " + (e3 % 2 == 0 ? "짝수":"홀수")); //10 >> 짝수
int e3 = 11;
System.out.println(e3 + " >> " + (e3 % 2 == 0 ? "짝수":"홀수")); //11 >> 홀수

 

 

 

 

9.연산자를 이용한 예제

example > OperatorExample.java

1) 한대의 가격이 1억 5천원만인 비행기를 20대 구매할 경우 지불해야될 금액을 계산하여 출력하세요. (단, 15대 이상 구매할 경우 1대당 25%의 할인율을 적용하여 계산하세요. )

//방법1.
int aCar = 150_000_000;
int num = 20;
long tot = aCar * (long)num;
System.out.println("총 합계= "+ tot); //총 합계= 3000000000
System.out.println("총 합계= " + ( num >= 15 ? tot * 0.75 : tot)); //총 합계= 2.25E9
System.out.println("총 합계= " + (long)( num >= 15 ? tot * 0.75 : tot)); //총 합계= 2250000000

//방법2.
//변수 하나에 삼항연산자로 두가지 조건을 걸어서 사용해보자!
int aCar = 150_000_000;
int num = 20;
long tot = (long)(num >= 15 ? aCar * 0.75 : aCar) * num; //tot변수 자체에 조건 걸기!
System.out.println("총 합계= "+ tot); //총 합계= 2250000000

 

 

2) 245678초를 일시분초 형식으로 변환하여 출력하세요.

//네모 그림을 그린 뒤 몫과 나머지를 나눠서 가져가는 그림을 그려보자!
//몫을 새 변수에 할당하지 않고, 기존 변수의 값을 사용하지 않는다면 재할당하여 사용해보기!

int cho = 245678;
System.out.println(cho + "초 = ");
int day = cho / 86400; //24*60*60 = 86400초 (하루는 800초)
cho %= 86400; //cho 이제 쓸 필요 없으니 새로운 변수 생성하지 말고 재할당하기!

int hour = cho / (60*60);   //몫 가져가기
cho%=3600;                  //나머지 재할당하기

int min = cho /60;         //몫 가져가기
int sec = cho % 60;        //나머지 변수에 담기

System.out.println( day+"일 "+hour+"시 " + min+"분 " + sec+"초");