CH02. 변수, 연산자, 조건문

[ CH02. 변수, 연산자, 조건문 ]

 

1. 자바 프로그램의 기본 구조

 

• 클래스
  - class 키워드로 클래스 선언- 클래스 코드는 {} 내에 모두 작성
• 주석문
  - // 한 라인 주석
  - /* 여러 행 주석 */
• main() 메서드
  - main()에서 실행 시작
  - public static void로 선언
  - String[] args로 실행 인자를 전달 받음
• 변수 선언
  - 변수 타입과 변수 이름 선언
  - 메서드 내에서 선언된 변수는 지역 변수 -> 메소드 실행 끝나면 자동 소멸
• 문장
  - ;로 한 문장의 끝을 인식
• 화면 출력
  - 표준 출력 스트림 System.out의 println() 메소드 호출
  - println()
     - 여러 타입의 데이터 출력
     - 출력 후 다음 행으로 커서 이동

---

2. 식별자(identifier)

• 정의
  - 클래스, 변수, 상수, 메소드 등에 붙이는 이름
• 원칙
  - 사용 가능 O
     - '_', '$'
     - 유니코드 문자, 한글
     - 숫자
  - 사용 불가능 X
     - 특수문자, 공백, 탭
     - 자바 언어 키워드(예약어)
     - 식별자의 첫 번째 문자에 숫자
     - 불린 리터럴(true, false)
     - 널 리터럴(null)
  - 길이 제한 없음
  - 대소문자 구별
• 언어 관습
  - 가독성 높은 이름(목적의 분명성)
  - 클래스 이름
     - 첫 번째 문자는 대문자로 시작 
     - 각 단어의 첫 번째 문자만 대문자
  - 변수, 메서드 이름
     - 첫 단어 이후 각 단어의 첫 번째 문자는 대문자로 시작
  - 상수 이름
     - 모든 문자를 대문자로 표시
     - 여러 단어로 이루어진 경우 => '_'로 구분

// 클래스 이름
public class HelloWorld{}
class AutoVendingMachine{}

// 변수, 메소드 이름
int myAge;
boolean IsSingle;
public int getAge() {}

// 상수 이름
final static double PI = 3.141592;

---

3. 데이터 타입

3.1 기본형(Primitive type)

• boolean, char, byte, short, int, long, float, double (8개)
• 실제 값을 저장
• 타입의 크기가 정해져 있음
  - cpu나 운영체제에 따라 변하지 않음

 

3.2 레퍼런스 타입(Reference type)

• 기본형을 제외한 나머지 (ex. String, System 등)
  - 배열(array)에 대한 레퍼런스
  - 클래스(class)에 대한 레퍼런스
  - 인터페이스(interface)에 대한 레퍼런스
• 객체의 주소를 저장(4 byte)

---

4. 변수

• 정의
  - 프로그램 실행 중에 값을 임시 저장하기 위한 공간
     - 프로그램 수행 중 변경 가능
  - 데이터 타입에서 정한 크기의 메모리 할당
• 변수 선언
  - 변수의 타입 옆에 변수 이름을 적어 변수 선언

// 변수 선언
int radius;
char c1, c2, c3; // 3 개의 변수를 한 번에 선언한다.

• 변수 초기화
  - 변수에 처음으로 값 저장
  - 지역변수는 사용되기 전에 반드시 초기화해야 함
  - 지역변수가 아닌 변수는 보통 각 타입의 기본값으로 자동 초기화됨

// 변수 초기화
int radius = 10;
char c1 = 'a', c2 = 'b', c3 = 'c';
double weight = 75.56;

• 변수 읽기와 저장
  - 대입 연산자 = 다음에 식

radius = 10 * 5;
c1 = 'r';
weight = weight + 5.0;

---

5. 리터럴

• 정의
  - 프로그램에서 직접 표현한 값
  - 정수, 실수, 문자, 논리, 문자열 리터럴

5.1 기본형의 리터럴

• 정수 리터럴
  - 10진수, 8진수, 16진수, 2진수 리터럴
  - int형으로 컴파일
  - long 타입 리터럴은 숫자 뒤에 L 또는 l을 붙여 표시
     ex) long g = 24L;

