GitJav 멘토링: 자바의 변수와 자료형, 연산자 ep.1

이번 첫 시간에는 메모리에 대한 기본적인 개념과 자바의 변수와 자료형

그리고 연산자에 대해서 알아보도록 하겠습니다.

GitJav 1기 - OT 리뷰 테스트

 

시작하기 전에! Git 을 CLI 로 다루기 위해서는 기본적인 리눅스 명령어를 알아둘 필요가 있기 때문에

리눅스 명령어 몇 가지만 찍먹을 해보도록 하겠습니다:)

 

---

https://www.urbanbrush.net/downloads/메모리-일러스트-ai-무료다운로드-free-memory-vector/

 

컴퓨터 메모리란 컴퓨터가 데이터를 저장하는 공간입니다. 이 데이터는 컴퓨터가 작업을 수행하는 동안 필요한 정보이며, 프로그램, 파일, 그리고 컴퓨터가 실행 중인 다른 작업들을 포함합니다. 메모리는 일종의 테이블이라고 생각할 수 있습니다. 이 테이블은 숫자와 문자 등의 데이터를 저장할 수 있으며, 각각의 데이터는 고유한 주소를 가지고 있습니다. 이 주소를 통해 컴퓨터는 데이터를 읽고 쓸 수 있습니다.

메모리는 RAM(Random Access Memory)과 ROM(Read Only Memory)으로 나뉩니다.
RAM은 일시적인 데이터를 저장하며, 컴퓨터가 작업을 수행하는 동안 필요한 정보를 저장합니다. 반면 ROM은 영구적인 데이터를 저장하며, 컴퓨터가 부팅할 때 필요한 정보를 저장합니다.

RAM과 ROM은 모두 컴퓨터에서 사용되는 기억장치로서, 다음과 같은 카테고리로 비유할 수 있습니다:

RAM은 일시적으로 저장되는 정보를 담는 "작업 메모리"와 비슷합니다. 작업 메모리는 일시적인 작업에 필요한 정보를 저장하고, 작업이 끝나면 그 내용이 삭제되는 것과 같이, RAM에 저장된 정보는 일시적으로 사용되고 나면 삭제됩니다.

반면에, ROM은 "영구 메모리"와 비슷합니다. 영구 메모리는 컴퓨터 부팅 시 필요한 정보나 프로그램 등을 저장하고, 컴퓨터가 꺼져도 내용이 유지되는 것과 같이, ROM에 저장된 정보는 컴퓨터가 꺼져도 영구적으로 저장됩니다.

마지막으로, 메모리는 다른 하드웨어 컴포넌트와 연결되어 있으며, CPU(Central Processing Unit)가 데이터를 메모리로부터 읽어와 작업을 수행하고, 결과를 메모리에 저장합니다. 이를 통해 컴퓨터가 프로그램을 실행하고 데이터를 처리할 수 있게 됩니다.

CPU는 중앙 처리 장치로서, 컴퓨터의 모든 작업을 수행하는데, 이때 필요한 데이터를 RAM에서 읽어와서 처리합니다. RAM은 주 기억 장치로서, 컴퓨터가 동작하는 동안에 일시적으로 데이터를 저장하고, CPU가 필요에 따라 읽어 들이는 역할을 합니다.

ROM은 읽기 전용 메모리로서, 컴퓨터의 부팅 프로세스나 운영 체제, BIOS 등의 시스템 소프트웨어가 저장되어 있습니다. ROM은 전원이 켜진 상태에서는 읽을 수 있지만, 쓰기 작업은 불가능합니다. 이러한 특성 때문에, 시스템 소프트웨어는 ROM에 저장되어 있어서, 컴퓨터가 부팅되기 전에 필요한 정보들을 ROM에서 읽어와서 초기화 및 설정 작업을 수행합니다.

CPU는 ROM에서 시스템 소프트웨어를 읽어들여서, 이를 RAM에 복사하거나 CPU 내부에 저장한 후, 이를 실행하게 됩니다. 이를 통해, 컴퓨터가 부팅되어 동작하는 동안에는 CPU는 ROM에서 필요한 시스템 소프트웨어를 읽어오고, 이를 RAM으로 복사하여 사용하게 됩니다.

