• Java에서 제공하는 표준 GUI library인 Swing을 대체하기 위해서 만들어진 library
• 당연히 표준 library는 아니다.
• 외부 library이고 다운로드 받아서 설치한 후 사용해야 한다.
• 특별한 용도로 사용되며 일반적으로 사용되는 library는 아니다.
• https://gluonhq.com/products/javafx/
• Properties → Java build Path → library → module path → add external jars
• run as configuration
• arguments → VM ~~
• 사용할 VM arguments
• --module-path“C:\Program Files\Java\javafx-sdk-17.0.10\lib” --add-modules javafx.controls,javafx.fxml

--module-path "C:\Program Files\Java\javafx-sdk-17.0.10\lib" --add-modules javafx.controls,javafx.fxml

package javafxexam;

import javafx.event.EventHandler;
import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class JavaFXExample extends Application{

    @Override
    public void start(Stage primaryStage) throws Exception {
        // 화면구성

        // 1. Pane이라고 표현되는 layout을 만들어야 한다.
        // 여러종류의 Pane이 있는데 그 중 하나를 이용하면 된다.
        // Pane종류마다 버튼같은 component를 배치시키는 방법이 다르다.
        StackPane root = new StackPane();

        // 2. 화면에 보여줄 요소를 생성한다.
        Button btn = new Button();
        btn.setText("클릭");
        // 버튼이 클릭되면 무슨일을 할지 코드로 작성해야 한다.
        // 자바의 event model은 delegation model을 이용한다.
        // 이벤트처리를 위임한다는 의미로 delegation이라는 표현을 이용한다.
        // 버튼을 클릭하면 당연히 버튼이 event source가 된다.
        // event source는 이벤트가 발생한 객체를 지칭한다. => 버튼이 된다.
        // 그런데 이벤트가 발생했을때 이벤트의 처리(로직수행)를 event source가
        // 직접 처리하지 않고 별도의 객체를 이용하게 된다. => Listener객체라고 한다.
        // 당연히 해당 객체 안에는 이벤트를 처리하는 method가 있다.
        // 이 method를 흔히 handler라고 한다.
        // 마지막으로 event source에 listener를 부착시키는 과정이 필요하다.
        // 우리는 Action이라는 event를 사용하자.
        // Action이라는 event는 마우스 클릭, 입력상자에서 enter키 입력을
        // 지칭하는 event

        // 버튼(event source)에서 Action Event가 발생했을 때 처리하는
        // Event Handler객체를 만들어서 이벤트 처리를 하자.
        // 먼저 리스너객체를 만들어 보자.
        // 리스너객체도 당연히 종류가 있다.
        // 어떤 이벤트를 처리하느냐에 따라서 종류가 다르다.
//        btn.setOnAction(new EventHandler<ActionEvent>() {
//            
//            @Override
//            public void handle(ActionEvent arg0) {
//                // TODO Auto-generated method stub
//                System.out.println("너무 힘들어요!");
//            }
//        });

        btn.setOnAction((e) -> {
                // TODO Auto-generated method stub
                System.out.println("출력합니다.");
            }
        );

        // 3. Pane위에 표현할 Component를 위치시켜요!
        root.getChildren().add(btn);

        // 4. Scene을 생성해야 해요!
        Scene scene = new Scene(root, 300, 250);

        // 5. Stage에 Scene을 설정하면 되요!
        primaryStage.setTitle("첫 화면");
        primaryStage.setScene(scene);

        primaryStage.show();

    }

    public static void main(String[] args) {
        launch(args);
    }
}

• Java 1.0부터 제공되는 자바의 기본적인 입출력 방식
• Java IO는 입출력에 관련된 상당히 많은 클래스와 인터페이스를 제공하고, java.io package로 묶어서 제공한다.
• Stream을 기반으로 처리한다.
• 기본적으로 Blocking I/O 방식을 이용한다. 입출력이 완료될 때까지 Thread가 block 된다.
• 대표적인 클래스로 InputStream, OutputStream, Reader, Writer 등이 있다.
• 참고로 Java NIO도 있다.
  • Java 1.4에 처음 등장했다.
  • 이름에서 의미하다시피 Non-Blocking IO를 지원한다. ⇒ 쉽게 말해 비동기 입출력할 수 있다.
  • Stream을 사용하지 않고, Channel과 Buffer을 이용한 처리를 한다.

2. 표준 입력과 표준 출력

• 표준 입력과 표준 출력(standard-in, standard-out)은 사용하는 기기마다 다르다.
• 우리는 PC를 이용하고 있기 때문에 표준 입력 ⇒ 키보드, 표준 출력 ⇒ 모니터로 설정되어 있다.
• 자바에서는 이 표준 입력과 표준 출력을 어떻게 표현할까?
  • System.out ⇒ 표준 출력에 대한 Stream
• 해당 객체(Stream)의 method를 이용해서 데이터를 출력할 수 있다.
  • System.out.println()
• 정리하면 Java는 우리에게 출력 Stream 객체를 하나 기본으로 제공하고 있다. 당연히 해당 객체를 만들기 위한 class가 존재한다. ⇒ java.io.PrintStream

3. Stream

3.1 Stream은 객체이다.

3.2 Stream은 방향성이 있다.

3.3 Stream은 FIFO구조

3.4 Stream은 결합해서 사용할 수 있다.

package test;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class StreamTest {
    public static void main(String[] args) {

        // 키보드로 한 line을 입력 받아서 그대로 출력한다.
        // 당연히 입력 Stream과 출력 Stream이 필요하다.
        // 키보드로부터 입력을 받기 위한 Stream
        // 모니터에 출력하기 위한 출력 Stream
        // 표준 입력(키보드 입력) System.in -> 불편함
        // 표준 출력(모니터 출력) System.out
        InputStreamReader isr = new InputStreamReader(System.in);
        // 아직도 불편하다. InputStreamReader은 문자 단위로 입력 받는다.
        // 우리는 한 line 단위로 입력을 받고 싶다. (문자열 단위로)
        BufferedReader br = new BufferedReader(isr);

        try {
            String msg = br.readLine();
            System.out.println("입력받은 데이터: " + msg);
        } catch (Exception e) {

        }
    }
}

• Monitor : Thread가 획득할 수 있는 자격
• Thread → Runnable → 공용 객체

  package test;
  

// 공유 자원 한 가지 정의 // Thread에 의해서 같이 사용되는 자원 // 즉, 공유 객체를 만들어서 사용한다. // 공유 객체를 만들려면 당연히 class가 있어야 한다. class Account { private int balance = 1000; // 잔액

// 잔액 알아오는 method
public int getBalance() {
    return balance;
}

// 출금하는 method
// synchronized 키워드는 하나의 Thread가 이 메소드를 쓰면
// 다른 Thread는 block이 걸리면서 순차적으로 처리가 된다.
// Critical Section 임계 영역이 생긴다.
// 임계 영역을 설정해서 다수의 Thread가 동시에 사용할 수 없도록
// synchronized 키워드로 임계 영역을 설정한다.
// 당연히 순차 처리가 된다.
// 그러나 method에 이 키워드를 사용하는게 부담스럽다.
// 이 method 안에 모든 코드들이 동기화를 필요로 하는 것이 아니기 때문에
// 따라서 일반적으로 synchronized block을 이용한다.
public synchronized void withdraw(int money) {
    if (balance > money) {
        try {
            Thread.sleep(1000);
        } catch (Exception e) {

        }

// synchronized (this) { // 임계 영역을 줄여서 훨씬 효율적으로 synchronized를 사용한다. // balance -= money; // } balance -= money; } }

}

// Thread → Runnable → 공용 객체 class MySyncRunnable implements Runnable {

Account acc = new Account(); // 공용 객체
@Override
public void run() {
    while(acc.getBalance() > 0) {
        int money = (int)(Math.random() * 3 + 1) * 100;
        acc.withdraw(money);
        System.out.println("잔액은 " + acc.getBalance());
    }
}

}

public class ThreadSyncTest { public static void main(String[] args) { MySyncRunnable r = new MySyncRunnable();

    // 같은 Runnable 객체를 다른 Thread가 사용
    Thread t1 = new Thread(r);
    Thread t2 = new Thread(r);

    t1.start();
    t2.start();
}

}

