• 순서가 중요하지 않은 요소를 다룰 때 주로 사용
• Collection 인터페이스의 하위 인터페이스
• 중복을 허용하지 않음
• 각 요소의 고유성 보장
• null 값 저장 가능 (단, 하나만)

요소의 정렬 여부는 구현체에 따라 다름:

🔷 주요 메소드

📌 HashSet

• Set 인터페이스의 대표 구현체
• 내부적으로 HashMap을 기반으로 동작
• 순서 보장 X
• 중복 허용 X, null 저장 가능
• 해시 함수를 이용해 빠른 접근 (평균 시간 복잡도: O(1))

🔷 동작 원리

1. hashCode() 값 계산

   • 요소의 해시값을 이용해 배열의 인덱스를 결정
   • 예: 배열 길이 5 → hashCode % 5로 저장 위치 결정

2. 해시 충돌(Collision) 처리

   • 같은 해시값 → 같은 버킷
   • Java 7까지는 LinkedList, Java 8부터는 일정 개수 초과 시 Red-Black Tree로 변환

3. equals()로 중복 여부 확인

   • 해시값이 같더라도 equals()로 비교하여 정확한 중복 여부 판별

4. 저장

   • add() 메소드는 내부적으로 HashMap.put() 사용

💻 예제 코드

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("apple");
        set.add("banana");
        set.add("apple"); // 중복 무시
        System.out.println(set); // [banana, apple] (순서 보장 X)
    }
}

🔷 HashSet에서 객체를 저장할 때hashCode()와 equals()를 재정의해야 하는 이유

Java에서 HashSet, HashMap, Hashtable과 같은 해시 기반 컬렉션은 객체를 저장하거나 검색할 때 내부적으로 hashCode()와 equals() 메소드를 사용

이 메소드들을 제대로 재정의하지 않으면, 중복 체크나 검색이 제대로 동작하지 않아 예상치 못한 결과를 낳을 수 있습니다.

🔶 Hash 기반 컬렉션의 동작 원리

1. 객체의 hashCode()를 호출해서 저장할 버킷(bucket) 위치를 찾음
2. 해당 버킷에 데이터가 존재하면, equals()를 호출해서 동일 객체인지 비교
   • equals() 결과가 true → 중복으로 판단하고 추가하지 않음
   • false → 같은 버킷에 저장 (해시 충돌 처리)

⚠️ 재정의를 안 하면 생기는 문제

❌ hashCode()를 재정의하지 않은 경우

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (o instanceof Person) {
            return this.name.equals(((Person) o).name);
        }
        return false;
    }

    // hashCode()를 재정의하지 않음
}

public class Main {
    public static void main(String[] args) {
        HashSet<Person> set = new HashSet<>();
        set.add(new Person("Alice"));
        set.add(new Person("Alice")); // 서로 다른 객체지만 equals는 true → hashCode는 달라서 다른 버킷에 저장됨
        System.out.println(set.size()); // 출력: 2
    }
}

✅ 재정의 한 경우

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (o instanceof Person) {
            return this.name.equals(((Person) o).name);
        }
        return false;
    }

    @Override
    public int hashCode() {
        return name.hashCode(); // 문자열의 hashCode 사용
    }
}

public class Main {
    public static void main(String[] args) {
        HashSet<Person> set = new HashSet<>();
        set.add(new Person("Alice"));
        set.add(new Person("Alice")); // equals와 hashCode 모두 같음 → 중복으로 인식
        System.out.println(set.size()); // 출력: 1
    }
}

📌 TreeSet

• Set 인터페이스를 구현한 클래스 중 하나로 중복을 허용하지 않으며, 요소를 자동 정렬함
• 내부적으로 TreeMap을 기반으로 동작
• 이진 탐색 트리(Binary Search Tree)의 일종인 Red-Black Tree 구조를 사용
• 기본 정렬은 오름차순
• 사용자 정의 정렬을 위해 Comparator 사용 가능
• 성능: 검색, 삽입, 삭제 O(log N)

🔷 특징

• 중복 X, 정렬 O, 순서 O (정렬된 순서)
• 삽입과 삭제가 많고, 정렬이 필요한 경우에 적합

💻 예제 코드

import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<Integer> set = new TreeSet<>();
        set.add(30);
        set.add(10);
        set.add(20);
        System.out.println(set); // [10, 20, 30] (자동 오름차순 정렬)
    }
}

📌 LinkedHashSet

