자바의정석- 변수

1. 화면에 글자 출력하기

print( )와 println( )

**System.out.print()**의 경우, 괄호 안의 내용을 출력하고 줄바꿈

**System.out.println()**은 괄호 안의 내용을 출력하고 줄바꿈

**2. 덧셈, 뺄셈 계산하기**

3. 변수의 선언과 저장

변수란?-"하나의 값을 저장할 수 있는 저장공간"

하나의 변수에 단 하나의 값만 저장할 수 있고, 새로운 값을 저장하면 기존의 값은 사라진다.

1-2. 변수의 선언과 초기화

• 변수의 선언

변수의 선언은 "변수타입"과 "변수이름"으로 선언

`int age;`

• 변수의 초기화

변수를 선언한 이후부터는 변수를 사용,그 전에 반드시 변수를 "초기화"

`int age = 25;	// 변수 age를 선언하고 25로 초기화 한다`

*`//예제 2-1/ch2/VarEx1.java`*

**`public** **class** VarEx1 {`

**`public** **static** **void** main(String[] args) {`

**`int** year = 0;`

**`int** age = 14;`

`System.out.println(year);`

`System.out.println(age);`

`year = age + 2000; *// 변수 age의 값에 2000을 더해 변수 year에 저장*`

`age = age + 1; *// 변수 age에 저정된 값을 1 증가시킨다.*`

`System.out.println(year);`

`System.out.println(age);`

`}`

`}`

*`//예제2-2/초2/VarEx2.java`*

**`public** **class** VarEx2 {`

**`public** **static** **void** main(String[] args) {`

**`int** x = 10 , y = 20;`

**`int** tmp = 0;`

`System.out.println("x:" + x + " y:" + y);`

`tmp = x; *//x는 10인데 10을 tmp에 넣어준다 -> tmp=10*`

`x = y; *// y값을 x에 넣어준다. x = 20*`

`y = tmp; *// tmp값을 y에 넣어준다. 위에서 tmp=10이므로 y=10*`

`System.out.println("x:" + x + " y:" + y);    *//실행결과    x:10 y:20*`

`}                                                *//          y:20 x:10*`

`}`

**1-3. 변수의 명명규칙**

1. 대소문자가 구분되며 길이에 제한이 없다.

2. 예약어를 사용해서는 안 된다.

3. 숫자로 시작해서는 안 된다.

4. 특수문자는'_'와'$'만을 허용한다.

-자바프로그램에서 권하는 규칙

1. 클래스의 이름의 첫 글자는 항상 대문자로 한다.

2. 여러 단어로 이루어진 이름은 단어의 첫 글자를 대문자로 한다. (카멜표기법)

3. 상수의 이름은 모두 대분자로한다. 여러 단어로 이루어진 경우 '_'로 구분한다.

-알기쉽고 의미있는 이름

1-4. 변수의 타입

자료형은 크게 "기본형"과 "참조형" 두 가지로 나뉜다.

기본형은 실제 값(data)를 저장하고, 참조형은 값이 저장되어있는 메모리 공간의 주소(address)를 값으로 갖는다.

(1) 기본형(Primitive Type) : 8가지

• boolean

② 문자형

• char(character)

③ 정수형

• byte
• short
• int(integer)
• long

④ 실수형

• float
• double

**(2) 참조형 : 기본형 이 외**

String : 문자열(여러 문자)

5. 상수와 리터럴

(1) 변수(variable)

"하나의 값을 저장하기 위한 공간"

(2) 상수(constant)

"값을 한번만 저장할 수 있는 공간", 변수의 타입 앞에 키워드 'final' 상수의 이름은 모두 대문자로 하는 것이 관례

// 상수 선언 시 변수타입 앞에 "final"을 붙여주면 된다 final int MAX_SPEED = 10;

변수 : 하나의 값을 저장하기 위한 공간

상수 : 값을 한번만 저장할 수 있는 공간

리터럴 : 그 자체로 값을 의미하는 것

(3) 리터럴(literal)-"그 자체로 값을 의미하는 것"

1) 논리형

① 리터럴 : true, false