![](https://velog.velcdn.com/images/jiyoon9-velog/post/cedc90be-93d8-473c-9290-c1eff25affbe/image.png)
![](https://velog.velcdn.com/images/jiyoon9-velog/post/46bbe9d9-b217-40ba-aa07-86705810bb23/image.png)
```java
package test;

class Shared {

    // method 1개 만든다.
    // 해당 공유 객체는 여러 Thread에 의해서 같이 사용되는데
    // method를 호출할 때는 동기화시켜서 사용한다.
    public synchronized void printNum() {
        try {
            for (int i=0; i<10; i++) {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + ":" + i);
                notify(); // 아까 전의 Thread를 깨운다.
                wait();
            }
        } catch (Exception e) {

        }
    }
}

class MyRunnable_10 implements Runnable {

    private Shared shared;

    public MyRunnable_10(Shared shared) {
        this.shared = shared;
    }

    @Override
    public void run() {
        shared.printNum();
    }
}

public class ThreadWaitNotiTest {
    public static void main(String[] args) {
        Shared obj = new Shared(); // 공유 객체

        Thread t1 = new Thread(new MyRunnable_10(obj));
        Thread t2 = new Thread(new MyRunnable_10(obj));

        t1.setName("첫 번째 Thread");
        t2.setName("두 번째 Thread");

        t1.start();
        t2.start();
    }
}

• 상태 전이도 전체적인 그림

• 실제 Thread가 수행해야 하는 코드는 run() method를 overriding해서 구현한다.
• 이 method를 우리가 직접 호출하는 게 아니라 start()라는 non-blocking method를 호출해서 Thread를 동작시킨다.

5. Thread의 우선 순위(priority)

• Thread에는 우선 순위라는 게 있다. 기본적으로 5라는 값을 가진다.
• 1부터 10까지 범위 내에서 값을 설정해서 사용한다.
• main thread는 우선 순위 5를 가진다.
• Thread의 우선순위는 자기를 만든 Thread의 우선 순위를 물려 받아서 사용한다.
• 당연히 single core에서는 이 우선 순위가 Thread Scheduler에게 영향을 준다.
• 하지만 multi core에서는 이 값이 Thread 선택에 영향을 주지 않는다.
• 이 우선순위는 Thread가 일단 시작(start)하면 변경할 수 없다.
• Thread 객체 상태에서 변경할 수 있다.

package test;

public class ThreadPriorityTest {
    public static void main(String[] args) {

        // 추상 메소드를 가진 인터페이스이므로 객체를 생성할 수 없다.
        // 따라서 run() 메소드를 오버라이딩하면 쓸 수 있다.
        Thread t1 = new Thread(() -> {
            for(int i=0; i<10; i++) {
                System.out.println(Thread.currentThread().getName());
            }
        });
        t1.setPriority(1);

        Thread t2 = new Thread(() -> {
            for(int i=0; i<10; i++) {
                System.out.println(Thread.currentThread().getName());
            }
        });
        t2.setPriority(10);

        t1.start();
        t2.start();
    }
}

6. Daemon Thread(데몬 쓰레드)

• 우리가 사용하는 일반 Thread와는 다르게 보조적인 역할을 수행하는 Thread.
• JVM의 garbage collector, 워드 프로세서의 auto save 기능 같은 것을 생각하자.
• 일반 Thread가 모두 종료되면 당연히 Daemon Thread도 존재의 의미가 없어지기 때문에 같이 종료된다.

  package test;
  

public class DaemonThreadTest implements Runnable {

static boolean autuSave = false;
public static void main(String[] args) {
    Thread t = new Thread(new DaemonThreadTest());
    t.setDaemon(true); // 내가 만든 Thread는 DaemaonThread로 사용할 것이다.

    t.start(); // 언젠가는 이 Thread가 동작하게 될 것이다.

    for (int i=0; i<10; i++) {
        try {
            Thread.sleep(1000);
        } catch (Exception e) {

        }
        System.out.println("i의 값은: "+ i);
        if (i==5) {
            autuSave = true;
        }
    }

}

@Override
public void run() {
    while (true) {

        try {
            Thread.sleep(3000); // 3초가 지나면 or 중간에 누군가 방해하면 Interrupt를 걸면 깬다.
        } catch (Exception e) {
            System.out.println("오류 발생");
        }

        if (autuSave) { // 3초 중지 -> 자동 저장 -> 3초 중지 -> 자동 저장
            System.out.println("자동 저장");
        }

    }
}

}

## 7. Thread의 실행 제어

- 원래 Thread의 상태를 제어하는 쉬운 method가 있었다.
- stop(), suspend(), resume() 이다.
- 하지만 이런 method는 사용하기 편하지만 코드를 잘못 작성하면 dead-lock에 빠질 확률이 많다.
- 따라서 이 method들은 **`deprecated`** 되었다.
- 대신 실행 제어를 위한 다른 method를 제공한다.

### 7.1 sleep()

- sleep은 지정된 시간 동안 Thread를 멈추는 역할을 수행한다.
- sleep()에 의해서 일시 정지된 Thread는 지정된 시간이 다 되거나 혹은 interrupt()라는 method가 호출되면 이때 Exception이 발생하면서 잠에서 깬다.
- 따라서 예외 처리(try~catch) 구문이 강제로 사용된다.
- 다음과 같은 Thread의 상태 전이가 일어난다.
![](https://velog.velcdn.com/images/jiyoon9-velog/post/c621fbe2-9848-4b1c-8f53-b3eb8a87ca90/image.png)
```java
package test;

class Sleep_1 extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(2000);
        } catch (Exception e) { }

        for (int i=0; i<300; i++) {
            System.out.print("-");
        }
        System.out.println("<<Thread 1 종료>>");
    }
}

class Sleep_2 extends Thread {
    @Override
    public void run() {
        for (int i=0; i<300; i++) {
            System.out.print("|");
        }
        System.out.println("<<Thread 2 종료>>");
    }
}

public class ThreadSleepTest {
    public static void main(String[] args) {
        Thread t1 = new Sleep_1();
        Thread t2 = new Sleep_2();

        t1.start();
        t2.start();

        try {
            // t1.sleep(2000); 이렇게는 사용하지 않는다.
            // t1을 지정해서 sleep 시킬 수 없다.
            Thread.sleep(2000); // main thread가 자게 된다.
            // sleep은 static method이고 현재 Thread를 sleep 시키는 method이다.
            // t1을 재우려면 t1의 run에 sleep이 있어야 한다.
        } catch (Exception e) { }

        System.out.println("<< main thread 종료 >>");
    }
}

7.2 interrupt(), interrupted(), isInterrupted()

• 진행 중인 Thread를 작업이 다 끝나기 전에(run method의 수행이 끝나기 전에) 실행을 중지 시켜야 할 때도 있다.
• 예제에는 이 작업을 stop() method로 해결했다. 하지만 이제는 이렇게 못한다.
• 따라서 interrupt()라는 method를 대신 제공해서 이 작업을 수행할 수 있도록 해준다.
• 그런데 한 가지 주의해야 할 점이 있다.
• interrupt()는 Thread에게 작업을 중지하라고 요청하는 것이며, stop()처럼 강제로 중지 시키지 않는다.
• interrupt() method는 Thread가 내부적으로 가지고 있는 interrupted state를 변경하는 역할을 수행한다.
• interrupted(), isInterrupted() 이 2개의 method는 Thread가 내부적으로 가지고 있는 interrupted state 값을 알아오는 것이다.
• 만약, 해당 Thread가 interrupt()가 호출되었으면 true가 리턴 되며, 그렇지 않으면 false가 리턴 된다.
• 한 가지 조심할 점은 interrupted() 이 method는 static으로 지정되어 있다.
  • 현재 수행 중인 Thread의 interrupted state를 알려준다.
  • 그 상태를 알려준 다음에 무조건 값을 false로 변경한다.
• 반면, isInterrupted()는 아주 심플하다.
  • instance method이다.
  • 해당 Thread의 interrupted state를 알려주고 아무 일도 하지 않는다.
  • 즉, 값을 변경하지 않는다.
• sleep()에 의해서 해당 Thread가 일시 정지 되어 있을 때 해당 Thread에 interrupt()를 호출해서 Interrupt Exception 발생하게 하고 해당 Thread를 Runnable 상태로 변경해준다.

  package test;
  

import javax.swing.*;

class MyThread_3 extends Thread { @Override public void run() { int i = 10;

    // isInterrupted() -> interrupt면 true, 아니면 false 반환
    while (i != 0 && !isInterrupted()) { // interrupt도 아니고 i가 10이면
        System.out.println(i--);
        for (long k=0; k<25000000000L; k++); // 시간 지연
    }
    System.out.println("카운트가 종료되었습니다.");
}

}

public class ThreadInterruptTest { public static void main(String[] args) { Thread t = new MyThread_3(); t.start();