따라서, CPU, RAM, 그리고 ROM은 모두 서로 다른 역할을 수행하면서, 컴퓨터가 동작하는데 필수적인 역할을 합니다.

 

https://codingclimber.tistory.com/28

 

자바에서 변수(variable)는 값을 저장하고 참조하는 데 사용되는 메모리 공간을 말합니다.
변수는 프로그램에서 중요한 역할을 합니다. 변수를 사용하면 데이터를 저장하고 처리할 수 있습니다.

 

자바 가상 머신(JVM)은 자바 프로그램이 실행될 때 사용하는 메모리 공간을 관리합니다. JVM은 다양한 용도로 사용되는 메모리 공간을 나누어 관리합니다.

JVM의 메모리 구조는 크게 세 가지 영역으로 나눌 수 있습니다.

- 메서드 영역(Method Area 또는 Permanent Generation)
: 메서드 영역은 자바 클래스 파일에서 로드된 클래스 정보, 상수, 정적 변수 등을 저장합니다. 이 영역은 모든 스레드가 공유하며, 가비지 컬렉션의 대상이 아닙니다. 

- 힙(Heap Area)
: 힙 영역은 동적으로 할당된 객체와 배열을 저장합니다. 힙 영역은 가비지 컬렉터(Garbage Collector)가 관리하며, 더 이상 참조되지 않는 객체를 제거합니다. 힙의 크기는 제한됩니다.

- 스택(Stack Area)
: 스택 영역은 스레드마다 하나씩 생성되며, 메서드 호출 시 메서드의 매개변수, 지역변수, 리턴값 등을 저장합니다. 메서드가 호출되면 스택 프레임(Stack Frame)이 생성되고, 메서드가 종료되면 스택 프레임이 제거됩니다. 스택은 후입선출(LIFO) 구조로 데이터를 저장합니다. 스택 오버플로우(Stack Overflow)가 발생할 수 있으므로 스택의 크기는 제한됩니다.

JVM의 메모리 구조는 자바 프로그램이 실행되는 동안 필요한 데이터와 객체를 관리하며, 각각의 영역은 자신이 담당하는 역할을 수행합니다.

public class MemoryStructureExample {
    public static void main(String[] args) {
        // 스택 영역
        int x = 1;
        int y = 2;
        int z = add(x, y); // 메서드 호출 시 스택에 스택 프레임이 생성됨
        System.out.println("z = " + z); // z = 3
    }
    
    public static int add(int a, int b) {
        // 스택 영역
        int result = a + b;
        return result; // 메서드 종료 시 스택 프레임이 제거됨
    }
    
    // 힙 영역
    public static class MyClass {
        private int value;
        
        public MyClass(int value) {
            this.value = value;
        }
    }
    
    public static void heapExample() {
        // 힙 영역
        MyClass obj1 = new MyClass(1);
        MyClass obj2 = new MyClass(2);
        MyClass obj3 = obj1; // obj1과 obj3는 같은 객체 참조
        
        obj1 = null; // obj1은 더 이상 참조하지 않음
        obj2 = null; // obj2도 더 이상 참조하지 않음
        
        // 가비지 컬렉터가 obj1과 obj2를 제거하고, obj3만 남게 됨
    }
}

위 코드에서 main 메서드가 호출되면서 스택 영역에 x, y, z 변수가 생성됩니다. 

add 메서드가 호출되면서 새로운 스택 프레임이 생성되고, result 변수가 생성됩니다. add 메서드가 종료되면서 스택 프레임이 제거되고, z 변수에는 result 값이 저장됩니다.

MyClass 클래스는 힙 영역에 생성되고, obj1, obj2, obj3 변수는 MyClass 객체를 참조합니다. obj1과 obj2가 더 이상 참조되지 않는 시점에서 가비지 컬렉터가 이들 객체를 제거하고, obj3 변수는 여전히 MyClass 객체를 참조하게 됩니다.

 

자바에서 변수는 다음과 같은 세 가지 요소로 구성됩니다.

1. 변수 타입: 저장하는 데이터의 종류를 결정합니다.
   자바에서는 기본 데이터 타입과 참조 데이터 타입으로 구분됩니다.
   
   