② 접미사 : 없음

(2) 정수형

① 리터럴

• 10진수 ex) 10, 11, 12 ...
• 2진수(0b) ex) 0101 = 5(10진수) 0b
  
• 8진수(0) ex) 77 = 63(10진수) 0
  
• 16진수(0x) ex) FF = 255(10진수) 0x
  

② 접미사

• long타입 접미사 : l or L
• 기본형(접미사X) : int

(3) 실수형

float와 double, 2가지가 있습니다. 연산속도의 향상이나 메모리를 절약하려면 float를 선택하고, 더 큰 값의 범위라던가 더 높은 정밀도를 필요로 한다면 double을 선택해야 한다.

① 접미사

• float타입 접미사 : f or F
• double타입(기본형) 접미사 : d or D

*//예제2-10/ch2/FloatEx1.java*

**public** **class** FloatEx1 {

**public** **static** **void** main(String[] args) {

**float** f = 9.123456878901234567890f;

**float** f2 = 1.2345678901234567890f;

**double** d = 9.12345678901234567890d;

System.out.printf("    123456789012345678901234%n");

System.out.printf("f : %f%n", f);*//소수점 이하 6째자리까지 출력/7자리에서 반올림되서 출력된다.*

System.out.printf("f : %24.20f%n", f2);

System.out.printf("f2 : %24.20f%n", f2);

System.out.printf("d : %24.20f%n", d);

}

}

*//예제2-11/ch2/FloatToBinEx.java*

**public** **class** FloatToBinEx {

**public** **static** **void** main(String[] args) {

**float** f = 9.1234567f;

**int** i = Float.floatToIntBits(f);*//floatToIntBits()는 float타입값을 int타입값으로 해석해서 반환해준다.*

System.out.printf("%f%n", f);

System.out.printf("%X%n", i); *//16진수로 출력*

}

}

7. 문자 리터럴과 문자열 리터럴

(4) 문자형(char 타입)

① 리터럴

' '(작은 따옴표)로 문자 하나를 감싼 것

※ ''안에 반드시 하나의 문자가 있어야 합니다.

② 접미사 : 없음

(5) 문자열(String 타입)

① 리터럴

""(큰 따옴표)로 두 문자 이상을 감싼 것, 빈문자열을 허용

② 접미사 : 없음

**8. 문자열 결합**

문자열 + any type → 문자열 + 문자열 → 문자열

any type + 문자열 → 문자열 + 문자열 → 문자열

※ 변수의 기본값과 초기화-변수의 초기화 -“변수에 처음으로 값을 저장”

-**타입의 불일치**

리터럴의 타입은 저장될 변수의 타입과 일치하는 것이 보통

하지만 타입이 달라도 넓은 타입에 좁은 타입의 값을 저장하는 것은 허용

*//예제 2-3/ch2/StringEx.java*

**public** **class** StringEx {

**public** **static** **void** main(String[] args) {

String name = "Ja" + "va";

String str = name + 8.0;

System.out.println(name);  *// 결과 : Java*

System.out.println(str);   *// 결과 : Java8.0*

System.out.println(7 + " ");

System.out.println(" " + 7);

System.out.println(7 + "");

System.out.println("" + 7);

System.out.println("" + "");

System.out.println(7 + 7 + "");

System.out.println("" + 7 + 7);

System.out.println(" " + 7 + 7);

}

}

'A'와 같이 작은따옴표로 문자 하나를 감싼 것을 '문자 리터럴'이라고 한다. 두 문장 이상은 큰 따옴표로 감싸야하며 '문자열 리터럴’이라고함

**9. 두 변수의 값 바꾸기**

**10. 기본형과 참조형**

**11. 기본형의 종류와 범위**

① boolean은 true와 false 두 가지 값만 표현할 수

있으면 되므로 가장 작은 크기인 1byte입니다.

② char은 Java에서 2byte 문자체계인 유니코드를

사용하고 있으므로 2byte입니다.

③ 기본형 int(4byte)를 기준으로

짧으면 short(2byte), 길면 long(8byte)입니다.

④ flaot(4byte)의 두 배(double)인