• Set 인터페이스를 구현한 클래스 중 하나
• 중복을 허용하지 않으면서 삽입 순서를 유지함
• 내부적으로 LinkedHashMap을 기반으로 동작
• 정렬 기능은 없음 (순서만 유지, TreeSet과 다름)

🔷 특징

• 중복 X, 순서 O, 정렬 X
• 순서를 유지하고 싶지만 정렬은 필요 없는 경우에 적합

💻 예제 코드

import java.util.LinkedHashSet;

public class Main {
    public static void main(String[] args) {
        LinkedHashSet<String> set = new LinkedHashSet<>();
        set.add("B");
        set.add("A");
        set.add("C");
        System.out.println(set); // [B, A, C] - 입력한 순서 그대로 출력
    }
}

📌 List 인터페이스란?

• Collection 인터페이스의 하위 인터페이스
• 중복된 요소를 저장할 수 있음
• 요소의 삽입 순서를 유지
• 인덱스를 사용하여 요소에 접근 가능
• 저장된 데이터의 양에 따라 자동으로 크기가 조절

📌 주요 메서드

📌 주요 구현체

1. ArrayList

• 내부적으로 배열을 기반으로 구현
• 요소 접근 속도가 빠름 (O(1))
• 삽입/삭제는 느릴 수 있음 (중간 요소 이동 필요)

2. LinkedList

• 노드(Node) 기반으로 구현 (연결 리스트)
• 요소 삽입/삭제가 빠름 (특히 앞/뒤)
• 요소 접근은 느림 (O(N))

3. Vector

• ArrayList와 유사하지만, 동기화(synchronized) 지원
• 멀티스레드 환경에서 안전하지만 성능 저하 우려

📌 ArrayList

🔍 특징

• 내부적으로 동적 배열을 사용
• 처음에는 일정 크기로 시작, 꽉 차면 크기를 자동 확장
• 중복 요소 허용, 삽입 순서 유지

✅ 장점

• 빠른 접근 속도 → O(1)
• 자동 크기 확장
• 인덱스를 통한 직관적인 요소 접근

❌ 단점

• 중간 요소 삭제 시 모든 요소를 이동해야 함 → O(N)

💻 예제 코드

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add(1, "Orange"); // 인덱스 1에 삽입
        list.remove("Banana"); // Banana 삭제
        System.out.println(list.get(0)); // Apple
        System.out.println(list); // [Apple, Orange]
    }
}

📌 LinkedList

🔍 특징

• LinkedList는 자료구조인 연결 리스트(Linked List)를 기반으로 구현된 List의 구현체입니다.
• 각 요소는 노드(Node)로 구성되며, 데이터와 다음 노드에 대한 참조(링크)를 포함합니다.
• 순차적인 인덱스를 사용하는 배열과 달리, 메모리 공간이 연속적이지 않아도 되며, 삽입 및 삭제에 유리합니다.

✅ 장점

• 빠른 삽입/삭제
  리스트 앞이나 뒤에서의 삽입/삭제는 O(1)의 시간 복잡도를 가짐
• 동적 크기 조정
  배열처럼 크기를 미리 지정할 필요가 없음
• 양방향 연결 리스트
  앞뒤 요소 탐색이 모두 가능 (LinkedList는 Doubly Linked List)

❌ 단점

• 느린 요소 접근 속도
  인덱스를 사용해 접근할 경우, 처음부터 순차 탐색해야 하므로 O(N)
• 더 많은 메모리 사용
  각 노드가 데이터와 함께 이전/다음 노드 참조 정보를 함께 저장

💻 예제 코드

import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("Dog");
        list.add("Cat");
        list.addFirst("Tiger"); // 맨 앞에 삽입
        list.removeLast();      // 맨 뒤 요소 삭제
        System.out.println(list); // [Tiger, Dog]
    }
}

• 변수 : 데이터를 저장하기 위한 메모리 공간

• 상수

  • 상수는 최초 초기화 후 값을 재정의 할 수 없음
  • static final 키워드 사용

• 변수명 규칙

  • 대소문자 구분
  • 길이제한 없음
  • 숫자로 시작할 수 없음
  • 특수문자는 "_, $" 만 허용
  • 변수명에 공백 X
  • 예약어 사용 금지

• 기본 자료형

  • 정수형 : byte, short, int, long
  • 실수형 : float, double
  • 논리형 : boolean
  • 문자형 : char (한 개로 이루어진 문자)

