조건식을 연결할 때, 단일 조건만으로는 부족할 수 있습니다.
이럴 때 사용하는 것이 바로 논리 연산자(Logical Operator) 입니다.

이번 글에서는 &&, ||, ! 세 가지 논리 연산자의 사용법을 간단한 예제와 함께 알아보겠습니다.

💻 예제 코드

public class LogicalOperatorExample {
	public static void main(String[] args) {
		int charCode = 'A';
		
		if(65 <= charCode && charCode <= 90)
			System.out.println("대문자입니다.");
		else if(97 <= charCode && charCode <= 122)
			System.out.println("소문자입니다.");
		else if(48 <= charCode && charCode <= 57)
			System.out.println("0-9 숫자입니다.");
		
		int value = 6;
		
		if(value % 2 == 0 || value % 3 == 0)
			System.out.println("2 or 3의 배수입니다.");
		
		boolean re = value % 2 == 0 || value % 3 == 0;
		if(!re)
			System.out.println("2 or 3의 배수가 아닙니다.");
	}
}

💬 코드 설명

문자 범위 판별 (&& 연산자)

if(65 <= charCode && charCode <= 90)

• &&는 AND 조건으로, 두 조건이 모두 참이어야 전체 조건이 true가 됨
• 'A'의 유니코드는 65이므로 "대문자입니다." 출력됨

숫자 판별 (48 ~ 57)

• 유니코드 기준으로 숫자는 48~57에 해당

2 또는 3의 배수 판별 (|| 연산자)

if(value % 2 == 0 || value % 3 == 0)

• ||는 OR 조건. 하나라도 참이면 전체가 true
• value = 6 이므로 2와 3의 배수이기도 해서 조건 만족

논리 부정 (! 연산자)

if(!re)

• !는 NOT, 즉 결과를 반대로 뒤집음
• re == true 이므로 !re == false → 출력 안 됨

📃 실행 결과

대문자입니다.
2 or 3의 배수입니다.

📌 핵심 요약

💡 포인트 정리

• && : 두 조건이 모두 참일 때만 전체 참
• || : 하나만 참이어도 전체 참
• ! : 조건의 결과를 반대로 뒤집음
• 유니코드 범위를 활용한 문자 판별도 가능

자바에서는 변수의 값을 1씩 증가시키거나 감소시키는 증감 연산자를 사용할 수 있습니다.
이번 강의에서는 ++, -- 연산자가 앞에 붙을 때와 뒤에 붙을 때 어떤 차이가 있는지 예제를 통해 알아보겠습니다.

💻 예제 코드

public class SignOperatorExample {
	public static void main(String[] args) {
		int x = 10, y = 10, z;
		
		x++;
		++x;
		System.out.println("x = " + x);

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

		y--;
		--y;
		System.out.println("y = " + y);
		System.out.println("--------------------");

		z = x++;
		System.out.println("z = " + z);
		System.out.println("x = " + x);
		System.out.println("--------------------");

		z = ++x + y++;
		System.out.println("z = " + z);
		System.out.println("x = " + x);
		System.out.println("y = " + y);
	}
}

💬 코드 설명

✅ x++, ++x의 차이

• x++: 현재 값을 먼저 사용하고, 나중에 1 증가 (후위 증가)
• ++x: 값을 먼저 1 증가시키고, 그 값을 바로 사용 (전위 증가)

✅ x--, --x도 동일하게 작동

• -- 연산자는 감소 연산자이며, 동작 방식은 ++와 동일

💬 실행 결과

x = 12
--------------------
y = 8
--------------------
z = 12
x = 13
--------------------
z = 22
x = 14
y = 9

📌 연산 흐름 정리

📌 증감 연산자 정리

💡 포인트 요약

• ++와 --는 변수의 값을 1씩 증가/감소시키는 연산자
• 앞에 붙으면 먼저 연산, 뒤에 붙으면 나중에 연산
• 계산식 안에서 사용될 때는 순서에 따라 값이 달라질 수 있음
• 디버깅하거나 계산 순서가 중요한 경우 주의해서 사용해야 함

✅ 1. 변수의 범위 (VariableScopeExample)

• 변수는 선언된 블록 내에서만 사용 가능
• if문 외부에서 선언한 변수는 if문 내부에서도 사용 가능
• 조건문 실행 여부에 따라 변수 값이 결정되므로 주의 필요