    // 약간의 시간 지연을 위해 Swing을 이용한다.
    // swing에서 값을 입력하면 바로 while 문이 끝난다.
    String input = JOptionPane.showInputDialog("값을 입력하세요!");
    System.out.println("입력된 값은 " + input + " 입니다.");

    t.interrupt(); // isInterrupted() 메소드에 의해 while 문을 탈출한다.
}

}

- 위 코드는 잘 동작하긴 하지만, 사용하면 안 되는 코드가 들어있다.
- sleep을 이용해서 해결하여 코드를 다시 써보자.
- 한 가지 기억해야 하는 것은 sleep() 도중에 interrupt()가 호출되면 InterruptedException이 발생한다.
- 즉, catch문이 수행된다.
- 이 다음에 내부적으로 해당 Thread의 interrupted state가 false로 자동 초기화된다.
- 그래서 다시 interrupt()를 설정해야 한다.

```java
package test;

import javax.swing.*;

class MyThread_3 extends Thread {
    @Override
    public void run() {
        int i = 10;

        // isInterrupted() -> interrupt면 true, 아니면 false 반환
        while (i != 0 && !isInterrupted()) { // interrupt도 아니고 i가 10이면
            System.out.println(i--);

            try {
                Thread.sleep(4000); // 4초 자고 깨서 다시 while문 반복
                // sleep에서 깨면서 내부적으로 interrupt가 false가 된다.
            } catch (Exception e) { // Exception 발생하면 바로 while문으로 가며 interrupt가 발생하면서 while문이 끝난다.
                interrupt();
            }
        }
        System.out.println("카운트가 종료되었습니다.");
    }
}

public class ThreadInterruptTest {
    public static void main(String[] args) {
        Thread t = new MyThread_3();
        t.start();

        // 약간의 시간 지연을 위해 Swing을 이용한다.
        // swing에서 값을 입력하면 바로 while 문이 끝난다.
        // 즉, swing에서 값을 입력하면 interrupt가 발생한다.
        String input = JOptionPane.showInputDialog("값을 입력하세요!");
        System.out.println("입력된 값은 " + input + " 입니다.");

        t.interrupt(); // isInterrupted() 메소드에 의해 while 문을 탈출한다.
    }
}

7.3 yield()

• yield() method는 Thread 자신에게 주어진 실행 시간을 다음 차례의 Thread에게 양보하는 method이다.
• 프로그램의 응답 시간을 줄이기 위해 사용한다.
• 일반적으로 응답성을 높이는 목적으로 사용된다.
• 만약, yield()가 호출되면 자신은 Runnable 상태로 다시 들어가게 된다.
• deprecated 된 suspend(), resume(), stop()을 한번 이용해 보자.

package test;

class MyRunnable_4 implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println(Thread.currentThread().getName()); // 현재 Thread
            try {
                Thread.sleep(1000);
            } catch (Exception e) {

            }
        }
    }
}

public class ThreadYieldTest {
    public static void main(String[] args) {
        // Runnable 객체
        MyRunnable_4 r = new MyRunnable_4();

        Thread t1 = new Thread(r, "*"); // Thread 이름 지정
        Thread t2 = new Thread(r, "**"); // Thread 이름 지정
        Thread t3 = new Thread(r, "***"); // Thread 이름 지정

        t1.start();
        t2.start();
        t3.start();

        try {
            Thread.sleep(2000); // main thread가 sleep
            t1.suspend(); // t1을 일시 중지
            Thread.sleep(2000); // main thread가 sleep
            t2.suspend(); // t2을 일시 중지
            Thread.sleep(3000); // main thread가 sleep
            t1.resume();
            Thread.sleep(3000); // main thread가 sleep
            t1.stop();
            t2.stop();
            Thread.sleep(2000); // main thread가 sleep
            t3.stop();
        } catch (Exception e) {

        }
    }
}

• 위의 코드를 변수와 로직을 이용해서 똑같이 구현해 보자.

package test;

class MyRunnable_4 implements Runnable {

    // 인스턴스 variable이므로 Thread가 이것을 공유할 수 없다.
    // 객체를 만들어서 각각 Thread와 맵핑한다.
    volatile boolean suspended = false;
    volatile boolean stoped = false;

    private Thread t;

    public void setThread(Thread t) {
        this.t = t;
    }

    @Override
    public void run() {

        while (!stoped) {
            if (!suspended) {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {

                }
            } else {
                Thread.yield();
            }
        }
    }

    public void suspend() {
        suspended = true;
        // thread에 대해서 interrupt 걸면 된다.
        // thread에 대한 reference가 있어야 한다.
        t.interrupt();
    }

    public void resume() {
        suspended = false;
    }

    public void stop() {
        stoped = true;
    }
}

public class ThreadYieldTest {
    public static void main(String[] args) {
        // Runnable 객체
        MyRunnable_4 r1 = new MyRunnable_4();
        MyRunnable_4 r2 = new MyRunnable_4();
        MyRunnable_4 r3 = new MyRunnable_4();

        Thread t1 = new Thread(r1, "*"); // Thread 이름 지정
        Thread t2 = new Thread(r2, "**"); // Thread 이름 지정
        Thread t3 = new Thread(r3, "***"); // Thread 이름 지정

        r1.setThread(t1);
        r2.setThread(t2);
        r3.setThread(t3);

        t1.start();
        t2.start();
        t3.start();

        try {
            Thread.sleep(2000); // main thread가 sleep
            r1.suspend(); // t1을 일시 중지
            Thread.sleep(2000); // main thread가 sleep
            r2.suspend(); // t2을 일시 중지
            Thread.sleep(3000); // main thread가 sleep
            r1.resume();
            Thread.sleep(3000); // main thread가 sleep
            r1.stop();
            r2.stop();
            Thread.sleep(2000); // main thread가 sleep
            r3.stop();
        } catch (Exception e) {

        }
    }
}

7.4 join()

• Thread가 자신이 하던 작업을 잠시 멈추고 다른 Thread를 지정된 시간 혹은 해당 Thread가 일을 다 마칠 때까지 Thread의 실행 시간을 확보하는 method
• join()도 sleep()처럼 interrupt()에 의해서 대기 상태에서 벗어날 수 있다. try-cath 구문을 이용해야 한다.
• 기억해야 하는 점 중 하나는 sleep()은 static method이다. joint은 특정 Thread를 지칭해야 하기 때문에 static이 아니다.

package test;

class MyThread_8 extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println("-");
        }
    }
}

class MyThread_9 extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println("|");
        }
    }
}

public class ThreadJoinTest {
    public static void main(String[] args) {
        MyThread_8 t1 = new MyThread_8();
        MyThread_9 t2 = new MyThread_9();

        t1.start();
        t2.start();

        try {
            t1.join(); // t1을 참여시키고, main thread를 일시 정지 시키고(대기), t1이 끝나면 main이 다시 실행
            t2.join();
        } catch (Exception e) {

        } // t1, t2 중 누가 어떻게 먼저 끝날지는 모르지만 적어도 main이 가장 늦게 끝날 것이다.
    }
}

• 많이 들어본 용어
  • process : 실행 중인 프로그램의 instance. 현재 실행 중인 프로그램을 지칭하는 용어
    • process가 동작하려면 당연히 resource가 필요하다.
    • 이 resource는 OS로 부터 할당 받는 메모리, CPU 시간, 디스크, 입출력 장치 등등
  • thread : 프로그램의 실행 흐름
    • process는 하나 이상의 Thread로 구성된다.
    • Thread는 프로세스 내에서 실행되는 작은 실행 단위라고 할 수 있다.
    • Thread는 process의 resource를 공유한다. (메모리를 공유함) ⇒ process의 효율성을 향상시킨다.
    • 만약, 둘 이상의 Thread를 가진 process라면 multi-thread process라고 한다.
  • multitasking : 시분할(time-slicing)기법을 이용해서 아주 짧은 시간동안 여러 process를 번갈아 가면서 수행시켜 마치 동시에 실행되는 것처럼 보이게 하는 기법
  • multiprocessing : 서로 다른 core가 서로 다른 process를 시간적으로 동시에 실행시키는 개념
  • multiprocessing (multithreading)
• Hyper-Threading : 1 core에 여러 Thread 담당

2. Multithreading의 장, 단점

• 장점 : CPU와 resource를 효율적으로 사용함으로 process의 실행 효율을 높일 수 있다. 결국, 사용자에 대한 응답성을 확보할 수 있다.
• 단점 : resource를 공유하기 때문에 항상 동기화(Synchronization)에 신경을 써야 하고, 교착 상태(dead-lock) 상태에 빠질 수 있기 때문에 역시 이 부분도 신경을 써야 한다.

3. Thread를 구현해 보자

• Process 안에서 Thread는 실행시키는 단위
• method ≠ Thread
• Thread 별로 콜 스택을 따로 따로 가지고 있다.
• Stack은 Thread마다 별도로 할당이 된다.
• Thread가 다 종료되어야 전체 프로그램이 종료된다.
• 지금까지 작성했던 자바 프로그램은 사실 single thread process 였다.
• main method를 호출해서 실행시키는 thread를 우리는 main thread라고 부른다.
• 프로그램 종료는 프로그램(process)안에서 생성한 모든 thread가 종료되어야 전체 process가 종료된다.
• 자바는 Thread 라는 class를 제공한다. 이 class를 이용해야만 Thread를 생성할 수 있다.

3.1 첫 번째 방법

• 가장 쉬운 방법은 제공된 Thread class를 상속해서 사용자 정의 Thread class를 정의한 후, instance를 만들어서 사용하는 것이다.

3.2 두 번째 방법

• Java가 제공해주는 Runnable이라는 interface를 구현해서 class를 만든 후, instance를 생성한다.
• 그런 다음 Thread의 생성자에 runnable 객체를 인자로 주어서 객체를 생성하면 Thread가 만들어진다.

package test;

// 첫 번째 방법
class MyThread extends Thread { // Thread의 run()은 일반 메소드

    @Override
    public void run() {
        // Thread의 실행 코드
        System.out.println("여기는 첫 번째 Thread");
    }
}

// 두 번째 방법(이걸 더 많이 씀)
// 일반 추상 클래스는 객체를 만들지 않는다.
class MyRunnable implements Runnable { // Runnable의 run()은 추상 메소드
    // Thread의 실행 코드는 무조건 run() 안에 들어간다.
    @Override
    public void run() {
        // Thread의 실행 코드
        System.out.println("여기는 두 번째 Thread");
    }
}

public class ThreadTest {

    // main thread
    public static void main(String[] args) {
        MyThread t1 = new MyThread(); // Thread 생성
        t1.start(); // Thread 실행
        // start()는 non-blocking method
        // start()는 thread scheduler에게 thread를 실행시켜 달라고 요청하는 method
        // JVM이 thread scheduler를 가지고 있다.

        MyRunnable r = new MyRunnable(); // Runnable 객체
        Thread t2 = new Thread(r); // Thread 실행
        t2.start();
    }
}

package test;

public class ThreadTest2 {

    // main thread
    public static void main(String[] args) {
        // interface는 추상 method가 있어서 객체(new Runnable())를 만들 수 없다.
        // 객체를 만들 수 없는 이유는 추상 method가 있기 때문이다.
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("너무 복잡하다.");
            }
        }).start(); // new Thread부터 .start() 전까지 Thread이다.

        new Thread(() -> {
                System.out.println("너무 복잡하다...");
            }
        ).start();
    }
}

• 지금까지 동작을 그림(Thread의 상태 전이도)로 표현하면 아래와 같다.

package test;

class MyThread1 extends Thread {

    public MyThread1(String name) {
        // super(); 상위 클래스에서 인자가 없는 생성자
        super(name); // 상위 클래스에서 name 인자를 가진 생성자
    }

    @Override
    public void run() { // Thread 객체가 가지고 있는 run() 메소드
        for (int i=0; i<9; i++) {
            System.out.println(this.getName()); // 결국 this는 Thread
        }
    }
}

class MyRunnable2 implements Runnable {
    @Override
    public void run() {
        for (int i=0; i<9; i++) {
            System.out.println(Thread.currentThread().getName()); // 인스턴스가 없어도 쓸 수 있는 static(메소드 or 필드)
            // 글씨가 기울어져 있으면 static
        }
    }
}
public class ThreadTest3 {
    public static void main(String[] args) {

        MyThread1 t1 = new MyThread1("홍길동");
        MyRunnable2 r = new MyRunnable2();
        Thread t2 = new Thread(r);

        t1.start();
        t2.start();
        // Runnable(실행이 가능한) 상태로 Thread가 들어온다. Thread 큐로 들어온다.
        // Thread Scheduler가 Thread를 선택하고 Core가 붙어서 Running 상태로 만든다.
        // run이 끝나면 Thread가 Dead 상태가 된다.
        // 즉, 여러 가지 상태 전이가 일어난다.
        // 누가 먼저 실행 될지는 아무도 모른다.
    }
}

• 프로그램 실행 시 발생하는 다양한 형태의 오류
• 만약 오류가 발생하고 우리가 코드로 특별한 처리를 하지 않는다면 당연히 비정상 종료가 일어난다.
• 그런데 Exception Handling을 하게 되면 이런 상황에서 프로그램을 비정상 종료 시키지 않고 지속적으로 수행시킬 수 있다.
• 이런 Exception은 다양한 class들로 제공된다.
• 모든 Exception class들의 최 상위 class는 Exception class

package test;

public class ExceptionTest {

    public static void main(String[] args) {

        System.out.println("예외 상황 발생시키기");
        int result = 10 / 0;  // Exception 발생
        // Exception이 발생하면 해당 Exception에 대한
        // 클래스를 찾아서 Exception 객체를 생성한다.
        // (java.lang.ArithmeticException)
        // 자동으로 생성된 이 객체를 프로그램적으로 처리를 안해주면
        // 프로그램 비정상 종료!
        // Exception Handling 해서 강제 종료를 하지 않는다.
        System.out.println("이거 수행될까?");

    }
}

• 기본적인 처리 코드는 다음과 같아요! ( try ~ catch 구문 )

package test;

public class ExceptionTest {

    public static void main(String[] args) {

        System.out.println("예외 상황 발생시키기");
        try {
            int result = 10 / 0;  // Exception 발생    
        } catch(ArithmeticException e) {
            // 발생한 예외에 대한 처리 코드
            System.out.println("처리 완료");
        }
        System.out.println("이거 수행될까?");

    }
}

• Exception(가장 상위 클래스)은 catch 구문 가장 첫 번째로 쓰면 안된다.
  • 다른 하위 Exception 클래스를 먼저 위에 써야 한다.

package test;

public class ExceptionTest {
    public static void main(String[] args) {
        System.out.println("예외 상황을 발생시켜보자.");
        try { // Exception e <- 이것은 Exception의 상위 클래스
            // int result = 10 / 0; // Exception 발생
            ExceptionTest t = null;
            System.out.println(t.toString());
        } catch (ArithmeticException e) {
            // 발생한 예외에 대한 처리코드가 나온다.
            System.out.println("처리 완료");
        } catch (NullPointerException e) {
            System.out.println("NullPointer 처리 완료");
        } finally {
            System.out.println("finally는 무조건 수행");
        }

        // Exception이 발생하면 해당 Exception에 대한
        // 클래스를 찾아서 Exception 객체를 생성한다.
        // (java.lang.ArithmeticException)
        // 자동으로 생성된 이 객체를 프로그램적으로 처리를 안해주면
        // 프로그램 비정상 종료!
        // Exception Handling 해서 강제 종료를 하지 않는다.
        System.out.println("이 문장 출력되나요?"); // 프로그램의 비정상 종료

    }
}

• 추가적으로 예외 상황을 만들고 싶으면 어떻게 해야 할까?
  • 내가 예외 상황을 새롭게 정의하고 싶다면
  • 그러면 당연히 Exception class를 상속해서 우리 class를 정의하면 된다.
  • is-a 관계에 의해 우리가 새로운 Exception을 정의할 수 있다.
• 사용자 정의 Exception

package test;

class MyException extends Exception {

}

public class ExceptionTest2 {
    public static void main(String[] args) {
        try {
            throw new MyException();
        } catch (Exception e) {
            System.out.println("사용자 정의 Exception 발생");
        }
    }
}

• 모든 class의 최상위 class
• 몇 가지 주요한 method를 제공한다.
• 여기서는 equals() 와 toString() 에 대해 알아보자.
• equals()

package test;

public class Student {

    // field
    private String name;
    private int age;

    // constructor
    public Student() {
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    // getter & setter
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // method
    @Override
    public boolean equals(Object obj) {
        // 인자로 들어온 instance가 equals method를 가지고 있는
        // instance의 내용과 같으면 같은 객체로 판별하는 로직을 작성하면 된다.
        // 당연히 처음은 두 instance의 type을 똑같이 맞춰야 한다.
        Student target = (Student)obj;
        boolean result = false;
        if(this.getName() == target.getName() && this.getAge() == target.getAge()) {
            result = true;
        }
        return result;
    }
}

class MyMain {
    public static void main(String[] args) {
        Student s1 = new Student("홍길동", 20);
        Student s2 = new Student("홍길동", 20);

        boolean result = s1 == s2; // 서로 인스턴스 값이 같은지?
        System.out.println(result); // false
        System.out.println(s1.equals(s2));
    }
}

• toString()

package test;

public class Student {

    // field
    private String name;
    private int age;

    // constructor
    public Student() {
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    // getter & setter
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // method
    @Override
    public boolean equals(Object obj) {
        // 인자로 들어온 instance가 equals method를 가지고 있는
        // instance의 내용과 같으면 같은 객체로 판별하는 로직을 작성하면 된다.
        // 당연히 처음은 두 instance의 type을 똑같이 맞춰야 한다.
        Student target = (Student)obj;
        boolean result = false;
        if(this.getName() == target.getName() && this.getAge() == target.getAge()) {
            result = true;
        }
        return result;
    }

    @Override
    public String toString() {
        return this.getName() + " : " + this.getAge();
    }
}

class MyMain {
    public static void main(String[] args) {
        Student s1 = new Student("홍길동", 20);

        System.out.println(s1);
        // toString() 오버라이딩 X -> 메모리 주소값이 나온다. test.Student@4554617c
        // toString() 오버라이딩 O -> 홍길동 : 20
    }
}

2. String class

• Java는 primitive type으로 총 8개의 데이터 타입을 제공한다.
• 정수형 4개, 실수형 2개, 논리형 1개, 문자 1개
  • 자바는 문자는 존재하지만, 문자열은 존재 X
  • 자바스크립트 및 파이썬은 문자열은 존재하지만, 문자는 X
• 즉, 문자열은 기본 타입으로 제공되지 않으므로 reference type으로 제공된다. 즉, class로 제공된다.
• 따라서 사용하기 불편하다.

String a = new String("불편불편!!");

// 너무 불편하다. 그래서 다음과 같이 사용한다.

String b = "편해편해!!";
String c = "편해편해!!";
String d = new  String("불편불편!!"); 

b= "아이편해";
// 문자열은 불변이기 때문에 값을 수정할 수 없다. 새로 만들어야 한다.

3. Array

• Java 배열
• 배열은 같은 data type을 여러 개 저장할 수 있는 집합형 자료구조
• 기호는 [ ] 사용
• 저장 순서 존재. index 개념 존재
• 배열은 instance이고, 특수한 형태로 생성을 한다.

int a = 100;

int[] arr = new int[6];

4. ArrayList class

package test;

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

class MyStudent {

}

public class ArrayListTest {
    public static void main(String[] args) {

        // ArrayList 객체를 만들어서 사용하자.
        // List 계열은 객체면 type에 상관없이 다 저장 가능하다.
        // 다른 reference data type들을 저장할 수 있다.
        // 그런데 실제로 구현하다보면 거의 예외없이
        // 같은 데이터 타입을 이용해서 사용하게 된다. (마치 배열처럼)
        List list = new ArrayList();
        list.add("홍길동"); // 문자열 (오버라이딩 되어있다.)
        list.add(new MyStudent()); // class (오버라이딩 X)
        list.add(100); // integer (오버라이딩 되어있다.)
        // 100은 int형태의 primitive type이다.
        // 따라서 ArrayList 안에 저장될 수 없다.
        // 자바에는 primitive type에 각각 대응되는 wrapper class가 존재
        // list.add(100); => list.add(new Integer(100));
        // boxing 이라는 표현을 사용한다.
//        for(int i=0; i<10; i++) {
//
//        }
        for(Object obj : list) {
            System.out.println(obj.toString());
        }

        List<String> myList = new ArrayList<String>();
        myList.add("홍길동");
        myList.add("신사임당");

        for(String str : myList) { // generic을 쓰면 type이 명시되어 있어 편리하다.
            System.out.println(str);
        }
    }
}

5. HashMap class

• key와 value 쌍으로 이루어진 집합형 자료구조

package test;

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

public class HashMapTest {
    public static void main(String[] args) {
        // 상위타입 Map = 실제 구현 클래스 하위타입 HashMap
        Map<String, String> map = new HashMap<String, String>();

        map.put("1", "안녕하세요!");
        map.put("2", "하이하이");

        System.out.println(map.get("2"));
    }
}

6. HashSet class

• set은 바구니 같은 자료구조
• 저장되는 순서는 없다.
• set은 중복 허용 X

package test;

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

public class HashSetTest {
    public static void main(String[] args) {

        Set<String> set = new HashSet<String>();

        set.add("홍길동");
        set.add("신사임당");
        set.add("홍길동");

        // Iterator 생성
        Iterator<String> iter = set.iterator();
        while(iter.hasNext()) { // 다음 것이 있는지 체크하고 있으면 출력
            System.out.println(iter.next());
        }
    }
}

• field 앞에 final이 올 경우 : 해당 field의 값을 변경할 수 없다. (상수로 사용)
• method 앞에 final이 올 경우 : 하위 class에서 해당 method를 overriding 할 수 없다.
• class 앞에 final이 올 경우 : 해당 class를 아예 상속할 수 없다.

14. abstract class(추상 클래스)

• abstract method를 1개 이상을 보유하고 있는 class는 반드시 abstract class로 지정해야 한다.
• 가장 큰 특징은 아직 완성되지 않은 class이기 때문에 instance 생성이 안된다.
• 사용 방법 : 추상 클래스를 상속받는 하위 클래스를 만들어서 추상 method를 overriding해서 사용하면 된다.
• 재활용성의 폭이 넓혀진다.

  package test;
  

// class 안에 추상 메소드가 있으면 추상 클래스다. public abstract class TestA { // field private int age; private String name;

// constructor
public TestA() {
}

// constructor overloading
public TestA(int age, String name) {
    super();
    this.age = age;
    this.name = name;
}

// method
public void myFunc() {
    // method를 정의했다.
}

// 추상 (abstract method)
public abstract void sayHello(); // method를 선언했다.

}

class MySubClass extends TestA { @Override public void sayHello() {

}

}

## 15. interface(인터페이스)
- class와 유사함. class의 아주 특별한 형태
- interface는 class 대용으로 사용한다. (특수한 경우)
- interface 안에 method가 있을 수 있다. (추상 method만 나올 수 있다.)
- 그렇기 때문에 일반적으로 public abstract는 생략해서 구현한다.
- interface 안에 field도 나올 수 있다. (상수만 사용할 수 있다.)
- 특성 상 당연히 public static으로 잡혀야 하며, 상수로 만들어야 해서 final을 사용한다.
- 그래서 public static final은 생략이 가능하다.
- 하위 클래스에서 상위 클래스를 ~~ 한다.
    - 클래스 - 상속 / 인터페이스 - 구현
- 하위 class에서 interface를 구현해서 사용하면 된다.
- 하나의 인터페이스를 확장된 인터페이스를 만들려면 extends를 쓴다.
- 하나의 인터페이스를 구현하려면 implements를 쓴다.
- class의 확장과 다르게 interface는 다중 구현이 가능하다.
- is-a relation 관계가 당연히 성립한다.
```java
package test;