2. 변수 이름: 변수를 식별하는 데 사용되는 이름입니다.
   변수 이름은 영문자, 숫자, 밑줄, 달러 기호 등으로 구성됩니다. 변수 이름은 대소문자를 구분하며, 예약어를 사용할 수 없습니다.
   
   
3. 변수 값: 변수에 저장된 데이터입니다.
   변수 값은 변수 타입에 따라 다르게 저장됩니다.

예를 들어, 정수형 변수를 선언하고 초기값을 할당하는 코드는 다음과 같습니다.

int num = 10;

변수를 사용할 때는 변수 이름을 사용하여 변수 값을 참조하거나 변경할 수 있습니다.
예를 들어, 위에서 선언한 정수형 변수의 값을 출력하는 코드는 다음과 같습니다.

System.out.println(num);

변수의 값을 변경하려면 변수 이름과 새로운 값을 대입 연산자 "=" 로 연결하여 사용합니다.

num = 20;

위 코드에서 변수 num의 값은 20으로 변경됩니다.

// 변수의 타입(type)과 이름(identifier)을 지정하여 선언
// 이후에 변수의 값을 할당할 수 있음
타입 이름;
이름 = 값;

// 변수의 타입과 이름을 지정하면서 선언과 동시에 값을 할당할 수도 있음
타입 이름 = 값;

int count; // count 변수 선언
count = 0; // count 변수에 0 할당

// 또는 다음과 같이 한 줄로 작성할 수 있음
int count = 0; // count 변수 선언과 동시에 0 할당

---

자바에서 변수는 스코프(scope)라는 개념에 따라 사용 가능한 범위가 제한됩니다. 스코프는 변수가 선언된 블록 내에서만 유효하며, 블록을 벗어나면 변수는 더 이상 사용할 수 없습니다. 이러한 스코프 규칙을 이용하여 변수의 유효 범위를 제한하고 변수 이름의 충돌을 방지할 수 있습니다.

 

대표적으로 블록 스코프(Block Scope)와 메소드 스코프(Method Scope)가 있습니다. 

블록 스코프는 중괄호 {}로 둘러싸인 코드 블록 내에서 선언된 변수가 해당 블록 내에서만 참조 가능한 스코프를 말합니다. 예를 들어, if문, for문 등의 제어문에서 선언된 변수는 해당 제어문 내에서만 사용할 수 있습니다.

반면에 메서드 스코프는 메소드 내에서 선언된 변수가 해당 메서드 전체에서 참조 가능한 스코프를 말합니다. 즉, 메소드의 매개변수나 로컬 변수는 해당 메서드 내에서 사용될 수 있습니다.

스코프는 변수의 유효 범위를 제한하여 변수 이름의 충돌을 방지하고, 프로그램의 가독성을 높이는 등의 이점을 가지고 있습니다. 

public class Example {
    int globalVariable = 10; // 전역 변수

    public void method() {
        int methodVariable = 30; // 메소드 스코프 변수

        System.out.println(globalVariable); // 전역 변수 참조
        System.out.println(methodVariable); // 메소드 스코프 변수 참조

        if (methodVariable > 20) {
            int blockVariable = 40; // 블록 스코프 변수

            System.out.println(blockVariable); // 블록 스코프 변수 참조
        }

	// 오류 발생: 블록 스코프 변수는 블록 밖에서 참조 불가능
        // System.out.println(blockVariable); 
    }
}

위의 코드에서 globalVariable은 클래스 내부 어디서든지 참조 가능한 전역 변수입니다. methodVariable은 method() 메소드 내에서만 참조 가능한 메서드 스코프 변수입니다. blockVariable은 if문 블록 내에서만 참조 가능한 블록 스코프 변수입니다.

 

---

https://m.blog.naver.com/dokkosam/221157601817

 

자바에서는 기본 자료형(primitive data type)과 참조 자료형(reference data type) 두 가지 유형의 자료형을 제공합니다.

 

기본 자료형

기본 자료형은 값 자체를 저장합니다. 즉, 변수에는 값이 직접 저장됩니다. 기본 자료형에는 다음과 같은 유형이 있습니다.

• byte: 8비트 부호 있는 정수형(-128 ~ 127)

