2023.06.08.목.TIL

heeh·2023년 6월 8일

TIL

목록 보기

17/82

팀프로젝트

오류 때문에 팀원분이 리셋하고 해주심...

Java

C/C++과 유사하며, 안정성, 이식성, 보안성 등의 특징

변수 (Variables)

변수의 유형에는 정수(int), 실수(double), 문자(char), 논리(boolean) 등

int age = 25;  // 정수형 변수 선언 및 초기화
double pi = 3.14;  // 실수형 변수 선언 및 초기화
char grade = 'A';  // 문자형 변수 선언 및 초기화
boolean isTrue = true;  // 논리형 변수 선언 및 초기화

데이터 유형 (Data Types)

기본 데이터 유형과 참조 데이터 유형을 제공

기본 데이터 유형 : 정수형, 실수형, 문자형, 논리형 등

정수형 (Integer Types)

byte myByte = 10; 
// 8비트로 표현되는 부호 있는 정수를 저장, 128부터 127까지

short myShort = 20000;
// 16비트로 표현되는 부호 있는 정수를 저장, -32,768부터 32,767까지

int myInt = 1000000;
// 32비트로 표현되는 부호 있는 정수를 저장, -2,147,483,648부터 2,147,483,647까지

long myLong = 123456789L;
// L을 사용하여 long 유형임을 나타냅니다.
// 64비트로 표현되는 부호 있는 정수를 저장, -9,223,372,036,854,775,808부터 9,223,372,036,854,775,807까지

실수형 (Floating-Point Types)

float myFloat = 3.14f;
// f를 사용하여 float 유형임을 나타냅니다.
// 32비트로 표현되는 단정밀도 부동소수점 수를 저장, 범위와 정밀도에 제한

double myDouble = 3.14159;
// 64비트로 표현되는 배정밀도 부동소수점 수를 저장, 기본적으로 실수 값에는 double을 사용

문자형 (Character Type)

char myChar = 'A'; // char: 16비트로 표현되는 유니코드 문자를 저장

논리형 (Boolean Type)

boolean myBoolean = true; // boolean : 참(True) 또는 거짓(False) 값을 저장

참조 데이터 유형 : 클래스, 배열 등

클래스 (Class)
- 클래스를 사용하여 객체를 정의하고 관련된 데이터와 메서드를 포함 시킨다
- 클래스는 사용자 정의 데이터 유형으로, 필드(속성)와 메서드(동작)로 구성
```
public class Person {
    String name;
    int age;

    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}
```
- Person 클래스는 name과 age라는 필드를 가지며, sayHello()라는 메서드를 정의
배열 (Array)
- 배열은 고정 크기로 선언, 인덱스를 사용하여 개별 요소에 접근할 수 있다
- 배열은 한 번 생성되면 크기를 변경할 수 없고 요소의 유형과 크기가 고정됨
```
int[] numbers = new int[5];
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;
```
인터페이스(Interface)
- 추상 메서드
  - 인터페이스는 추상 메서드의 집합을 정의
  - 추상 메서드는 메서드의 선언만 있고 구현은 없음
  - 인터페이스를 구현하는 클래스는 해당 메서드를 구체적으로 구현해야 함
- 상수
  - 인터페이스는 상수(변하지 않는 값)를 정의할 수 있음
  - public static final
  - 인터페이스를 구현하는 클래스에서 접근할 수 있음
- 다중 상속
  - 클래스는 단일 상속 지원, 인터페이스는 다중 상속 지원
  - 클래스가 여러 인터페이스를 구현할 수 있으므로 다중 상속을 통해 클래스에 다양한 기능을 추가할 수 있음
```
public interface Drawable {
    void draw();  // 추상 메서드 선언

    // 상수 선언
    int MAX_WIDTH = 100;
    int MAX_HEIGHT = 100;
}
```
- Drawable 인터페이스는 draw() 메서드와 MAX_WIDTH, MAX_HEIGHT라는 상수를 정의
- 이 인터페이스를 구현하는 클래스는 draw() 메서드를 구체적으로 구현