public interface MyInterface {

    // field
    int MY_NUM = 100;
    // public static final int MY_NUM = 100;
    // 모든 field에 public, static, final 이 다 붙어야 해서 생략 가능

    // method
    // public abstract void myFunc();
    void myFunc();
    // 인터페이스에는 모든 메소드에 abstract이 다 붙어야 해서 생략 가능
    // 즉, 추상 메소드만 넣을 수 있다.
    // method는 선언만 한다.
}

// MyClass1 부분과 MyInterface 부분이 같으면 extends
// MyClass1 부분과 MyInterface 부분이 다르면 implements
// 콤마찍고 인터페이스(MyInterface 부분) 여러 개 동시 구현 가능
class MyClass1 implements MyInterface {
    @Override
    public void myFunc() {
    }
}

• 상속은 부모 class가 가지고 있는 내용을 자식 class가 물려 받는 개념이다.
• 그래서 매번 class를 작성할 때 처음부터 작성하는 게 아니라 기존 클래스를 확장해서 작성하는 개념이다.
• 클래스의 계층 구조도 생긴다.
• 부모 클래스, parent class, upper class, super class
• 자식 클래스, child class, sub class

9.1 상속이 필요한 이유

• 코드로 상속 표현하기
• keyword ⇒ extends 활용
• Java는 단일 상속만 지원한다.
• 상속은 항상 좋을까?
  • 클래스 간 결합도가 증가한다.
  • 상속은 class 간의 결합도를 증가시킨다. (tightly coupled)
  • 그로 인해서 클래스의 재활용성을 낮추게 된다.