• 실수 리터럴
  - 소수점 형태나 지수 형태로 표현한 실수
     ex) 12. 12.0 .1234 0.1234 1234E-4
  - 실수 타입 리터럴은 double 타입으로 컴파일
  - 숫자 뒤에 f(float)나 d(double)을 명시적으로 붙이기도 함

// 실수 타입 리터럴 -> double 타입으로 컴파일
double d = 0.1234;
double e = 1234E-4; // 1234E-4 = 1234x10-4이므로 0.1234와 동일

// 숫자 뒤 f, d
float f = 0.1234f;
double w = .1234D; // .1234D와 .1234는 동일

• 문자 리터럴
  - 단 하나의 문자
  - 단일 인용부호('')로 문자 표현
  - 반드시 하나의 문자가 있어야 함
  - \u다음 4자리 15진수(2바이트의 유니코드)로 표현
  - 특수문자 리터럴은 백 슬래시(\)를 이용해 표현

char a = 'A';
char b = '글';
char c = '';	 // ERROR: 빈 문자 X
char d = ' ';	 // OK: 공백문자로 변수 초기화 가능
char e = \u0041; // 문자 'A'의 유니코드 값(0041) 사용
char f = \uae00; // 문자 '글'의 유니코드 값(ae00) 사용

 

• 논리 리터럴
  - true, false

boolean a = true;
boolean b = 10 > 0; // 10>0가 참이므로 b 값은 true
boolean c = 1;     // 타입 불일치 오류. C/C++와 달리 자바에서 1,0을 참, 거짓으로 사용 불가

while(true) {     // 무한 루프. while(1)로 사용하면 안 됨
...
}

5.2 기본형 이외의 리터럴

• null 리터럴
  - 레퍼런스에 대입 사용

int n = null;	   // ERROR: 기본 타입에 사용 불가
String str = null; // OK

• 문자열 리터럴(스트링 리터럴)
  - 이중 인용부호("")로 묶어 표현
     ex) "good", "3.19", "a"
  - String 객체로 자동 처리
     - new를 사용하여 String 객체를 직접 생성해도 됨
  - 빈 문자열 저장 가능
  - 피연산자 중 어느 한쪽이 문자열 -> 나머지 한쪽도 문자열로 변환한 다음 두 문자열 결합
     - 문자열이 섞인 + 연산 => 문자열 연결

String name = new String("Java") // new 연산자를 이용한 String 객체 생성

String toolName = "JDK";	// 문자열 리터럴

// 문자열이 섞인 + 연산
toolName + 1.8          	 // "JDK1.8"
"(" + 3 + "," + 5 + ")"  	// "(3,5)"
true + ""			// "true"

String str2 = "";		// 빈 문자열 가능

※ '_' 허용
- 가독성을 위해 사용
- 숫자 리털럴의 아무 위치에나 언더스코어('_') 허용
   - 컴파일러는 리터럴에서 '_'를 빼고 처리

// 허용O
int price = 20_100; 				// 20100과 동일
long cardNumber = 1234_5678_1357_9998L; 	// 1234567813579998L와 같음
long controlBits = 0b10110100_01011011_10110011_111110000;
long maxLong = 0x7fff_ffff_ffff_ffffL;
int age = 2______5; 				// 25와 동일

// 허용X
int x = 15_; 		// 오류. 리터럴 끝에 사용할 수 없다.
double pi = 3_.14; 		// 오류. 소수점(.) 앞뒤에 사용할 수 없다.
long idNum = 981231_1234567_L; // 오류. _L(_F) 앞에 사용할 수 없다.
int y = 0_x15; 		// 오류. 0x 중간이나 끝에 사용할 수 없다. 0x_15(오류)​

※ var
- Java 10 부터 도입
- 지역 변수의 선언에서만 사용 가능
- 변수 타입 선언 생략(컴파일러가 변수 타입 추론)
- 변수 선언문에 반드시 초깃값 지정해야 함

var price = 200; 		// price는 int 타입으로 결정
var name = "kitae"; 		// name은 String 타입으로 결정
var pi = 3.14; 		// pi는 double 타입으로 결정
var point = new Point(); 	// point는 Point 타입으로 결정(4장 참조)
var v = new Vector<Integer>(); 	// v는 Vector<integer> 타입으로 결정(7장 참조)