double은 8byte입니다.

⑤ byte < short = char < int < long < float < double

12. printf( )를 이용한 출력

이전에 배운 print()나 println()은

변수의 값을 그대로 출력하는 반면,

printf()의 경우, 지시자(specifier)를 통해

변수의 값을 여러 가지 형식으로

변환하여 출력합니다.

자주 사용하는 지시자

① %d : 정수의 형식(10진수)으로 출력

② %x : 정수의 형식(16수)으로 출력

③ %f : 실수의 형식으로 출력

④ %c : 문자(character)로 출력

⑤ %s : 문자열(string)으로 출력

⑥ %n : 줄바꿈

**13. printf()를 이용한 출력(예제)**

//예제2-4/ch2/PrintfEx1.java
ublic class PrintfEx1 {
public static void main(String[] args) {
byte b = 1;
short s = 2;
char c = 'A';

    int finger = 10;
    long big = 100_000_000_000L; //long big = 100000000000
    long hex = 0xFFFF_FFFF_FFFF_FFFFL;

    int octNum = 010;
    int hexNum = 0x10;
    int binNum = 0b10;

    System.out.printf("b = %d%n", b); // b = 1
    System.out.printf("s = %d%n", s); // s = 2
    System.out.printf("c = %c, %d %n", c, (int)c); // c = A, 65   %d가 왜 65가 나왔냐? 영문 대문자 'A'는 숫자 65를 뜻함
    System.out.printf("finger = [%5d]%n", finger); // finger = [   10]
    System.out.printf("finger = [%4d]%n", finger);//finger = [  10]
    System.out.printf("finger = [%3d]%n", finger);//finger = [ 10]
    System.out.printf("finger = [%d]%n", finger);// finger = [10]
    System.out.printf("finger = [%-5d]%n", finger);// finger = [10   ]
    System.out.printf("finger = [%05d]%n", finger); // finger = [00010]

    System.out.printf("big = %d%n", big);// big = 100000000000
    System.out.printf("hex = %x %n", hex); // hex = ffffffffffffffff    %x는 16진정수의 형식으로 출력
    System.out.printf("hex = %#x %n", hex);// hex = 0xffffffffffffffff  %x는 16진정수의 형식으로 출력 // #은 접두사 0x가 붙는다
    System.out.printf("hex = %#X %n", hex);// hex = 0XFFFFFFFFFFFFFFFF  %X는 16진정수의 형식으로 출력(대문자로출력)

    System.out.printf("octNum = %o, %d%n",octNum, octNum);// octNum = 10, 8    %o는 8진정수의 형식으로 출력 // 8진수 10, 10진수 8
    System.out.printf("hexNum = %x, %d%n", hexNum, hexNum);// hexNum = 10, 16
    System.out.printf("binNum = %s, %d%n", Integer.toBinaryString(binNum), binNum);// binNum = 10, 2
    //10진수를 2진수로 출력해주는 지시자는 없어 정수를 2진 문자열로 변환해주는 Integer.toBinaryString(int i)를 사용하고 이 메서드는 정수를
    //2진수로 변환해서 문자열로 반환하므로 지시자 %s를 사용함.
}

}

*//예제2-5/ch2/PrintEx2.java*

**public** **class** PrintfEx2 {

**public** **static** **void** main(String[] args) {

String url = "www.codechobo.com";

**float** f1 = .10f;

**float** f2 = 1e1f;

**float** f3 = 3.14e3f;

**double** d = 1.23456789;

System.out.printf("f1 = %f, %e, %g%n", f1, f2, f3);

System.out.printf("f2 = %f, %e, %g%n", f2, f2, f2);

System.out.printf("f3 = %f, %e, %g%n", f3, f3, f3);

System.out.printf("d = %f%n", d);

System.out.printf("d = %14.10f%n", d); *//전체 14자리 중 소수점 10자리*

System.out.printf("[12345678901234567890]%n");

System.out.printf("[%s]%n", url);

System.out.printf("[%20s]%n", url);

System.out.printf("[%-20s]%n", url);*//왼쪽 정렬*

System.out.printf("[%.8s]%n", url);*// 왼쪽에서 8글자만 출력*

}

}