9.2 is-a relationship(IS-A 관계) 개념

• ⇒ sub class is a super class
• 이 말의 의미는 sub class가 super class와 같으니까..
• sub class를 써야 하는 자리에 super class를 사용할 수 있다.
• 포유류, 사람… 당연히 포유류가 상위 클래스 사람은 하위 클래스
• 사람 is a 포유류 (O)
• 포유류 is a 사람 (X)
• 다형성 : 같은 객체를 reference variable의 type을 변경시킴으로 인해 다른 형태로 객체를 사용하는 방법

10. (method) overriding

• 하위 클래스에서 상속받은 상위 클래스의 method를 재 정의해서 사용하는 방법
• 만약 field를 하위 클래스에서 재 정의해서 사용하게 되면 이는 shadow라고 표현한다. (잘 일어나지 않는다.)
• 부모 클래스

  package test;
  

public class SuperClass { // extends java.lang.Object 최상위로 항상 상속

int a = 100;
String b = "여기는 super class";

public SuperClass() { // 항상 인자 없는 생성자를 만들어야 한다.
    super();
}

public void myFunc() {
    System.out.println("super");
}

}

- 자식 클래스

```java
package test;

public class SubClass extends SuperClass {

    // 추가적인 field와 method를 정의하면 된다.
    int a = 5000; // shadow
    int b = 500;

    public SubClass() {
        this(10); // int형을 가지고 있는 생성자를 호출
    }

    public SubClass(int k) {
        // 현재 class가 최상위 클래스인지 확인하고 아니면
        // 상위 클래스의 instance를 만드는 코드
        // SuperClass(); 이건 못 쓰고 대신 super을 쓴다.
        super(); // 상위 클래스를 찾아서 상위 클래스의 생성자를 호출하는 코드
    }

    @Override
    public void myFunc() {
        System.out.println("여기는 sub class 입니다.");
    }
}

package test;

public class Main {
    public static void main(String[] args) {

        // instance를 생성하자.
        SubClass sub = new SubClass();
        System.out.println(sub.a); // 5000
        sub.myFunc(); // 여기는 sub class 입니다.

    }
}

• overriding에서 조심해야 할 점은 dynamic binding이 발생한다.

  package test;
  

public class Main { public static void main(String[] args) {

    // instance를 생성하자.
    // 동적 바인딩
    // 메소드는 오버라이딩되어 있으면 오버라이딩 된 것을 찾아 출력한다.
    SuperClass sub = new SubClass();
    System.out.println(sub.a); // 100
    sub.myFunc(); // 여기는 sub class 입니다.
}

}

## 11. this, super, this(), super()
- this : 현재 사용하고 있는 객체에 대한 reference
- super : 현재 사용하고 있는 객체에 대한 reference (상위 타입의 객체를 지칭)
- super() : 상위 클래스의 생성자를 호출
- this() : 내가 가진 오버로딩된 해당 클래스의 다른(인자의 개수나 타입이 다른) 생성자를 호출

## 12. 연습문제
- 부모 클래스
```java
package test;