• 래퍼런스 타입(Reference Type) : 자바에서 변수에 저장되는 값이 기본 자료형의 값이 아닌, 객체나 주소(참조)인 데이터 타입이며,실제 데이터는 힙(Heap) 메모리 공간에 저장된다.

  • String, Array, Class, Interface, Object, Enum, 사용자 정의 객체 등
  • 박싱 (boxing) : 기본 자료형의 값을 래퍼런스 타입으로 변환하는 과정
  • 언박싱 (unboxing) : 반대로 래퍼런스 타입을 기본 자료형으로 변환하는 과정
  • Java5 이후부터는 명시적으로 변환하지 않아도 자동 변환되는 오토박싱과 오토언박싱을 지원함

• 기본 자료형과 래퍼런스 타입의 차이점

2. 연산자

• 연산자 : 프로그램에서 연산을 위해 사용하는 기호를 연산자(Operator)라고 한다. 자바에서 사용하는 연산자(Operators)는 크게 산술 연산자, 비교 연산자, 논리 연산자, 대입 연산자, 비트 연산자 등 여러 종류로 나눌 수 있다

2-1. 산술 연산자 (Arithmetic Operators)

산술 연산자는 수학적인 계산을 수행할 때 사용된다.

2-2. 비교 연산자 (Comparison Operators)

비교 연산자는 두 값을 비교하고, 결과를 불리언 값 (true 또는 false)으로 반환한다.

2-3. 논리 연산자 (Logical Operators)

논리 연산자는 두 개 이상의 조건을 결합하여 결과를 true 또는 false로 반환한다.

2-4. 대입 연산자 (Assignment Operators)

대입 연산자는 변수에 값을 할당하는 데 사용된다.

2-5. 비트 연산자 (Bitwise Operators)

비트 연산자는 이진수 단위로 비트 연산을 수행한다.

2-6. 증감 연산자 (Increment and Decrement Operators)

증감 연산자는 변수를 1만큼 증가시키거나 감소시킬 때 사용된다.

2-7. 삼항 연산자 (Ternary Operator)

삼항 연산자는 조건에 따라 두 값을 선택하는 간단한 조건문이다.

3. 조건문

조건문은 프로그램의 흐름을 제어하고 특정 조건에 따라 다른 코드를 실행하게 해주는 구문을 말한다.

3-1. if문

if 문은 주어진 조건이 true일 때 특정 코드를 실행한다. 조건이 false일 경우에는 실행되지 않는다.

if (조건) {
    // 조건이 true일 때 실행되는 코드
}

3-2. else if 문

else if 문은 여러 개의 조건을 검사하고, 그 중 첫 번째로 참인 조건을 실행한다. 모든 조건이 거짓일 경우, else 블록이 실행된다.

if (조건1) {
    // 조건1이 true일 때 실행되는 코드
} else if (조건2) {
    // 조건2가 true일 때 실행되는 코드
} else {
    // 모든 조건이 false일 때 실행되는 코드
} 

3-3. switch 문

switch 문은 여러 가지 조건 중에서 하나를 선택하는데 유용한 조건문이다. switch 문은 조건이 여러 개일 때 더 깔끔하게 작성할 수 있다.

switch (변수) {
    case 값1:
        // 변수의 값이 값1일 때 실행되는 코드
        break;
    case 값2:
        // 변수의 값이 값2일 때 실행되는 코드
        break;
    default:
        // 변수의 값이 어떤 case와도 일치하지 않을 때 실행되는 코드
}

3-4. break, continue

• break: 반복문에서 조건을 만족하면 즉시 반복을 종료하여 벗어난다.
• continue: 반복문에서 조건을 만족하면 해당 반복을 건너뛰고 다음 반복으로 넘어간다.

4. 반복문

반복문은 특정 조건이 참일 동안 특정 코드 블록을 반복적으로 실행한다.

4-1. for 문

for문은 중복된 코드를 특정 횟수만큼 반복할 때 사용한다. (초기값, 조건값, 증감식)으로 구성되어 있다.

for (int i = 0; i < 5; i++) {
    System.out.println("i : " + i);
}

4-2. while 문

while문은 주어진 조건이 true일 때 계속 반복한다. 반복 전에 조건을 먼저 검사하고 조건이 false이면 반복문을 종료한다.

int i = 0;
while (i < 5) {
    System.out.println("i : " + i);
    i++;
}

4-3. do-while 문

do-while문은 반목문을 최소 한번 실행한 후 조건을 검사한다. 즉, 조건이 false일지라도 코드 블록이 한번은 실행된다.

