java #3, #4 Constant/형변환/API/연산자/진수

java #3, #4 Constant/형변환/API/연산자/진수

 

* Constant

- 변수와 상수

	장점	단점
변수	가독성	값 변경 가능성 우려
상수	값 변경이 없음	가독성 낮음

Constant 는...

- 변수를 상수처럼 사용할 때.

- 변수의 값을 변경할 수 없게 만든다.

- Class의 field 에서만 정의할 수 있다.

field : class 안 & 메소드 밖의 영역

<작성법> 

public : 클래스 외부에서 사용 가능

static : 모든 메모리 영역에서 사용 가능

final : 값 할당, 변경 불가

public static final 데이터형 상수명 = 값;

                    기본형, 참조형 대문자

	정의된 클래스 안	다른 클래스
사용법	상수명 or 클래스명.상수명	클래스명.상수명

/*
Constant
변수를 상수처럼 사용하기 : 상수에 이름을 부여해서 사용하되 값을 변경하지 못하도록 만드는 것.

Constant에 입력되는 값은 한번 결정되면 잘 변경되지 않는 값을 넣는다. (프로그램 작성시 기준값)
*/
 
class  UseConstant{
     //상수는 class의 field에서만 정의된다. main 메소드 안에서는 정의할 수 없음.
     public static final int MAX_SCORE=100;
     public static final int MIN_SCORE=0;
     public static void main(String[] args) {
 
     int myScore=85;
 
     //상수의 사용은 변수처럼 상수명만 가지고 사용하는것과
     System.out.println("최고점 : "+MAX_SCORE);
     //클래스명.상수명으로 사용하는 것 두가지 방식이 있다.
     System.out.println("최저점 : "+UseConstant.MIN_SCORE);
    
     //변수는 값을 여러번 할당할수있다.
     myScore=87;
     //상수는 선언시에만 값을 할당할 수 있다.
     //MAX_SCORE=99;
 
     System.out.println("내점수 : "+myScore+", 최고점수와 내 점수의 차이 : "+(UseConstant.MAX_SCORE - myScore));
     }//main
}//class

---

* API

- Java에 기본적으로 탑재된 라이브러리에 관한 매뉴얼

http://docs.oracle.com/javase/7/docs/api/index.html

---

*자동형변환

- 코딩시 데이터형을 자동으로 변경 해주는 것.

- int의 하위 데이터형(byte, short)은 연산이 되면 연산 결과를 int로 저장하게 된다.

          

byte+byte=int

short+short=int

byte+short=int

*강제형변환(Casting)

- 개발자가 데이터형을 강제적으로 변경하여 사용하는 것.

- 기본형(boolean형 제외), 참조형 데이터형(상속관계의 클래스 끼리 있을 때만)에서 사용할 수 있다.

- 값 손실 발생 할 수 있다.

- 동일형끼리만 가능하다.

(변경할 데이터형) 변수명 or 상수명

double d=3.54;
int i = (int)d
 
//결과 : i = 3 (소수점 이하 버림)

-----------------------------------------

byte b1=10, b2=20, result=0;
result = (byte)(b1+b2);
//result는?

UseCasting.class

UseCasting.java

---

* 연산자(operator)

- 연산시 사용하는 예약된 부호들 (좌측일수록 우선)

     논

최 단 산 쉬 관 리 삼대 콤 마

우 항 술 프 계     항입     지

선         트                    막

※ 아래 세부 설명 중 빨간글자는 2진수로 연산함을 의미

1) 최우선 : 괄호

2) 단항연산자 : 연산에 필요한 항이 하나인 연산자.