✅ 2. 사용자 입력 처리 (ScannerExample)

• Scanner 클래스를 이용한 입력 받기 (nextInt(), nextLine())
• nextLine() 전에 nextInt() 사용 시, 입력 버퍼 비우기 위해 nextLine() 한 번 호출 필요
• "q" 입력 시 while 루프 종료 → 문자열 비교는 equals() 메서드 사용

✅ 3. 증감 연산자 (SignOperatorExample)

• x++, ++x, y--, --y 등의 사용
• 후위 연산 (x++)은 먼저 값을 사용 후 증가
• 전위 연산 (++x)은 먼저 증가 후 값 사용
• 연산 순서에 따라 결과 값 달라짐

✅ 4. 산술 연산자 (ArithmeticOperatorExample)

• 기본 사칙연산 +, -, *, /, %
• / 연산은 정수형 연산 시 소수점 제거
• double 캐스팅 필요: (double) v1 / v2
• %는 나머지 연산

✅ 5. 비교 연산자 (CompareOperatorExample)

• ==, !=, <, <= 등
• 정수 vs 실수 비교 가능 (1 == 1.0 → true)
• float와 double의 비교는 주의 (0.1f != 0.1)
• 문자열 비교는 == 대신 equals() 사용!

✅ 6. 논리 연산자와 조건문 (LogicalOperatorExample)

• && (AND), || (OR), ! (NOT)
• 유니코드 값 비교로 문자 분류 (대문자/소문자/숫자 판별)

if(65 <= charCode && charCode <= 90) // 대문자

• 복합 조건식 사용하여 조건 분기 구현
• 결과값을 boolean 변수에 저장해 조건 재사용 가능

📌 3일차 핵심 요약

자바 프로그램에서 사용자로부터 값을 입력받으려면 어떻게 해야 할까요?
이번 강의에서는 Scanner 클래스를 이용해 정수를 입력받고 계산하는 방법을 배워보겠습니다.
특히 System.in을 통해 키보드로 입력받는 기초 흐름을 익히는 것이 목표입니다.

💻 예제 코드

import java.util.Scanner;

public class ScannerExample {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		System.out.print("x input : ");
		int x = sc.nextInt();
		
		System.out.print("y input : ");
		int y = sc.nextInt();
		
		int z = x + y;
		System.out.println("x + y = " + z);
	}
}

💬 코드 설명

📃 실행 결과

x input : 5
y input : 3
x + y = 8

👉 사용자가 키보드로 5와 3을 입력하면, 두 값을 더한 결과인 8이 출력됩니다.

📌 간단 정리

💡 포인트 요약

• 자바에서 사용자 입력을 받으려면 Scanner 객체를 사용한다.
• 정수 입력: nextInt(), 문자열 입력: nextLine(), next()
• 입력을 받을 때는 항상 import java.util.Scanner;가 필요하다.

🕘 오전 수업 내용 요약

1. 변수 값 교환

• temp를 활용한 값 교환 실습

2. 자료형의 범위 확인

• byte: -128 ~ 127
• long: 큰 정수는 L 접미사 필요
• char: 유니코드 문자, 정수형 캐스팅 가능

3. 논리형과 조건식

• boolean 타입과 비교 연산자, 논리 연산자(&&) 사용

4. 문자열 처리와 특수문자