int i = 0;
do {
    System.out.println("i의 값: " + i);
    i++;
} while (i < 5);

5. 배열

배열은 동일한 데이터 타입의 값을 여러 개 저장할 수 있는 데이터 구조이다. 자바에서 배열은 고정 크기를 가지며, 인덱스를 통해 배열의 각 요소에 접근할 수 있다.

5-1. 배열 선언

배열을 선언할 때는 배열의 데이터 타입을 먼저 지정하고, 그 뒤에 대괄호 []를 붙여 배열임을 명시합니다.

타입[] 배열명;
// ex
int[] numbers;
String[] names;

5-2. 배열 생성

배열의 크기는 생성시에 지정되며, 배열 크기는 고정되어 변경할 수 없다.

배열명 = new 타입[크기];
// ex
numbers = new int[5];  // 크기가 5인 정수형 배열 생성
names = new String[3]; // 크기가 3인 문자열 배열 생성

5-3. 배열 초기화

배열을 선언과 동시에 값을 초기화 할 수 있다. 배열을 초기화할 때는 대괄호 안에 값을 넣는다.

타입[] 배열명 = {값1, 값2, 값3, ...};
// ex
int[] numbers = {1, 2, 3, 4, 5};  // 크기가 5인 배열 초기화
String[] names = {"John", "Jane", "Tom"};  // 크기가 3인 배열 초기화

5-4. 배열 값 접근

배열 값은 인덱스를 사용하여 접근한다. 배열의 인덱스는 0부터 시작한다.

int[] numbers = {1, 2, 3, 4, 5};
System.out.println(numbers[0]);  // 첫 번째 요소 출력 -> 1
System.out.println(numbers[3]);  // 네 번째 요소 출력 -> 4

5-5. 다차원 배열

타입[][] 배열명;
배열명 = new 타입[행의 수][열의 수];

// ex
int[][] matrix = new int[3][3];  // 3x3 배열 생성
matrix[0][0] = 1;  // 첫 번째 행 첫 번째 열에 값 1 할당
matrix[2][2] = 9;  // 세 번째 행 세 번째 열에 값 9 할당

6. 클래스 (Class)

객체를 생성하기 위한 설계도로 변수, 생성자와 메소드로 구성되어있다. 객체 지향 프로그래밍(OOP)의 기본 단위이며, 클래스를 사용하여 객체를 생성하고 해당 객체가 수행할 동작을 정의할 수 있다.

• 클래스가 필요한 이유

  • 데이터 관리의 효율성
  • 코드의 재사용성
  • 데이터 보호 (캡슐화)
  • 코드의 구조화

6-1. 클래스 선언

클래스를 선언할 때는 class 키워드를 사용하여 클래스 이름 지정한다. 클래스 이름은 각 단어의 첫 글자를 대문자(파스칼 케이스)로 사용한다.

public class 클래스명 {
    // 필드 (변수)
    // 메서드
}

6-2. 클래스의 변수

• 인스턴스 변수

  • 객체마다 가지는 고유한 값
  • 객체 생성 시에만 사용 가능

• static 변수

  • 모든 객체가 공유하는 값
  • 객체 생성 없이도 사용 가능

• 상수

  • 한 번 값이 정해지면 변경 불가능
  • 보통 static과 함께 사용

6-3. 생성자

• 생성자

  • 객체가 생성될 때 자동으로 호출되는 특별한 메소드
  • 객체의 초기화를 담당
  • 클래스명과 동일한 이름을 가짐

• 기본 생성자

  • 클래스에 생성자가 없으면 자동으로 생성

• 매개변수가 있는 생성자

  • 객체 생성시 초기값을 전달 받음

    public class Car {
    // 필드 (변수)
    
    // 1. 기본 생성자
    public Car() {}
    
    // 2. 매개변수가 있는 생성자
    public Car(String modelName, int price){
    this.modelName = modelName;
    this.price = price;
    }
    }

    6-4. 메소드

• 인스턴스 메소드

  • 객체를 생성해야만 사용할 수 있는 메소드