~      (titld, 틸드, 1의 보수연산) 1->0 0->1 2진수로 바꿔서 계산해야함. ~양수 = 1증가후 음수가 됨. ex) ~10 = -11 ex) ~-9 = 8	!       (not) : boolean형과 관계연산자에 사용. true와 false의 상태를 서로 바꿈
+       (형식적 제공)	-      (2의 보수 연산, 부호 바꿈 연산),
++      (증가연산) : 대상체의 값을 1씩 증가 - 대입연산자와 같이 사용되면 전위와 후위가 다른 값을 대입한다. - 전위 : 내 것 먼저(증감 연산 후 대입) - 후위 : 남의 것 먼저(대입먼저한 후 증감 연산)	--     (감소연산) :대상체의 값을 1씩 감소
/* 단항 연산자 : ~, !, +, -, ++, -- */ class Operator1 { public static void main(String[] args) { int i = 2, j = -6; //~(titld) : 1의 보수 연산 //~양수 : 부호변경 `증가, ~음수 : 부호변경 1감소 System.out.println("~"+i+" = "+~i);//-3 System.out.println("~"+j+" = "+~j);//5 boolean b=true, c=false; // ~(not) : ~true : -> false, !false -> true System.out.println("!"+ b + " = " + !b);//flase System.out.println("!"+ c + " = " + !c);//true //+:형식적제공 System.out.println("+" +i+ " = "+ +i);//2 System.out.println("+" +j+ " = "+ +j);//-6 //- : 2의 보수연산(부호변경연산) System.out.println("-" +i+ " = " + -i);//-2 System.out.println("-" +j+ " = " + -j);//6 //증가,감소연산 i=5; j=10; //전위연산 ++i; //5->6 --j;//10->9 System.out.println("전위연산 후 i = "+i+", j = "+j); //후위연산 i++;//6->7 j--;//9->8 System.out.println("후위연산 후 i = "+i+", j = "+j); //대입연산자(다른연산자)와 같이 사용되면 전위, 후위가 다른값을 대입한다. int result = 0; //전위 : 내것 먼저 (연산후 대입) result = ++i;//8로 증가시킨 후 대입수행 System.out.println("전위연산 i = " +i+ ", result = " +result); //후위 : 남의것 먼저 (대입후 연산) result = 0; result = i++;//8을 대입한 후 9로 증가 System.out.println("후위연산 i = " +i+ ", result = " +result); }//main }//class	---------- run ---------- ~2 = -3 ~-6 = 5 !true = false !false = true +2 = 2 +-6 = -6 -2 = -2 --6 = 6 전위연산 후 i = 6, j = 9 후위연산 후 i = 7, j = 8 전위연산 i = 8, result = 8 후위연산 i = 9, result = 8 출력 완료 (0초 경과) - 정상 종료 Operator1.java Operator1.class

* 2진수의 양수와 음수

0000 0011     3

0000 0010     2

0000 0001     1

0000 0000     0

1111 1111    -1

1111 1110    -2 (-1에 1의 보수)

1111 1101    -3 (-2에 2의 보수)

3) 산술연산자 : 

+, -, *, /, 

%(나머지) : 많은수를 적은 수로 나눌때 몇가지수가 나오느냐?(띠)

4) 쉬프트연산(shift) : 비트밀기 연산

<<(lift shift) : 비트를 왼쪽으로 밀고 빈칸을 항상 0으로 채운다.

>>(right shift) : 비트를 오른쪽으로 밀고 빈칸을 최상위 부호비트에 따라 양수면 0, 음수면 1을 채운다.

>>>(unsigned right shift) : 비트를 오른쪽으로 밀고 빈칸을 항상 0으로 채운다.

int i=5;
i<<2;

0000     0101 -> 0001     0100

int i =33;
i>>3;

0010     0001 -> 0000     0100

int i = 13;
i>>>2;

0000     1101 -> 0000     0011