public class SuperClass2 {
    static int staticCall(String msg) {
        System.out.println(msg);
        return 0;
    }

    int a = staticCall("1번 문장");
    static int b = staticCall("2번 문장");

    public SuperClass2() {
        staticCall("3번 문장");
    }

    public SuperClass2(int i) {
        this();
        staticCall("4번 문장");
    }

    public void myFunc() {
        System.out.println("5번 문장");
    }
}

• 자식 클래스

  package test;
  

public class Exam01_InheritanceOrder extends SuperClass2 {

int c = staticCall("6번 문장");
static int d = staticCall("7번 문장");
// 상위 클래스의 static 먼저 출력, 다음으로 하위 클래스 static 출력

public Exam01_InheritanceOrder() {
    super(100);
    staticCall("8번 문장");
    super.myFunc();
}

@Override
public void myFunc() {
    System.out.println("9번 문장");
}

public static void main(String[] args) {
    System.out.println("10번 문장");
    SuperClass2 obj = new Exam01_InheritanceOrder();
    obj.myFunc();
}

}

2번 문장 7번 문장 10번 문장 1번 문장 3번 문장 4번 문장 6번 문장 8번 문장 5번 문장 9번 문장 ```

• public
  • 이 키워드는 field, method, constructor, class 앞에 붙을 수 있다.
  • package에 상관없이 자유롭게 access할 수 있도록 해주는 접근 제어자
  • class가 public이라고 해서 변수를 마음대로 쓸 수 있는 것이 아니다.
  • 변수 역시 public이어야 한다.
• default (키워드 아님, 직접 명시하지 않음)
  • field, method, constructor, class에 선언할 수 있다.
  • 같은 package의 다른 class에 의해 사용될 수 있다.
  • 다른 package에서는 못 쓴다.
• private
  • field, method, constructor에 선언할 수 있다.
  • 해당 field, method, constructor를 같은 class내에서만 access 가능하도록 선언한다.
  • constructor 앞에 붙일 때는 싱글톤 패턴일 때 사용

싱글톤 패턴

public class Singleton {
    // 정적 참조 변수(싱글톤 객체를 담을 변수)
    private static Singleton instance;

    // private 생성자로 외부에서 인스턴스 생성을 막습니다.
    // private 생성자
    private Singleton() {
    }

    // 정적 메서드를 통해 단일 인스턴스를 반환합니다.
    // getInstance()
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

7.1 Encapsulation(캡슐화)

• class는 객체가 가지고 있는 특징(값), 기능(함수)를 하나의 단위로 묶어놓은 개념이다.
• class가 encapsultation한 결과이다.

7.2 Information Hiding(정보 은닉)

• 이런 class 안에는 값과 기능이 들어가 있다.
• 여기서는 값이 더 중요하다.
• 외부에서 이 값을 함부로 변경하는 것은 당연히 막아야 한다.
• 그래서 class 내부에서만 값을 수정할 수 있고, 외부에서 함부로 값을 변경할 수 없도록 데이터를 보호해야 하는데 이 개념을 Information Hiding(정보 은닉)이라고 한다.

7.3 구현 방법

• Java 언어에서는 이 개념을 access modifier로 구현한다.
• private를 이용해서 field를 선언한다. (특별한 이유가 없는 한)
• method를 이용해서 해당 field를 제어하는 식으로 class를 design을 한다.
• 추가적으로 외부 class(instance)에서 private으로 설정된 값을 알아가거나 설정하기 위해 특수한 형태의 method를 이용하게 되는데 getter / setter 이라고 한다.

8. static block

• class가 로드된 후 바로 수행되는 코드 block이고 main()보다 먼저 수행된다.

• register : 프로그램의 실행 포인터를 저장하고 관리한다. 신경 쓸 필요가 없다.
• Runtime Constant Pool : 상수들을 위한 저장 공간. 역시 신경 쓸 필요가 없다.
• Method Area
  • 클래스 자체에 대한 정보가 들어가 있는 공간.
  • 당연히 클래스 안에 정의된 method에 대한 실행 코드도 여기 존재한다.
  • 해당 클래스가 사용될 때 한번 동적으로 클래스에 대한 정보가 올라간다.
  • 클래스가 처음 사용되는 시점 딱 1번 해당 정보가 메모리에 올라간다.
• Heap
  • instance의 생성되는 메모리 공간.
  • instance variable의 공간이 생성된다.
  • 또한, method의 실행 포인터를 들고 있다.
• Call Stack(일반적으로 stack이라고 함)
  • 스택은 메소드가 호출되면 stack 영역에 해당 메소드를 위한 공간이 생성된다.
  • 지역 변수가 이 공간 안에 있다.
  • 당연히 method의 수행이 끝나면 해당 영역은 pop되어서 없어지고 안에 있는 지역변수 역시 공간이 날라간다.

4.1 코드 실행

• 코드 실행으로 어떻게 메모리에 정보가 들어가는지 알아보자.
• 코드 작성이 끝나면 컴파일하자.
• javac.exe MyTest.java ⇒ 그 결과로 MyTest.class 파일이 생성된다.
• java.exe MyTest ⇒ JVM이 bytecode를 읽어서 실행한다.
• 예제

  package test;
  

public class InstanceTest { static int a = staticCall("1번 출력"); int b = staticCall("2번 출력");

public static int staticCall(String msg) {
    System.out.println(msg);
    return 100;
}

public InstanceTest() {
    this.b = staticCall("3번 출력");
}

public static void main(String[] args) {
    System.out.println("4번 출력");
    int c = staticCall("5번 출력");
    InstanceTest d = new InstanceTest();
}

}

1번 출력 4번 출력 5번 출력 2번 출력 3번 출력

```