---

6. 상수

• final 키워드 사용
• 한 번만 값을 저장할 수 있는 공간
• 선언 시 초기값 지정
• 실행 중 변경 불가

---

7. 타입 변환

• boolean을 제외한 나머지 7개의 기본형은 서로 형 변환 가능
• 기본형과 참조형 서로 형변환 X

7.1 자동 타입 변환

• 작은 타입은 큰 타입으로 자동 변환 by 컴파일러
• 치환문(=)이나 수식 내에서 타입이 일치하지 않을 때 변환 발생

7.2 강제 타입 변환

• 큰 타입이 작은 타입으로 변환할 때 자동으로 타입 변환이 안되므로 강제로 타입 변환 지시
  - () 안에 변환할 타입 지정
• 값 손실 우려

---

8. 형식화된 출력 : printf()

• 지시자를 통해 변수의 값을 여러 가지 형식으로 변환하여 출력
• 출력 후 줄바꿈 X -> 줄바꿈 하려면, 지시자 '%n' 또는 '\n'을 사용 

지시자	설명
%b	불리언(boolean) 형식으로 출력
%d	10진(decimal) 정수 형식으로 출력
%o	8진(octal) 정수 형식으로 출력
%x, %X	16진(hexa-decimal) 정수 형식으로 출력
%f	부동 소수점(floating-point)의 형식으로 출력
%e, %E	지수(exponent) 표현식의 형식으로 출력
%c	문자(character)로 출력
%s	문자열(string)로 출력

 

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 hex = 0xFFFF_FFFF_FFFF_FFFFL ;  	// long hex = 0xFFFFFFFFFFFFFFFFL;

		int octNum = 010;       			//  8진수 10, 10진수로는 8
		int hexNum = 0x10;      			// 16진수 10, 10진수로는 16
		int binNum = 0b10;      			//  2진수 10, 10진수로는 2

		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
		System.out.printf("finger=[%5d]%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); 	// '#'은 접두사(16진수 0x, 8진수 0) 
        						// hex=0xffffffffffffffff
		System.out.printf("octNum=%o, %d%n", octNum, octNum);	// octNum=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
		
	}
}

class PrintfEx2 {
	public static void main(String[] args) {
		String url = "www.codechobo.com";

		float f1 = .10f;   // 0.10, 1.0e-1
		float f2 = 1e1f;   // 10.0, 1.0e1, 1.0e+1
		float f3 = 3.14e3f;
		double d = 1.23456789;
        
		// f1=0.100000, 1.000000e-01, 0.100000
		System.out.printf("f1=%f, %e, %g%n", f1, f1, f1); 
		// f2=10.000000, 1.000000e+01, 10.0000
		System.out.printf("f2=%f, %e, %g%n", f2, f2, f2); 
		// f3=3140.000000, 3.140000e+03, 3140.00
		System.out.printf("f3=%f, %e, %g%n", f3, f3, f3); 
        
		System.out.printf("d=%f%n", d);		// d=1.234568
		System.out.printf("d=%14.10f%n", d); 	// 전체 14자리 중 소수점 10자리
        						// d=  1.2345678900

		System.out.printf("[12345678901234567890]%n");	// [12345678901234567890]
		System.out.printf("[%s]%n", url);		// [www.codechobo.com]
		System.out.printf("[%20s]%n", url);		// [   www.codechobo.com]

		System.out.printf("[%-20s]%n", url); // 오른쪽 정렬 // [www.codechobo.com   ]
		System.out.printf("[%.8s]%n", url);  // 왼쪽에서 8글자만 출력 // [www.code]
     }
}

---

9. 키 입력

• System.in
  - 키보드로부터 읽는 자바의 표준 입력 스트림
  - 키 값을 바이트(문자 X)로 리턴
  - 바이트 데이터로 리턴되므로 응용프로그램을 통해 문자로 변환해야 함