byte age = 20;

• short: 16비트 부호 있는 정수형(-32,768 ~ 32,767)

short temperature = -10;

• int: 32비트 부호 있는 정수형(-2,147,483,648 ~ 2,147,483,647)

int num = 10;

• long: 64비트 부호 있는 정수형(-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807)

long population = 83000000L;

• float: 32비트 부동소수점형(1.4E-45 ~ 3.4028235E38)

float weight = 65.5f;

• double: 64비트 부동소수점형(4.9E-324 ~ 1.7976931348623157E308)

double pi = 3.141592;

• char: 16비트 유니코드 문자('\u0000' ~ '\uffff')

char letter = 'a';

int num = 97;
char ch = (char) num;
System.out.println(ch); // 출력 결과: a

• boolean: 논리값(true, false)

boolean flag = true;

 

 

참조 자료형

참조 자료형은 값이 저장된 메모리 위치를 참조합니다. 즉, 변수에는 값이 저장된 위치를 가리키는 주소가 저장됩니다. 참조 자료형에는 다음과 같은 유형이 있습니다.

• 클래스(class): 객체를 생성하기 위한 설계도
• 인터페이스(interface): 클래스가 구현해야 하는 메서드를 정의하는 데 사용되는 추상 타입
• 배열(array): 동일한 타입의 여러 값을 저장할 수 있는 데이터 구조

String name = "John";
String greeting = "Hello, " + name + "!";

Integer age = 25;
Integer nextAge = age + 1;

Double pi = 3.141592;
Double area = pi * radius * radius;

Boolean isSunny = true;
Boolean isWarm = temperature > 20;

ArrayList<String> fruits = new ArrayList<String>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");

String fruit = fruits.get(1); // Returns "Banana"

HashMap<String, Integer> scores = new HashMap<String, Integer>();
scores.put("John", 80);
scores.put("Jane", 90);
scores.put("Mike", 85);

Integer johnScore = scores.get("John"); // Returns 80

Object obj = "Hello World!";
if (obj instanceof String) {
  String str = (String) obj;
  System.out.println(str);
}

기본 자료형과 참조 자료형의 큰 차이점은 다음과 같습니다:

값의 저장 방식
기본 자료형은 변수에 값을 직접 저장합니다. 반면에, 참조 자료형은 객체의 주소값을 변수에 저장하며, 객체의 데이터는 해당 주소를 참조하여 접근합니다. 

// 기본 자료형 변수의 값 저장 방식
int num1 = 10;
int num2 = num1;
num2 = 20;

System.out.println("num1: " + num1); // 출력: num1: 10
System.out.println("num2: " + num2); // 출력: num2: 20

// 참조 자료형 변수의 값 저장 방식
int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;
arr2[0] = 4;

System.out.println("arr1[0]: " + arr1[0]); // 출력: arr1[0]: 4
System.out.println("arr2[0]: " + arr2[0]); // 출력: arr2[0]: 4

위 코드에서, 기본 자료형 변수의 경우 num1 변수에 10이라는 값을 저장하고, num2 변수에 num1 변수의 값을 할당합니다. 그리고 num2 변수에 20이라는 값을 저장합니다. 이때, num1 변수의 값은 변하지 않으며, num2 변수의 값만 바뀝니다.

반면에, 참조 자료형 변수의 경우 arr1 변수에 {1, 2, 3}이라는 값을 가지는 배열을 생성하고, arr2 변수에 arr1 변수를 할당합니다. 그리고 arr2[0]의 값을 4로 변경합니다. 이때, arr1[0]의 값도 함께 변경되므로, 참조 자료형 변수는 객체의 주소값을 저장하기 때문에 객체의 데이터가 변경되면 같이 변경됩니다.

 

초기값
기본 자료형은 변수를 초기화하지 않으면 자동으로 기본값으로 초기화됩니다. 예를 들어, int 변수는 0으로 초기화됩니다. 반면에, 참조 자료형 변수는 null로 초기화됩니다.

// 기본 자료형 변수의 초기값
int num;
double dnum;
boolean flag;

System.out.println("num: " + num);     // 출력: num: 0
System.out.println("dnum: " + dnum);   // 출력: dnum: 0.0
System.out.println("flag: " + flag);   // 출력: flag: false