• static 메소드

  • 객체 생성 없이 클래스만으로도 호출 가능한 메소드

  • 인스턴스 변수를 사용할 수 없음

    public class Car {
    String modelName;
    int price;
    
    // 1. 인스턴스 메소드
    void printPrice(String modelName, int price){
      System.out.println(modelName + "의 가격은 " + price + "원 입니다".
    }
    // 2. static 메소드
    static void printPrice(String modelName, int price){
      System.out.println(modelName + "의 가격은 " + price + "원 입니다".
    }
    }

    6-5. 객체 생성

    클래스를 정의한 후 new 키워드를 사용하여 객체를 생성할 수 있다. 각 객체는 독립적인 메모리 공간을 가지면 같은 클래스로 만들어도 서로 다른 객체는 독립적이다.

    클래스명 객체명 = new 클래스명();
    // ex
    Car myCar = new Car(); 

6-6. 접근제어자

6-6-1. 클래스의 접근제어자

클래스를 정의할 때 public 와 deafult 두 가지 접근제어자를 사용할 수 있다.

• public : public 을 사용하면, 모든 클래스에서 이 패키지 상관없이 클래스에 접근이 가능함
• default : 같은 패키지 안에 클래스만 접근이 가능함

6-6-2. 클래스 멤버의 접근제어자

• public 멤버 : 모든 클래스에서 접근 가능
• private 멤버 : 같은 클래스안에 있는 멤버만 접근 가능
• protected 멤버 : 같은 패키지 안의 멤버, 다른 패키지의 자식 클래스 멤버만 접근 가능
• default 멤버 : 같은 패키지 안에 클래스 멤버만 접근이 가능함

7. 상속

부모 클래스의 기능을 자식 클래스가 물려받아 코드를 재사용하고 확장할 수 있는 개념이다. 객체지향의 핵심 기법으로 코드의 재사용성을 높이고 상속을 통해 클래스 간의 계층적 구조를 설계할 수 있다.

public class Animal {
}

public class Dog extends Animal{
}

7-1. super와 this 키워드

super 키워드를 통해 부모 클래스의 기능을 참조할 수 있다. 만약 생성자에서 호출할 때는 가장 먼저 호출해야한다.

public class Animal {
    Streing name;

    Animal(String name){
        this.name = name;
    }
}

public class Dog extends Animal{
    String breed;

    Dog(String name, String breed){
        super(name); // 부모 생성자 호출
        this.breed = breed;
    }
}

this 키워드는 자기 자신의 멤버(필드 , 메소드)를 참조할 때 사용한다.

public class Animal {
    Streing name;

    // 기본 생성자
    Animal(){
        this("하늘이"); // 다른 생성자 호출
    }

    // 생성자
    Animal(String name){
        this.name = name;
    }
}

7-2. 메소드 오버로딩 (Method Overloading)

메소드 오버로딩은 같은 클래스 내에서 같은 이름의 메소드를 여러 개 정의하는 것이다. 매개변수의 타입, 개수, 순서를 다르게 하여 구분할 수 있다.

class Calculator{
    int add(int a, int b){
        return a + b;
    }
    double add(double a, double b){
        return a + b;
    }
}

7-3. 메소드 오버라이딩 (Method Overriding)

메소드 오버라이딩은 부모 클래스의 메소드를 자식 클래스에서 재정의하는 것을 말한다. 부모의 메소드를 자식 클래스에 맞게 수정해서 사용한다.

public class Animal {
    void sound(){
        System.out.println("동물 소리");
    }
}

public class Dog extends Animal{
    @Override
    void sound(){
        System.out.println("멍멍!");
    }
}

8. 다형성 (Polymorphism)

다형성은 하나의 객체가 여러 가지 타입을 가질 수 있는 것을 말한다. 다형성을 활용하면 부모 타입 참조 변수로 자식 객체를 참조할 수 있다.

• 장점

  • 코드의 유연성 증가
  • 재사용성 향상
  • 유지보수 용이

public class Animal {
    void sound(){
        System.out.println("동물 소리");
    }
}

public class Dog extends Animal{
    @Override
    void sound(){
        System.out.println("멍멍!");
    }
}

public class Main{
    public static void main(String[] args){
        Animal dog = new Dog(); // 개 객체를 동물 타입으로 참조
    }

8-1. 업캐스팅 (Upcasting)

객체의 업캐스팅은 자식 객체를 부모 타입으로 변환하는 것을 말한다. 업캐스팅은 자동으로 변환된다. (묵시적 형변환)

Animal dog = new Dog(); 

8-2. 다운캐스팅 (Downcasting)

객체의 다운캐스팅은 부모 타입을 자식 타입으로 변환하는 것을 말한다. 이 경우에는 명시적 형변환이 필요하다.

Animal animal = new Dog(); 
Dog dog = (Dog) animal;

9. 추상 클래스 (Abstract Class)

• 추상은 객체의 공통 특징이나 속성을 추출하는 개념을 말한다.
• 추상화하는 과정은 복잡한 것을 단순화 하는 것이라고 볼 수 있다.
• 추상 클래스는 abstract 키우더를 사용해 생성할 수있다.
• 내부에는 생성자, 필드, 일반 메소드, 추상 메소드가 포함될 수 있다.
• new 연산자로 객체를 생성할 수 없으며 자식 클래스에서 추상 클래스의 기능을 필수로 구현해야 한다.

9-1. 추상 메소드

• 추상 메소드는 추상 클래스를 상속 받은 자식 클래스가 필수로 구현해야하는 메소드이다.
• 공통 동작은 추상 클래스에서 직접 구현하며, 자식 클래스마다 세부 구현이 달라질 수 있으면 추상 메소드로 선언한다.

10. 인터페이스 (Interface)

객체의 동작을 표준화하는 기법을 인터페이스라고 한다. 추상 메소드와 상수만 가질 수 있다. interface 키워드로 인터페이스를 만들고 구현 클래스에 implements 키워드로 구현하고 싶은 인터페이스를 선언한다.

인터페이스를 사용하는 이유

• 표준화
  • 개발에 필요한 기본 틀 제공
  • 개발자들 간의 일관성 있는 개발 가능
• 다형성 구현
  • 하나의 인터페이스로 다양한 구현이 가능
  • 객체 교체가 쉬움
• 개발 독립성
  • 인터페이스만 정의되면 개발 시작 가능
  • 다른 팀/개발자와 동시 개발 가능
• 유연성
  • 기존 코드 변경 없이 새로운 기능 추가 가능
    • 독립적인 기능 구현 가능

public interface 인터페이스 이름{
    // 상수
    // 추상 메소드
    // default 메소드
}

🔥 Java의 역사

Java는 1991년 Sun Microsystems의 제임스 고슬링과 그의 팀이 개발한 프로그래밍 언어로 처음에 "Oak(오크)"라고 불렸다. Oak는 초기에 가전제품을 제어할 수 있는 언어로 개발되었지만, 1990년대 중반 인터넷의 급격한 성장으로 웹과 네트워크에서 실행 가능한 프로그래밍 언어로 방향을 바꾸게 되었다. 이후 1995년에 Java 1.0을 정식 출시했다.

Java의 장단점

장점

1️⃣ 플랫폼 독립성 (Write Once, Run Anywhere)

Java 프로그램은 JVM(Java Virtual Machine) 위에서 실행되므로, 운영체제(OS)에 상관없이 실행 가능함

2️⃣ 객체지향 프로그래밍 (Object-Oriented Programing, OOP) 지원

캡슐화, 상속, 다형성, 추상화 같은 OOP 개념을 지원하여 코드의 재사용성과 유지보수가 뛰어남

3️⃣ 메모리 자동 관리 (Garbage Collection, GC)

Java의 가비지 컬렉터가 자동으로 메모리를 관리하여 개발자가 직접 메모리에 관여하지 않아도 됨

4️⃣ 멀티스레딩 지원

Java는 멀티스레딩(Multithreading)을 지원하여 여러 작업을 동시에 실행 가능함

5️⃣ 방대한 라이브러리와 프레임워크 지원

Java는 다양한 라이브러리와 프레임워크(Spring, Hibernate, Apache Kafka 등)을 제공하여 개발 속도를 높일 수 있음

단점

1️⃣ 실행 속도가 느림

Java는 JVM 위에서 실행되기 때문에 C, C++ 같은 네이티브 언어보다 속도가 느릴 수 있음.
하지만 JIT(Just-In-Time) 컴파일러와 GraalVM 같은 기술로 성능을 점점 개선하고 있음.

2️⃣ 코드 작성

Java는 문법이 비교적 길어서 Python 같은 언어보다 코드 작성이 번거로움

3️⃣ 로우레벨 지원 부족

하드웨어 직접 제어와 운영체제 수준의 프로그래밍이 어려움

Java의 실행 및 개발 환경

Java의 동작 방식

1. Java 컴파일러가 소스 코드를 바이트 코드(.class)로 변환됨
2. 바이트 코드가 JVM(Java Virtual Machine)에 의해 메모리에 로드됨
3. JVM의 인터프리터(Interpreter) 또는 JIT(Just-In-Time)컴파일러가 바이트 코드를 실행
4. 프로그램 실행이 끝나면 JVM이 할당된 메모리를 정리한 뒤 종료