14. 화면으로부터 입력받기

(1) Scanner란?

"화면으로부터 데이터를 입력받는

기능을 제공하는 클래스"

(2) Scanner를 사용하는 방법

① import문 추가

import java.util.Scanner;

(단축키 Shift + Ctrl + O)

*import java.util.*;  //Scanner클래스를 사용하기 위해 추가*

② Scanner 객체 생성

Scanner sc = new Scanner(System.in);

*Scanner scanner = new Scanner(System.in);  // Scanner클래스의 객체를 생성*

③ Scanner 객체 사용

• int n1 = sc.nextInt();

(화면에서 입력받은 정수를 n1에 저장)

• float f1 = sc.nextFloat();

(화면에서 입력받은 실수를 f1에 저장)

• String str = sc → 줄(행) 단위 .nextLine();
  

String str = sc.next(); → 띄어쓰기 단위

(화면에서 입력받은 내용을 str에 저장)

↓

int n1 = Integer.parseInt(str);

문자열(str)을 숫자(n1)으로 변환

String input = scanner.nextLine(); // 입력받은 내용을 input에 저장

int num = Integer.parseInt(input); // 입력받은 내용을 int 타입의 값으로 반환

*//예제 2-6/ch2/ScannerEx.java*

**import** java.util.*; *//Scanner를 사용하기 위해 추가*

**public** **class** ScannerEx {

**public** **static** **void** main(String[] args) {

Scanner scanner = **new** Scanner(System.in); *// Scanner클래스의 객체를 생성*

System.out.print("두자리 정수를 입력하세요 : ");

String input = scanner.nextLine(); *// 입력받은 내용을 input에 저장*

**int** num = Integer.parseInt(input); *//입력받은 문자열을 숫자로 변환*

*//입력받은 문자열을 숫자(int타입의 정수)로 변환하려면,Interger.parseInt() 메서드를 이용*

System.out.println("입력내용 :" + input);

System.out.printf("num = %d%n", num);

}

}

15. 정수형의 오버플로우

오버플로우

"타입이 표현할 수 있는 범위를 넘어서는 것"

최댓값 + 1 → 최솟값

최댓값 + 1 → 최댓값

16. 부호있는 정수형의 오버플로우

부호가 없는 정수는 2진수로 '0000'이 될 때 오버플로우가 발생하고, 부호가 있는 정수는 부호 비트가 0에서 1이 될 때 오버플로우가 발생한다.

(1) 부호가 없는 정수

ex) 4bit

최댓값 : 1111 (15)

최솟값 : 0000 (0)

(2) 부호가 있는 정수

ex) 4bit

최댓값 : 0111 (7)

최솟값 : 1111 (-8)

//예제2-9/ch2/OverflowEx.java

public class OverflowEx {

public static void main(String[] args) {

short sMin = -32768;

short sMax = 32767;

char cMin = 0;

char cMax = 65535;

System.out.println("sMin = " + sMin);

System.out.println("sMin-1" + (short)(sMin-1));

System.out.println("sMax = " + sMax);

System.out.println("sMax+1" + (short)(sMax+1));

System.out.println("cMin = " + (int)cMin);

System.out.println("cMin-1 = " + (int)cMax);

System.out.println("cMax = " + (int)cMax);

System.out.println("cMax+1= " + (int)++cMax);

}

}

sMin = -32768

sMin-1 = 32767

sMax = 32767

sMax+1 = -32768

cMin = 0

cMin-1 = 65535

cMax = 65535

cMax+1 = 0

17. 타입 간의 변환방법

형변환(Casting)

"값의 타입을 다른 타입으로 변환하는 것"

변수 또는 상수(리터럴)의 타입을 다른 타입으로 변환하는 것

형 변환의 방법은 아주 간단한데, 형 변환하고자 하는 변수나 리터럴 앞에 타입을 괄호와 함께 붙여주면 된다.

// 형 변환 방법 : 타입(피연산자) double d = 85.4; int score = (int)d; // double타입의 변수 d를 int타입으로 변환