// 참조 자료형 변수의 초기값
String str;
int[] arr;
ArrayList<String> list;

System.out.println("str: " + str);     // 출력: str: null
System.out.println("arr: " + arr);     // 출력: arr: null
System.out.println("list: " + list);   // 출력: list: null

위 코드에서, 기본 자료형 변수는 초기화하지 않으면 해당 자료형의 기본값으로 자동 초기화됩니다. int형 변수인 num은 0으로, double형 변수인 dnum은 0.0으로, boolean형 변수인 flag는 false로 초기화됩니다.

반면에, 참조 자료형 변수는 초기화하지 않으면 null 값으로 자동 초기화됩니다. String 클래스의 객체를 참조하는 str 변수, int 배열 객체를 참조하는 arr 변수, 그리고 ArrayList 클래스의 객체를 참조하는 list 변수는 모두 null 값으로 초기화됩니다.

메모리 사용
기본 자료형은 스택 메모리에 저장됩니다. 반면에, 참조 자료형은 힙 메모리에 객체가 저장되며, 해당 객체를 참조하는 변수는 스택 메모리에 저장됩니다.

연산 방식

기본 자료형은 값에 대한 연산을 수행합니다. 반면에, 참조 자료형은 객체에 대한 연산을 수행합니다. 예를 들어, String 객체의 경우 문자열 연산을 수행할 수 있습니다.

클래스 상속
기본 자료형은 클래스를 상속받을 수 없습니다. 반면에, 참조 자료형은 클래스를 상속받을 수 있습니다.

상속은 객체 지향 프로그래밍에서 매우 중요한 개념 중 하나로, 기존의 클래스를 확장하여 새로운 클래스를 만들 때 사용됩니다. 즉, 상속을 통해 기존 클래스의 모든 멤버 변수와 메서드를 새로운 클래스에 물려받을 수 있습니다.

기존 클래스를 부모 클래스 또는 슈퍼 클래스라고 하며, 상속을 받은 새로운 클래스를 자식 클래스 또는 서브 클래스라고 합니다. 자식 클래스는 부모 클래스의 모든 멤버 변수와 메서드를 사용할 수 있으며, 필요한 경우 이를 확장하거나 재정의하여 새로운 기능을 추가하거나 변경할 수 있습니다.

상속을 사용하면 코드의 재사용성을 높일 수 있으며, 코드 중복을 피할 수 있습니다. 또한 상속을 통해 코드의 유지 보수성을 향상시킬 수 있으며, 객체 지향 프로그래밍의 다형성 개념을 구현할 수 있습니다.

// 부모 클래스
class Animal {
    void eat() {
        System.out.println("동물이 먹이를 먹습니다.");
    }
}

// 자식 클래스
class Dog extends Animal {
    void bark() {
        System.out.println("강아지가 짖습니다.");
    }
}

// 실행 클래스
class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat(); // Animal 클래스의 eat() 메소드 호출
        myDog.bark(); // Dog 클래스의 bark() 메소드 호출
    }
}

// 동물이 먹이를 먹습니다.
// 강아지가 짖습니다.

myDog.eat() 코드가 실행되면 Animal 클래스의 eat() 메서드가 호출되어 "동물이 먹이를 먹습니다." 라는 출력 결과가 나오게 됩니다.

그리고 myDog.bark() 코드가 실행되면 Dog 클래스의 bark() 메소드가 호출되어 "강아지가 짖습니다."라는 출력 결과가 나오게 됩니다.

 

동등성 비교
기본 자료형은 == 연산자를 사용하여 값의 동등성을 비교할 수 있습니다. 반면에, 참조 자료형은 == 연산자를 사용하여 주소값의 동등성을 비교할 수 있습니다. 객체의 데이터의 동등성 비교는 equals() 메서드를 사용해야 합니다.

// 기본 자료형 변수의 동등성 비교
int num1 = 10;
int num2 = 10;

if (num1 == num2) {
    System.out.println("num1과 num2는 같습니다.");
} else {
    System.out.println("num1과 num2는 다릅니다.");
}

