증감 연산자
- 단항 연산자로 구분된다 (단항: 피연산자가 하나)
- 피연산자의 값에 1을 더하거나 빼는 연산자(++,--)로 위치에 따라 결과 값이 다르게 나타남
- 주의해야하는 것은 연산의 순서
- 전위 연산 : 먼저 전위 연산 후 다른 연산 실행
int a = 10;
int b = ++a;
- 후위 연산 : 다른 연산 우선 실행 후 후위 연산
- 다른 연산이라는 것은 대입이나 println을 통한 출력을 의미
- 다른 연산, 즉 대입이나 출력을 먼저 한 후 값을 출력하는 것
- 어떤 연산이 있든 가장 마지막에 하는 연산이다.
int a = 10;
int b = a++;
< 증감 연산자 >
/* 피연산자의 앞 or 뒤에 사용이 가능하다 */
/* '++' : 1의 증가 의미 */
/* '--' : 1의 감소 의미 */
int num = 20;
System.out.println("num : " + num); // 20
num++;
System.out.println("num : " + num); //21
++num;
System.out.println("num : " + num); //22
num--;
System.out.println("num : " + num); //21
--num;
System.out.println("num : " + num); //20
/* 증감연산자만 사용 될 때는 1증가/1감소의 의미를 가진다
* 하지만 문제는 다른 연산자와 함께 사용할때 전위/후위 연산의 구분이 필요하다. */
int firstNum = 20;
int result1 = firstNum++ * 3;
// 후위 연산은 다른 연산을 먼저 처리하고 난 뒤 마지막에 처리 됨
System.out.println("result1 : " + result1); //60
System.out.println("firstNum : " + firstNum); //21
int secondNum = 20;
int result2 = ++secondNum * 3;
// 전위 연산은 증가를 먼저 처리하고 난 뒤 다른 연산을 함
System.out.println("result2 : " + result2); //63
System.out.println("secondNum : " + secondNum); //21
비교 연산자
- 데이터가 같은지, 다른지, 혹은 대소 비교를 할 때 사용
- 항상 논리 값(true, false)이 결과 값
- ‘==‘과 ‘!=‘은 모든 자료형에 사용 가능 (정수, 실수, 논리 등)
- ‘==‘과 ‘!=‘을 제외한 비교 연산자(>, >=, <, <=)는 기본형 boolean과 참조형(String)을 제외하고
나머지 자료형에 모두 사용 가능
'==' 연산자 / 값이 같은지 묻는 연산자
int a = 10;
int b = 11;
boolean c = a == b; (a와 b의 값이 같은지 c로 반환)
이때의 c는 false
'!=' 연산자 / 값이 같지 않은지 묻는 연산자
int a = 10;
int b = 11;
boolean c == a != b; (a와 b의 값이 다른지 c로 반환)
이때의 c는 true
/* 비교연산자 */
/* 비교연산자는 피연산자 사이에서 상대적인 크기를 판단하여 참 혹은 거짓을 반환하는 연산자이다.
* 연산자 중 참 혹은 거짓을 반환하는 연산자는 삼항 연산자의 조건식이나 조건문의 조건절에 많이 사용된다.
* */
/* 1. 숫자값 비교 */
/* 1-1. 정수 비교 */
int inum1 = 10;
int inum2 = 20;
System.out.println("===========정수값 비교============");
System.out.println("inum1과 inum2가 같은지 비교 : " + (inum1 == inum2));
System.out.println("inum1과 inum2가 같지 않은지 비교 : " + (inum1 != inum2));
System.out.println("inum1과 inum2가 큰지 비교 : " + (inum1 > inum2));
System.out.println("inum1과 inum2가 작은지 비교 : " + (inum1 < inum2));
System.out.println("inum1과 inum2가 작거나 같은지 비교 : " + (inum1 <= inum2));
// ===========정수값 비교============
// inum1과 inum2가 같은지 비교 : false
// inum1과 inum2가 같지 않은지 비교 : true
// inum1과 inum2가 큰지 비교 : false
// inum1과 inum2가 작은지 비교 : true
// inum1과 inum2가 작거나 같은지 비교 : true
/* 1-2. 실수 비교 */
double dnum1 = 10.0;
double dnum2 = 20.0;
System.out.println("===========실수값 비교============");
System.out.println("dnum1과 dnum2가 같은지 비교 : " + (dnum1 == dnum2 ));
System.out.println("dnum1과 dnum2가 같지 않은지 비교 : " + (dnum1 != dnum2 ));
System.out.println("dnum1과 dnum2가 큰지 비교 : " + (dnum1 > dnum2 ));
System.out.println("dnum1과 dnum2가 작은지 비교 : " + (dnum1 < dnum2 ));
System.out.println("dnum1과 dnum2가 작거나 같은지 비교 : " + (dnum1 <= dnum2 ));
// ===========실수값 비교============
// dnum1과 dnum2가 같은지 비교 : false
// dnum1과 dnum2가 같지 않은지 비교 : true
// dnum1과 dnum2가 큰지 비교 : false
// dnum1과 dnum2가 작은지 비교 : true
// dnum1과 dnum2가 작거나 같은지 비교 : true
/* 2. 문자값 비교 */
char ch1 = 'a';
char ch2 = 'A';
System.out.println("===========문자값 비교============");
System.out.println("ch1과 ch2가 같은지 비교 : " + (ch1 == ch2 ));
System.out.println("ch1과 ch2가 같지 않은지 비교 : " + (ch1 != ch2 ));
System.out.println("ch1과 ch2가 큰지 비교 : " + (ch1 > ch2 ));
System.out.println("ch1과 ch2가 작은지 비교 : " + (ch1 < ch2 ));
System.out.println("ch1과 ch2가 작거나 같은지 비교 : " + (ch1 <= ch2 ));
//===========문자값 비교============
//ch1과 ch2가 같은지 비교 : false
//ch1과 ch2가 같지 않은지 비교 : true
//ch1과 ch2가 큰지 비교 : true
//ch1과 ch2가 작은지 비교 : false
//ch1과 ch2가 작거나 같은지 비교 : false
/* 3. 논리값 비교 */
boolean bool1 = true;
boolean bool2 = false;
System.out.println("===========논리값 비교============");
System.out.println("bool1과 bool2가 같은지 비교 : " + (bool1 == bool2 ));
System.out.println("bool1과 bool2가 같지 않은지 비교 : " + (bool1 != bool2 ));
// System.out.println("bool1과 bool2가 큰지 비교 : " + (bool1 > bool2 ));
// System.out.println("bool1과 bool2가 크거나 같은지 비교 : " + (bool1 >= bool2 ));
// System.out.println("bool1과 bool2가 작은지 비교 : " + (bool1 < bool2 ));
// System.out.println("bool1과 bool2가 작거나 같은지 비교 : " + (bool1 <= bool2 ));
// 주석처리한 부분은 비교가 불가능한 것, true와 false 값의 대소를 비교할 수 없다.
/* 4. 문자열값 비교 */
/* 문자열도 ==과 !=은 비교가 가능하지만 대소비교는 불가능하다. */
String str1 = "java";
String str2 = "java";
System.out.println("===========문자열값 비교============");
System.out.println("str1과 str2가 같은지 비교 : " + (str1 == str2 ));
System.out.println("str1과 str2가 같지 않은지 비교 : " + (str1 != str2 ));
// System.out.println("str1과 str2가 큰지 비교 : " + (str1 > str2 ));
// System.out.println("str1과 str2가 크거나 같은지 비교 : " + (str1 >= str2 ));
// System.out.println("str1과 str2가 작은지 비교 : " + (str1 < str2 ));
// System.out.println("str1과 str2가 작거나 같은지 비교 : " + (str1 <= str2 ));
// ===========문자열값 비교============
// str1과 str2가 같은지 비교 : true
// str1과 str2가 같지 않은지 비교 : false
논리 연산자
논리 값(true, false)를 취급하는 연산자
- && : 두 피연산자가 모두 true일 때 true 반환 (AND)
- || : 두 피연산자 중 하나만 true여도 true 반환 (OR)
| a | b | a && b | a || b |
| true | true | true | true (추정 불필요) |
| true | false | false | true (추정 불필요) |
| false | true | false (추정 불필요) | true |
| false | false | false (추정 불필요) | false |
* 추정 불필요?
이미 첫번째 조건만으로 판단근거가 나왔기에 두번째 조건을 수행할 이유가 없는 경우. 컴퓨터는 연산을 효율적으로 한다. 각 연산자의 특징에 기반해서, 굳이 확인을 안해도되는 경우는 확인을 안한다. or같은 경우 하나만 true여도 true를 반환한다. 그러므로 a값에서 true값을 확인했다면 b부분은 확인하지않고 넘어간다.
논리 연산자
- 논리 값을 부정하여 반대 값으로 변경
- 제어문을 활용할 때 많이 쓰임
- 논리 부정 연산자
boolean bool1 = true;
boolean bool2 != bool1;
/* 논리 연산자 */
/* 논리값(true or false)을 취급하는 연산자이다. */
/* 1. 논리 연산자 결과 값 확인 */
System.out.println("true와 true의 논리 and 연산 : " + (true && true) );
System.out.println("true와 false의 논리 and 연산 : " + (true && false));
System.out.println("false와 true의 논리 and 연산 : " + (false && true));
System.out.println("false와 false의 논리 and 연산 : " + (true && false));
//Dead code가 뜨는 이유? 코드 흐름자체가 도달하지 않으므로 추정 불필요를 의미
// 콘솔창은 다음과 같이 출력
// true와 true의 논리 and 연산 : true
// true와 false의 논리 and 연산 : false
// false와 true의 논리 and 연산 : false
// false와 false의 논리 and 연산 : false
System.out.println("true와 true의 논리 or 연산 : " + (true || true) );
System.out.println("true와 false의 논리 or 연산 : " + (true || false));
System.out.println("false와 true의 논리 or 연산 : " + (false || true));
System.out.println("false와 false의 논리 or 연산 : " + (true || false));
// 콘솔창은 다음과 같이 출력
// true와 true의 논리 or 연산 : true
// true와 false의 논리 or 연산 : true
// false와 true의 논리 or 연산 : true
// false와 false의 논리 or 연산 : true
System.out.println("true와 논리 not 연산 : " + (!true));
System.out.println("false의 논리 not 연산 : " + (!false));
// true와 논리 not 연산 : false //콘솔
// false의 논리 not 연산 : true //콘솔
/* 2. 논리식에 논리연산자 활용 */
int a = 10;
int b = 20;
int c = 30;
int d = 40;
System.out.println("a가 b보다 작으면서 c가 d보다 작은지 확인 : " + (a < b && c < d));
System.out.println("a가 b보다 작으면서 c가 d보다 큰지 확인 : " + (a < b && c > d));
System.out.println("a가 b보다 크면서 c가 d보다 작은지 확인 : " + (a > b && c < d));
System.out.println("a가 b보다 크면서 c가 d보다 큰지 확인 : " + (a > b && c > d));
//콘솔창
// a가 b보다 작으면서 c가 d보다 작은지 확인 : true
// a가 b보다 작으면서 c가 d보다 큰지 확인 : false
// a가 b보다 크면서 c가 d보다 작은지 확인 : false
// a가 b보다 크면서 c가 d보다 큰지 확인 : false
System.out.println("a가 b보다 작거나 c가 d보다 작은지 확인 : " + (a < b || c < d));
System.out.println("a가 b보다 작거나 c가 d보다 큰지 확인 : " + (a < b || c > d));
System.out.println("a가 b보다 크거나 c가 d보다 작은지 확인 : " + (a > b || c < d));
System.out.println("a가 b보다 크거나 c가 d보다 큰지 확인 " + (a > b || c > d));
//콘솔창
// a가 b보다 작거나 c가 d보다 작은지 확인 : true
// a가 b보다 작거나 c가 d보다 큰지 확인 : true
// a가 b보다 크거나 c가 d보다 작은지 확인 : true
// a가 b보다 크거나 c가 d보다 큰지 확인 false /* 논리 연산자의 우선순위와 활용 */
/* && : 11순위
* || : 12순위
* && 연산자가 ||연산자보다 우선순위가 높다
* */
/* 1. 1부터 100사이의 값인지 확인 */
/* 1 <= 변수 <= 100 ============== 수학적으로 했던 표현이므로 이렇게는 사용x
* 변수 >= 1 && 변수 <=100 ======== 이렇게 사용해야 한다. */
int num1 = 55;
System.out.println("1부터 100사이인지 확인 : " + (num1 >= 1 && num1 <= 100));
// 1보다 크거나 같으면서 100보다 작거나 같은지 확인
int num2 = 105;
System.out.println("1부터 100사이인지 확인 : " + (num2 >= 1 && num2 <= 100));
// 1부터 100사이인지 확인 : true
// 1부터 100사이인지 확인 : false
/* 2. 영어 대문자인지 확인 */
/* 영어 대문자냐? ---> 문자변수 >= 'A' && 문자변수 <= 'Z' */
char ch1 = 'G';
System.out.println("영어 대문자인지 확인 : " + (ch1 >= 'A' && ch1 <= 'Z'));
char ch2 = 'g';
System.out.println("영어 대문자인지 확인 : " + (ch2 >= 'A' && ch2 <= 'Z'));
// 영어 대문자인지 확인 : true
// 영어 대문자인지 확인 : false
/* 3. 대소문자 상관없이 영문자 y인지 확인 */
/* 문자변수 == 'y' || 문자변수 == 'Y' */
char ch3 = 'Y';
System.out.println("영문자 y인지 확인 : " + (ch3 == 'y' || ch3 == 'Y'));
char char4 = 'y';
System.out.println("영문자 y인지 확인 : " + (ch3 == 'y' || ch3 == 'Y'));
// 영문자 y인지 확인 : true
// 영문자 y인지 확인 : true
/* 4. 영문자인지 확인 */
/* A: 65, Z:90, a: 97, z: 122 (중간에 91~96은 영문자가 아님) */
/* 연산자 우선순위를 고려한다면 and 연산이 먼저 수행되기 때문에 괄호를 묶지 않아도 되지만
* 논리적으로 먼저 실행하는 내용을 괄호로 묶어주면 코드를 읽기에 좋다. */
char ch5 = 'f';
System.out.println("영문자인지 확인 : " + ((ch5 >= 'A' && ch5 <= 'Z') || (ch5 >= 'a' && ch5 <= 'z')));
char ch6 = 'F';
System.out.println("영문자인지 확인 : " + ((ch6 >= 'A' && ch6 <= 'Z') || (ch6 >= 'a' && ch6 <= 'z')));
// 영문자인지 확인 : true
// 영문자인지 확인 : true
char ch7 = '가';
System.out.println("영문자인지 확인 : " + ((ch7 >= 'A' && ch7 <= 'Z') || (ch7 >= 'a' && ch7 <= 'z')));
// 영문자인지 확인 : false
/* AND 연산과 OR 연산자의 특징
* 논리식 && 논리식 : 앞의 결과가 false이면 뒤를 실행 안함
* 논리식 || 논리식 : 앞의 결과가 true이면 뒤를 실행 안함 \
* */
/* 1. 논리식 && 논리식 : 앞의 결과가 false이면 뒤를 실행 안함 */
/* 조건식 두개가 모두 만족해야 true를 반환하지만 앞에서 미리 false가 나오게되면
* 뒤의 조건을 확인할 필요 없이 false를 반환한다.
* 따라서 연산 횟수를 줄이기 위해서는 &&연산의 경우 앞에 false가 나올 가능성이 높은 조건을
* 작성하는 편이 좋다. */
int num1 = 10;
int result1 = (false && ++num1 > 0) ? num1 : num1;
System.out.println("&& 실행 확인 : " + result1);
// && 실행 확인 : 10 // 콘솔창
/* 2. 논리식 || 논리식 : 앞의 결과가 true 이면 뒤를 실행 안함 */
/* 조건식 둘 중 하나라도 true를 반환하면 true를 반환하기 때문에 앞에서 미리 true가 나오면
* 뒤의 조건을 확인할 필요도 없이 true를 반환한다.
* 따라서 연산 횟수를 줄이기 위해서는 ||연산의 경우 앞에 true 가 나올 가능성이 높은 조건을 작성하는 편이 좋다. */
int num2 = 10;
int result2 = (true || ++num2 > 0) ? num2 : num2;
System.out.println("||실행을 확인 : " + result2);
// ||실행을 확인 : 10 //콘솔창
삼항 연산자
- 자바에서 유일하게 피연산자 항목이 3개인 연산자
- 공식
조건식 ? 식1 : 식2;
- 조건식의 결과 값(true or false)에 따라 연산을 처리하는 방식
- 결과 값이 참일 경우 식1, 거짓일 경우 식2 수행
- 삼항 연산자 안에 삼항 연산자를 중첩하여 쓰는 것도 가능
< 삼항연산자 >
int result1 = a > b ? a++ : b--;
int result2 = a < b ? a++ : (b == 0 ? a-- : b++) ---- 삼항연산자 내부 삼항연산자 중첩
- 후위 연산자이므로 값으로 도출된 a혹은 b는 result에 값을 대입한 뒤 증감이 이루어 질것이다.
- 단 조건문이 복잡해 지는 경우 삼항연산자를 쓰는것을 지양한다.
/* 삼항 연산자 */
/* 자바에서 유일하게 피연산자 항목이 3개인 연산자이다. */
/* 삼항연산자 공식 -> 조건식 ? 참일때 사용값1 : 거짓일시 사용값2 */
/* 조건식은 반드시 결과가 true 또는 false로 나오게끔 작성해야 함
* 비교/논리 연산자가 주로 사용 됨 */
int num1 = 10;
int num2 = -10;
String result1 = (num1 > 0 ) ? "양수이다." : "양수가 아니다.";
String result2 = (num2 > 0 ) ? "양수이다." : "양수가 아니다.";
System.out.println("num1은 " + result1);
System.out.println("num2은 " + result2);
// 콘솔창
// num1은 양수이다.
// num2은 양수가 아니다.
/* 삼항연산자의 중첩사용도 가능하다. */
int num3 = 5;
int num4 = 0;
int num5 = -5;
String result3 = (num3 > 0) ? "양수이다." : (num3 == 0) ? "0이다." : "음수이다.";
String result4 = (num4 > 0) ? "양수이다." : (num4 == 0) ? "0이다." : "음수이다.";
String result5 = (num5 > 0) ? "양수이다." : (num5 == 0) ? "0이다." : "음수이다.";
System.out.println("num3은 " + result3);
System.out.println("num4은 " + result4);
System.out.println("num5은 " + result5);
// 콘솔창
// num3은 양수이다.
// num4은 0이다.
// num5은 음수이다.
연산자 종류와 우선 순위
| 종류 | 구분 | 세부구분 | 연산자 | 우선순위 |
| 최우선 연산자 | 직접 접근 연산자 | ( ) . { } | 1 | |
| 단항 연산자 | + - ! (자료형) ++ -- | 2 | ||
| 이항 연산자 | 산술 연산자 | * / % | 3 | |
| + - | 4 | |||
| 쉬프트 연산자 | >> << >>> | 5 | ||
| 비교 연산자 | > < >= <== | 6 | ||
| == != | 7 | |||
| 논리 연산자 | 비트 논리 연산자 | & | 8 | |
| ^ | 9 | |||
| | | 10 | |||
| 일반 논리 연산자 | && | 11 | ||
| || | 12 | |||
| 삼항 연산자 | (조건식) ? 참값 : 거짓값 | 13 | ||
| 대입 연산자 | 순수대입 | = | 14 | |
| 복합대입 | 산술 대입 | += -= *= /= %= | ||
| 쉬프트 대입 | <<= >>= >>>= | |||
| 비트 논리 대입 | &= ^= |= | |||
| 나열 연산자 | , | 15 |
더보기
학습점검
✅ 연산자 우선순위의 개념을 이해할 수 있다.
✅ 산술 연산자를 이용하여 데이터 연산을 수행할 수 있다.
✅ 복합 대입 연산자를 이용하여 데이터 연산을 수행할 수 있다.
✅ 증감 연산자를 이용하여 데이터 연산을 수행할 수 있다.
✅ 비교 연산자를 이용하여 데이터 연산을 수행할 수 있다.
✅ 논리 연산자를 이용하여 데이터 연산을 수행할 수 있다.
✅ 삼항 연산자를 이용하여 데이터 연산을 수행할 수 있다.
✅ 연산자 우선순위를 활용하여 데이터 연산을 수행할 수 있다.
메소드
특정 작업을 수행하기 위한 명령문의 집합
- 수학에서의 함수와 비슷한 의미. 함수는 무언가 연산을 하여 값을 도출하듯 메소드 역시 값을 받아 연산을 하여 결과값을 도출, 어떠한 작업을 수행하는지는 메소드에 따라 다르다.
- 메소드는 다른 메소드를 호출 가능 (메소드를 호출한 곳으로 돌아옴)
/* 메소드란? */
/* 메소드(method)는 어떤 특정 작업을 수행하기 위한 명령문의 집합이라고 할 수 있다.
* 자세한 메소드 사용법은 객체 부분에서 다루게 되니 지금은 호출 흐름에 대해 이해할 수 있도록 하자
* */
System.out.println("main() 시작됨...");
/* 작성한 메소드 호출 */
/* 클래스명 사용할 이름 = new 클래스명(); // 객체생성
* 사용할 이름.메소드명() // 메소드 호출
* */
Application1 app1 = new Application1(); //메소드가 선언된 클래스를 이와같이 작성
app1.methodA(); //methodA를 호출하고 싶다면 이와같이 작성한다.
System.out.println("main() 종료됨...");
}
/* 호출 확인을 위한 메소드 */
public void methodA() {
System.out.println("methodA() 호출함...");
methodB(); //위 객체생성순서와 호출방식이 약간 다르지만 우선 호출 흐름에 집중해서 확인하기
System.out.println("methodA() 종료됨...");
}
/* 호출 확인을 위한 메소드 */
public void methodB() {
System.out.println("methodB() 호출됨...");
methodC();
System.out.println("methodB() 종료됨... ");
}
/* 호출 확인을 위한 메소드 */
public void methodC() {
System.out.println("methodC 호출함...");
System.out.println("methodC 종료됨...");
}
// 콘솔창은 다음과 같다.
//main() 시작됨...
//methodA() 호출함...
//methodB() 호출됨...
//methodC 호출함...
//methodC 종료됨...
//methodB() 종료됨...
//methodA() 종료됨...
//main() 종료됨...
}
public class Application2 {
public static void main(String[] args) {
/* 메소드 호출 흐름 연습 */
/* Application1 에서 했던 것과 비슷하지만 호출 흐름을 메인 메소드에서 제어해보자 */
System.out.println("main() 시작함...");
/* methodA(), methodB(), methodC() 를 차례대로 호출한다. */
Application2 app2 = new Application2();
app2.methodA();
app2.methodB();
app2.methodB();
System.out.println("main() 종료됨...");
}
public void methodA() {
System.out.println("methodA() 호출됨...");
System.out.println("methodA() 종료됨...");
}
public void methodB() {
System.out.println("methodB() 호출됨...");
System.out.println("methodB() 종료됨...");
}
public void methodC() {
System.out.println("methodC() 호출됨...");
System.out.println("methodC() 종료됨...");
}
// 콘솔창
//main() 시작함...
//methodA() 호출됨...
//methodA() 종료됨...
//methodB() 호출됨...
//methodB() 종료됨...
//methodB() 호출됨...
//methodB() 종료됨...
//main() 종료됨...
}
값을 전달하면서 메소드를 실행하기
- 메소드 실행 시 어떠한 값을 미리 줄 수 있는데 이 값을 전달인자라고 한다.
- 전달인자가 없으면 비워 둘 수 있다 -> ( )
- 그 값을 활용(매개변수)해서 메소드 수행 가능
| method (50) | public void methodA (int var) { System.out.println(var); } |
| 50은 전달인자 | int var는 매개변수 |
public class Application3 {
public static void main(String[] args) {
/* 전달인자(argument)와 매개변수(parameter)를 이용한 메소드 호출
*
* 지금까지 우리가 배운 변수는 지역변수에 해당한다.
* 다양한 변수의 종류들이 존재하는데 이는 차차 배우게 될 것이다.
*
* 1. 지역변수 - 지역변수는 그 메소드안에서만 유효하다.
* 2. 매개변수 - 다른 메소드끼리 전달해도 유효한 변수
* 3. 전역변수(필드)
* 4. 클래스(static) 변수
*
*
* 지역 변수는 선언한 메소드 블럭 내부에서만 사용이 가능하다. 이것을 지역변수의 스코프라고 한다.
* 다른 메소드간 서로 공유해야 하는 값이 존재하는 경우, 메소드 호출 시 사용하는 괄호를 이용해서 값을 전달할 수 있다.
* 이 때 전달하는 값을 전달 인자(argument) 라 부르고,
* 메소드 선언부 괄호 안에 전달 인자를 받기 위해 선언하는 변수를 매개변수(parameter)라고 부른다.
*
* */
}
매개변수의 개수나 자료형의 제한은 없으며 상수(final 키워드)도 사용 가능함
public class Application3 {
public static void main(String[] args) {
/* 전달인자(argument)와 매개변수(parameter)를 이용한 메소드 호출
*
* 지금까지 우리가 배운 변수는 지역변수에 해당한다.
* 다양한 변수의 종류들이 존재하는데 이는 차차 배우게 될 것이다.
*
* 1. 지역변수 - 지역변수는 그 메소드안에서만 유효하다.
* 2. 매개변수 - 다른 메소드끼리 전달해도 유효한 변수
* 3. 전역변수(필드)
* 4. 클래스(static) 변수
*
*
* 지역 변수는 선언한 메소드 블럭 내부에서만 사용이 가능하다. 이것을 지역변수의 스코프라고 한다.
* 다른 메소드간 서로 공유해야 하는 값이 존재하는 경우, 메소드 호출 시 사용하는 괄호를 이용해서 값을 전달할 수 있다.
* 이 때 전달하는 값을 전달 인자(argument) 라 부르고,
* 메소드 선언부 괄호 안에 전달 인자를 받기 위해 선언하는 변수를 매개변수(parameter)라고 부른다.
*
* */
Application3 app3 = new Application3();
/* 전달 인자와 매개변수를 이용한 메소드 호출 테스트 */
/* 1. 전달 인자로 값 전달 테스트 */
/* 호출하려는 메소드의 매개변수 선언부에 미리 선언해둔 자료형 타입과 갯수, 순서가 일치하게 값을 넣어 호출한다.
* */
app3.testMethod(30);
//app3.testMethod("40");
// The method testMethod(int) in the type Application3 is not applicable for the arguments (String)
// 매개변수는 int 형이지만 인자가 String 형이기 때문에 호출될 수 없다.
//app3.testMethod(20, 30, 40);
// The method testMethod(int) in the type Application3 is not applicable for the arguments (int, int, int)
// 매개변수는 int 형 한개지만 인자는 3개이기 때문에 호출할 수 없다.
//app3.testMethod();
//The method testMethod(int) in the type Application3 is not applicable for the arguments ()
// 매개변수는 선언되어 있지만 인자로 값을 전달하지 않으면 호출할 수 없다.
/* 2. 변수에 저장한 값 전달 테스트 */
/* 2-1. 변수에 저장 된 없을 이용하여 값을 전달할 수 있다. */
int age = 20;
app3.testMethod(age); //변수값으로 전달
// 같은 age를 메소드에도 인트 변수에도 똑같이 쓸 수 있을까?
// 결론은 된다. 왜냐하면 age는 지역 변수이므로, 각자의 지역에서만 사용되며, 각자의 지역안에서는 중복되면 안되지만 엄연히 다른 지역에 있는 것이기 때문
// 같은 지역 내에서 같은 변수명을 사용하는 것은 안된다.
/* 2-2. 자동형변환을 이용하여 값 전달을 할 수 있다. */
byte byteAge = 10;
app3.testMethod(byteAge);
/* 2-3. 강제형변환을 이용하여 값 전달을 할 수 있다. */
long longAge = 80;
app3.testMethod((int) longAge);
// app3.testMethod(longAge);
// 컴파일 에러: The method testMethod(int) in the type Application3 is not applicable for the arguments (long)
// int 로 강제형변환을 하여 전달을 하게되면 문제없다.
/* 2-4. 연산 결과를 이용해서 값 전달을 할 수 있다. */
app3.testMethod(age * 3);
}
public void testMethod(int age) {
// int age = 10; // 매개 변수에서 선언된 변수명과 같은 지역변수를 선언할 수 없다.
System.out.println("당신의 나이는 " + age + "세 입니다.");
}
// 메소드를 호출하며 어떤 값을 input 할 수 있다.
// 단 값을 넘길때 선언해둔 자료형과 갯수와 순서가 일치해야만 한다. 그렇지않으면 컴파일 오류가 난다.
// 이를 전달인자라고 부르고. 전달인자를 받기위해 선언하는 변수를 매개변수라 한다.
/**
* <pre>
* Class : Application4
* Comment : 여러개의 전달인자와 매개변수를 이용한 메소드 호출
* History :
* <2021/12/21 (임수연) 처음작성함>
* <2021/12/31 (아무개) 수정함
* </pre>
* @author 임수연
* @version 1.0.0
* */
public class Application4 {
public static void main(String[] args) {
/* 여러 개의 전달 인자를 이용한 메소드 호출 테스트 */
Application4 app4 = new Application4();
app4.testMethod("유관순", 15, '여');
/* */ // 범위주석
// //한줄주석
/** */ // 앞에 별이 두개붙으면, 문서에대해서 설명할때 붙이는 주석, 무언가 문서적인 설명을 하고자 할때 사용.
// app4.testMethod(20, "홍길동", '남');
// The method testMethod(String, int, char) in the type Application4 is not applicable for the arguments (int, String, char)
// 왜 오류가 날까? 값의 개수는 맞지만 순서가 다르게 전달되면 호출하지 못한다. 정해진 순서대로 전달해야 함
/* 변수에 저장된 값을 전달하며 호출할 수 있다. */
String name = "신사임당";
int age = 40;
char gender = '여';
app4.testMethod(name, age, gender);
}
/**
* <pre>
* 이름과 나이와 성별을 전달받아 한 번에 출력해주는 기능을 제공합니다.
* </pre>
* @param name 출력할 이름을 전달 해 주세요
* @param age 출력할 나이를 전달 해 주세요
* @gender gender 출력할 성별을 전달해주세요. 성별은 변경되지 않을 것을 보장합니다.
* */
public void testMethod(String name, int age, final char gender) {
/* 매개변수도 일종의 지역변수로 구분된다.
* 매개변수 역시 final 키워드를 사용할 수 있다.
* 지역변수에 final 키워드를 붙여 상수를 만드는 것과 동일하다.
* final 매개변수는 상수 네이밍 규칙을 선택적으로 따르는 경향이 있다. (써도 되고 안써도 됨)
* 즉 늘 대문자로 작성하기를 권할때와는 달리 상수가 매개변수로 쓰일땐 굳이 대문자만 고집하지 않아도 된다.
* */
System.out.println("당신의 이름은 " + name + "이고, 나이는 " + age + "세 이며, 성별은 " + gender + "입니다.");
}
}
'Programming > JAVA' 카테고리의 다른 글
| 스캐너와 조건문 (0) | 2021.12.23 |
|---|---|
| 메소드 (0) | 2021.12.22 |
| 변수와 리터럴 (0) | 2021.12.20 |
| 변수 파트 암기할 표 정리 (0) | 2021.12.18 |
| 변수 (0) | 2021.12.17 |