//예제2-12/ch2/CastingEx1.java

public class CastingEx1 {

public static void main(String[] args) {

double d = 85.4;

int score = (int)d;

System.out.println("score = " + score); //결과 : score = 85

System.out.println("d = " +d); // 결과 : d = 85.4

}

}

기본형(primitive typte)에서 boolean을 제외한 나머지 타입들은 서로 형 변환이 가능하다.

@ float타입의 값을 int타입으로 변환할 때 소수점 이하의 값은 반올림이 아닌 버림 처리가 된다.@

큰 타입에서 작은 타입으로 변환할 때는 타입의 크기가 작아지기 때문에 크기의 차이만큼 값이 잘려나간다.그래서 경우에 따라 값 손실이 발생

**자동 형 변환**

범위가 큰 타입간의 대입이나 연산을 할 때, 형 변환으로 타입을 일치시키는 것이 원칙의성을 위해 형 변환을 생략할 수 있다.

`double d = 1234;	// 에러 X, double d = (float)1234; 와 동일
byte b = 1000;		// 에러 O, 1000은 byte 범위(-128~127)을 넘어감`

byte 예시의 에러를 해결하려면 처음 배운 명시적 형 변환으로 선언-값손실이 있어도 에러발생 x

연산 시에도 자동 형 변환이 이루어지는데, 연산되는 두 타입 중 더 넓은(큰) 타입으로 형 변환하여 타입을 일치시킨 후 연산

`int a = 10;
double b = 1.1 + a;		// 형변환을 하지 않아도 더 큰 타입인 double형으로 연산되어 반환`

정수형 간의 형 변환

큰 타입에서 작은 타입으로의 변환에서는 값 손실이 발생할 수 있다.

//예제2-13/ch2/CastingEx2.java

**public** **static** **void** main(String[] args) {

**int** i = 10;

**byte** b = (**byte**)i;

System.out.printf("[int -> byte] i=%d -> b=%d%n", i, b);

i = 300;

b = (**byte**)i;

System.out.printf("[int -> byte] i=%d -> b=%d%n", i, b);

b = 10;

i = (**int**)b;

System.out.printf("[byte -> int] b=%d -> i=%d%n", b, i);

b = -2;

i = (**int**)b;

System.out.printf("[byte -> int] b=%d -> i=%d%n", b, i);

System.out.println("i = " + Integer.toBinaryString(i));

}

}

*//결과*

*//[int -> byte] i=10 -> b=10*

*//[int -> byte] i=300 -> b=44*

*//[byte -> int] b=10 -> i=10*

*//[byte -> int] b=-2 -> i=-2*

*//i = 11111111111111111111111111111110*

실수형 간의 형 변환

실수형에서도 정수형처럼 작은 타입에서  큰 타입으로 변환하는 경우, 빈 공간을 0으로 채운다. float타입의 값을 double으로 변환하는

경우, 지수(E)는 float의 기저인 127을 뺀 후 double 기저인 1023을 더해서 변환하고, 가수(M)는 float의 가수 23자리를 채우고 남은

자리를 0으로 채운다.

Copy
//예제2-14/ch2/CastingEx3.java
publicclass CastingEx3 {

publicstaticvoid main(String[] args) {

float f = 9.1234567f;

double d = 9.1234567;

double d2 = (double)f;

        System.out.printf("f = %20.18f\n", f);

        System.out.printf("d = %20.18f\n", d);

        System.out.printf("d2 = %20.18f\n", d2);

    }

}

//결과
// f = 9.123456954956055000
// d = 9.123456700000000000
// d2 = 9.123456954956055000

기존의 값을 최대한 보존할 수 있는 타입으로 자동 형 변환한다.

1. boolean을 제외한 나머지 7개의

기본형은 서로 형 변환이 가능하다.

2. 기본형과 참조형은 서로 형 변환할 수 없다.

3. 서로 다른 타입의 변수간에 연산은 형 변환을 하는 것이 원칙이지만, 값의 범위가 작은 타입에서 큰 타입으로의 형 변환은 생략할 수 있다.