// 참조 자료형 변수의 동등성 비교
String str1 = new String("Hello");
String str2 = new String("Hello");

if (str1 == str2) {
    System.out.println("str1과 str2는 같습니다.");
} else {
    System.out.println("str1과 str2는 다릅니다.");
}

위 코드에서, 기본 자료형 변수는 해당 변수의 값을 직접 비교할 수 있습니다. 따라서 num1 변수와 num2 변수의 값이 같으므로, if 문에서는 num1 == num2 조건이 참이 되어 "num1과 num2는 같습니다."라는 메시지가 출력됩니다.

반면에, 참조 자료형 변수는 변수가 참조하는 객체의 주소값을 비교해야 합니다. 따라서 str1 변수와 str2 변수가 참조하는 String 클래스의 객체는 값이 같지만, 다른 객체입니다. 따라서 if 문에서는 str1 == str2 조건이 거짓이 되어 "str1과 str2는 다릅니다."라는 메시지가 출력됩니다.

참조 자료형의 경우 객체의 값이 아닌 객체의 주소값을 비교하기 때문에, 객체의 값이 같은지 비교하려면 equals() 메서드를 사용해야 합니다.

이러한 차이점들로 인해, 기본 자료형과 참조 자료형은 서로 다른 방식으로 동작하며, 각각의 장단점이 존재합니다.

 

public class MyClass {
    public static void main(String[] args) {
        // Stack 영역에 변수 a를 생성하고, 값 10을 저장한다.
        int a = 10; 
        
        // Stack 영역에 변수 str을 생성하고, 
        // Heap 영역에 문자열 "Hello, World!"를 생성하고,
        // 변수 str에 Heap 영역의 문자열 주소값을 저장한다.
        String str = "Hello, World!";
        
        // Stack 영역에 변수 obj를 생성하고, 
        // Heap 영역에 MyClass 객체를 생성하고, 
        // 변수 obj에 Heap 영역의 객체 주소값을 저장한다.
        MyClass obj = new MyClass();
        
        // methodA() 메소드를 호출하면, 
        // 새로운 Stack 프레임이 생성되고, 
        // 메소드에서 사용하는 변수들이 Stack 프레임에 저장된다.
        obj.methodA();
    }

    public void methodA() {
        // methodA() 메소드 호출 시, 
        // Stack 영역에 변수 b를 생성하고, 값 20을 저장한다.
        int b = 20; 
        
        // methodA() 메소드 호출 시, 
        // Stack 영역에 변수 obj를 생성하고, 
        // Heap 영역에 MyClass 객체를 생성하고, 
        // 변수 obj에 Heap 영역의 객체 주소값을 저장한다.
        MyClass obj = new MyClass();
        
        // methodB() 메소드를 호출하면, 
        // 새로운 Stack 프레임이 생성되고, 
        // 메소드에서 사용하는 변수들이 Stack 프레임에 저장된다.
        obj.methodB(); 
    }

    public void methodB() {
    	// methodB() 메소드 호출 시, 
        // Stack 영역에 변수 c를 생성하고, 값 30을 저장한다.
        int c = 30; 
        
        // methodB() 메소드 호출 시,
        // Stack 영역에 변수 str을 생성하고, 
        // Heap 영역에 문자열 "Hello, Java!"를 생성하고, 
        // 변수 str에 Heap 영역의 문자열 주소값을 저장한다.
        String str = "Hello, Java!"; 
    }
}

 

---

https://cloudstudying.kr/lectures/299

 

자바에서 사용되는 연산자는 크게 산술 연산자, 비교 연산자, 논리 연산자, 비트 연산자, 삼항 연산자, 할당 연산자 등으로 나눌 수 있습니다. 각각의 연산자에 대해 간단히 설명해 보겠습니다.

산술 연산자 : 더하기(+), 빼기(-), 곱하기(*), 나누기(/), 나머지(%) 등의 연산을 수행하는 연산자입니다.

int a = 10;
int b = 5;
int result1 = a + b; // 더하기 연산
int result2 = a - b; // 빼기 연산
int result3 = a * b; // 곱하기 연산
int result4 = a / b; // 나누기 연산
int result5 = a % b; // 나머지 연산