• this는 현재 사용하고 있는 reference의 객체, 지금 만들어지는 그 객체를 말함.

5. method overloading

5.1 연산자 오버로딩

• • → 당연히 숫자를 더하는 기호다. (앞과 뒤에 숫자가 나와서 숫자를 더한다.)
• “문자열” + 10 → 문자열 연결하는 기호로 의미가 변한다.

5.2 오버로딩

💡 메소드의 이름은 같지만 만약 메소드의 인자의 개수나 인자의 type이 다른 경우 서로 다른 method로 구분되어서 사용할 수 있다.

• 생성자 오버로딩도 하고, 메소드 오버로딩도 된다.
• 이렇게 여러 개의 생성자를 사용하는 생성자 오버로딩은 각기 다른 방식으로 인스턴스를 초기화할 필요가 있기 때문이다.
• 따라서 하나의 클래스 안에는 여러 개의 생성자가 존재할 수 있다.

6. package와 import

6.1 package

• package는 클래스를 용도별로, 종류별로 묶어주는 논리적인 단위이다.
• 유지보수와 재활용성을 높이기 위해서 서로 관련 있는 클래스를 묶어서 관리한다.
• 당연히 물리적으로는 package 이름으로 되어 있는 폴더를 만들어서 그 안에 class를 저장한다.
• 만약 package 구문을 사용하지 않으면 클래스는 default package 라는 것으로 묶인다.
• package는 계층 구조로 사용할 수 있다. 이 계층 구조를 표현할 때, “.” 를 이용한다.

6.2 import

• import는 다른 package에 있는 class를 가져다가 사용하기 위해서 사용하는 구문이다.
• 자바 코드는 거의 예외 없이 package 구문이 나온다.

• class를 간단히 정의하자면
  1. 객체 모델링의 수단(전체적인 프로그램 설계 시)
  2. instance를 생성하는 수단(프로그래밍 실행 관점)
  3. ADT(자료구조 측면에서 프로그램을 바라볼 때)

2. instance

• class에 정의된 field(변수), method(함수)를 사용하기 위해서 메모리에 공간을 확보한 것

3. constructor(생성자)

• class로 부터 instance를 생성하기 위해서 호출되는 것.
• 당연히 class 내부에 위치한다.
• 모든 class는 무조건 1개의 이상의 constructor를 가지고 있다.

3.1 생성자의 특징

• constructor은 이름이 클래스의 이름과 같다.

  • 생성자(인스턴스의 초기화)

    public class Car {
      private String color;
      private String model;
    
      // 기본 생성자
      public Car() {
          this.color = "Red";
          this.model = "Toyota";
      }
    
      // 매개변수를 받는 생성자
      public Car(String color, String model) {
          this.color = color;
          this.model = model;
      }
    
      // 기타 메서드
    }

• 메소드는 아니다. (메소드는 해당 메소드가 만드는 리턴 타입이 명시가 되어야 한다.)

  • 리턴 타입

  1. 기본형(primitive types): int, double, boolean 등과 같은 기본 데이터 타입을 리턴할 수 있다.

  2. 참조형(reference types): 클래스, 인터페이스, 배열 등과 같은 참조형 데이터 타입을 리턴할 수 있다.

  3. void: 메서드가 아무런 값을 반환하지 않을 경우 void를 리턴 타입으로 지정한다. 이는 메서드가 작업을 완료한 후 어떠한 값도 반환하지 않음을 의미한다.

     public int add(int a, int b) {
      return a + b;
     }

     public void greet() {
      System.out.println("Hello!");
     }

• new 라는 키워드와 함께 호출되며 주로 하는 일은 instance의 초기화를 담당한다.

3.2 클래스와 패키지

• 클래스를 묶어 놓은 논리적인 단위, 유사한 종류의 클래스를 꾸러미로 묶어 놓음, 클래스의 집합 → 패키지
• 패키지는 일반적으로 소문자로 이름을 정함
• 패키지는 계층구조를 가질 수 있다. 점(.)을 활용해서!
• public이 붙은 class는 파일 이름 역시 해당 class의 이름으로 정해야 한다.
• 한 파일에는 public이 붙은 class는 하나만 존재해야 한다.
• 생성자를 안 쓰면 자동으로 생성자를 넣어주긴 한다.
• 예제 1

  // package는 관련 있는 class들을 하나로 묶는 논리적인 단위이고
  // 물리적으로는 폴더로 표현된다.
  // 거의 예외없이 package는 사용을 한다.
  

// 하나의 자바 파일에 public이 붙은 class는 // 두 개 이상 존재할 수 없다. (하나만 있어야 한다.) // 만약, public class가 존재하면 파일명은 반드시 // public class 이름으로 설정해야 한다.

package test;

public class HelloWorld {

// field들
int age;

// constructor들
// constructor는 이름이 클래스 이름과 같다.
// 모양은 method와 유사하다. (리턴 타입 존재 X)
// constructor는 instance의 초기화를 담당하는 일을 주로 한다.
public HelloWorld() {

}
// 만약 생성자를 직접적으로 명시하지 않으면
// javac compiler가 소스 코드를 bytecode로 컴파일 할 때
// default constructor를 자동으로 삽입한다.
// default constructor는 인자도 없고 하는 일도 없는 생성자다.
// default constructor는 반드시 작성하는 버릇을 들이자.
// 그러고 오버로딩해서 여러 생성자를 만들던가 한다.

// method들
public void sayHello() {

}

// 프로그램의 entry point 진입점
public static void main(String args[]) {
    System.out.println("안녕하세요~");

    // 인스턴스 만들기
    // 메모리 공간의 heap 영역에 대부분 인스턴스가 만들어진다.
    // java는 강타입 언어기 때문에 무조건 데이터 타입을 명시해 주어야 한다.
    // a는 reference variable이라고 부른다.
    // Heap 영역의 instance의 시작 주소를 가지고 있기 때문에 그렇다.
    HelloWorld a = new HelloWorld();
}

}