컬렉션(Collection)

여러 요소를 모아서 관리하기 위한 데이터 구조를 제공
동적으로 크기가 조정되며, 다양한 연산(추가, 삭제, 검색, 정렬 등)을 수행할 수 있는 유용한 기능을 제공
동적 크기: 컬렉션은 요소의 개수를 동적으로 조정할 수 있음
- 필요에 따라 요소를 추가하거나 제거할 수 있어 유연성을 제공
제네릭(Generic) 지원: 컬렉션 클래스는 제네릭을 사용하여 다양한 유형의 요소를 저장할 수 있음
- 컬렉션 내의 요소 유형을 컴파일 시에 체크하여 안정성을 보장
다양한 연산 지원: 컬렉션은 요소 추가, 삭제, 검색, 정렬 등 다양한 연산을 지원
- 데이터를 효율적으로 관리하고 처리할 수 있음

주요 컬렉션 클래스

List: 순서가 있는 요소의 집합으로, 중복을 허용
→ ArrayList, LinkedList, Vector 등

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
    public static void main(String[] args) {
        // ArrayList 생성
        List<String> fruits = new ArrayList<>();

        // 요소 추가
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        fruits.add("Apple");  // 중복 요소 추가

        // 요소 접근
        System.out.println("첫 번째 과일: " + fruits.get(0));  // 인덱스 0의 요소 가져오기

        // 요소 순회
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // 요소 삭제
        fruits.remove("Banana");

        // 리스트 크기 확인
        System.out.println("리스트 크기: " + fruits.size());
    }
}



import java.util.LinkedList;
import java.util.List;

public class LinkedListExample {
    public static void main(String[] args) {
        // LinkedList 생성
        List<Integer> numbers = new LinkedList<>();

        // 요소 추가
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        // 요소 접근
        System.out.println("첫 번째 숫자: " + numbers.get(0));  // 인덱스 0의 요소 가져오기

        // 요소 순회
        for (int number : numbers) {
            System.out.println(number);
        }

        // 요소 삭제
        numbers.remove(1);

        // 리스트 크기 확인
        System.out.println("리스트 크기: " + numbers.size());
    }
}

Set: 순서가 없는 요소의 집합으로, 중복을 허용하지 않음
→ HashSet, TreeSet 등

import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        // HashSet 생성
        Set<String> colors = new HashSet<>();

        // 요소 추가
        colors.add("Red");
        colors.add("Green");
        colors.add("Blue");
        colors.add("Red");  // 중복된 요소 추가

        // 요소 접근
        for (String color : colors) {
            System.out.println(color);
        }

        // 요소 삭제
        colors.remove("Green");

        // 집합 크기 확인
        System.out.println("집합 크기: " + colors.size());
    }
}



import java.util.Set;
import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        // TreeSet 생성
        Set<Integer> numbers = new TreeSet<>();

        // 요소 추가
        numbers.add(10);
        numbers.add(50);
        numbers.add(30);
        numbers.add(20);
        numbers.add(10);  // 중복된 요소 추가

        // 요소 접근
        for (int number : numbers) {
            System.out.println(number);
        }

        // 요소 삭제
        numbers.remove(30);

        // 집합 크기 확인
        System.out.println("집합 크기: " + numbers.size());
    }
}

Map: 키-값 쌍으로 구성된 요소의 집합으로 키는 중복을 허용하지 않으며, 값은 중복을 허용
→ HashMap, TreeMap, LinkedHashMap 등

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        // HashMap 생성
        Map<String, Integer> studentGrades = new HashMap<>();

        // 요소 추가
        studentGrades.put("John", 85);
        studentGrades.put("Alice", 92);
        studentGrades.put("Bob", 78);
        studentGrades.put("John", 90);  // 중복된 키로 값 추가

        // 요소 접근
        System.out.println("John's grade: " + studentGrades.get("John"));
        System.out.println("Alice's grade: " + studentGrades.get("Alice"));
        System.out.println("Bob's grade: " + studentGrades.get("Bob"));

        // 모든 요소 순회
        for (Map.Entry<String, Integer> entry : studentGrades.entrySet()) {
            String name = entry.getKey();
            int grade = entry.getValue();
            System.out.println(name + "'s grade: " + grade);
        }

        // 요소 삭제
        studentGrades.remove("Bob");

        // 집합 크기 확인
        System.out.println("집합 크기: " + studentGrades.size());
    }
}