비교 연산자 : 두 개의 값을 비교하는 연산자로, 같음(==), 다름(!=), 크기(>, >=, <, <=) 등의 연산을 수행합니다.

int a = 10;
int b = 5;
boolean result1 = (a == b); // 같음 연산
boolean result2 = (a != b); // 다름 연산
boolean result3 = (a > b); // 크기 비교 연산
boolean result4 = (a >= b);
boolean result5 = (a < b);
boolean result6 = (a <= b);

논리 연산자 : 참/거짓을 판단하는 연산자로, AND(&&), OR(||), NOT(!) 연산을 수행합니다.

boolean a = true;
boolean b = false;
boolean result1 = (a && b); // AND 연산
boolean result2 = (a || b); // OR 연산
boolean result3 = (!a); // NOT 연산

 

비트 연산자 : 비트(bit) 단위로 연산을 수행하는 연산자로, AND(&), OR(|), XOR(^), NOT(~), 시프트(<<, >>, >>>) 등의 연산을 수행합니다.

int a = 60; // 0011 1100
int b = 13; // 0000 1101
int result1 = a & b; // AND 연산 : 0000 1100
int result2 = a | b; // OR 연산 : 0011 1101
int result3 = a ^ b; // XOR 연산 : 0011 0001
int result4 = ~a; // NOT 연산 : 1100 0011
int result5 = a << 2; // 왼쪽 시프트 연산 : 1111 0000
int result6 = a >> 2; // 오른쪽 시프트 연산 : 0000 1111
int result7 = a >>> 2; // 오른쪽 시프트 연산 (양수만) : 0000 1111

 

삼항 연산자 : 조건문과 유사한 형태로, 조건식 ? 참일 때 값 : 거짓일 때 값 형태로 사용되며, 조건식이 참이면 참일 때 값이 반환되고, 거짓이면 거짓일 때 값이 반환됩니다.

int a = 10;
int b = 5;

int result1 = (a > b) ? a : b; // a가 b보다 크면 a를, 아니면 b를 반환

 

할당 연산자 : 변수에 값을 할당하는 연산자로, 대입 연산자(=) 외에도 산술 연산과 함께 사용되는 +=, -=, *=, /=, %= 등의 연산자도 포함됩니다.

int a = 10;
int b = 5;
a += b; // a = a + b
a -= b; // a = a - b
a *= b; // a = a * b
a /= b; // a = a / b
a %= b; // a = a % b

 

증감 연산자: 변수를 1씩 증가시키거나 감소시키는 연산자입니다. ++ (증가)와 -- (감소)가 있습니다.

int x = 5;
System.out.println(x); // 출력값: 5

x++; // x를 1 증가시킴
System.out.println(x); // 출력값: 6

x--; // x를 1 감소시킴
System.out.println(x); // 출력값: 5

증감 연산자에는 전위 증감 연산자(prefix increment/decrement)와 후위 증감 연산자(postfix increment/decrement)가 있습니다. 전위 연산자는 변수의 값을 먼저 증가시키거나 감소시킨 다음에 다른 연산을 수행합니다. 반면 후위 연산자는 다른 연산을 먼저 수행한 다음에 변수의 값을 증가시키거나 감소시킵니다. 

 

int x = 5;

// 전위 증감 연산자 사용
int y = ++x;
System.out.println("전위 연산 결과: " + y); // 출력값: 6
System.out.println("전위 연산 이후 x 값: " + x); // 출력값: 6

// 후위 증감 연산자 사용
int z = x++;
System.out.println("후위 연산 결과: " + z); // 출력값: 6
System.out.println("후위 연산 이후 x 값: " + x); // 출력값: 7

++x는 변수 x를 먼저 1 증가시키고, 그 값(6)을 변수 y에 할당합니다. 따라서 y의 값은 6이 되고, x의 값도 6이 됩니다. 반면에 x++는 변수 x의 현재 값(6)을 변수 z에 할당한 다음에 x 값을 1 증가시킵니다. 따라서 z의 값은 6이 되고, x의 값은 7이 됩니다.

 

그러면, 문제: 변수 num의 값이 10일 때, 다음 코드의 실행 결과는 무엇인가요?

int num = 10;
int result = num++ * ++num;

 

 

---