- **`예제 2`**
```java
package test;

public class MyTest {

    // static block
    // 클래스가 로드될 때 가장 먼저 수행된다.
    static {

    }

    // 필드들
    // a라는 변수에 100을 넣을 것이다.
    // 넣는 것에서 끝나는 것이 아니라, 클래스로부터 인스턴스를 만들어야 함.
    // 인스턴스가 있어야 사용할 수 있는 변수
    // 즉, instance variable이라고도 한다.
    // instance variable은 메모리 heap 영역에 만들어진다.
    public int a = 100;

    private static int b = 200; // java에는 전역 변수는 따로 없다.
    // class variable
    // static이 붙으면 Method Area에 올라간다.
    // heap에 instance가 없어도 사용할 수 있다.
    // instance에는 b가 저기 있다고 알려주는 참조 값이 있다.

    private int c = 300;

    // 생성자들
    public MyTest() {

    }

    MyTest(int k) {

    }

    // 메소드들

    public static void main(String args[]) {
        // 위에 있는 a라고 되어 있는 field를 사용하려면
        // 당연히 instance가 존재해야 한다.
        MyTest obj = new MyTest();

        // obj 라는 시작 주소값이 들어있는 참조 변수 = 객체
        // obj 라는 reference variable을 이용해서 Heap 영역에
        // 생성된 instance를 사용할 수 있다.
        // reference variable을 이용해서 instance를 사용할 때
        // 우리가 이용하는 연산자가 있다.
        // dot operator(.)
        System.out.println("a의 값은 : " + obj.a);
        // import java.lang.*; 을 원래 추가해야하지만 javac 컴파일러가 자동으로 추가해준다.

        // 지역 변수는 메소드가 호출될 때 만들어지고
        // stack 영역에 공간이 잡히고
        // 메소드가 끝나면 pop되면서 사라지는 변수
        int k = 200; // 지역 변수(local variable)
        // 지역 변수는 stack 영역에 만들어진다.
    }

}

• 프로그램을 잘 하려면 데이터를 잘 다뤄야 한다.
• 데이터를 효율적으로 사용하기 위해서는 자료구조를 잘 알아야 한다.
• array, list, map, set, class
• 자바는 collection(list, map, set), 파이썬은 list, 자바스크립트는 array
• 시간적인 효율성을 추구하기 위해서는 알고리즘을 사용한다.
• Java 언어는 강타입 언어다.
• 변수를 만들 때 타입을 지정해서 만든다.

2. 식별자 명명 규칙

• 자바는 대소문자 구분을 한다.
• 식별자의 길이 제한이 없다.
• 당연히 예약어는 사용할 수 없다. (if, for, String, …)
• 숫자로 시작할 수 없다.
• 특수문자 사용할 수 있다.( $, _ )
• 클래스 이름은 첫 글자 항상 대문자로 시작하고 두 단어 이상으로 구성된 경우, 두 번째 단어의 첫 글자도 대문자로 시작한다. (PascalCase)
• field명이나 method명은 첫 글자는 소문자로 시작하고, 두 단어 이상으로 구성된 경우 두 번째 단어의 첫 글자도 대문자로 시작한다. (camelCase)
• 상수의 이름은 모두 대문자로 하고, 두 단어 이상으로 구분된 경우 단어의 연결은 _를 이용한다. (snakeCase)

3. 데이터 타입

• 자바의 데이터 타입은 크게 2가지이다.
• primitive data type 원시 타입(기본형) - 실제 값이 들어감
  • 원시 타입으로 선언된 변수 안에는 실제 데이터가 저장된다.
  • 정수형 4개, 실수형 2개, 문자형 1개, 논리형 1개
  • 총 8개의 데이터 타입 제공
  • byte, short, int, long(정수형) - int 많이 씀(효율성 측면)
  • float, double(실수형) - double 많이 씀.
  • char(문자) - 1byte, 유니코드 문자 정수가 들어가서.. 변환됨, 즉, 연산이 가능함.
  • boolean(논리) - true, false
• reference data type 참조 타입(참조형) - 메모리 주소값이 들어감(정확히는 해시 코드값)
  • 참조 타입으로 지정된 변수 안에는 메모리에 대한 해쉬 코드 값이 저장된다.
  • instance에 대한 메모리 주소 값을 가지고 있다.
  • class를 reference data type이라고 한다.

4. 형변환(Type Casting)

• ( )을 이용해서 형변환을 하면 된다.
• double a = (double)10

• JVM만 있으면 플랫폼과 상관없이 플랫폼에 독립적인 언어로써 돌아간다.
• C 계열 언어보다는 배우기 쉽다.
• 메모리 관리를 하지 않아도 된다.
  • 가비지컬렉터 - 메모리 관리를 자동적으로 수행함. 사용되지 않는 것이 자동으로 반환된다. (메모리 프레쉬 기능)
  • 코드 자체 로직에 대해 집중할 수 있다.
• 멀티쓰레드를 Java 언어 차원에서 지원한다.
• 강타입언어(Strong Type 언어)

2. JVM(Java Virtual Machine)

• 플랫폼에 종속적, 독립적인 형태
• C로 구현되어 있다.
• JVM ↔ Java 애플리케이션 ↔ JVM ↔ OS(Windows) ↔ 컴퓨터(하드웨어)
• 일반 애플리케이션 ↔ OS(Windows) ↔ 컴퓨터(하드웨어)
• 참고
• C보다 느리다.
• 예전에는 속도가 문제가 되었는데 지금은 JIT와 같은 기술이 발전되어서 속도 문제 거의 해결!
  • JIT 컴파일(just-in-time compilation) 또는 동적 번역(dynamic translation)은 프로그램을 실제 실행하는 시점에 기계어로 번역하는 컴파일 기법이다.
• 머신마다 쓰는 기계어가 다르기 때문에.. 컴파일 과정을 거친다..
• 컴파일 하면 바이트 코드가 나온다. 그럼 JVM이 이걸 읽고 기계어로 변환하여 머신이 읽는다.

3. JDK, JRE, JVM

• JVM ⊂ JRE ⊂ JDK
• JDK Java Development Kit (JDK안에 JRE가 들어간다.)
  • Java를 사용하기 위한 필요한 모든 기능을 갖춘 Java용 SDK이다.
  • JRE 포함 컴파일러 javac와 jdb, javadoc 등의 도구도 있다.
  • 즉, JDK는 프로그램을 생성하고 컴파일할 수 있다.
• JRE Java Runtime Environment (JRE안에 JVM이 들어간다.)
  • JVM, Java Class Library (API), Java Command 및 기타 인프라를 포함한 컴파일된 Java 프로그램을 실행하는 데 필요한 패키지
• 포함관계
• JDK 1.0부터 시작해서 버전업이 계속 되고 있다.
• JDK 1.5 버전이 되었을 때 언어 자체가 한 단계 업그레이드가 됐다. → Java 5.0으로 명명
• JDK 1.8은 당연히 Java 8이라고 부른다. (상당수가 Java 8을 기업에서 쓰고 있다.)
  • Java 9부터 패키지의 상위 개념인 모듈 개념이 생긴다.
  • 하위호환성 담보가 깨진다..
  • Java 11은 신규로 나온 곳이 많이 쓰고 있다고 함
  • 수업은 Java 8로 진행한다.
• Java는 부분 유료
  • 기본 기능은 무료(GPL license) 여기에 오라클이 추가적으로 제공하는 글꼴, Java Web Start는 유료로 제공된다.

4. 객체지향의 기본적인 개념

• 프로그래밍의 패러다임 변화부터 알아보자.
• 프로그래밍 방법론의 변화
• 함수형 프로그래밍 → 구조적 프로그래밍, 절차적 프로그래밍
• 객체지향 프로그래밍

4.1 절차적 프로그래밍

• 절차적 프로그래밍의 특징
  • 프로그램을 기능별로 세분화해서 함수로 나눠서 프로그래밍을 하는 방식
  • 프로그램을 기능 단위로 구현한다. 각 기능을 함수라는 실행 단위로 구현해서 그 함수를 모아 전체 프로그램을 완성
  • 장점: 프로그램의 설계가 쉽다. → 개발이 쉽다. → 개발 기간이 단축된다. → 비용 절감
  • 단점: 유지보수와 모듈(함수)의 재활용성이 떨어진다.
  • 이 단점을 해결하기 위해 나온 프로그래밍 패러다임이 바로 객체지향 프로그래밍이다.

4.2 객제지향 프로그래밍

• 객체지향 프로그래밍의 특징
  • 현실세계, 구성요소를 프로그래밍 적으로 표현한다.
  • 각각의 객체로 표현하고 모델링한다.
  • 구현하고자 하는 현실세계의 문제를 구성하고 있는 구성 요소를 파악하고 이 구성 요소를 프로그램적으로 모델링해서 해당 구성 요소들이 데이터를 주고 받는 형태를 프로그래밍하는 방법
  • 장점: 프로그램의 유지보수와 재활용성에 장점이 있다.
  • 단점: 설계와 구현이 상대적으로 어렵다.
• 현실 세계의 문제를 구성하고 있는 구성 요소를 파악하는 작업을 해야 한다.
  • Abstraction(추상화) 과정을 거쳐서 프로그램적으로 표현해야 하는 속성값, 행위로 표현한다.
  • 클래스라는 단위로 속성값 - 변수, 행위 - 함수로 표현한다.
  • 객체 모델링의 수단 - 클래스
  • 속성값은 변수로, 행위는 함수로, 프로그램적으로 표현해야 한다.
  • 이 2가지를 하나의 단위로 만들기 위해서 사용하는 개념이 바로 class.
  • 그래서 class의 의미 중 하나는 바로 객체 모델링의 수단
  • 변수는 필드 field라고 부른다.
  • class 내부에는 변수에 해당하는 field, 함수에 해당하는 method가 존재한다.
• 인스턴스
  • 인스턴스화 Instanciation → 클래스로 표현한 것을 메모리 상에 할당을 해야 한다.
  • 인스턴스: 메모리 공간
  • instance는 class 안에 정의된 변수(field)를 실제 메모리 영역에 공간을 확보한 것.
  • class는 instance를 만들어내기 위한 수단
  • class도 하나의 데이터 타입 (ADT)
  • 클래스는 추상 데이터 타입 Abstract Data Type ADT라고도 불린다.
  • class 안에 정의된 field를 이용해서 메모리 공간을 확보하고 해당 공간에 대한 데이터 타입은 당연히 class 명으로 설정해야 한다.
  • class는 하나의 데이터 타입.
  • 즉, 우리가 임의로 만들 수 있는 데이터 타입이기 때문에 ADT(Abstract Data Type) 이라고도 불린다.
  • 추상화의 결과로 나온 것이 결국 class이다.
• class란 무엇인가요?
  • 객체 모델링의 수단
  • 인스턴스를 만들어내기 위한 수단
  • ADT

5. Java program의 특징

• 우리가 자바 프로그램을 작성할 때
  • 원칙적으로 하나의 Java Source File에 하나의 class만 정의한다.
    • 재활용성 + 유지 보수 때문에!
• 소스 파일의 확장자는 .java를 사용
• 여러 개의 source file(여러 개의 class)가 모여서 하나의 Java application을 구성한다.
• Java program의 entry point(진입점)는 main() method이다.