반응형
<JAVA SE>
-연산자 우선순위
~이어서~
<JAVA SE>
*진법(2진수 구하기)
-2진수
-8진수
-16진수
*연산자
-단항연산자
-산술연산자
-쉬프트연산자
-관계
-논리
-삼항
-대입
*API
*인수값입력
*n진법
-
8진수는 옥타, 16진수는 헥사 라고 부르며, 코딩창에서 수만을 적었을때에는 십진수가 들어간다.
-
16진수의 경우 표현가능한 수가 많아서 색에 주로 사용된다.
-
8진수 : 0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 20,,,
-
=>코딩창에서 8진수를 사용시에는 숫자앞에 0을 붙여서 사용한다.
-
16진수 : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a(10), b, c, d, e, f(15), 10, 11, 12, 13,,,
-
=>코딩창에서 16진수를 사용할때에는 숫자앞에 0x를 붙여 사용한다.
-
(java는 연산시 모든 숫자를 2진수로 변환하여 처리?)
-
(java는 다 다른진수를 받아도 2진수로 저장하고 십진수로 내보낸다?)
class Test_Zinsu {
public static void main(String[] args) {
int doci = 15;
int octal = 017;
int hex = 0xF; //f대소문자=
int hex1 = 0xf;
//우리가 자바창에서 쓸수있는 진법은 이세가지가 전부이다.
System.out.println(doci+" / "+octal+" / "+hex+ " / "+ hex1 );
int tel = 01012345677;
System.out.println(tel);
//int tel1 = 0101238;//8진수로 인식을 해 8은 들어가지 않는다.
//System.out.println(tel1);
}
}
-진수변환
-
<1byte는 8개의 전선(말하자면)으로 이루어져있고 8개의 bit 또는 2개의 nibble로 이루어져있다.
-
<전선에 전류가 흐를때 1, 흐르지않아 스위치가 열려있을때 0
-
int형 변수일때 32개의 bit 가있고 매앤 앞 한자리는 최상위 부호비트 자리라고 하여 0이면 양수, 1이면 음수가 된다.
-
10진수=>2진수 변환시에
-
16 =>0000 0000 0001 0000
-
보통 하나하나 다 나누어서 구하나~더해서 구하는걸 알려준다!
-더해서 구하기
-
0 0 0 0 0 0 0 0 이면
-
128 64 32 16 8 4 2 1 을 첨자로 곱하여 더함으로 계산
-
ex)
-
10->8+2->0000 1010(2)
-
89=0101 1001(2)
-
29=0001 1101(2)
-
50=0011 0010(2)
-
99=0110 0011(2)
-
300=0001 0010 1100(2)
-
윈도우의 계산기에는 프로그래머ver 도 있다.
- 8진수를 2진수로 변환
-
8진수의 숫자 하나당 비트3개로 대치
-
첨자는 4, 2, 1로 사용
-
=>0101 0111(2)=>87(10진수)
-16진수를 2진수로 변환
-
16진수의 숫자 하나당 비트4개로 대치
-
첨자는 8, 4, 2, 1로 사용
-
=>0001 1010(2)=>26
-진수의 음수 표현
-
=보수법
-
1의 보수 : 0의 보수는 1, 1의 보수는 0, 각자리 숫자를 반전 (전기를 다넣은 1111 1111이 시작 0이 이미있어서 -1값넣음)
-
( 참고로 컴퓨터 상의 숫자0은 양수로 보고 값이 있는것으로 생각한다. )
-
0000 0001(2) => 1
-
0000 0000(2) => 0
-
1111 1111(2) => -1 (을 시작값(?)으로 -1이 되어버림)
-
1111 1110(2) => -2 (+1의 보수)
-
1111 1101(2) => -3 (+2의 보수)
-
=>그래서 맨앞에 자릿수가 1인게 음수인것.
-
1의 보수가 먼저 나왔으나 같은수의 음수와 양수를 더했을때 0이 되지않아 음수로의 표현이 부적합하게 되었다.
-
=>양수의 보수는 음수로 바뀌며 1증가가 됨 (양수n의 보수 = 음수(n+1) ), 그래서 나온게 2의 보수.
-
-
2의 보수 = 1의 보수 + 1
-
: 1의 보수에 1을 더하면 음의수가 딱 되었는데, 그걸 2의 보수라고 하고 이 수를 음수의 표현법으로 쓰게 되었다(부호만 반전)
-
-
ex)
-
-11의 이진수=>절댓값화=>11=>이진수화=>1011=>1의 보수화=>0100=>2의 보수화(+1)=>0101
-
=>따라서 10을 2진수로 만들어 보수화 하면 빠르게 구할수 있다.
-
000 1010 => 1111 0101 = -11
-
(자바는 기본이 4byte니까 8bit한블럭이 아니라 앞에 3블럭이 더있다고 생각해야한다. 8자리는 1byte~! )
*연산자
-단항연산자
-
연산에 사용되는 항이 하나인 연산자
-
사용법) 연산자 대상체(변수, 상수); < 문자열은 연산 되지 않는다!
-
연산자)
-
~ (틸드_tilde : 1의 보수연산(부호와 값이 바뀐다))
-
! (not : true->false/ false->true
-
+ ( :아무것도 하지 않는다->형식적 제공)
-
- ( :2의 보수연산(부호바꿈연산)_값은 그대로고 부호만 바뀐다)
-
++ (증가연산)
-
-- (감소연산)
-
-
~
-
~10 => -11 (~: 1의 보수(2진수))
-
~ 0000 1010=>1111 0101 (음수로 바뀌며 1이증가)
-
~-11 => 10 (부호바뀌고 1감소)
-
~양수 : 부호변경 1증가
-
~음수 : 부호변경 1감소
-
인것!
-
양수를 음수로 얻을때 틸드를 쓰는데 그때 적절히 1을 더하거나 빼야된다~!
-
-
! : NOT(true->false / false->true)
-
!true => false
-
3>2 => true
-
!3>2 => Error 관계랑 단항이 붙으면 단항이 먼저 연산되어 !3이 되어 t/f가 아니다
-
!(3>2) 가 되면 괄호안이 true가 되고 !붙으며 false
-
-
+ : 형식적 제공
-
10도 양수 +10도 양수이므로 안해도 괜찮아서 형식적인 제공이라고 하는것
-
-
- : 2의 보수연산 (부호바꿈연산)
-
-10=>10
-
값은 그대로이고 부호만 싹 바꾸어준다.
-
~쓰지않는 이유는 번거로워서 부호만 바꾸어주는게 편하니깐~!
-
~틸드가 먼저나왔고 불편해서 -나온것.
-
ex)
/*
단항연산자(Unary)
~, !, +, -, ++, --
*/
class Operator1 {
public static void main(String[] args) {
//자바어플리케이션 메인메소드가 들어있는것? 이것만으로도 돌아가서?
int i = 11;
int j = -11;
//~ (tilde) : 1의 보수 연산
//~양수 : 부호변경 1증가
System.out.println("~"+i+" = "+ ~i); //-12 <"+ ~i 틸드 띄어쓰기 주의
//~음수 : 부호변경 1감소
System.out.println("~"+j+" = "+ ~j); //10
//일반연산엔 잘안쓰고 암호화에 사용
//! (NOT) : true->false, false->true
boolean b = true;
boolean c = false;
System.out.println("!"+b+" = "+ !b); //false
System.out.println("!"+c+" = "+ !c); //true
//!는 t/f에만 쓸수있다!
System.out.println(!(11>15)); //!11이렇게 인식되어 int는 대상체로 될수 없다고 Error
//!은 boolean에만 사용가능하다. (casting도 안됀다고 생각하면되고_값을 까먹을 수도 있다_참조형의 캐스팅 더많이씀)
//+ : 형식적인 제공
System.out.println("+" +i+ "="+ +i); //11
System.out.println("+" +j+ "="+ +j); //-11
//일을 안한건아닌데 해도 바뀌는게 없다
//- : 2의 보수연산, 부호바꿈 연산
System.out.println("-" +i+ "="+ -i); //-11
System.out.println("-" +j+ "="+ -j); //11
//+와 다르게 일을한다(하는게 보인다) 부호바꿀일이 있다면 그냥 - 적으면된다.
}//main
}//class
-
++, -- : 대상체의 값을 변경하는 연산자
-
상수에는 사용할 수 없다.=>항상 대상체는 변수일것
-
두가지 형식으로 사용가능
-
연산자 대상체; / 대상체 연산자;
-
=>전위연산 =>후위연산
-
++: 대상체의 값을 1씩 증가 <oracle에서의 (변수명 := 변수명+1)부분인것 변수명++되니깐~!
-
--: 대상체의 값을 1씩 감소
-
int i=11;
-
++i;//11->12 i=i+1;
-
i++;//12->13 i=i+1;
-
주의)
-
단독으로 쓰이면 증가 잘~하고 감소 잘하지만!!
-
대입 연산자와 함께 사용되거나 method의 인수(Arguments)로 전달되는 경우에는 전위와 후위가 다른값을 할당하게 된다.
-
이때, 전위는 내것(단항연산자가 붙은 대상체)먼저 (대상체의 값을 먼저 변경), 후위는 남의것(대입) 먼저 (대입먼저 한후 대상체의 값을 변경하게 된다.)
-
int i = 11;
-
int j = 0;
-
j = ++i; //12=12
-
j = i++;//대입먼저해 j는 11, i는 12
-
ex)
//++ : 증가연산(대상체의 값을 1씩 증가)
i = 0;
j = 10;
//전위연산 : 연산자 대상체;
++i; //0->1
--j; //10->9
System.out.println("전위연산 후 : i = " +i+ ", j = "+ j);
//후위연산 : 대상체 연산자;
i++; //1->2
j--; //9->8
System.out.println("후위연산 후 : i = " +i+ ", j = "+ j);
//증가연산자와 감소연산자는 대입연산자와 함께 사용되면 전위와 후위가 다른값을 대입한다.
j=0;
//전위 : 내것먼저
j=++i;
System.out.println("전위연산 후 i : "+ i +", 대입 j : "+ j); //서로 같은값 가짐
//후위 : 남의 것 먼저
j=0;
j=i++;
System.out.println("후위연산 후 i : "+ i +", 대입 j : "+ j);
-산술연산자
-
+, -, *, /, %(나눈 나머지 _많은수에서 몇가지의 수로 만들때)
-
(이항연산자)
-
사용법) 대상체 연산자 대상체
-
ex) 10%2 = 0
-쉬프트연산자(비트밀기연산)
-
(정수형 변수에만 사용가능하고, 비트를 밀기 때문에 이진수를 알아야 연산가능 한다.)
-
<<(좌쉬프트_left shift), >>(right shift), >>>(unsigned right shift_음수를 표현하지않는 우쉬프트)
-
사용법) 대상체 연산자 밀칸수(밀비트수)
-
-
<< : 비트를 왼쪽으로 밀고 밀어서 빈칸을 항상 0으로 채운다(채우는 쪽은 수로 치지않는다)
-
이때 밀비트수는 31개 까지 밀수있다 기본 4byte가 32bit이므로!
-
ex)
-
5<<3;
-
0000 0101<<3
-
000 | 0010 1000 <좌시프트에는 0을 넣어줌
-
=40
-
10<<2;
-
0000 1010 << 2
-
00 | 0010 1000
-
=40 (*2*2)
-
1<<31
-
=-21억~~얼마
-
1<<32
-
=1 <다시 제자리로 돌아와버린다.//but 엉뚱한 값이 되어버릴수 있다.
-
9<<31 <만약 1이 아닌 수를 많이 밀면 9의 이진수인 1001(2)이 잘릴수 있어 값예측이 어려워진다.
-
-
>> : 비트를 오른쪽으로 밀고 밀어서 빈칸을 최상위 부호비트에 따라 양수면 0으로 음수면 1로 채운다.(부호유지)
-
ex)
-
17>>2
-
0001 0001>>2
-
0000 0100|01 <밖으로 나가면 버려버린다. 돌아오지 않는다.=>부호비트에 따라 0을 채울뿐
-
=4
-
17>>100
-
0001 0001>>100 <밀리는데로 밀리고 부호비트로 다채워진다.
-
=0
-
-1>>10000
-
1111 1111>>10000 <얼마를 밀어도 1이 들어오니까 -1
-
=-1
-
-
>>> : 비트를 오른쪽으로 밀고 (unsigned라 음수가 안들어감) 밀어서 빈칸을 항상 0으로 채운다. 따라서 무조건 양수
-
19>>>3
-
0001 0011 >>> 3
-
0000 0010|011 <0으로채움
-
=2
-
-1>>>1
-
0111 1111...1111 | 1
-
이라 양수의 최고의값 가질수있다...
-
=+21억~~얼마(양수의 최대값)
-
ex)
/*
쉬프트연산자
<< (left shift) : 비트를 왼쪽으로 밀고 밀어서 빈칸을 항상 0으로 채운다.
>> (right shift) : 비트를 오른쪽으로 밀고 밀어서 빈칸을 최상위 부호비트에 따라 양수면 0을, 음수면 1을 채운다.
>>> (unsigned right shift) : 비트를 오른쪽으로 밀고 밀어서 빈칸을 항상 0으로 채운다.
*/
class Operactor3 {
public static void main(String[] args) {
//method : <미리 선언해둔 클래스와 같다
//method : static method 사용 <메소드에 접근지정자에 스테틱이 붙어있으면
//클래스명.method명(값) <다른클래스에서 쓰는 상수와 사용방법이 같다 함수=메소드?
int i = 11;
System.out.println(Integer.toBinaryString(i) ); //1011
System.out.println(Integer.toOctalString(i) ); //013
System.out.println(Integer.toHexString(i) ); //0xb
i=9;
System.out.println(i+"<<3 = "+ (i<<3)); //72
//(i+"<<3 = "+ i<<3)은 문자열이 되어 연산되지 않는다. 괄호!
i=36;
System.out.println(i+">>3 = "+ (i>>3)); //4
i=120;
System.out.println(i+">>>4 = "+ (i>>>4)); //7
i=1;
System.out.println(i<<1); //2
System.out.println(i<<2); //4
System.out.println(i<<31); //-21억~
System.out.println(i<<32); //1
//31만큼 밀어내니 최상위 부호비트가 변경
i=-1;
System.out.println(i>>1); //-1
System.out.println(i>>2); //-1
System.out.println(i>>31); //-1
System.out.println(i>>100); //-1 <right shift로는 밀어도 1이 차서 -1이 유지된다.(최상위 부호비트 유지)
System.out.println(i>>>1); //양수가 가질수 있는 최고값 21억~
//하지만 unsigned right shift로 한칸 밀었을때, 최상위 부호비트부터 0으로 변경되어 최대값이 출력된다.
}//main
}//class
-Java API
-
java API의 lang 패키지 Integer클래스엔 진법반환하는 static method들이 존재
-
method : static method 사용
-
사용법) 클래스명.method명(값)
System.out.println(Integer.toBinaryString(i) ); //1011
System.out.println(Integer.toOctalString(i) ); //013
System.out.println(Integer.toHexString(i) ); //0xb 이부분.
<API_lang(class)-integer-method-static-to~ >
=>입력된걸 2진수로/16진수로/8진수로 내보낸다. unsigned인 이유는 0부터는 0을 출력하지 않아서, 0이나오면 헷깔릴까봐.
-관계연산자
-
>,<,<=,>=,==(같은지t/f),!=(<>ㄴㄴ)(다른지t/f)
-
ex)
/*
관계연산자 :
>,<,>=,<=, ==, !=
*/
class Operator4 {
public static void main(String[] args) {
int i=11, j=15, k=11;
System.out.println(i+" == "+ k +"="+ (i==k)); //true
System.out.println(i+" == "+ j +"="+ (i==j)); //false
System.out.println(i+" != "+ k +"="+ (i!=k)); //false
System.out.println(i+" != "+ j +"="+ (i!=j)); //true
//같지 않았을때 true~~
}//main
}//class
-논리연산자
-
<일반논리 / 비트논리(이진수로 바꾸어)
-
일반논리 : 여러개의 관계연산자를 붙일때
-
&&(AND) : 전항과 후항이 모두 "참"일때만 "참" 반환
-
||(OR) : 전항과 후항이 모두 "거짓"일때만 "거짓" 반환
-
&&
-
ture && true = true
-
진리표가 있다. (tt=t ff=f tf=f ft=f 이것) <표보다 말이 나은듯 =말로풀은것과 같당
-
&&특징) 전항이 false이면 후항을 계산하지 않는다. 무조건 거짓~!
-
||
-
true || ture = true
-
t||f = t f||t = t f||f = f
-
||특징) 전항이 true면 후항을 계산하지 않는다.(빠른 결과) f면 뒤에를 봐야..
-
< 11<15 || 11<3 실제로는 이렇게 된다.
-
비트논리 : 비트를 합치거나 분리할때 사용(쓸일..없..)
-
&(AND) : 상위비트와 하위비트가 모두 1인 경우에만 1내림 (그렇지 않으면 0내림)
-
|(OR) : 상위비트와 하위비트가 모두 0일때만 0내림 (그렇지 않으면 1내림)
-
^(XOR) : 상위비트와 하위비트 둘중 하나만 1인경우 1내림(둘다1이면 0 둘다0이면 0)
-
ex)
-
package day1115;
/*
논리연산지 :
일반논리
&& (AND): 전항과 후항이 모두 true일때만 true반환.이외f
|| (OR): 전항과 후항이 모두 false일때만 false반환.이외t
비트논리
& (AND): 상위비트와 하위비트 모두 1인경우 1내림
| (OR): 상위비트와 하위비트 모두 0인 경우 0내림
^ (XOR)-Exclusive OR: 상위비트와 하위비트 둘중 하나만 1인경우 1내림.
*/
class Operator5 {
public static void main(String[] args) {
boolean flag1 = true, flag2 = false, flag3 = true, flag4 = false;
int i = 0, j = 0;
//변수는 묶어서 한쪽에 만드는게 좋다.
System.out.println("------------&&------------");
System.out.println(flag1+" && " +flag3 + " = " + (flag1&&flag3)); //true
System.out.println(flag1+" && " +flag2 + " = " + (flag1&&flag2)); //flase
//전항이 false이면 후항을 계산하지 않고 false인 결과를 만든다.
System.out.println(flag2+" && " +flag1 + " = " + (flag2&&flag1)); //flase
System.out.println(flag2+" && " +flag4 + " = " + (flag2&&flag4)); //flase
System.out.println("------------||------------");
System.out.println(flag1+" || " +flag3 + " = " + (flag1||flag3)); //true
System.out.println(flag1+" || " +flag2 + " = " + (flag1||flag2)); //true
//전항이 true이면 후항을 계산하지 않고 true인 결과를 만든다.
System.out.println(flag2+" || " +flag1 + " = " + (flag2||flag1)); //true
System.out.println(flag2+" || " +flag4 + " = " + (flag2||flag4)); //flase
System.out.println("-----------------------------------");
flag1 = false;
flag2 = false;
flag3 = false;
flag3 = (flag1=3<4) && (flag2=5<4); //flag1에 3<4값이 들어감 그리고 같은지 비교
System.out.println("전항 : " +flag1+", 후항 : " +flag2+ ", 판정 : " +flag3); //true
flag3 = (flag1=3>4) && (flag2=5>4); //flag1에 3<4값이 들어감 그리고 같은지 비교
System.out.println("전항 : " +flag1+", 후항 : " +flag2+ ", 판정 : " +flag3); //false
//처리를 더빠르게 하는것을 돕는다.
//전항이 true면 뒤항 계산ㄴㄴ
System.out.println("-----------------------------------");
System.out.println(9&3);
// 1001 0011=>0001=1
System.out.println(9|3);
// 1001 0011=>1011=11
System.out.println(9^3);
// 1001 0011=>1010=10
//이진수로 바꿀줄알면 계산이 쉽다. 마찬가지로 거의 쓸일 없다.
System.out.println("-----------------------------------");
System.out.println("-----------------------------------");
i=28;
j=48;
System.out.println(i +" & " +j+ " = " +(i&j));
//0001 1100 & 0011 0000 = 0001 0000 = 16
i=16;
j=3;
System.out.println(i +" | " +j+ " = " +(i|j));
//0001 0000 | 0000 0011 = 0001 0011 = 19
i=10;
j=12;
System.out.println(i +" ^ " +j+ " = " +(i^j));
//0000 1010 ^ 0000 1100 = 0000 0110 =
System.out.println("-----------------------------------");
}//main
}//class
-삼항연산자(조건연산자)
-
<연산에 필요한 항이3개
-
? :
-
형식)
-
조건식 ? 항1 : 항2
-
=>관계,논리,not
-
=> 상수, 변수, 연산식, 객체 <(자바에서 쓸수있는 모든 값 다)
-
조건식 ? 항1 : 항2
-
true 일땐 항1을 앞으로
-
false 일땐 항2를 앞으로
-
int i = _;
-
i >=0 ? "양수" : "음수"
-
t=양수
-
f=음수 나가게 된다.
-
<항1과 2는 같아도 달라도 상관없다. 단 앞에 것의 형이 다감싸줄?받아줄만해야...
-
ex)
/*
삼항(조건)연산자
? :
*/
class Operator6 {
public static void main(String[] args) {
int i = 99;
System.out.println(i+ "는(은) "+ (i>=0?"양수":"음수"));
//절대값을 얻고 싶을때
System.out.println(i+ "의 절대값 "+ (i>=0? i :-i));
//변수를 내보낼수도 있다
//변수의 값이 짝수인지 홀수인지 판단하는 삼항연산자
System.out.println(i+ "는(은) " + (i%2==0?"짝수":"홀수"));
}//main
}//class
-대입연산자
-
=(우항의값을 좌항으로 넘겨라)(순수대입)
-
+=, -=, *=, /=, %= (산술대입)
-
<<=, >>=, >>>= (쉬프트대입)
-
&=, |=, ^= (비트논리대입)
-
<기존에 있던 연산자랑 합쳐짐
-
<연산결과를 변수에 다시 담는다.
-
연산한 결과를 변수에 대입하는 연산자
-
int i = 15;
-
i+=5; // i=i+5;와 같음
-
따라서 i는 20
-
<기존에있던값과 새로운값을 연산해 다시 넣음
-
i-=3; //i=i-3;
-
따라서 i는 17
-
i*=2; //i=i*2;....
-
<산술대입 많이쓴다.
-
<c에서 왔고 40년된 언어라 ... 그만큼 전에 본건데, 산술대입을 사용하는게 약2배정도 빠르다고 나왔다고..카더라
-
i=20;
-
i<<2;
-
=80
-
i=20;
-
i&15;
-
0000 0100=4
-
ex)
/*
대입연산자
=
+=, -=, *=, /=, %=
<<=, >>=, >>>=
&=, |=, ^=
*/
class Operator7 {
public static void main(String[] args) {
int i = 3; //(순수)대입
//산술대입
i+=2; //i=i+2; =5
i-=1; //i=i-1; =4
i*=2; //i=i*2; =8
//<오라클은 정수/정수는 때에따라 실수가 나오기도 하지만 자바는 무조건 정수가 나온다.
i/=3; //i=i/2; =2 // 정수 / 정수=정수(실수나올수없다)
i%=3; //i=i%3; =2
//쉬프트대입
i<<=4; //i=i<<4; // 0000 0010<<4 = 0010 0000 = 32
i>>=1; //i=i>>1; // 0010 0000>>1 = 0001 0000 = 16
i>>>=2; //i=i>>>2; // 0001 0000>>>2 = 0000 0100 = 4
//비트논리대입
i &= 12; //i=i&12; //0100 & 1100 = 0100 = 4
i |= 11; //i=i|11; //0100 | 1011 = 1111 = 15
i ^= 5; //i=i^5; //1111 ^ 0101 = 1010 = 10
System.out.println(i);
}//main
}//class
<연산자는 수를계산하는거지 문자열은 안된다~!
<문자열은 관계연산자로도 비교도 할 수 없다.
<문자열은 ==만~!가능 단, 문자열을 기본형 형식으로 만들었을때만! 참조했을땐 ㄴㄴㄴ
-
문자열은 관계연산자 중 == 으로 같다를 비교할 수 있다.
-
단, 문자열이 기본형형식으로 만들어진 경우에만!!!
-
기본형ex) String s = "안녕?";
-
참조형ex) String s = new String("안녕?");
-
문자열을 비교할 때에는 equals라는 method를 사용(기본형이든 참조형이든 같은결과를 내어준다)
-
사용법) 문자열변수.equals("비교할문자열") <equals주로 쓰게된다.
*main method 에 Arguments 입력 <동적
=>자바를 실행할때 호출
java^Test //Test 클래스의 main method를 호출하여 실행하세요 라는 의미
class Test{
public static void main (String[] args){ //보이드를 통해 위의테스트를 ...
=>파라미터(에 들어가는 값을 Arguments) //위에서 java Test 값^값^넣으면 파라미터에 들어간다. 이때 값들은 Arguments(인수값)이다.
//
}
}
-
-실행시 외부에서 java프로그램 내부로 값을 전달할 수 있게 된다.(프로그램이 동적으로 동작한다.) <(프로그램이 입력된값에 따라 다른실행->동적이 된다.)
-
-입력되는 값의 데이터형은 "문자열(String)" 이다. 무조건~!숫자로 넣어도 문자열~!
-
-main method 내에서는 배열로 처리된다.
-
<오라클의 테이블과 같다.. 테이블의 인덱스..!
-
<값을 집어 넣으면 이값들이 타고 들어오는데 처음값은 0번째 1번째 2번째...이렇게 카운팅
-
<자바는 0번부터 시작!
String[] args
데이터형[] 변수명
args[0]
args[1]
args[2]...
//없는인덱스쓰면 에러
-
-입력된 값을 배열의 인덱스로 사용한다. args[0] //0번부터 시작하더라~~
-
-없는 인덱스를 사용하면 Error <많이넣고 적게쓰는건 아무 상관없으나 적게쓰고 많이쓰겠다는건 Error
-
실행) Java^클래스명^값^값^값
-
=>String 으로 들어오게 되고 이 String는 +(붙여라), ==(되기도 안돼기도) 밖에 쓸수 없다.
-
ex)
package day1115;
/*
Java 프로그램 외부에서 Java 프로그램 내부로 값을 전달할 때 main method의 Arguments 사용.
실행 : java 클래스파일명(바이트코드명) 값 값 값...(최대 21억개_인덱스가 21억개까지 가능)
*/
class MainArguments {
public static void main(String[] args) {
System.out.println(args[0]);
System.out.println(args[1]);
System.out.println(args[0]+args[1]); //문자열은 + 합쳐져서~!이것만 되고, *는 되지 않는닷
//int i = args[0]; int i = (int)args[0]; ㄴㄴㄴ
//기본형 참조형 형이 달라 들어가지 않는다.캐스팅(int)도 되지않는다.
//문자열을 정수로 변환
//Integer.parseInt(문자열); Integer클래스의 parseInt메소드면, 문자열을 구분하여 int형으로 변환한후 그값을 반환하는 일을 한다.
//되게많이쓴다.★★★
int i = Integer.parseInt(args[0]); //다쳐내고 필요한것만 잘라내옴, 숫자형태의 문자열은 가능하지만 아니라면(문자같은건) Error
int j = Integer.parseInt(args[1]);
Integer.parseInt("ddd");
System.out.println(i*j);
//이렇게 Arguments 받아봄~!
System.out.println(args[2] +"님 안녕하세요");//인자쓸때는 인덱스를 주의 없는거면 Error /3번째로 넣은건 인덱스 2이다/더넣은건상관x
}//main
}//class
<인자값 테스트_먼저 cmd>
=>이때 숫자 크다작다 비굔ㄴㄴ 문자열임
<Editplus에서 인자값받기>
=> 도구-사용자도구~에서 프로그램 추가3
<API_lang-Integer-~아까와 같은곳에서 찾는다.>
=> parse - 구분지어 자르다
/*
숙제
1. 변수에 할당된 값이 양수일때만 2진수로 출력하고 음수라면 ~를 사용하여
양수로 변경하고 입력된 그대로의 10진수로 출력.
출력 예) " 양수 인경우" 10은 1010
"음수 인경우" -10 은 10
2. 2147483647의 값에서 상위 2byte와 하위 2byte 값을 분리하여 출력해보세요.
출력 예) 상위 2byte -> 32767=0111 1111 1111 1111
하위 2byte -> 65535=1111 1111 1111 1111
3. ||를 사용했을 때 전항이 true라면 후항을 연산하지 않는 것을 증명할 수 있는
코드를 작성하세요.
*/
class Work16 {
public static void main(String[] args) {
//1번
int i = Integer.parseInt(args[0]);
//System.out.println(Integer.toBinaryString(i) );//1011
//System.out.println(i+ "는(은) "+ (i>=0?"양수":"음수"));
System.out.println(i>=0?"양수 인경우 "+i+"은(는) "+Integer.toBinaryString(i) :"음수 인경우 "+i+"은(는) "+(~i+1));
//2번
int j = 2147483647;
System.out.println("상위2byte "+(j>>16));//0111 1111 1111 1111=>32767
System.out.println("하위2byte "+ ~(j<<16));//1111 1111 1111 1111=>65535
//3번
boolean flag1 = true, flag2 = false, flag3 = true, flag4 = false;
System.out.println(flag1+" || " +flag3 + " = " + (flag1||flag3)); //tt true
System.out.println(flag1+" || " +flag2 + " = " + (flag1||flag2)); //tf true
//전항이 true라면 후항을 연산하지 않는 것을 증명
flag2 = true;
System.out.println(flag1+" || " +flag2 + " = " + (flag1||flag2)); //tt true
System.out.println(flag2+" || " +flag1 + " = " + (flag2||flag1)); //ft true
System.out.println(flag2+" || " +flag4 + " = " + (flag2||flag4)); //ff flase
int a = 5, b = 0;
System.out.println("a는 "+a +", b는 "+b);
System.out.println("a!=0 || ++b!=0 = "+(a!=0 || ++b!=0));
//a는 5라서 0이 아니니 true, b는 1인 상태로 저장되어야한다. 하지만 결과는 0 계산 안됨!
System.out.println("a는 "+a +", b는 "+b);
}//main
}//class
반응형