## 연산자와 연산식
-연산 : 데이터를 처리하여 결과를 산출하는 것
-연산에 사용하는 기호를 연산자라고 한다.
-연산자 : 연산에 사용되는 표시나 기호(+ , - , * , / , =.....)
-피연산자 : 연산 대상이 되는 데이터(리터럴, 변수)
-연산식 : 연산자와 피연산자를 이용하여 연산의 과정을 기술하는것
-자바 언어에서는 다양한 연산자를 제공하고 있다.
이 연산자들은 피연산자를 연산해서 값을 산출하는데, 산출되는 값의 타입은 연산자별로 다르다.
예를 들어 산술 연산자일 경우는 숫자 타입(byte, short, int, long, float, double)으로 결과 값이 나오고，
비교 연산자와 논리 연산자는 논리(boolean) 타입으로 나온다.
-연산자는 필요로 하는 피연산자의 수에 따라 단항, 이항, 삼항 연산자로 구분된다.
-부호 연산자와 증가/감소 연산자논 피연신자 하나만을 요구하므로 단항 연산자이고,
조건 연산지는 조건식, A, B와같이 세 개의 피연산자가 필요하므로 삼항 연산자라고한다.
-그 이외의 연산자는 두 개의 피연산자를 요구하므로 모두 이항 연산자이다.
연산식은 반드시 하나의 값을 산출한다.
연산자 수가 아무리 많아도 두 개 이상의 값을 산출하는 연산식은 없다.
그렇기 때문에 하나의 값이 올 수 있는 곳이면 어디든지 값 대신에 연산식을 사용할 수있다.
보통 연산식의 값은 변수에 저장히는데, 다음과 같이 x와 y 변수의 값을 더하고 나서 result 변수에 저장한다.
# 연산의 방향과 우선순위
연산식에는 다양한 연산자가 복합적으로 구성된 경우가 많다.
프로그램에서는 연산자의 연산 방향과 연산자 간의 우선순위가 정해져 있다.
&& 보다는 > , < 가 우선순위가 높기 때문에 x > 0과 y < 0이 먼저 처리되고，
&&는 x > 0과 y < 0의 산출값을 가지고 연산하게된다.
그러면 우선순위가 같은 연산자들끼리는 어떤 순서로 처리가 될까?
이 경우에는 연산의 방향에 따라 달라진다 대부분의 연산지는 왼쪽에서부터 오른쪽으로(→) 연산을 시작한다.
예를 들어다음연산식을보자.
100 * 2 / 3 % 5
*, / , %는 같은 우선순위를 갖고 있다. 이 연산자들은 연산 방향이 왼쪽에서 오른쪽으로 수행된다.
100 * 2가 제일 먼저 연산되어 200이 산출되고, 그 디음 200 / 3이 연산되어 66이 산출된다.
그 다음으로 66 % 5가 연산되어 1이 나온다.
## 단항 연산자
-단항 연산자는 피연산자가 단 하나뿐인 연산자를 말하며, 여기에는 부호 연산자(+， -),
증감 연산자(++， --), 논리 부정 연산자(!), 비트 반전 연산자(~)가 있다.
# 부호 연산자(+， -)
-부호 연산지는 양수 및 음수를 표시하는 + , - 를 말한다.
-boolean타입과 char 타입을 제외한 나머지 기본 타입에 사용할 수 있다.
+ , - 는 산술 연산자이기도 하고, 부호 연산자이기도 하다. (부호 연산자로 쓰일 때에는 하나의 피연산자만 필요하다.)
일반적으로 부호 연산자를 다음과 같이 정수 및 실수 리터렬 앞에 붙여 양수 및 음수를 표현한다.
부호 연산자는 정수 또는 실수 타입 변수 앞에 붙일 수 있다.
이 경우는 변수를 양수 및 음수로 표현한 것이 아니고, 변수 값의 부호를 유지하거나 바꾸기 위해 사용된다.
+연산자는 변수 값의 부호를 유지한다. -연산자는 변수 값의 부호를 양수는 음수로 음수는 양수로 바꾼다.
// 값에 음수 또는 양수 (+.-)를 붙일 수 있다.
int a = +100;
int b = -100;
double c = 3.14;
double d = -10.5;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
# 증감 연산자
# 증감 연산자는 변수의 값을 1증가(++)시커거나 1감소(--)시키는 연산자를 말한다.
# -boolean 타입을 제외한 모든 기본타입의 피연산자에 사용할 수 있다.
=========================================================================
| 연산식 | 설명
=========================================================================
| ++ | 피연산자 | 다른 연산을 수행하기 전에 피연산자의 값을 1증가시킨다. |
---------------------------------------------------------------------------------------------------------------------------
| -- | 피연산자 | 다른 연산을 수행하기 전에 피연산자의 값을 1감소시킨다. |
---------------------------------------------------------------------------------------------------------------------------
| 피연산자 | ++ | 다른 연산을 수행한 후에 피연산자의 값을 1증가시킨다. |
---------------------------------------------------------------------------------------------------------------------------
| 피연산자 | -- | 다른 연산을 수행한 후에 피연산자의 값을 1감소시킨다. |
=========================================================================
# ++ 연산지는 피연산자의 기존 값에 1을 더해서 그 결과를 다시 피연산자에 저장한다.
예를 들어 num 변수의 기존 값이 5라면 ++num 연산 후 num 변수의 값은 6이 된다.
그래서 ++ 연산자를 증가 연산자라고 부른다.
# --연산자는 피연산자의 기존 값에 1 을 뺀 후 그 결과를 다시 피연산자에 저장한다.
예를 들어 num 변수의 기존 값이 5 라면 --num 연산 후 num 변수의 값은 4가 된다.
그래서 -- 연산자를 감소 연산자라고 부른다.
# 증가 연산자와 감소 연산자는 변수의 앞뒤 어디에든올 수 있다.
# 연산식에서 증감 연산자만 있는 경우에는 증감 연산자가 변수 앞 또는 뒤 어디든 위치해도 상관없다.
-증감연산자에서 ++나 --가 문자 뒤에 붙으면 먼저 값에 대입이 된 뒤에 계산을 제일 마지막에 한다. (a++ , a--)
int a = 1;
int b = 1;
// 변수 앞에 붙으면 가장 먼저 처리 된다.
int result1 = ++a;
// 변수 뒤에 붙으면 가장 뒤에 처리 된다. (b의 값인 1을 result2에 먼저 대입하고 그 다음에 증감연산자가 처리 되는 방식이다)
int result2 = b++;
System.out.println("result 1 =" + result1);
System.out.println("result 2 =" + result2);
System.out.println(" a =" + a);
System.out.println(" b =" + b);
int a= 10;
System.out.println(++a);
System.out.println(a++);
System.out.println(++a);
System.out.println(++a);
System.out.println(a++);
System.out.println(++a);
System.out.println(a);
int x = 10;
int y = 10;
int z;
System.out.println("-------------------------------");
++x; // 증감 연산자만 사용되는 경우 값은 1이 증가한다.
x++; // 증감 연산자만 사용되는 경우 값은 1이 증가한다.
System.out.println(" x = " + x); // x = 12
System.out.println("-------------------------------");
--y;
y--;
System.out.println(" y = " + y); // y = 8
System.out.println("-------------------------------");
z = x++;
System.out.println(" z = " + z); // x = 12
System.out.println(" x= " + x); // x = 13
System.out.println("-------------------------------");
z = ++x;
System.out.println(" z= " + z); // x = 14
System.out.println(" x= " + x); // x = 14
System.out.println("-------------------------------");
z = ++x + y++;
System.out.println(" x= " + x); // x = 15
System.out.println(" y= " + y); // y = 9
System.out.println(" z= " + z); // z = 23 // y++가 제일 마지막에 실행이 된다.
System.out.println("-------------------------------");
# 논리 부정 연산자 ( ! )
-논리 부정 연산자는 true를 false로 false를 true로 변경하기 때문에 boolean 타입에만 사용할 수 있다.
-논리 부정 연산자는 조건문과 제어문에서 사용되어 조건식의 값을 부정하도록 해서
실행 흐름을 제 할 때 주로 사용된다. 또한 두 가지 상태 (true/false)를 번갈아가며 변경하는
토글(toggle) 기능을 구현할 때도 주로 사용한다.
boolean play = true;
System.out.println(play); // true
play = !play;
System.out.println(play); // false
play = !play;
System.out.println(play); // true
// 변수로 저장된게 아니기에 (값에 저장을 한게 아니기에) 모두 값이 false로 나온다.
System.out.println("1) : " + !play);
System.out.println("2) : " + !play);
System.out.println("3) : " + !play);
System.out.println("4) : " + !play);
-위의 값 올바르게 대입하여 저장하기.
// 위의 값을 변동을 주고 싶으면 값을 대입해주면 된다. 이때, 값은 괄호로 우선 처리해줘야 값이 올바르게 저장된다.
System.out.println("1) : " + (play = !play));
System.out.println("2) : " + (play = !play));
System.out.println("3) : " + (play = !play));
System.out.println("4) : " + (play = !play));
## 이항연산자
이항 연산자는 피연산자가 두 개인 연산자를 말하며 여기에는
산술 연산자(+ , - , * , / , %) ,
문자열 연결 연산자(+),
대입 연산자(=， +=, -=, * =, / =, %=),
비교 연산자(< , <= , > , >= , == , !=),
논리 연산자(&& , || , ^)등이 있다.
# 산술 연산자
우리가 일반적으로 말하는사칙연산인 더하기(+), 빼기(-), 곱하기(*), 나누기(/)와
나머지를구 하는 연산자(%)를 포함해서 산술 연산자는 총 5개이다.
이 산술 연산자는 boolean 타입을 제외한 모든 기본타입에 사용할 수 있다.
산술 연산자는 우리가 익히 알고 있기 때문에 따로 설명을 하지 않아도 될 것 같다.
주의할 점은 곱셈의 경우 연산자가 x가아니라 *를사용하고 나눗셉의 경우 /를사용한다.
기본 형식
변수 = 피연산자 산술연산자 피연산자
# % = 나머지 연산자)
# %연산자는 나눗셈을 수행하고 몫이 아닌 나머지를 돌려주는 연산자이다.
int result = num % 3
int result = num % 3; 에서 result에 저장되는 값은 num의 값에 따라 0, 1, 2 중 한 값이 된다. (어떤 수를 3으로 나누었을 경우 나머지는 세 숫자중 하나)
산술 연산자의 특징은 피연산자들의 타입이 동일하지 않을 경우 다음과 같은 규칙을 사용해서
피연 산자들의 타입을 일치시킨 후 연산을 수행한다.
1) 피연산자들이 모두 정수 타입이고, int 타입(4byte)보다 크기가 작은 타입일 경우
모두 int 타입으로 변환 후, 연산을 수행한다. 따라서 연산의 산출 타입은 int이다. (int + int = int)
2) 피연산자들이 모두 정수 타입이고 long 타입이 있을 경우 모두 long 타입으로 변환 후， 연산을 수행한다.
따라서 연산의 산출 타입은 long이다. (long + long = long , long + int = long
※ 즉, 연산은 가장 큰 타입으로 변경이 된다.
3) 피연산자 중 실수 타입(float 타입， double 타입)이 있을 경우, 크기가 큰 실수 타입으로 변환 후，
연산을 수행한다. 따라서 연산의 산출 타입은 실수 타입이다. (double + double = double)
※ int + float = double
-앞에 double로 형변환을 해줬어도 어차피 int / int = int로 값이 나오기에 2라는 값을 실수로 표현해주기만 한다.
int int1 = 10;
int int2 = 4;
int result1 = int1 / int2;
System.out.println(result1); // 2
double result2 = int1 / int2; // 2.0 [기존에 int/int 값이 2이기에 double은 그저 실수로 바꿔줄 뿐이다. 값이 2.5로 나오는게 아님]
System.out.println(result2);
-범위가 더 큰 타입으로 결과 값이 바뀐다. double / int = double , int / double = double
double result3 = (int1 * 1.0) / int2; // 2.5 int1 * 1.0에서는 실수가 더 값이 크므로 실수로 바뀐다. double / int-> double = double
double result4 = (double)int1 / int2; // 2.5 double / int = double
double result5 = int1 / (double)int2; // 2.5 int / double = double
char ch1 = 'A';
System.out.println(ch1); // A
char ch2 = 'A' + 1;
System.out.println(ch2); // B
char ch3 = (char)(ch2 + 1);
System.out.println(ch3); // C
-overflow (값의 표현범위를 초과하는 데이터)를 조심하자.
// overflow : 값의 표현범위를 초과하는 데이터
// byte : -128 ~ 127
byte a = (byte)(100 + 30);
System.out.println(a); // -126
int b = 1000000;
int c = 1000000;
int result = b * c; // -727379968
System.out.println(result);
long longA = 10000000;
long longB = 10000000;
long resultLong = longA * longB; // longA * longB : 100000000000000
System.out.println("longA * longB : " + resultLong);
int intA = 1000000;
int intB = 1000000;
long resultLong2 = (long)intA * intB; // intA * intB : 1000000000000
System.out.println("intA * intB : " + resultLong2);
-Exception이 발생하여 계산이 중지 되는 경우
-문자열에 들어간 숫자와 +의 의미
// 문자열에 +가 들어가면 문자열과 문자열을 연결해주겠다는 의미이다.
System.out.println("대한" + "민국");
System.out.println("Hello" + "World~~!!");
// 문자열 뒤에 들어간 숫자는 문자 처리
System.out.println("문자열" + 100 + 100);
// 문자열 앞에 들어간 숫자는 숫자 처리
System.out.println(100 + 100 + "문자열");
int a = 10;
int b = 20;
int result = a+b;
System.out.println("a + b = " + result);
System.out.println("a + b = " + a + b);
System.out.println(a + b + " : a + b");
## 비교 연산자
비교 연산자는 대소(<，<=， >，>=) 또는 동등( ==， !=)을 비교해서 boolean 타입인 true/false를 산출한다.
대소 연산자는 boolean 타입을 제외한 기본 타입에 사용할 수 있고 동등 연산자는 모든 타입에 시용될 수 있다.
비교 연산자는 흐름 제어문인 조건문(if), 반복문(for, while)에서 주로 이용되어 실행 흐름을 제어할 때 사용된다.
== : 같다 (equal to)
!= : 같지않다. (not equal to)
> : 크다 (greater than)
< : 작다 (less than)
>= : 크거나 같다 (greater than or equal to)
<= : 작거나 같다 (less than or equal to)
만약 피연산자가 char 타입이면 유니코드 값으로 비교 연산을 수행한다.
예를 들어 ‘A’의 유니코드는 65 이고, ‘B’의 유니코드는 66이므로 비교 연산자는 65와 66을 비교하게 된다.
int num1 = 10;
int num2 = 10;
boolean result1 = num1 == num2;
boolean result2 = num1 != num2;
System.out.println(result1);
System.out.println(result2);
char cha1 = 'A'; // 자바는 문자를 유니코드로 저장 ('A' = 65)
char cha2 = 'B'; // 자바는 문자를 유니코드로 저장 ('B' = 66)
boolean result3 = cha1 ==cha2;
boolean result4 = cha1 != cha2;
boolean result5 = cha1 < cha2;
System.out.println(result3);
System.out.println(result4);
System.out.println(result5); // 65<66 true
#문자열 비교
String str1(변수명) = " 문자열 ";
int a = 10;
double b = 10.0;
-기본형 변수 값은 저장되면 스택(Stack)형으로 값 자체가 변수에 저장이 되는 것인데,
String은 기본형이 아닌, 참조형이기 때문에, 스택형으로 쌓이는 것이 아닌 힙(Heap) 형식으로 저장이 되는데,
힙에서는 데이터 주소로 "문자열" 이라는 데이터를 저장하고 String의 스택에서는 힙에서 생긴 데이터 주소를
참조하고 데이터 주소를 저장해놓은 것이다. (Class의 개념)
-String은 원래 참조형이기에, 데이터 주소가 나와야 하지만, String은 문자열로 워낙 많이 쓰기에 번지수로 출력이 되지 않고 값이 직접적으로 출력된다.
// String은 원래 참조형이기에, 데이터 주소가 나와야 하지만, String은 문자열로 워낙 많이 쓰기에 번지수로 출력이 되지 않고 값이 직접적으로 출력된다.
String str = "문자열";
System.out.println(str); // 문자열
String 타입의 문자열을 비교할 때에는 대소(< ， <= , > , > = ) 연산자를 사용할 수 없고，
동등(== , !=) 비교 연산자는 사용할 수 있으나 문자열이 같은지 다른지를 비교하는 용도로는 사용되지 않는다.
기본 타입 (byte, char, short, int, long, float , double, boolean)인 변수의 값을 비교할 때 에는
연산자를 시용하지만 참조 타입인 String 변수를 비교할 때 연산자를 사용하면 원하지않는 결과가 나올수도 있다.
String str1 = "java";
String str2 = "java";
-new String("문자열") = 새로운 메모리를 생성한다. (다른 메모리 주소)
String str1 = "java";
String str3 = new String("java");
System.out.println(str3 == str1);
// 값은 false가 나온다. (new String으로 새로운 메모리를 생성했기 때문에)
그래서, 메모리 주소가 같은지가 아닌, 정말 문자열 그 자체가 같은지를 알고 싶으면
-변수명1.equals(변수명2); = .equals() 메서드는 참조하는 메모리의 주소비교가 아니라 값을 비교시 사용하는 메서드이다.
boolean result1 = str1.equals(str3);
System.out.println(result1);
## 논리 연산자
-&와 &&의 차이 : &는 둘 다 확인 하겠다, &&는 앞에 값이 false면 뒤에 있는것은 확인도 하지 않겠다.
-|와 ||의 차이 : |는 둘다 확인 하겠다, ||는 앞에 값이 true면 뒤에 있는 것은 확인도 하지 않겠다.
# 논리 연산자는 boolean타입인 true, false 를 비교하는데 사용한다.
# && (그리고) : 두 피연산자가 모두 참이면 참을 반환, 둘중 하나라도 거짓이면 거짓을 반환
# || (또는) : 두 피연산자 중 하나라도 참이면 참을 반환, 둘다 거짓이면 거짓을 반환
# ! (부정) : 피연산자의 논리적 부정을 반환. 즉, 참이면 거짓을, 거짓이면 참을 반환
-AND(논리곱) (둘다 true여야만 한다)
# 조건이 모두 true인 경우에만 연산 결과는 true가 된다.
# true && true = true
# true && false = false
# false && true = false (첫번째 조건이 false일 경우 결과는 false이므로 실제로 계산하지 않는다.) (&는 계산함)
# false && false = false (첫번째 조건이 false일 경우 결과는 false이므로 실제로 계산하지 않는다.) (&는 계산함
System.out.println("--AND 연산 (&&)--");
System.out.println(true && true);
System.out.println(true && false);
System.out.println(false && true);
System.out.println(false && false);
-OR(논리합) (둘 중에 하나만 true면 된다)
# 조건중 한가지만 true여도 결과는 true가 된다.
# true || true = true
# true || false = true (첫번째 조건이 true일 경우 결과는 true이므로 실제로 계산하지 않는다.) (|는 계산함
# false || true = true (첫번째 조건이 true일 경우 결과는 true이므로 실제로 계산하지 않는다.) (|는 계산함
# false || false = false
System.out.println("--OR 연산 (||)--");
System.out.println(true || true);
System.out.println(true || false);
System.out.println(false || true);
System.out.println(false || false);// 변수 활용
boolean a = true;
boolean b = false;
System.out.println(a && b); // 둘 중에 하나라도 true가 아니면 false
System.out.println(a || b); // 둘 중에 하나라도 true면 true
System.out.println(!a); // 피 연산자의 논리값을 바꾼다.
System.out.println(!b); // 피 연산자의 논리값을 바꾼다.int a = 15;
boolean result = 10< a && a < 20;
System.out.println(result);
int b = 10;
boolean result2 = 0 < b && 5 < b && 10 < b;
System.out.println(result2); // false (한 가지라도 true가 아니면)
boolean result3 = b > 10 || b > 0 || b > 5;
System.out.println(result3); // true (한 가지라도 true)
-XOR(배타적 논리합) (둘 중에 하나는 꼭 true와 false가 나와야 한다)
-비교 조건이 같으면 false가된다.
# true ^ true = false (비교조건이 둘다 true이므로 false가 된다.)
# true ^ false = true
# false ^ true = true
# false ^ false = false (비교조건이 둘다 false이므로 false가 된다.)
int c = 10;
boolean result4 = c > 0 ^ c > 5; // false
boolean result5 = c<0 ^ c<5; // false
boolean result6 = c<0 ^ 5< c; //true
System.out.println(result4);
System.out.println(result5);
System.out.println(result6);
## 대입 연산자
int a = 10;
System.out.println(a); // 10
// a에다가 10을 더한 값을 저장한다.
a += 10;
System.out.println(a); // 20
a -= 10;
System.out.println(a); // 10
a *= 10;
System.out.println(a); // 100
a /= 10;
System.out.println(a); // 10
a %= 10;
System.out.println(a); // 0
# 진수변환
-2진수 변환
-2진수 변환을 통해 8진수와 16진수 구하기
-186 십진수를 각각의 진수로 변환하기.
-2진수 : 10111010
-8진수 : (10 111 010) 272
-16진수 : (1011 1010) BA
-374 8진수를 각각의 진수로 변환하기.
-11 111 010
-2진수 : 1111 1010
-16진수 : (1111 1010) FA
# 삼항 연산자
삼항 연산자( ? : )는 세 개의 피연산자가 필요로 하는 연산자를 말한다.
삼항 연산자는 ? 앞의 조건식 에 따라 콜론( : ) 앞뒤의 피연산자가 선택된다고 해서 조건 연산식이라고 부르기도 한다.
삼항 연산자를 사용하는 방법은 다음과 같다.
-조건식, 참_표현식, 거짓_표현식 이렇게 항이 3개이다.
-자바에서 유일하게 항이 3개인 연산자여서 삼항 연산자라 한다.
또는 특정 조건에 따라 결과가 나오기 때문에 조건 연산자라고도 한다.
-조건에 만족하면 참_표현식 이 실행되고, 조건에 만족하지 않으면 거짓_표현식 이 실행된다.
-if문과 유사하다.
-if문 처럼 코드 블럭을 넣을 수 있는 것이 아니라 단순한 표현식만 넣을 수 있다.
-삼항 연산자 없이 if 문만 사용해도 된다.
int a = 10;
// 조건식 ? 참_표현식 : 거짓_표현식;
System.out.println(a > 0 ? "크다" : "작다"); // 크다
System.out.println(a > 80 ? "크다" : "작다"); // 작다
System.out.println(a>5 || a>15 ? "크레이지" : "아케이드"); // 크레이지
System.out.println(a>10 && a> 5? "크레이지" : "아케이드"); // 아케이드
-삼항 연산자에는 true와 false 값 (boolea), 변수(variable)를 넣어줄 수 있다.
int x = a > 5 ? a+10 : a-10;
System.out.println(x); // 20
// true와 false로 출력
boolean b = a > 5 ? true : false;
System.out.println(b); // true
// 삼항연산자에 변수를 넣어줄 수 있다.
int a = 5;
int b = 100;
int c = 1;
int d =( a > 10) ? b : c;
System.out.println(d); // 1
int e =( a < 10) ? b : c;
System.out.println(e); // 1
int score = 80;
String resultString = (score > 60) ? "합격입니다." : "불합격입니다.";
System.out.println(score + "점은 " + resultString); // 80점은 합격입니다.
## 연습문제
연습문제 1) 3
1. 연산자와 연산식에 대한 설명 중틀린 것은 무엇입니까
1) 연산자는 피연산자의 수에 따라 단항, 이항, 삼항 연산자로 구분된다.
2) 비교 연산자와 논리 연산자의 산출 타입은 boolean (true/false) 이다
3) 연산식은 하나 이상의 값을 산출할수도 있다.
4) 하나의 값이 올 수 있는 자리라면 연산식도 올수 있다.
연습문제 2) 31
2. 다음 코드를 실행했을 때 출력 결과는 무엇입니까?
int x = 10;
int y = 20;
int z = (++x) + (y--);
System.out.println(z);
연습문제 3) 가
3. 다음 코드를 실행했을 때 출력 결과는 무엇입니까?
int score = 85;
String result = (!(score > 90 )) ? "가" : "나";
System.out.println(result );
연습문제 4)17, 24 / pencils / students, pencils % students
4. 534자루의 연필을 30명의 학생들에게 똑같은 개수로 나누어 줄 때 학생당 몇 개를 가질 수 있고，
최종적으로 몇 개가 남는지를 구히는 코드입니다.
( #1 ) 과 ( #2 ) 에 틀어갈 알맞은 코드를 작성하세요
int pencils = 534;
int students = 30;
//학생 한 명이 가지는 연필 수
int pencilsPerStudent = ( #1 );
System.out.println(pencilsPerStudent);
//남은 연필 수
int pencilsLeft = ( #2 );
System.out.println(pencilsLeft);
연습문제 5)value-56, (value/100) *100, value-(value%100)
5. 다음은 십의 자리 이하를 버리는 코드입니다.
변수 valu e의 값이 356이라면 300이 나올수 있도록 (#1 )에 알맞은 코드를 작성하세요(산술 연산자만 사용하세요)
int value = 356;
System.out.println( #1 );
연습문제 6) true, false
6. 다음코드는 비교 연산자와 논리 연산자의 복합연산식입니다. 연산식의출력 결과를 괄호( )속에 넣으세요
int x = 10;
int y = 5;
System.out.println( (x>7) && (y<=5) ); ------------( #1 )
System.out.println( (x%3 == 2) || (y%2 != 1) ); ------------( #2 )
연습문제 7)
7. 다음과 같은 작업을 수행하는 프로그램을 작성하시오
1. num1 , num2 , num3 라는 이름의 세 개의 int 변수를 선언하고, 각각 10, 20, 30으로 초기화하세요.
2. 세 변수의 합을 계산하고, 그 결과를 sum 이라는 이름의 int 변수에 저장하세요.
3.세 변수의 평균을 계산하고, 그 결과를 average 라는 이름의 int 변수에 저장하세요.
(평균 계산 시 소수점 이하의 결과는 버림)
4. sum과 average 변수의 값을 출력하세요.
int num1 = 10;
int num2 = 20;
int num3 = 30;
int sum = num1 + num2 + num3;
System.out.println(sum);
int average = sum /3;
System.out.println(average);
연습문제 8) 결과를 예측하고 결과를 확인해보자 a= 11. b= 11, c = 22
int a = 10;
int b = 10;
int c = ++a + ++b;
연습문제 9) 결과를 예측하고 결과를 확인해보자 a = 12, c = 23
int a = 10;
int c = ++a + ++a;
System.out.println(a);
System.out.println(c);
연습문제 10) 결과를 예측하고 결과를 확인해보자 a = 12, c = 22
int a = 10;
int c = ++a + a++;
System.out.println(a);
System.out.println(c);
연습문제 11) 결과를 예측하고 결과를 확인해보자 a = 12, c = 21
같은 변수가 후증가가 연속적으로 두 번일 경우, 한 번만 적용된다.
int a = 10;
int c = a++ + a++;
System.out.println(a);
System.out.println(c);
이 동작하기 때문에 a+1이 진행된다. (a = 12)
'java(2)↗' 카테고리의 다른 글
| java 클래스(2) (0) | 2024.04.22 |
|---|---|
| java 클래스 (0) | 2024.04.19 |
| java 데이터 참조 타입 (0) | 2024.04.18 |
| java 제어문(if, switch, for, while) (0) | 2024.04.16 |
| java특 (2) | 2024.04.12 |