[자바기초] 자바의 기초 문법 총정리
식별자, 키워드, 예약어
식별자(identifier)
[ 정의 ]
클래스, 변수, 상수, 메소드 등에 붙이는 이름
[ 원칙 ]
• 불가능: 특수문자(@, #, ! 등), 공백, 탭, 예약어(키워드), 논리리터럴(null, true), 널리터럴(false)
• 가능: 한글, 유니코드(2byte)
• 첫문자에 : 숫자불가능, 일부 기호(_, $) 가능하지만 잘 안씀
• 길이제한 없음
• 대소문자 구별
[ 예시 ]
//가능
int name;
char student_ID; // '_' 사용 가능
void $func() { } // '$' 사용 가능
class Monster3 { } // 숫자 사용 가능
int Java공부하기가가점점어려워짐; // 길이 제한 없음
int barChart; int barchart; // 대소문자 구분. barChart와 barchart는 다름
int 가격; // 한글 이름 사용 가능
//불가능
int 3Chapter; // 식별자의 첫문자로 숫자 사용 불가
class if { }; // 자바의 예약어 if 사용 불가
char false; // false 사용 불가
void null() { } // null 사용 불가
class %calc { } // '%'는 특수문자
키워드와 예약어
자바에서
키워드(Keyword)와예약어(Reserved Word)는 종종 같은 의미로 사용되는데, 엄밀히 따지면 약간 차이가 있다
[ 키워드 vs 예약어 ]
| 비교 | 키워드 | 예약어 |
|---|---|---|
| 정의 | 특정 기능을 수행하는 자바의 필수적인 단어 | 자바에서 미리 정의된 단어 |
| 변수/클래스/메서드명으로 사용 | 불가능 | 불가능 |
| 사용 | 모두 현재 사용 | 사용되고 있지 않은(미래에 사용될 수 있는) 단어도 존재 |
| 예시 | class, public 등 |
키워드, goto, const 등 사용되지 않는 단어 |
즉, 키워드는
프로그래밍에 실제 사용되는 단어이고, 예약어는단순히 예약된 단어 (키워드 + 현재 사용되지 않지만 미래를 위해 예약된 단어)를 의미한다
[ 키워드(예약어)의 종류 ]
| 구분 | 키워드(예약어) |
|---|---|
| 자료형 | byte, short, int, long,float, double, char, boolean, void |
| 제어문 | if, else, switch, case, default, while, do, for, break, continue, return |
| 접근제어자 | publice, private, protected, default(예약어X) |
| 클래스 및 객체 | class, interface, extends, implements, new, this, super, abstract, final, static, synchronized , this, volatile |
| 예외 처리 | try, catch, finally, throw, throws |
| 패키지/임포트 | package, import |
| 예약어 | instanceof, enum, native, strictfp, transient, assert |
| 리터럴(예약어X) | true, false,null |
| 사용X | const, goto |
리터럴 예약어는 아니지만 예약어처럼 동작한다
식(Expression)과 문장(Statement), 주석처리하기
식과 문장
[ 식 ]
• 값을 생성하는 코드 • 변수를 포함한 연산자, 메서드 호출 등을 의미
• 항상 값으로 평가됨
[ 문장 ]
• 하나의 완전한 실행(명령)의 단위
• 세미콜론(;)으로 끝남
• 선언문, 실행문, 제어문 등이 포함됨
| 문장의 종류 | 설명 | 예시 |
|---|---|---|
| 선언문 | 변수선언 | int x; |
| 대입문 | 변수에 값 할당 | x = 10; |
| 제어문 | 흐름 제어 (if, for, while) |
if (x > 0) {} |
| 메서드 호출문 | 메서드 실행 | System.out.println(x); |
| 반환문 | 메서드 결과 반환 | return x; |
자바 주석처리
[ 한 줄 주석 ]
// 안녕 나는 주석이야
[ 여러 줄 주석 ]
/*
안녕 나는
여러 줄 주석이야!
*/
자료형, 형변환
자료형
[ 정의 ]
자료형(Data Type)은변수에 저장할 수 있는 값의 종류를 정의하며, 크게 기본 자료형(Primitive Type)과 참조 자료형(Reference Type)으로 나뉜다
| 구분 | 기본자료형 | 참조자료형 |
|---|---|---|
| 저장방식 | 값 자체를 저장 | 객체의 주소값 저장 |
| 크기 | 고정 크기 | 동적 크기 가능 |
| 메모리 저장영역 | 스택(stack) | 힙(heap) |
| 기본값 | 0, false 등 |
null |
[ 종류 ]
1) 기본자료형(Primitive Data type)
자바에서 직접 값을 저장하는 데이터 타입
| 자료형 구분 | 종류 |
|---|---|
| 정수형(integer) | byte: 1byte, default 0, -128 ~ 127 ($-2^7 ~ 2^7 -1$)short: 2byte, default 0, -32,768 ~ 32,767 ($-2^15 ~ 2^15 -1$int: 4byte, default 0, -2^31 ~ 2^31 - 1 long: 8byte, default 0L, -2^64 ~ 2^63 - 1 |
| 실수형(real) | float: 4byte, default 0.0f, NaNdouble: 8byte, default 0.0d, 배정밀도(유효숫자의 개수가 두배), 기본타입, NaN |
| 문자형 | char: 2byte, default \u0000, 아스키 or 16비트 유니코드 문자 (0~65535) |
| 불리언형 | boolean: 1byte, default false, true, false, 숫자가 아님 |
• NaN: not a number, 계산 불가능한 결과를 나타낼 때 사용
• 숫자가 아님, 두가지 가능한 값(literal)만 있음 > true, false
• 숫자형(number): 정수형 + 실수형
• 논리형(boolean type, 부울형)
2) 참조자료형(Reference Data type)
객체의 주소값을 저장하는 타입
• 포인터 없이 객체의 참조(references:= 객체 데이터를 가리키는 자료형) 사용
• similar to pointers
• 프로그래머가 주소계산(+, -)을 직접할 수는 없음
• 종류: 클래스, 배열, 인터페이스
(1) 배열 (array): 같은 타입의 데이터를 연속적(메모리상 연속된 공간에)으로 저장하는 자료구조
• 한 번 크기를 정하면 변경할 수 없음
• 기본형의 배열에는 각 칸에 값/숫자가, 참조형의 배열에는 참조가 들어있음
• 배열 사용하기
/* 배열 선언 후 초기화 */
// 배열 선언하기
int[] numbers; // 권장
int numbers2[]; // 비권장, 하지만 가능
// 배열 초기화(Initialization) > 할당(allocation)
numbers = new int[5]; // java default값을 초기값으로 지정
/* 배열 선언과 초기화를 동시에 */
// 방법 1: 배열 리터럴 사용
int[] numbers = {1, 2, 3, 4, 5}; // 명시적으로 초기화(할당)
// 방법 2: new 연산자 사용
int[] numbers2 = new int[]{10, 20, 30};
// 방법 3: 개별 값 할당
int[] numbers3 = new int[3];
numbers3[0] = 100;
numbers3[1] = 200;
numbers3[2] = 300;
// 객체 배열
Car theCars[] = new Car[3];
String names[] = new String[40];
names[0] = "애마";
System.out.print (names[0] +”!”);
names[1] = "애첩";
names[2] = "애기";
theCars[1] = new Car(“골프”);
theCars[0] = new Car(“프라이드”);
theCars[1].info();
theCars[0].info();
public class ArrayWork {
public static void main(String[] a) {
new ArrayWork();
}
ArrayWork() {
String names[] = {"애마", "애첩", "애기"};
Car theCars[] = new Car[3]; // 배열객체 생성
theCars[0] = new Car("프라이드");
theCars[1] = new Car("골프");
theCars[2] = new Car("미니");
theCars[0].모델 = names[0]; // 애칭을 변경
for(int i = 0; i < theCars.length; i++)
theCars[i].move();
}
}
• 2차원 배열 사용하기
// 2차원 배열 선언 및 크기 지정
int[][] matrix = new int[3][3]; // 3x3 배열 (초기값: 0)
// 2차원 배열 초기화 (직접 할당)
int[][] matrix2 = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// 개별 요소 접근
matrix[0][0] = 10; // 첫 번째 행, 첫 번째 열 값 변경
• 3차원 배열 사용하기
int twoArray[][];
String threeArray[][][]; // 배열 객체 만들어짐, 크기는 모름
• twoArray = new int[5][8];
• twoArray = new int[5][];
• threeArray = new String[3][][]; // 세 학년 (크기 결정)
threeArray[0] = new String[10][]; // 1학년은 10개 반
threeArray[0][0] = new String[40]; // 1학년1학급은 40명
threeArray[0][0][0] = “홍길동”;
threeArray[0][0][1] = “이순신”;
threeArray[1] = new String[9][]; // 2학년은 9개 반
(2) 클래스(class): 사용자가 정의한 객체를 생성하는 데이터 타입
• 사용자가 직접 정의한 데이터 타입이자, 새롭고 복합적인 데이터 타입
• 프로그램: 클래스 정의들의 모음
• 프로그램 실행: 클래스 정의에 따라 객체를 생성하고, 서로 메시지를 주고받는 것 (메서드 호출)
class Car { //1. 클래스 정의: 새로운 참조 자료형의 선언
String name;
}
Car mycar; //2. 자료형의 변수 선언(어딘가) <-> C언어에서는 선언 + 객체생성
mycar = new Car(); // 3. 객체 생성 - in java
mycar.name = "붕붕이"; // 4. 문자열 객체(!=객체) 생성 및 할당
// 컴파일 시 문자열 객체 생성
// 객체 생성 및 배정(assignment)
// name = Car 유형 객체의 멤버 변수
(3) 인터페이스(interface): 다형성을 구현하기 위해 사용하는 참조형 타입
이름 정도만 있고 구체적인 내용/정의가 없는 클래스
• 여러 클래스의 공통된 기능/인터페이스를 표준화하는 방법(~요구 스펙)
public interface Runnable {
void run();
}
public interface Serializable { }
public interface Comparable { }
public class Thread implements Runnable {
Thread() { }
void start() { }
static void sleep(long ms) { }
void run() { }
...
}
(4) 문자열(string)
기본 자료형X, 문자의배열X, 문자들의 집합,
String클래스의 객체로 취급됨
• String 클래스로 문자열 표현, 즉 문자열을 표현하는 클래스
• 문자열 리터럴: “안녕”
• 내용 변경X: 자르고 늘일 수 없고, 필요하면 새로운 객체로 만들어야 함
• 연산:+연산자 = 스트링 접합/연결 -> 새 객체를 생성
• 비교:
👉==(참조변수의 값, 같은 객체인가, 같은 메모리 주소)
👉.equals()(두 객체의 내용이 같은가, 메모리 주소는 달라도 됨)
// str1 != arr
String str1 = "abcde"; // 문자열/스트링 객체
char arr[] = {'a', 'b', 'c', 'd', 'e'} // 문자 배열
// str1 != str2, str1.equals(str) == true
String str2 = new String(arr);
String msg1, msg2;
msg1 = "Hello";
msg2 = msg1 + "World!"; // msg2 = msg2 + "World!"
System.out.println ("Salute: " + msg2); // -> “Salute: HelloWorld!” - 제 3의 객체
String a = new String("abc");
String b = "abc";
String c = "abc";
if(a==b) {...} //false(a는 힙에, b는 문자열 풀에 > 주소다름)
if(a.equals(b)) {...} //true > 내용이 같으므로
if(b==c) {...} //true(둘 다 문자열 풀에 같은 주소 참조)
if(b.equals(c)) {...} //true > 내용이 같으므로
리터럴과 상수
[ Literal(리터럴) ]
value representation (값 자체의 표현)
int: 2, 0xA, 0b0110 // 0x 16진수, 0b 이진수
long: 2L
float: 3.14f
double: 2.0, 2.0E4 // = 2.0 * 10^4 = 20,000.0
char: ‘K’, ‘\n’, ‘\t’ // escape characters, - \u000a \u0009
boolean: true, false
String : "Man is mortal" // 글자를 모아 만든 객체 , !=배열
[ 상수 ]
선언
final 키워드 사용
• 변수 선언 시 초기값을 지정한다
• 실행 중 값 변경 불가
상수 선언 사례
final int LENGTH = 20;
static final double PI = 3.141592; // 변치 않는 수, static으로 선언하자
var 예약어, enum
[ var 예약어 ]
• Java 10부터 도입
• 자료형을 생략하고 변수 선언 가능(컴파일러가 추론하여 변수 타입 결정)
• 변수 선언 시 초기값이 주어지지 않으면 컴파일 오류
• 지역변수 선언에만 한정적으로 사용할 수 있음
int price = 200;
String name = "kitae";
[ enum(나열형) ]
• 유한한 종류/가짓수의, 일종의 상수형 자료를 새로 정의
• 식별자/identifier 처럼 보이기도 하고String (문자열)처럼 출력되기도 하지만 내부적으로 정수로 취급된다
• Defined at two levels
👉 class × interface level에서 정의: global
👉 변수/method 수준의 정의: member
enum Week {월, 화, 수, 목, 금, 토} // class level, no ‘;’
public class TestEnum {
enum RGB { red, green, blue } // class-internal
int year;
public static void main(-) {
Week today = Week.월;
RGB color = RGB.red;
System.out.println(“오늘은 ” + today + “요일”);
System.out.println(“단풍잎 색은 “ + color);
}
}
형변환
[ 형변환 ]
한 자료형의 값을 다른 형의 값으로 변환
자동형변환
• 컴파일러에 의해 원래의 자료형보다 큰 형식으로 자동 변환
• 치환문(=)이나 수식 내에서 형이 일치하지 않을 때
강제형변환
개발자의 의도적 형변환
• ‘(자료형)’ 형식으로 명시적으로 형변환을 지정한다
• 강제 변환은 값 손실 가능
long m = 25; // 25는 int 형 25가 long 형으로 자동 변환
double d = 3.14 * 10; // 실수 연산 위해 10이 10.0으로 자동 변환
byte b = (byte)n; // 손실
int n = 300;
byte b = n; //오류
byte b = (byte)n; //손실, 하지만 가능
double d = 1.9;
int n = (int)d; // n = 1, 강제형변환으로 소숫점 이하 0.9 손실
byte b = 127;
int i = 100;
System.out.println(b+i); // 227
System.out.println(10/4); // 2
System.out.println(10.0/4); // 2.5
System.out.println((char)0x12340041); // A
System.out.println((byte)(b+i)); // -29
System.out.println((int)2.9 + 1.8); // 3.8
System.out.println((int)(2.9 + 1.8)); //4
System.out.println((int)2.9 + (int)1.8); //3
[ 포장자(Wrapper) 클래스 ]
Primitive data type 데이터를 객체로 처리할 필요가 있을 때 객체로 만들어(‘포장해’) 줄 수 있는 클래스
• (참조형으로, 일종의 형변환 해주는 클래스)
| 래퍼클래스 | 역할 |
|---|---|
Byte |
for byte |
Short |
for short |
Integer |
for int |
Long |
for long |
Float |
for float |
Double |
for double |
Boolean |
for boolean |
Character |
for char |
Byte B = new Byte(127);
Integer y = new Integer(2015);
Byte B = Byte.valueOf((byte)127); // 권장
Integer y = Integer.valueOf(2015); // 권장
Byte B = 127; // 오토박싱 (자동 변환)
Integer y = 2015; // 오토박싱
//참고
int n = Integer.parseInt(“123”);
자바 변수의 유효범위
변수의 종류
자바의 변수는 선언된 위치에 따라 종류가 나뉘고, 이에 따라 유효범위(scope)도 결정됨(즉, 선언위치에 따라 = 유효범위에 따라)
참고 데이터 타입에 따라: 기본형 변수, 참조형 변수
| 변수 종류 | 설명 |
|---|---|
| Class Variables | 클래스 변수, static 변수로, 동종의 객체(클래스 전체)에서 공유(글로벌) |
| Instance Variables | 인스턴스 변수, 각 객체마다 개별적으로 존재하는 변수(로컬, 복사본처럼 따로 저장) |
| Local Variables | 지역 변수, 메서드나 블록 내에서 선언되어 그 범위 안에서만 유효한 변수(유효범위규칙) |
| Array Elements | 배열 요소, 배열의 각 인덱스에 저장된 값 |
| Method Arguments | 메서드 인자, 메서드 호출 시 전달되는 값 |
| Constructor Arguments | 생성자 인자, 생성자 호출 시 전달되는 값 |
| Exception Handler Arguments | 예외 처리 인자, 예외 처리 블록(catch)에서 전달받는 예외 객체 |
멤버변수class variables + instance variables
// 배열요소
num[0]
// 메서드인자
void greet(String name) {
// name은 method argument
}
// 생성자인자
public Car(String color) {
this.color = color; // color는 constructor argument
}
// 예외처리인자
try {
// 코드
} catch (Exception e) {
// e는 예외 처리 인자
}
//
[ 멤버 변수 (Member Variable) ]
• 클래스 내부에서 선언된 변수
• 객체(인스턴스) 변수 + 클래스(static) 변수를 포함하는 개념
• 클래스 내부에서 선언되지만, 메서드 내부에는 선언되지 않음
class Car {
String brand; // 멤버 변수 (인스턴스 변수)
static int wheels = 4; // 멤버 변수 (클래스 변수)
}
멤버 변수는 자동으로 기본값이 할당됨
(int→0,boolean→false,String→null)
[ 클래스 변수 (Static Variable) ]
• static 키워드가 붙은 변수
• 객체에 속하지 않고 클래스 자체에 속함
• 모든 객체가 공유하는 변수 (한 번만 메모리에 저장됨)
• 프로그램 실행 시 자동으로 메모리에 할당됨 (Method 영역에 저장됨)
class Student {
static int totalStudents = 0; // 클래스 변수 (공유됨)
Student() {
totalStudents++; // 모든 객체가 같은 변수를 공유
}
}
Student.totalStudents로 접근 가능 (객체를 생성하지 않아도 접근 가능)
[ 인스턴스 변수 (Instance Variable) ]
• new 키워드로 객체를 생성할 때 각 객체마다 별도로 할당되는 변수
• 클래스 내부에서 선언되지만, static이 붙지 않음
• 객체가 생성될 때 힙(Heap) 메모리에 저장됨
• 객체마다 값을 가질 수 있음 (각 객체마다 독립적)
class Person {
String name; // 인스턴스 변수 (객체마다 다름)
int age; // 인스턴스 변수
}
Person p1 = new Person();
p1.name = "Alice";
p1.age = 25;
Person p2 = new Person();
p2.name = "Bob";
p2.age = 30;
p1.name과p2.name은 서로 다른 변수! (객체마다 별도로 존재)
[ 지역 변수 (Local Variable) ]
• 메서드, 생성자, 또는 블록 {} 내부에서 선언된 변수
• 해당 블록이 실행될 때 생성되고, 블록이 종료되면 삭제됨 (스택에 저장)
• 반드시 초기화 후 사용해야 함 (자동 초기화 없음)
void myMethod() {
int localVar = 10; // 지역 변수 (이 블록에서만 사용 가능)
System.out.println(localVar);
}
localVar는myMethod()블록 안에서만 유효하고, 밖에서는 접근 불가
[ 매개 변수 (Parameter Variable) ]
• 메서드의 인자로 전달되는 변수
• 메서드가 호출될 때 생성되고, 호출이 끝나면 사라짐
• 메서드가 실행될 때 스택(Stack) 메모리에 저장됨
예제
void greet(String name) { // 매개변수 name
System.out.println("Hello, " + name);
}
greet("Alice")를 호출하면name = "Alice"가 됨. 메서드 실행 후 사라짐
유효범위를 확인해보자!
class ILoveJava{
static String name = "ILoveJava"; // class variable
String titles[] = new String[2]; // instance variables
// constructor(함수이름 = 클래스 이름)
ILoveJava(String iHave[]){ // constructor argument
int n = iHave.lenght(); // local variable
titles[1] = iHave[1]; // array element
print(titles[1]);
}
// 멤버함수 = method
void print(String str){ // method argument
try{
System.out.println("My title is" + str);
}catch(IOExepstion ex){ // exception handler argument
System.out.println(ex);
System.exit();
}
}
}
변수의 저장 위치 (메모리 영역)
자바 변수는 선언된 위치에 따라 메모리에서 다른 영역에 저장
| 변수 종류 | 저장 위치 | 생성 시점 | 소멸 시점 |
|---|---|---|---|
| 지역 변수 | 스택(Stack) | 메서드 실행 시 | 메서드 종료 시 |
| 매개 변수 | 스택(Stack) | 메서드 호출 시 | 메서드 종료 시 |
| 인스턴스 변수 | 힙(Heap) | 객체 생성 시 | 객체가 참조되지 않으면 GC에 의해 삭제 |
| 클래스 변수 (static) | 메서드(Method) 영역 | 프로그램 실행 시 | 프로그램 종료 시 |
자바 변수 구분 요약
| 변수 종류 | 선언 위치 | 저장 위치 | 소멸 시점 | 접근 방법 |
|---|---|---|---|---|
| 기본형 변수 | 어디서든 선언 가능 | 스택(Stack) | 블록 종료 시 | 직접 값 저장 |
| 참조 변수 | 어디서든 선언 가능 | 힙(Heap) 주소 저장 | GC 실행 시 | 객체 참조 |
| 멤버 변수 | 클래스 내부 | 힙(Heap) / 메서드 영역 | 객체 소멸 시 | 객체명.변수 |
| 클래스 변수 | static 붙은 변수 |
메서드(Method) 영역 | 프로그램 종료 시 | 클래스명.변수 |
| 인스턴스 변수 | static 없이 선언 |
힙(Heap) | 객체 소멸 시 | 객체명.변수 |
| 지역 변수 | 메서드 내부 | 스택(Stack) | 메서드 종료 시 | 직접 접근 가능 |
| 매개 변수 | 메서드의 인자 | 스택(Stack) | 메서드 종료 시 | 직접 접근 가능 |
자바의 연산자(Operators)
연산자의 종류
자바의 연산자는 기능에 따라 6가지 유형으로 나뉜다
참고피연산자의 개수에 따라 구분하기도 함
• unary operators (단항-):-1,++a,n--
• binary operators (이항-):1 + 2,p == q,a > b
• ternary operators (삼항-):a = YN ? 1 : 2
[ 산술 연산자 (Arithmetic Operators) ]
숫자에 대한 기본적인 계산을 수행하는 연산자
| 연산자 | 설명 | 예제 | 결과 |
|---|---|---|---|
+ |
덧셈 | 5 + 3 |
8 |
- |
뺄셈 | 5 - 3 |
2 |
* |
곱셈 | 5 * 3 |
15 |
/ |
나눗셈(몫) | 10 / 3 |
3(정수 나눗셈, 소수점 이하 버림) |
% |
나머지 | 10 % 3 |
1 |
[ 대입 연산자 (Assignment Operators) ]
변수에 값을 저장할 때 사용되는 연산자
| 연산자 | 설명 | 예제 | 결과 |
|---|---|---|---|
= |
값 할당 | x = 10; |
x가 10이 됨 |
+= |
더한 후 할당 | x += 5; |
x = x + 5 |
-= |
뺀 후 할당 | x -= 3; |
x = x - 3 |
*= |
곱한 후 할당 | x *= 2; |
x = x * 2 |
/= |
나눈 후 할당 | x /= 2; |
x = x / 2 |
%= |
나머지 후 할당 | x %= 3; |
x = x % 3 |
[ 비교 연산자 (Comparison Operators) ]
두 값을 비교하고 boolean 값(
true또는false)을 반환
| 연산자 | 설명 | 예제 | 결과 |
|---|---|---|---|
== |
두 값이 같은지 비교 | 5 == 3 |
false |
!= |
두 값이 다른지 비교 | 5 != 3 |
true |
> |
왼쪽이 큰지 비교 | 5 > 3 |
true |
< |
오른쪽이 큰지 비교 | 5 < 3 |
false |
>= |
왼쪽이 크거나 같은지 비교 | 5 >= 5 |
true |
<= |
오른쪽이 크거나 같은지 비교 | 5 <= 3 |
false |
[ 논리 연산자 (Logical Operators) ]
조건문에서 주로 사용되며, true 또는 false 값을 반환
| 연산자 | 설명 | 예제 | 결과 |
|---|---|---|---|
&& |
AND (둘 다 true이면 true) |
(5 > 3) && (10 > 2) |
true |
|| |
OR (하나라도 true이면 true) |
(5 > 3) || (10 < 2) |
true |
! |
NOT (반대값 반환) | !(5 > 3) |
false |
[ 비트 연산자 (Bitwise Operators) ]
2진수 비트 단위로 연산을 수행하는 연산자
| 연산자 | 설명 | 예제(a=5, b=3) |
결과 | |
|---|---|---|---|---|
& |
비트 AND | 5 & 3 |
1 (0101 & 0011 = 0001) |
|
| |
비트 OR | 5 | 3 |
7 (0101 |
0011 = 0111) |
^ |
비트 XOR | 5 ^ 3 |
6 (0101 ^ 0011 = 0110) |
|
~ |
비트 NOT | ~5 |
-6 (비트 반전) |
|
<< |
왼쪽 시프트 | 5 << 2 |
20 (5 × 2²) |
|
>> |
오른쪽 시프트 | 5 >> 1 |
2 (5 ÷ 2¹) |
[ 증감 연산자 (Increment & Decrement) ]
변수의 값을 1 증가 또는 감소시키는 연산자
| 연산자 | 설명 | 예제 | 결과 |
|---|---|---|---|
++ |
1 증가 | x++ 또는 ++x |
x = x + 1 |
-- |
1 감소 | x-- 또는 --x |
x = x - 1 |
[ 삼항 연산자 (Ternary Operator) ]
간단한 조건문 대체
조건 ? 참일 때 값 : 거짓일 때 값;
연산자 우선순위(Operator Precedence)
| Prec. | Operators | Associativity | |
| 1 | ++, --, +, -, !, (cast) |
R > L | |
| 2 | *, /, % |
L > R | |
| 3 | +, - |
L > R | |
| 4 | <<, >>, >>> |
L > R | |
| 5 | <, >, <=, >=< instance of |
L > R | |
| 6 | ==, != |
L > R | |
| 7 | & |
L > R | |
| 8 | ^ |
L > R | |
| 9 | | |
L > R | |
| 10 | && |
L > R | |
| 11 | || |
L > R | |
| 12 | ?: |
R > L | |
| 13 | =,*=, +=, -=, <<=, … |
R > L |
자바의 제어문
제어문이란?
자바에서 제어문
Control Statement은 프로그램의 흐름을 제어하는 문장으로 조건문, 반복문, 분기문으로 나뉜다
제어문의 종류
| 분류 | 종류 | 설명 |
|---|---|---|
| 조건문 | if, if-else, switch |
특정 조건에 따라 코드 실행 |
| 반복문 | for, while, do-while |
특정 조건 동안 반복 실행 |
| 분기문 | break, continue, return |
반복문 또는 메서드 실행 흐름 변경 |
조건문(Conditional Statements)
조건문은 특정 조건을 만족할 때만 코드가 실행되도록 한다
(1) if 문
• 조건이 true일 때 코드 블록 실행
• 중괄호 {} 없이 단일 문장 실행 가능 (비추천)
if (조건식) {
// 실행될 코드
}
int age = 20;
if (age >= 18) {
System.out.println("성인입니다.");
}
(2) if-else 문
• 조건이 true이면 if 블록 실행, false이면 else 블록 실행
if (조건식) {
// 참일 때 실행될 코드
} else {
// 거짓일 때 실행될 코드
}
int age = 16;
if (age >= 18) {
System.out.println("성인입니다.");
} else {
System.out.println("미성년자입니다.");
}
(3) if-else if-else 문
• 여러 개의 조건을 검사할 때 사용
• 위에서부터 차례대로 검사하며, 첫 번째 true 조건이 실행되면 나머지는 실행되지 않음
if (조건1) {
// 조건1이 참일 때 실행
} else if (조건2) {
// 조건2가 참일 때 실행
} else {
// 모든 조건이 거짓일 때 실행
}
int score = 85;
if (score >= 90) {
System.out.println("A 학점");
} else if (score >= 80) {
System.out.println("B 학점");
} else if (score >= 70) {
System.out.println("C 학점");
} else {
System.out.println("F 학점");
}
(4) switch 문
• 여러 개의 조건을 비교할 때 사용 (== 비교만 가능)
• case 값과 비교하여 일치하는 경우 실행
• break를 사용하여 실행 종료 (없으면 다음 case까지 실행됨)
• default는 모든 case가 일치하지 않을 때 실행
switch (변수) {
case 값1:
// 실행될 코드
break;
case 값2:
// 실행될 코드
break;
default:
// 위 조건에 해당하지 않을 경우 실행
}
int day = 3;
switch (day) {
case 1:
System.out.println("월요일");
break;
case 2:
System.out.println("화요일");
break;
case 3:
System.out.println("수요일");
break;
default:
System.out.println("기타 요일");
}
// 수요일 출력
반복문(Loop Statements)
반복문은 특정 조건이 참인 동안 코드를 반복 실행한다
(1) for 문
• 반복 횟수가 정해진 경우 사용
• 초기식 → 조건식 → 실행 → 증감식 순서로 실행
for (초기식; 조건식; 증감식) {
// 반복 실행될 코드
}
for (int i = 1; i <= 5; i++) {
System.out.println("Hello, Java! " + i);
}
/*
Hello, Java! 1
Hello, Java! 2
Hello, Java! 3
Hello, Java! 4
Hello, Java! 5
*/
(2) while 문
• 조건이 true인 동안 계속 반복
• 반복 횟수가 정해지지 않은 경우 사용
while (조건식) {
// 반복 실행될 코드
}
int i = 1;
while (i <= 5) {
System.out.println("반복 횟수: " + i);
i++;
}
(3) do-while 문
• while과 동일하지만, 최소 1번은 실행됨 (조건 검사 전에 실행)
do {
// 최소 1회 실행될 코드
} while (조건식);
int i = 1;
do {
System.out.println("반복 횟수: " + i);
i++;
} while (i <= 5);
분기문 (Break / Continue / Return)
분기문은 제어문의 흐름을 변경하는 역할을 한다
(1) break 문
• 반복문을 즉시 종료하고 빠져나옴
• switch 문에서도 사용됨
for (int i = 1; i <= 10; i++) {
if (i == 5) {
break; // i가 5면 반복문 종료
}
System.out.println(i);
}
/*
1
2
3
4
*/
(2) continue 문
• 현재 반복을 건너뛰고 다음 반복으로 이동
for (int i = 1; i <= 5; i++) {
if (i == 3) {
continue; // i가 3이면 건너뛰고 다음 반복 실행
}
System.out.println(i);
}
/*
1
2
4
5
*/
(3) return 문
• 메서드를 즉시 종료하고 호출한 곳으로 돌아감
• 반환값이 있는 경우 return 값; 사용
public static int add(int a, int b) {
return a + b; // 실행 후 결과 반환
}