HashMap 예제 코드 해석

          import java.util.HashMap;
          import java.util.Map;
          
          public class HashMapExample {
              public static void main(String[] args) {
                  // HashMap 생성
                  Map<String, Integer> studentGrades = new HashMap<>();

HashMap<String, Integer>를 사용하여 학생 이름(String)과 성적(Integer)을 저장하기 위한 HashMap 객체를 생성
HashMap에 Integer 을 사용하는 이유?
- 값의 크기를 표현 : Integer 객체는 정수 값을 갖고 있으며, 이를 통해 값의 크기를 표현할 수 있습니다.
- 객체 타입을 일치 : Integer 객체를 통해 값의 타입을 일치시킬 수 있습니다.
- 자동 박싱과 언박싱을 지원 : int 타입의 값을 Integer 객체로 변환하거나, Integer 객체를 int 타입으로 변환
- 자동 박싱(Autoboxing)? 언박싱(Unboxing)?
  - 자동 박싱(Autoboxing) : 기본형 값을 해당 래퍼 클래스의 객체로 자동 변환
    → int 값을 Integer 객체로 자동 변환
  - 언박싱(Unboxing) : 래퍼 클래스의 객체를 기본형 값으로 자동 변환
    → Integer 객체를 int 값으로 자동 변환
  - HashMap에서 Integer를 사용하는 경우, 값으로 기본형 int를 사용하더라도 자동 박싱과 언박싱이 지원되기 때문에 래퍼 클래스인 Integer 객체로 값을 저장하고 가져올 수 있습니다. 예를 들어, HashMap<String, Integer>의 값으로 int 값을 저장할 수 있고, HashMap은 내부적으로 자동으로 int 값을 Integer 객체로 변환하여 저장하며, 필요한 경우에는 Integer 값을 int로 자동 변환하여 반환합니다.
- HashMap은 키와 값으로 객체를 사용해야 하기 때문에 기본형(primitive)인 int를 직접적으로 사용할 수는 없습니다.
- 기본형을 사용하는 대신 해당하는 래퍼 클래스인 Integer를 사용하여 HashMap에 저장할 수 있습니다.
- HashMap에서 int를 사용해야 한다면 Integer로 변환하여 사용해야 합니다.
- 자동 박싱(Autoboxing)을 통해 편리하게 처리할 수 있습니다.
- 자바에서는 기본형과 해당하는 래퍼 클래스 간의 자동 박싱과 언박싱을 지원하기 때문에, int 값을 Integer로 자동 변환하여 HashMap에 저장하고 가져올 수 있습니다.
```
     javaCopy code
             // 요소 추가
             studentGrades.put("John", 85);
             studentGrades.put("Alice", 92);
             studentGrades.put("Bob", 78);
             studentGrades.put("John", 90);  // 중복된 키로 값 추가
    
```
put() 메서드를 사용하여 학생 이름과 성적을 추가
HashMap에 put() 메서드를 사용하는 이유?
- HashMap에 데이터를 추가하고자 할 때 put() 메서드를 사용하는 것이 일반적
"John"의 성적을 85로, "Alice"의 성적을 92로, "Bob"의 성적을 78로 저장
"John"의 성적을 90으로 변경

HashMap은 중복된 키를 허용하지 않으므로, "John"이라는 키에 해당하는 값은 이전 값인 85가 아닌 90으로 대체

          javaCopy code
                  // 요소 접근
                  System.out.println("John's grade: " + studentGrades.get("John"));
                  System.out.println("Alice's grade: " + studentGrades.get("Alice"));
                  System.out.println("Bob's grade: " + studentGrades.get("Bob"));

get() 메서드를 사용하여 특정 학생의 성적을 조회
HashMap에 get() 메서드를 사용하는 이유?
- HashMap에서 데이터를 가져오는 작업에는 get() 메서드가 가장 일반적이고 효율적
"John"의 성적을 출력하고, "Alice"와 "Bob"의 성적도 출력

get() 메서드는 주어진 키에 해당하는 값을 반환

          javaCopy code
                  // 모든 요소 순회
                  for (Map.Entry<String, Integer> entry : studentGrades.entrySet()) {
                      String name = entry.getKey();
                      int grade = entry.getValue();
                      System.out.println(name + "'s grade: " + grade);
                  }

entrySet() 메서드를 사용하여 모든 요소를 순회
entrySet()은 Map의 모든 요소를 Map.Entry 객체의 형태로 반환
- 각 Map.Entry 객체는 키와 값으로 구성되어 있으며, getKey() 메서드로 키를 얻고, getValue() 메서드로 값을 얻을 수 있음
학생의 이름과 성적을 반복문을 통해 출력
해석이 필요해
- for (Map.Entry<String, Integer> entry : studentGrades.entrySet())
  - studentGrades라는 HashMap의 모든 요소를 반복하기 위한 for-each 루프
  - Map.Entry<String, Integer> entry
  - HashMap에서 키-값 쌍을 나타내는 인터페이스
  - String은 키의 데이터 유형을, Integer는 값의 데이터 유형
  - entry는 각 항목의 키-값 쌍을 나타내는 변수
: studentGrades.entrySet()는 studentGrades HashMap의 모든 키-값 쌍을 반환
- entrySet()은 Map 인터페이스의 메서드 중 하나
- Map 객체의 모든 키-값 쌍을 나타내는 Set을 반환
- studentGrades.entrySet()에서 entrySet()은 studentGrades 맵의 모든 요소를 나타내는 집합(Set)을 반환하는 메서드
- entrySet() 메서드는 이 맵의 모든 요소를 맵 항목(Map.Entry)의 집합으로 반환
- for-each 루프를 통해 이러한 각 항목을 entry 변수에 할당하여 반복
- 즉, for (Map.Entry<String, Integer> entry : studentGrades.entrySet())는 studentGrades HashMap의 모든 항목을 반복하면서 각 항목의 키-값 쌍을 entry 변수에 할당하여 처리하는 것을 의미
String name = entry.getKey();
int grade = entry.getValue();
- entry.getKey()는 entry 객체에서 키 값을 반환하는 메서드
- entry.getValue()는 entry 객체에서 값(value)을 반환하는 메서드
- entry.getKey(); 이게 studentGrades.put("John", 85); 여기서 "John”
- entry.getValue(); 이게 studentGrades.put("John", 85); 여기서 85
- for-each문으로 인해 Map.Entry<String, Integer> entry가 studentGrades.entrySet를 참조하여 entry.getValue();에 entry가 붙는다는 것 같음
```
        javaCopy code
                // 요소 삭제
                studentGrades.remove("Bob");
        
```

remove() 메서드를 사용하여 "Bob"의 성적을 삭제

          javaCopy code
                  // 집합 크기 확인
                  System.out.println("집합 크기: " + studentGrades.size());

size() 메서드를 사용하여 HashMap에 저장된 요소의 개수를 확인
- HashMap에 남은 요소의 개수를 출력
- HashMap을 사용하여 학생 이름과 성적을 관리하는 간단한 예제
- HashMap은 키-값 쌍으로 구성된 요소를 효율적으로 저장하고 접근할 수 있는 자료구조

HashMap 예제 코드의 터미널 해석
해당 코드를 실행하면 다음과 같은 터미널 결과가 출력됩니다:

           // 요소 접근
          John's grade: 90
          Alice's grade: 92
          Bob's grade: null
          
          // 모든 요소 순회
          John's grade: 90
          Alice's grade: 92
          
          // 집합 크기 확인
          집합 크기: 2

첫 번째 줄에서는 "John"의 성적이 90으로 출력
- 중복된 키인 "John"에 대한 값이 마지막으로 추가된 값인 90으로 대체되었기 때문
두 번째 줄에서는 "Alice"의 성적이 92로 출력
- "Alice"의 성적은 중복된 키가 없으므로 92가 그대로 유지
세 번째 줄에서는 "Bob"의 성적이 null로 출력
- "Bob"이라는 키에 대한 값이 삭제되었기 때문
- remove() 메서드를 사용하여 "Bob"의 성적을 삭제했기 때문에 해당 키에 대한 값이 없어져서 null이 출력
네 번째 줄부터는 for 루프를 통해 모든 요소를 순회하면서 학생의 이름과 성적을 출력
- 출력되는 결과는 "John"과 "Alice" 두 명의 학생에 대한 정보
- 마지막 줄에서는 집합의 크기를 출력
- 요소 "Bob"이 삭제되었으므로 HashMap에는 "John"과 "Alice" 두 개의 요소가 남아서 "집합 크기: 2"가 출력
열거형(Enum) 등도 참조 데이터 유형에 해당

조건문 (Conditional Statements)

프로그램의 흐름을 제어

if문

int num = 10;

if (num > 0) {
    System.out.println("양수입니다.");
} else if (num < 0) {
    System.out.println("음수입니다.");
} else {
    System.out.println("0입니다.");
}

switch문

int day = 3;
String dayName;

switch (day) {
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    case 4:
        dayName = "Thursday";
        break;
    case 5:
        dayName = "Friday";
        break;
    default:
        dayName = "Invalid day";
        break;
}

System.out.println("Day is: " + dayName);

반복문 (Loops)

반복적인 작업을 수행
for문
- 기본적인 for문
```
for (int i = 1; i <= 5; i++) {
    System.out.println("Count: " + i);
} // 1부터 5까지의 숫자를 출력
```
  - int i = 1
    → 변수 i를 초기값 1로 설정
  - i <= 5
    → i가 5 이하인 동안 반복
  - i++
    → i가 1씩 증가
- 배열과 함께 사용하는 for-each문
```
int[] numbers = {1, 2, 3, 4, 5};

for (int number : numbers) {
    System.out.println("Number: " + number);
} // numbers 배열의 모든 요소를 출력
```
  - numbers에 저장된 요소들을 하나씩 순회하며 출력하는 for-each문의 예제
  - numbers 배열의 각 요소를 number 변수에 할당하여 반복문 내에서 사용
- 이중 for문
```
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        System.out.println("i: " + i + ", j: " + j);
    }
} //1부터 3까지의 숫자를 각각 3번씩 출력
```
  - 외부의 for문은 변수 i가 1부터 3까지 반복하며 실행
  - 내부의 for문은 변수 j가 1부터 3까지 반복하며 실행
  - 반복문 내에서 i와 j의 값을 출력
```
i: 1, j: 1
i: 1, j: 2
i: 1, j: 3
i: 2, j: 1
i: 2, j: 2
i: 2, j: 3
i: 3, j: 1
i: 3, j: 2
i: 3, j: 3
```
  - 외부의 for문에서 변수 i가 1일 때 내부의 for문이 실행되고, 변수 j가 1, 2, 3 순서로 반복하며 값을 출력
while문
- 기본적인 while문
```
int count = 1;

while (count <= 5) {
    System.out.println("Count: " + count);
    count++;
} // 1부터 5까지의 숫자
```
  - count를 초기값 1로 설정
  - count가 5 이하인 동안 반복
  - System.out.println("Count: " + count);
    → "Count: "와 count의 값을 출력
  - count++;
    → count를 1씩 증가
- 사용자 입력에 따른 while문
```
import java.util.Scanner;

Scanner scanner = new Scanner(System.in);
String input = "";

while (!input.equals("quit")) {
    System.out.print("Enter a value (or 'quit' to exit): ");
    input = scanner.nextLine();
    System.out.println("You entered: " + input);
}

scanner.close();
```
  - 사용자가 "quit"를 입력하기 전까지 값을 입력받는 while문
  - 입력된 값이 "quit"가 아닐 경우, 입력된 값을 "You entered: "와 함께 출력
  - (!input.equals("quit")
    → input: 사용자로부터 입력받은 값을 저장한 변수
    → equals("quit"): input 변수의 값과 문자열 "quit"을 비교
    → equals() 메소드는 문자열을 비교하는 메소드
    → input 값과 "quit"이 동일한지를 검사
    → !: 논리 부정 연산자로, 결과값을 반대로 바꿔줌
    → input.equals("quit")의 결과값에 논리 부정을 적용
    → "quit"와 동일하지 않을 때 참(true)이 되는 조건식
    → 참이 돼서 계속 실행됨
  - true(참)이 되면 계속 실행되고 false가 되면 종료?
    - 만약 조건식이 true로 평가되면, 조건문 내의 코드 블록이 실행됩니다. 이후에 다시 조건식을 평가하고, 조건식이 여전히 true인 경우 코드 블록이 반복해서 실행됩니다. 이런 방식으로 조건식이 true인 동안 계속해서 실행됩니다.
    - 하지만 조건식이 false로 평가되면, 조건문 내의 코드 블록이 실행되지 않고 조건문을 빠져나옵니다. 따라서 조건식이 false인 경우에는 해당 코드 블록이 실행되지 않습니다.
```
Enter a value (or 'quit' to exit): Hello
You entered: Hello
Enter a value (or 'quit' to exit): Java
You entered: Java
Enter a value (or 'quit' to exit): quit
You entered: quit
```
  - "Hello"를 입력하고 출력한 후, "Java"를 입력하고 출력
  - 사용자가 "quit"를 입력하면 반복문이 종료
- do-while문
```
do {
    // 코드 블록
} while (조건식);
```
  - do-while 문은 일단 코드 블록을 실행한 후에 조건식을 평가
  - 코드 블록은 최소한 한 번은 실행
  - 반복문의 실행을 최소한 한 번 보장해야 하는 경우에 유용하게 사용됨
```
int count = 0;
do {
    System.out.println("Count: " + count);
    count++;
} while (count < 5);
```
  - int count = 0;
    → ount 변수를 0으로 초기화
  - System.out.println("Count: " + count);
    → do-while 문을 사용하여 count 값을 출력
  - count++;
    → count를 증가
  - while (count < 5);
    → count가 5보다 작은 동안에는 계속해서 반복 실행
```
Count: 0
Count: 1
Count: 2
Count: 3
Count: 4
// 0부터 4까지의 숫자가 출력
```
  - do 블록 실행 시 count는 0이므로 "Count: 0"이 출력
  - count는 1로 증가
  - count < 5가 여전히 참이므로 다시 do 블록이 실행
  - count가 4까지 증가할 때까지 반복

메서드 (Methods)

프로그래밍에서 기능을 수행하는 코드의 블록
필요한 경우 매개변수(파라미터)를 받아들일 수 있고, 결과값을 반환할 수도 있음
코드의 재사용성과 모듈화를 촉진하는 데 사용

[접근 제어자] [리턴 타입] [메서드 이름](매개변수 리스트) {
    // 메서드의 실행 코드
    // 필요한 작업을 수행
    [return 문;]
}

접근 제어자(Access Modifier): 메서드에 접근할 수 있는 범위를 지정, 일반적으로 public, private, protected 등이 사용
리턴 타입(Return Type): 메서드가 반환하는 값의 데이터 유형을 지정, 메서드가 결과값을 반환하지 않을 경우 void로 지정
메서드 이름(Method Name): 메서드를 식별하기 위한 이름
매개변수 리스트(Parameter List): 메서드가 필요로 하는 입력 값을 전달받는 변수들의 목록, 매개변수가 없을 수도 있음
메서드의 실행 코드: 메서드가 수행하는 작업을 정의하는 코드 블록
return 문: 메서드가 값을 반환하는 경우, return 키워드를 사용하여 해당 값을 반환
- return 문은 메서드의 실행을 종료하고, 값을 호출한 곳으로 반환

메서드의 예제

두 개의 정수를 더하는 메서드의 예
```
public class MethodExample {
    public static void main(String[] args) {
        int result = addNumbers(3, 5);
        System.out.println("두 숫자의 합: " + result);
    }

    public static int addNumbers(int a, int b) {
        int sum = a + b;
        return sum;
    }
}
```
- addNumbers라는 이름의 메서드는 int 타입의 두 개의 매개변수 a와 b를 받아들임
- 메서드는 a와 b를 더한 값을 sum 변수에 저장
- return 문을 사용하여 결과값을 반환
- main 메서드에서 addNumbers 메서드를 호출하고, 결과값을 result 변수에 저장
- 실행하면 "두 숫자의 합: 8"이 출력
- return을 왜 써?
  - return을 사용하지 않으면 메서드는 실행된 후 아무 값도 반환하지 않고, 호출한 곳으로 돌아감
  - 메서드가 값을 반환하는 경우, 호출한 곳에서 반환값을 받아서 다양한 방식으로 활용할 수 있음
  - return 안 쓰게 된다면?
```
public static int multiply(int a, int b) {
    int result = a * b;
}
```
    - a와 b를 곱한 값을 계산한 후, 어떤 값을 반환하지 않고 메서드가 끝나게 되면 호출한 곳에서는 multiply 메서드의 결과를 활용할 수 없음
    - multiply 메서드를 호출하더라도 결과를 저장하거나 활용할 수 있는 방법이 없음
  - multiply 메서드에서 return을 사용하여 값을 반환하는 예제
```
public static int multiply(int a, int b) {
    int result = a * b;
    return result;
}
```
    - 하지만 return 문을 사용하여 값을 반환한다면, 호출한 곳에서 해당 값을 활용할 수 있음
```
int product = multiply(3, 5);
```
    - multiply 메서드에서 계산된 결과가 product 변수에 저장되어 활용

메서드의 다른 쉬운 예제

public class Calculator {
    public static int add(int a, int b) {
        int sum = a + b;
        return sum;
    }

    public static void main(String[] args) {
        int result = add(3, 5);
        System.out.println("결과: " + result);
    }
}

Calculator 클래스 안에 add 메서드를 정의
add 메서드는 두 개의 정수를 받아서 더한 후 그 결과를 반환
main 메서드에서는 add 메서드를 호출하고, 반환된 값을 변수 result에 저장한 후 출력
즉, 두 개의 숫자를 더한 결과가 반환되어 변수 result에 저장
```
결과: 8
```

그렇다면 변수가 들어있고 그 변수를 리턴해주는 메서드를 만들면 그 메서드는 다른 메서드에서 응용해서 사용할 수 있다는거야?
- 맞습니다! 변수를 리턴하는 메서드를 정의하면, 해당 메서드의 반환값을 다른 메서드나 코드에서 활용할 수 있음
```
public static int calculateSum(int a, int b) {
    int sum = a + b;
    return sum;
}
```
- 위의 메서드는 a와 b를 더한 값을 계산, sum 변수에 저장한 후 그 값을 반환
- 다른 메서드에서 이 calculateSum 메서드를 활용할 수 있음
- main 메서드에서 calculateSum 메서드를 호출하고 반환값을 변수에 저장하는 예제
```
public static void main(String[] args) {
    int result = calculateSum(3, 5);
    System.out.println("결과: " + result);
}
```
  - calculateSum(3, 5)는 메서드를 호출하고 반환된 결과를 result 변수에 저장
  - result 변수의 값을 출력
  - calculateSum 메서드를 정의하고 반환값을 활용하면, 다른 메서드에서 이 값을 변수에 저장하거나 다른 연산에 활용할 수 있음
  - 이를 통해 메서드 간에 데이터를 주고받거나, 계산 결과를 활용하는 등 다양한 응용이 가능