• String 사용 및 이스케이프 문자(\t, \n, \") 출력

🕐 오후 수업 내용 요약

1. 자동 형 변환 (Promotion)

• 작은 자료형 → 큰 자료형 자동 변환

byte → int → long → float → double
char → int

2. 강제 형 변환 (Casting)

• 큰 자료형을 작은 자료형으로 변환 시 형 변환 연산자 사용 필요

int x = (int) 3.14;  // 소수점 버려짐
char c = (char) 65;  // 유니코드 문자 'A'

3. 연산 시의 자료형 승급 (Operation Promotion)

• 정수끼리 연산 시 결과는 int 이상
  • byte + byte → int
• 다른 타입 간 연산 시 큰 자료형으로 자동 변환
• 문자 연산 시 숫자로 변환되어 처리됨

char c = 'A';  // 65
int result = c + 1;  // 66

• 정수 / 정수 = 정수 (소수점 버려짐)
  • 해결: 하나를 double로 캐스팅

4. 문자열 ↔ 기본형 변환

• 문자열 → 기본형

int num = Integer.parseInt("10");
double d = Double.parseDouble("3.14");

• 기본형 → 문자열

String s = String.valueOf(10);

📌 2일차 핵심 요약

프로그래밍을 하다 보면 문자열을 숫자로 바꾸거나,
숫자를 다시 문자열로 바꿔야 할 상황이 자주 생깁니다.

자바에서는 이를 위한 전용 메서드들이 제공되며,
String → 기본형, 기본형 → String 간의 변환은 아주 간단하게 할 수 있습니다.

이번 강에서는 이런 기본 타입 <-> 문자열 변환 방법을 예제를 통해 알아보겠습니다.

💻 예제 코드

public class PrimitiveAndStringConversionExample {
	public static void main(String[] args) {
		int value1 = Integer.parseInt("10");
		double value2 = Double.parseDouble("3.14");
		boolean value3 = Boolean.parseBoolean("true");

		System.out.println(value1);
		System.out.println(value2);
		System.out.println(value3);

		String str1 = String.valueOf(10);
		String str2 = String.valueOf(3.14);
		String str3 = String.valueOf(true);

		System.out.println(str1);
		System.out.println(str2);
		System.out.println(str3);
	}
}

💬 코드 설명

1. String → int 변환

int value1 = Integer.parseInt("10");

• 문자열 "10"을 정수 10으로 변환
• 숫자가 아닌 문자를 넣으면 NumberFormatException이 발생함

2. String → double 변환

double value2 = Double.parseDouble("3.14");

• 실수형 문자열 "3.14" → 실수 3.14로 변환
• 소수점 있는 문자열도 가능

3. String → boolean 변환

boolean value3 = Boolean.parseBoolean("true");

• "true" → true
• "false" → false
• 대소문자 구분 없이 true/false 처리

4. 기본형 → String 변환

String str1 = String.valueOf(10);
String str2 = String.valueOf(3.14);
String str3 = String.valueOf(true);

• 숫자, 실수, 불리언을 문자열로 변환
• String.valueOf() 메서드는 모든 기본형에 사용 가능
• 숫자를 문자열로 만들거나, 출력할 때 많이 사용됨

📃 실행 결과

10
3.14
true
10
3.14
true

📌 간단 정리

💡 포인트 정리

1. 문자열을 숫자로 바꿀 땐 parseInt(), parseDouble() 등 해당 타입의 클래스 사용
2. 숫자, 실수, 논리값을 문자열로 바꿀 땐 String.valueOf()가 가장 안전하고 쉬움
3. 문자열 파싱 시 입력값에 따라 예외가 발생할 수 있음 (숫자 형식 주의)

자바에서 다양한 자료형끼리 연산을 하면 자동으로 형변환이 일어납니다.
특히 작은 자료형끼리의 연산 결과가 예상과 다르게 나오는 경우도 많기 때문에,
자동 타입 변환(Promotion)의 원리를 이해하는 것이 중요합니다.

이번 글에서는 연산 중 자동으로 발생하는 타입 변환 과정을 코드로 확인해보겠습니다.

💻 예제 코드

public class OperationPromotionExample {
    public static void main(String[] args) {
        byte result1 = 10 + 20;
        System.out.println(result1);

        byte v1 = 10, v2 = 20;
        int result2 = v1 + v2;
        System.out.println(result2);

        byte v3 = 10;
        int v4 = 100;
        long v5 = 1000L;
        long result3 = v3 + v4 + v5;
        System.out.println(result3);

        char v6 = 'A', v7 = 1;
        int result4 = v6 + v7;
        System.out.println(result4);
        System.out.println((char) result4);

        int v8 = 10, result5 = v8 / 4;
        System.out.println(result5);

        int v9 = 10;
        double result6 = v9 / 4.0;
        System.out.println(result6);

        int v10 = 1, v11 = 2;
        double result7 = (double) v10 / v11;
        System.out.println(result7);
    }
}

💬 코드 설명

1. byte + byte 연산

byte result1 = 10 + 20;

• 숫자 리터럴끼리 연산은 컴파일 타임에 처리되며 byte 범위 내라면 에러 없이 저장됩니다.
• 10 + 20 = 30이 byte 범위(-128~127)라서 문제 없음.

2. byte 변수 + byte 변수 연산

int result2 = v1 + v2;

• 변수끼리 연산은 무조건 int로 변환됨!
• 그래서 결과를 byte가 아닌 int에 담아야 합니다.

3. byte + int + long

long result3 = v3 + v4 + v5;

• 여러 타입이 섞이면 가장 큰 자료형인 long으로 자동 변환됩니다.
• int보다 long이 크므로, 결과 타입도 long.

4. char + int

char v6 = 'A', v7 = 1;
int result4 = v6 + v7;

• 'A'는 유니코드 65입니다.
• 65 + 1 = 66 → 정수 결과가 되므로 int로 저장해야 합니다.
• System.out.println((char) result4); → 다시 문자 'B'로 출력됨.

5. 정수 나눗셈

int result5 = v8 / 4;

• 10 / 4 = 2, 소수점 버림

6. 실수 나눗셈

double result6 = v9 / 4.0;

• 정수와 실수를 연산하면 자동으로 double 변환됨 → 결과 2.5

7. 형변환 후 나눗셈

double result7 = (double) v10 / v11;

• 명시적 형변환으로 double 연산 수행
• 1 / 2 = 0.5

📃 실행 결과

30
30
1110
66
B
2
2.5
0.5

📌 간단 정리

💡 포인트 정리

1. byte, short, char → 연산 시 int로 자동 변환됨
2. 연산에 서로 다른 타입이 섞이면 큰 타입으로 변환
3. 정수 나눗셈은 항상 소수점 버림! → double로 바꿔야 실수 결과
4. 자동 변환이 일어나는 규칙을 이해하면, 실수 줄이기 쉬워요!

프로그래밍에서는 값의 자료형을 바꾸는 것이 아주 중요합니다.

특히 큰 자료형을 작은 자료형으로 바꿀 때는 명시적인 형변환이 필요합니다.

이번 글에서는 자바의 강제 타입 변환을 예제로 알아보겠습니다.

💻 예제 코드

public class CastingExample {
    public static void main(String[] args) {
        int x1 = 10;
        byte x2 = (byte) x1;
        System.out.println(x2);

        long x3 = 300;
        x1 = (int) x3;
        System.out.println(x1);

        int x4 = 65;
        char x5 = (char) x4;
        System.out.println(x5);

        double x6 = 3.14;
        int x7 = (int) x6;
        System.out.println(x7);
    }
}

💬 코드 설명

1. int ▶ byte 형변환

int x1 = 10;
byte x2 = (byte) x1;

int는 4바이트이며, byte는 1바이트이다.

작은 자료형으로 바꾸는 건 자동 변환이 안 되서 (byte) 처럼 명시적 형변환이 필요하다.

값이 byte 의 범위(-128~127)를 벗어날 경우 데이터 손실 발생 가능성이 있다.

2. long ▶ int 형변환

long x3 = 300;
x1 = (int) x3;

long은 8바이트, int는 4바이트이다.

큰 정수형을 작은 정수형으로 변환할 때도 형변환이 필요하다.

3. int ▶ char 형변환

int x4 = 65;
char x5 = (char) x4;

문자형 char 은 유니코드 정수로 저장됩니다.

숫자 65 ▶ 문자 'A' 로 변환합니다. (ASCII 코드)

숫자를 문자로 바꿀 때 유용합니다.

4. double ▶ int 형변환

double x6 = 3.14;
int x7 = (int) x6;

1. 실수 ▶ 정수로 변환 시 소수점 이하를 버립니다.

결과는 3.14에서 .14를 없애고 3만 출력합니다.

📃 실행 결과

10
300
A
3

📌 간단 정리

📌 명시적 형변환(강제 타입 변환)이란?

큰 자료형 ▶ 작은 자료형으로 변환할 때 사용하는 방식

(자료형) 을 붙여서 명시적으로 바꿔줘야 한다.

💡 포인트 정리

1. 작은 타입 ▶ 큰 타입 : 자동 형변환 (Promotion)

2. 큰 타입 ▶ 작은 타입 : 명시적 형변환 (Casting) 필요

형변환 시 데이터 손실 가능성을 꼭 고려할 것!