/* 쉬프트연산자 : <<, >>, >>> << : 비트를 왼쪽으로 밀어서 빈칸을 항상 0으로 채운다. >> : 비트를 오른쪽으로 밀어서 빈칸을 최상위 부호비트에 따라 양수면 0을 음수면 1을 채운다. >>> : 비트를 오른쪽으로 밀어서 빈칸을 항상 0으로 채운다. (무조건 양수) */ class Operater3 { public static void main(String[] args) { int i=9; System.out.println(i+"<< 3 = " + (i <<3)); //72 i = 31; System.out.println(i+">> 2 = " + (i >>2)); //7 i = 20; System.out.println(i+">>> 1 = " + (i >>>1)); //10 } } Operater3.java Operater3.class

5) 관계연산 : >, <, >=, <=, ==(같은지를 비교할 땐 꼭 두개를 써야함), !=

/* 관계연산자(대소비교) >, <, >=, <=, ==, != */ class Operator4{ public static void main(String[] args) { int i=2, j=6, k=2; System.out.println(i+" > "+j+" = "+(i>j));//false System.out.println(i+" < "+j+" = "+(i<j));//true System.out.println(i+" >= "+j+" = "+(i>=j));//false System.out.println(i+" <= "+j+" = "+(i<=j));//false System.out.println(i+" == "+j+" = "+(i==j));//false System.out.println(i+" == "+k+" = "+(i==k));//true System.out.println(i+" != "+j+" = "+(i!=j));//true System.out.println(i+" != "+k+" = "+(i!=k));//false } } Operator4.java Operator4.class

6) 논리연산 : 

- 일반논리 : 관계연산자를 묶어서 비교할때

  &&(and) : 전항, 후항이 모두 참일때 참반환

  ||(or) : 전항과 후항이 모두 거짓일때 거짓반환

- 비트논리 : 비트연산

&(and) : 상위비트와 하위비트 모두 1일때 1내림

|(or) : 상위비트와 하위비트 모두 0일때 0내림

^(xor) : 상위비트와 하위비트 둘중 하나만 1일때 1내림

int i=9, j=12 일때 1001 & 1100 = 1000 1001 | 1100 = 1101 1001 ^ 1100 = 0101 /* 논리연산자 일반논리(여러개의 관계연산자를 연결) &&(AND) : 전항과 후항이 모두 참인 경우에 참 반환, ||(OR) : 전항과 후항이 모두 거짓인 경우 거짓 반환 비트논리(비트를 계산) &(and) : 상위비트와 하위비트 모두 1일때 1내림 |(or) : 상위비트와 하위비트 모두 0일때 0내림 ^(xor) : (eXclusive OR) 상위비트와 하위비트 둘중 하나만 1일때 1내림 */ class Operator5 { public static void main(String[] args) { boolean b=true, c=false, d=true, e=false; System.out.println("-----------------AND-----------------"); System.out.println(b+" && " +d+" = " +(b && d)); //T System.out.println(b+" && " +c+" = " +(b && c)); //F //전항이 false 일때에는 후항을 연산하지않고 false를 반환 System.out.println(c+" && " +b+" = " +(c && b));//F System.out.println(c+" && " +e+" = " +(c && e));//F System.out.println("-----------------OR-----------------"); //전황이 true 일때 후항을 연한하지 않고 true를 반환 System.out.println(b+" || " +d+" = " +(b || d)); //T System.out.println(b+" || " +c+" = " +(b || c)); //T System.out.println(c+" || " +b+" = " +(c || b));//T System.out.println(c+" || " +e+" = " +(c || e));//F System.out.println("-----------------비트논리-----------------"); int i =19, j=27; System.out.println(i+" & " +j+ " = " +(i&j));//19 System.out.println(i+" | " +j+ " = " +(i|j));//27 System.out.println(i+" ^ " +j+ " = " +(i^j));//8 }//main }//class Operator5.class Operator5.java

7) 삼항 (조건) 연산자: ?, :

연산식      ?      항1      :      항2

true/false         항1과 항2에는 자바의 모든 항을 넣을 수 있음

/* 삼항연산자 (조건연산자) : 연산에 필요한 항이 3개인 연산자(? :) 사용법 : 연산식 ? 항1 : 항2 전항의 연산식이 true를 내보내면 항1이 수행, false면 항2가 수행. */ class Operator6{ public static void main(String[] args) { //변수에 있는 값이 홀수인지 짝수인지 판단하여 출력 int num = 7; System.out.println(num+"은(는)"+(num%2==0?"짝수":"홀수")); int num1=-1; //num1이 양수인지 음수인지 판단하여 출력해보세요 System.out.println(num1+"은(는)"+(num1>0?"양수":num1==0?"0":"음수")); }//main }//class Operator6.java Operator6.class

8) 대입 연산자

=, 순수대입 +=, -=, *=, /=, %=, 산술대입 <<=, >>=, >>>=, 쉬프트대입 &=, |=, ^= 비트논리대입

---

*진수

10진수	0 1 2 3 4 5 6 7 8 9
8진수	0 1 2 3 4 5 6 7	숫자 앞에 0을 붙이면 8진수로 인식
16진수	0 1 2 3 4 5 6 7 8 9 A B C D E F	숫자 앞에 0x을 붙이면 16진수로 인식
2진수	0 1

4bit = niddle

8bit = 1byte

최상위부호비트  (0양수, 1음수)