• Scanner 클래스
  - System.in에게 키를 읽게 하고, 읽은 바이트를 문자, 정수, 실수, 불린, 문자열 등 다양한 타입으로 변환하여 리턴
  - 입력되는 키 값을 공백('\t', '\f', '\n', ' ', '\r')으로 구분되는 아이템 단위로 읽음

import java.util.Scanner; // import 문 필요
Scanner scanner = new Scanner(System.in); // Scanner 객체 생성

String name = scanner.next(); 	// "Kim"
String city = scanner.next(); 	// "Seoul"
int age = scanner.nextInt(); 	// 20
double weight = scanner.nextDouble(); // 65.1
boolean single = scanner.nextBoolean(); // true

 

---

10. 연산자

 

• 산술 연산
  - 더하기(+), 빼기(-), 곱하기(*), 나누기(/), 나머지(%)
• 증감 연산
  - 1 증가(++) 혹은 감소(--) 시키는 연산

• 대입 연산
  - 연산의 오른쪽 결과는 왼쪽 변수에 대입

• 비교 연산
  - 두 피연산자를 비교하여 true 또는 false의 논리 값을 내는 연산

• 논리 연산
  - NOT(~), OR(||), AND(&&), XOR(^)으로 논리 값을 내는 연산

• 조건 연산자
  - condition? opr2 : opr3
  - 3개의 피연산자로 구성된 삼항 연산자
  - condition이 true이면, 연산식의 결과는 opr2, false이면 opr3
  - if-else을 간결하게 표현 가능

• 비트 논리 연산
  - 비트끼리 AND, OR, XOR, NOT 연산

• 비트 시프트 연산
  - 비트를 오른쪽이나 왼쪽으로 이동
  - x << n은 x * 2^n의 결과와 같음
  - x >> n은 x / 2^n의 결과와 같음
  
  

• 이항 연산자의 특징
  - 이항 연산자는 연산 수행 전에 피연산자의 타입 일치시킴
  - int보다 크기가 작은 타입은 int로 변환 (byte, char, short → int)
  - 피연산자 중 표현 범위가 큰 타입으로 형 변환 

• 연산자 우선순위
  - 괄호의 우선순위가 제일 높음
  - 산술 > 비교 > 논리 > 대입
  - 단항 > 이항 > 삼항
  - 연산자의 연산 진행 방향 : → 
    단항, 대임 연산자 진행 방향 : ←

 

---

11. 조건문

11.1 if문

• 단순 if문
  - if의 조건식이 true일 경우 실행 문장을 실행
  - if의 괄호 안에 조건식은 논리형 변수나 논리 연산, 비교 연산자
  - 실행 문장이 단일 문장인 경우 둘러싸는 {} 생략 가능
  
  

• 다중 if-else문
  - if문의 조건식을 만족하지 못할 때, 아래 else if문 또는 else문으로 가서 조건을 만족하는지 확인
  - if-else가 연속되는 형태

package day02;

import java.util.Scanner;

public class NestedIf {

	public static void main(String[] args) {

	Scanner scanner = new Scanner(System.in);
	
	System.out.print("점수를 입력하세요(0~100): ");
	int score = scanner.nextInt();
	
	System.out.print("학년을 입력하세요(1~4): ");
	int year = scanner.nextInt();
	
	if(score >= 60) {
		if(year != 4)
			System.out.println("합격!");
		else if(score >= 70)
			System.out.println("합격!");
		else
			System.out.println("불합격!");
	}
	else
		System.out.println("불합격!");
	
	scanner.close();
	}

}

• 중첩 if문
  - if문 안에 또 다른 if문 중첩
  - 중첩 횟수 제한 X

11.2 switch문

• 개념
  - 식과 case문의 값과 비교
  - break를 만나면 switch문에서 벗어남
  - case의 비교 값과 일치하는 것이 없으면, default문 실행
  - case문에 break문이 없다면, 다음 case문으로 실행하며, break문 만날 때까지 계속 내려가면서 실행
  - default문 생략 가능

• case 문의 값
  - 문자, 정수, 문자열 리터럴만 허용
  - 실수 리터럴, 변수는 허용 X

---

[ 참조 ]

1. Java의 정석 3판 (지은이 : 남궁성)

2. 명품 JAVA Programming 개정 3판 (지은이 : 황기태, 김효수)