자바가 처음 세상에 나온 건 1995년인데, 그때부터 이미 GUI 개발 기능을 품고 있었음ㅋㅋ
처음엔 AWT(Abstract Window Toolkit)라는 녀석이 등장했고,
이후 더 강력한 Swing이 나왔고, 그 다음엔 JavaFX가 등장하면서 지금에 이름.
각각의 기술이 왜 나왔는지, 어떤 차이가 있는지 알면 어떤 걸 써야 할지 감이 잡힘! 🎯

AWT는 Java 1.0 시절부터 있던 가장 오래된 GUI 라이브러리야.
특징은 운영체제의 네이티브 컴포넌트를 직접 사용한다는 것.
즉, 윈도우에서 버튼을 만들면 진짜 윈도우 버튼이 나오고, 맥에서 만들면 맥 버튼이 나오는 방식임.
"Write Once, Run Anywhere"라는 자바 철학과 어울리는 것 같지만...

1997년 Java 1.2와 함께 등장한 Swing은 AWT의 문제를 해결하기 위해 만들어졌어.
가장 큰 차이점은 순수 자바로 컴포넌트를 직접 그린다는 것!
OS 네이티브 컴포넌트에 의존하지 않고, 자바가 직접 픽셀 단위로 그려내기 때문에
어느 플랫폼에서든 동일한 모양을 보장할 수 있게 됐음.

Swing은 Look and Feel(L&F) 개념을 도입해서
Metal, Nimbus, Windows, GTK 등 다양한 테마를 적용할 수 있게 됐고,
지금도 수많은 기업용 애플리케이션에서 현역으로 활약 중임 💪

JavaFX는 2008년 처음 등장했고, Java 8부터 JDK에 번들로 포함됐어.
(Java 11부터는 다시 분리됐지만 OpenJFX로 계속 발전 중!)
CSS 스타일링, FXML 마크업 언어, 하드웨어 가속 렌더링, 애니메이션 API 등
현대적인 UI 개발에 필요한 모든 것을 갖추고 있음.
웹 개발자들이 자바 데스크톱 개발로 넘어올 때 진입장벽이 낮다는 것도 큰 장점! 🚀

AWT를 직접 쓸 일은 많지 않지만, Swing이 AWT를 기반으로 만들어졌기 때문에
AWT의 기본 개념을 이해하는 건 중요해. 특히 이벤트 처리 모델은 지금도 그대로 쓰임!

AWT의 모든 컴포넌트는 java.awt.Component 클래스를 상속받아.
컴포넌트들을 담는 컨테이너는 java.awt.Container를 상속받고,
최상위 윈도우는 java.awt.Frame을 사용함.

import java.awt.*;
import java.awt.event.*;

public class BasicAWTExample {
    public static void main(String[] args) {
        // Frame 생성 (최상위 윈도우)
        Frame frame = new Frame("AWT 기본 예제");
        frame.setSize(400, 300);
        frame.setLayout(new FlowLayout());
        
        // 컴포넌트 추가
        Label label = new Label("안녕하세요!");
        Button button = new Button("클릭하세요");
        TextField textField = new TextField(20);
        
        // 버튼 이벤트 처리
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                label.setText("버튼이 클릭됐어요! 👋");
            }
        });
        
        frame.add(label);
        frame.add(textField);
        frame.add(button);
        
        // 윈도우 닫기 처리
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        
        frame.setVisible(true);
    }
}

AWT에서 컴포넌트 배치는 레이아웃 매니저가 담당해.
절대 좌표로 배치하는 것보다 레이아웃 매니저를 쓰면 화면 크기가 바뀌어도 자동으로 조정됨!

Swing은 자바 GUI 개발의 핵심이야. 지금도 IntelliJ IDEA, Eclipse 같은 대형 IDE들이
Swing 기반으로 만들어져 있다는 사실 알고 있었음?ㅋㅋ
그만큼 성숙하고 안정적인 기술이라는 증거지! 💼

Swing 컴포넌트는 모두 J로 시작해. JFrame, JPanel, JButton, JLabel...
AWT 컴포넌트에 J를 붙인 버전이라고 생각하면 쉬움!
모든 Swing 컴포넌트는 javax.swing.JComponent를 상속받아.

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class SwingBasicExample extends JFrame {
    
    private JLabel statusLabel;
    private JTextField inputField;
    private JButton submitButton;
    
    public SwingBasicExample() {
        setTitle("Swing 기본 예제");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(450, 300);
        setLocationRelativeTo(null); // 화면 중앙에 배치
        
        initComponents();
        setVisible(true);
    }
    
    private void initComponents() {
        // 메인 패널 설정
        JPanel mainPanel = new JPanel(new BorderLayout(10, 10));
        mainPanel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
        
        // 상단 레이블
        JLabel titleLabel = new JLabel("이름을 입력하세요", JLabel.CENTER);
        titleLabel.setFont(new Font("맑은 고딕", Font.BOLD, 18));
        
        // 중앙 입력 패널
        JPanel inputPanel = new JPanel(new FlowLayout());
        inputField = new JTextField(20);
        submitButton = new JButton("확인");
        inputPanel.add(inputField);
        inputPanel.add(submitButton);
        
        // 하단 상태 레이블
        statusLabel = new JLabel("결과가 여기 표시됩니다", JLabel.CENTER);
        statusLabel.setForeground(Color.GRAY);
        
        // 이벤트 처리 (람다식 사용!)
        submitButton.addActionListener(e -> {
            String name = inputField.getText().trim();
            if (!name.isEmpty()) {
                statusLabel.setText("안녕하세요, " + name + "님! 👋");
                statusLabel.setForeground(new Color(70, 130, 180));
            } else {
                statusLabel.setText("이름을 입력해주세요!");
                statusLabel.setForeground(Color.RED);
            }
        });
        
        mainPanel.add(titleLabel, BorderLayout.NORTH);
        mainPanel.add(inputPanel, BorderLayout.CENTER);
        mainPanel.add(statusLabel, BorderLayout.SOUTH);
        
        add(mainPanel);
    }
    
    public static void main(String[] args) {
        // EDT(Event Dispatch Thread)에서 실행 - 중요!
        SwingUtilities.invokeLater(() -> new SwingBasicExample());
    }
}

기업용 앱에서 가장 많이 쓰이는 컴포넌트가 바로 JTable이야.
MVC 패턴을 기반으로 설계되어 있어서 데이터와 뷰를 분리할 수 있음!

import javax.swing.*;
import javax.swing.table.*;
import java.awt.*;

public class JTableExample extends JFrame {
    
    public JTableExample() {
        setTitle("JTable 예제");
        setSize(600, 400);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
        
        // 컬럼 헤더 정의
        String[] columns = {"이름", "나이", "직업", "연봉(만원)"};
        
        // 데이터 정의
        Object[][] data = {
            {"김자바", 28, "백엔드 개발자", 4500},
            {"이스윙", 32, "풀스택 개발자", 5200},
            {"박FX", 25, "UI/UX 개발자", 3800},
            {"최코딩", 35, "시니어 개발자", 6800},
            {"정데스크", 29, "데스크톱 개발자", 4200}
        };
        
        // DefaultTableModel 사용
        DefaultTableModel model = new DefaultTableModel(data, columns) {
            @Override
            public boolean isCellEditable(int row, int column) {
                return column != 0; // 이름 컬럼은 수정 불가
            }
        };
        
        JTable table = new JTable(model);
        table.setRowHeight(30);
        table.setFont(new Font("맑은 고딕", Font.PLAIN, 13));
        table.getTableHeader().setFont(new Font("맑은 고딕", Font.BOLD, 13));
        
        // 연봉 컬럼 오른쪽 정렬
        DefaultTableCellRenderer rightRenderer = new DefaultTableCellRenderer();
        rightRenderer.setHorizontalAlignment(JLabel.RIGHT);
        table.getColumnModel().getColumn(3).setCellRenderer(rightRenderer);
        
        // 스크롤 패널에 추가 (JTable은 항상 JScrollPane에 넣어야 함!)
        JScrollPane scrollPane = new JScrollPane(table);
        add(scrollPane);
        
        setVisible(true);
    }
    
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new JTableExample());
    }
}

Swing의 이벤트 처리는 옵저버 패턴을 기반으로 해.
이벤트 소스(버튼 등)에 리스너를 등록하면, 이벤트 발생 시 리스너가 호출되는 구조야.

// 다양한 이벤트 처리 방법들

// 1. 익명 클래스 방식 (전통적인 방법)
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("버튼 클릭!");
    }
});

// 2. 람다식 방식 (Java 8+, 가장 깔끔함!)
button.addActionListener(e -> System.out.println("버튼 클릭!"));

// 3. 마우스 이벤트 처리
panel.addMouseListener(new MouseAdapter() {
    @Override
    public void mouseClicked(MouseEvent e) {
        System.out.println("클릭 위치: " + e.getX() + ", " + e.getY());
    }
    
    @Override
    public void mouseEntered(MouseEvent e) {
        panel.setBackground(Color.LIGHT_GRAY); // 마우스 오버 효과
    }
    
    @Override
    public void mouseExited(MouseEvent e) {
        panel.setBackground(Color.WHITE);
    }
});

// 4. 키보드 이벤트 처리
textField.addKeyListener(new KeyAdapter() {
    @Override
    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_ENTER) {
            // 엔터 키 눌렸을 때 처리
            processInput();
        }
    }
});

// 5. 컴포넌트 크기 변경 이벤트
frame.addComponentListener(new ComponentAdapter() {
    @Override
    public void componentResized(ComponentEvent e) {
        System.out.println("창 크기: " + frame.getSize());
    }
});

기본 컴포넌트로 부족할 때는 직접 그릴 수 있어!
JPanel을 상속받고 paintComponent() 메서드를 오버라이드하면 됨.

import javax.swing.*;
import java.awt.*;
import java.awt.geom.*;

// 커스텀 원형 진행 표시 컴포넌트
public class CircularProgressBar extends JPanel {
    
    private int progress = 0; // 0 ~ 100
    private Color progressColor = new Color(91, 155, 213);
    private Color bgColor = new Color(230, 240, 248);
    
    public CircularProgressBar() {
        setPreferredSize(new Dimension(150, 150));
        setOpaque(false);
    }
    
    public void setProgress(int progress) {
        this.progress = Math.max(0, Math.min(100, progress));
        repaint(); // 다시 그리기 요청
    }
    
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g.create();
        
        // 안티앨리어싱 설정 (부드러운 곡선)
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
                             RenderingHints.VALUE_ANTIALIAS_ON);
        
        int size = Math.min(getWidth(), getHeight()) - 20;
        int x = (getWidth() - size) / 2;
        int y = (getHeight() - size) / 2;
        
        // 배경 원 그리기
        g2d.setColor(bgColor);
        g2d.setStroke(new BasicStroke(12, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
        g2d.drawOval(x, y, size, size);
        
        // 진행 호 그리기
        g2d.setColor(progressColor);
        int angle = (int) (360.0 * progress / 100);
        g2d.drawArc(x, y, size, size, 90, -angle);
        
        // 텍스트 그리기
        g2d.setColor(new Color(44, 74, 110));
        g2d.setFont(new Font("맑은 고딕", Font.BOLD, 22));
        FontMetrics fm = g2d.getFontMetrics();
        String text = progress + "%";
        int textX = (getWidth() - fm.stringWidth(text)) / 2;
        int textY = (getHeight() + fm.getAscent()) / 2 - 4;
        g2d.drawString(text, textX, textY);
        
        g2d.dispose();
    }
}

JavaFX는 자바 데스크톱 개발의 미래야. CSS 스타일링, FXML, 바인딩, 애니메이션...
웹 개발에서 쓰던 개념들이 그대로 들어와 있어서 웹 개발자들도 금방 적응할 수 있음ㅋㅋ
지금부터 JavaFX의 핵심을 하나씩 파헤쳐보자! 🔍

Java 11 이후로 JavaFX는 JDK에서 분리됐어.
OpenJFX(https://openjfx.io)에서 다운받거나, Maven/Gradle로 의존성 추가하면 됨!

<!-- Maven pom.xml에 추가 -->
<dependency>
    <groupId>org.openjfx</groupId>
    <artifactId>javafx-controls</artifactId>
    <version>21.0.1</version>
</dependency>
<dependency>
    <groupId>org.openjfx</groupId>
    <artifactId>javafx-fxml</artifactId>
    <version>21.0.1</version>
</dependency>

// Gradle build.gradle에 추가
plugins {
    id 'org.openjfx.javafxplugin' version '0.1.0'
}

javafx {
    version = "21.0.1"
    modules = ['javafx.controls', 'javafx.fxml']
}

JavaFX는 극장 비유로 이해하면 쉬워!
Stage(무대) → Scene(장면) → Node(배우/소품) 계층 구조로 이루어져 있음.

import javafx.application.Application;
import javafx.scene.*;
import javafx.scene.control.*;
import javafx.scene.layout.*;
import javafx.stage.Stage;
import javafx.geometry.Insets;
import javafx.geometry.Pos;

public class JavaFXBasicExample extends Application {
    
    @Override
    public void start(Stage primaryStage) {
        // Stage = 윈도우 (극장의 무대)
        primaryStage.setTitle("JavaFX 기본 예제");
        
        // 레이아웃 컨테이너
        VBox root = new VBox(15); // 수직 배치, 간격 15px
        root.setPadding(new Insets(20));
        root.setAlignment(Pos.CENTER);
        
        // 컴포넌트 생성
        Label titleLabel = new Label("JavaFX에 오신 것을 환영합니다! 🎉");
        titleLabel.setStyle("-fx-font-size: 18px; -fx-font-weight: bold; -fx-text-fill: #2c4a6e;");
        
        TextField nameField = new TextField();
        nameField.setPromptText("이름을 입력하세요...");
        nameField.setMaxWidth(250);
        
        Button greetButton = new Button("인사하기");
        greetButton.setStyle("-fx-background-color: #5b9bd5; -fx-text-fill: white; " +
                            "-fx-padding: 8 20; -fx-border-radius: 6; -fx-background-radius: 6;");
        
        Label resultLabel = new Label("");
        resultLabel.setStyle("-fx-text-fill: #4a6fa5; -fx-font-size: 14px;");
        
        // 이벤트 처리
        greetButton.setOnAction(e -> {
            String name = nameField.getText().trim();
            if (!name.isEmpty()) {
                resultLabel.setText("안녕하세요, " + name + "님! 반갑습니다 😊");
            } else {
                resultLabel.setText("이름을 입력해주세요!");
            }
        });
        
        // 엔터 키 처리
        nameField.setOnAction(e -> greetButton.fire());
        
        root.getChildren().addAll(titleLabel, nameField, greetButton, resultLabel);
        
        // Scene = 장면 (Stage에 올라가는 내용)
        Scene scene = new Scene(root, 450, 300);
        
        primaryStage.setScene(scene);
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args); // JavaFX 앱 실행
    }
}

JavaFX의 가장 큰 장점 중 하나가 CSS 스타일링이야!
웹 CSS와 거의 비슷한 문법을 사용하는데, 자바FX 전용 속성은 -fx- 접두사를 붙임.

/* styles.css 파일 */

/* 루트 컨테이너 */
.root {
    -fx-background-color: #f4f8fc;
    -fx-font-family: "맑은 고딕", "Malgun Gothic", sans-serif;
}

/* 커스텀 버튼 스타일 */
.primary-button {
    -fx-background-color: #5b9bd5;
    -fx-text-fill: white;
    -fx-font-size: 14px;
    -fx-font-weight: bold;
    -fx-padding: 10 24;
    -fx-background-radius: 8;
    -fx-cursor: hand;
}

.primary-button:hover {
    -fx-background-color: #4a8ac4;
    -fx-effect: dropshadow(gaussian, rgba(91,155,213,0.4), 8, 0, 0, 2);
}

.primary-button:pressed {
    -fx-background-color: #3a7abf;
    -fx-scale-x: 0.97;
    -fx-scale-y: 0.97;
}

/* 카드 스타일 */
.card {
    -fx-background-color: white;
    -fx-background-radius: 12;
    -fx-effect: dropshadow(gaussian, rgba(0,0,0,0.1), 10, 0, 0, 3);
    -fx-padding: 20;
}

/* 입력 필드 */
.custom-field {
    -fx-background-color: #f4f8fc;
    -fx-border-color: #c8ddf0;
    -fx-border-radius: 6;
    -fx-background-radius: 6;
    -fx-padding: 8 12;
    -fx-font-size: 13px;
}

.custom-field:focused {
    -fx-border-color: #5b9bd5;
    -fx-border-width: 2;
}

// Java 코드에서 CSS 적용하기
Scene scene = new Scene(root, 600, 400);

// 외부 CSS 파일 적용
scene.getStylesheets().add(getClass().getResource("/styles.css").toExternalForm());

// 특정 노드에 스타일 클래스 추가
button.getStyleClass().add("primary-button");
cardPane.getStyleClass().add("card");
textField.getStyleClass().add("custom-field");

FXML은 XML 기반의 마크업 언어로, UI 구조를 코드 대신 파일로 정의할 수 있어.
HTML처럼 생겼는데, Scene Builder라는 드래그앤드롭 도구로 시각적으로 만들 수 있음!
MVC 패턴에서 View 역할을 FXML이 담당하고, Controller 클래스가 로직을 처리함.

<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.layout.*?>
<?import javafx.scene.control.*?>
<?import javafx.geometry.*?>

<!-- main.fxml -->
<VBox xmlns:fx="http://javafx.com/fxml"
      fx:controller="com.example.MainController"
      spacing="15" alignment="CENTER"
      style="-fx-padding: 20; -fx-background-color: #f4f8fc;">
    
    <Label text="회원 정보 입력" 
           style="-fx-font-size: 20px; -fx-font-weight: bold; -fx-text-fill: #2c4a6e;"/>
    
    <GridPane hgap="10" vgap="10" alignment="CENTER">
        <Label text="이름:" GridPane.columnIndex="0" GridPane.rowIndex="0"/>
        <TextField fx:id="nameField" promptText="이름 입력" 
                   GridPane.columnIndex="1" GridPane.rowIndex="0"/>
        
        <Label text="이메일:" GridPane.columnIndex="0" GridPane.rowIndex="1"/>
        <TextField fx:id="emailField" promptText="이메일 입력"
                   GridPane.columnIndex="1" GridPane.rowIndex="1"/>
        
        <Label text="나이:" GridPane.columnIndex="0" GridPane.rowIndex="2"/>
        <Spinner fx:id="ageSpinner" min="1" max="100" initialValue="25"
                 GridPane.columnIndex="1" GridPane.rowIndex="2"/>
    </GridPane>
    
    <HBox spacing="10" alignment="CENTER">
        <Button text="저장" onAction="#handleSave" 
                styleClass="primary-button"/>
        <Button text="초기화" onAction="#handleReset"/>
    </HBox>
    
    <Label fx:id="statusLabel" text="" 
           style="-fx-text-fill: #4a6fa5;"/>
</VBox>

// MainController.java
import javafx.fxml.FXML;
import javafx.scene.control.*;

public class MainController {
    
    @FXML private TextField nameField;
    @FXML private TextField emailField;
    @FXML private Spinner<Integer> ageSpinner;
    @FXML private Label statusLabel;
    
    @FXML
    public void initialize() {
        // FXML 로드 후 초기화
        ageSpinner.setValueFactory(
            new SpinnerValueFactory.IntegerSpinnerValueFactory(1, 100, 25)
        );
    }
    
    @FXML
    private void handleSave() {
        String name = nameField.getText().trim();
        String email = emailField.getText().trim();
        int age = ageSpinner.getValue();
        
        if (name.isEmpty() || email.isEmpty()) {
            statusLabel.setText("⚠️ 모든 필드를 입력해주세요!");
            statusLabel.setStyle("-fx-text-fill: #e08aaa;");
            return;
        }
        
        // 저장 로직...
        statusLabel.setText("✅ " + name + "님의 정보가 저장됐어요!");
        statusLabel.setStyle("-fx-text-fill: #6bbf8e;");
    }
    
    @FXML
    private void handleReset() {
        nameField.clear();
        emailField.clear();
        ageSpinner.getValueFactory().setValue(25);
        statusLabel.setText("");
    }
}

// FXML 로드하기
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;

public class MainApp extends Application {
    @Override
    public void start(Stage stage) throws Exception {
        FXMLLoader loader = new FXMLLoader(getClass().getResource("/main.fxml"));
        Parent root = loader.load();
        
        // 컨트롤러 접근 (필요한 경우)
        MainController controller = loader.getController();
        
        Scene scene = new Scene(root, 500, 400);
        scene.getStylesheets().add(getClass().getResource("/styles.css").toExternalForm());
        
        stage.setTitle("FXML 예제");
        stage.setScene(scene);
        stage.show();
    }
}

JavaFX의 킬러 기능 중 하나가 바로 Property와 Binding이야!
데이터가 바뀌면 UI가 자동으로 업데이트되는 마법 같은 기능임ㅋㅋ
React의 상태 관리와 비슷한 개념이라고 생각하면 됨!

import javafx.beans.property.*;
import javafx.beans.binding.*;
import javafx.scene.control.*;

// Property 기본 사용
IntegerProperty age = new SimpleIntegerProperty(25);
StringProperty name = new SimpleStringProperty("김자바");

// 값 변경 감지
age.addListener((observable, oldValue, newValue) -> {
    System.out.println("나이 변경: " + oldValue + " → " + newValue);
});

// Binding - 두 값을 연결
Slider slider = new Slider(0, 100, 50);
Label valueLabel = new Label();

// 슬라이더 값이 바뀌면 레이블도 자동으로 바뀜!
valueLabel.textProperty().bind(
    Bindings.format("현재 값: %.0f", slider.valueProperty())
);

// 복잡한 바인딩 표현식
IntegerProperty width = new SimpleIntegerProperty(100);
IntegerProperty height = new SimpleIntegerProperty(50);
IntegerProperty area = new SimpleIntegerProperty();

// 넓이 = 가로 × 세로 (자동 계산!)
area.bind(width.multiply(height));

System.out.println("넓이: " + area.get()); // 5000
width.set(200);
System.out.println("넓이: " + area.get()); // 10000 (자동 업데이트!)

// 양방향 바인딩
TextField field1 = new TextField("초기값");
TextField field2 = new TextField();

// 두 필드가 서로 동기화됨
field1.textProperty().bindBidirectional(field2.textProperty());

JavaFX는 강력한 애니메이션 API를 제공해.
Timeline, Transition 클래스들을 활용하면 부드러운 애니메이션을 쉽게 만들 수 있음!

import javafx.animation.*;
import javafx.scene.shape.*;
import javafx.util.Duration;

// 1. FadeTransition - 페이드 인/아웃
FadeTransition fade = new FadeTransition(Duration.millis(500), node);
fade.setFromValue(0.0);
fade.setToValue(1.0);
fade.play();

// 2. TranslateTransition - 이동 애니메이션
TranslateTransition move = new TranslateTransition(Duration.millis(300), button);
move.setByX(100); // X축으로 100px 이동
move.setByY(50);  // Y축으로 50px 이동
move.play();

// 3. ScaleTransition - 크기 변환
ScaleTransition scale = new ScaleTransition(Duration.millis(200), node);
scale.setToX(1.1);
scale.setToY(1.1);
scale.setAutoReverse(true);
scale.setCycleCount(2);
scale.play();

// 4. RotateTransition - 회전
RotateTransition rotate = new RotateTransition(Duration.seconds(2), node);
rotate.setByAngle(360);
rotate.setCycleCount(Timeline.INDEFINITE); // 무한 반복
rotate.play();

// 5. Timeline - 가장 유연한 애니메이션
Timeline timeline = new Timeline(
    new KeyFrame(Duration.ZERO, 
        new KeyValue(node.opacityProperty(), 0),
        new KeyValue(node.translateYProperty(), -20)
    ),
    new KeyFrame(Duration.millis(300),
        new KeyValue(node.opacityProperty(), 1),
        new KeyValue(node.translateYProperty(), 0)
    )
);
timeline.play();

// 6. 애니메이션 체이닝 (순서대로 실행)
SequentialTransition sequence = new SequentialTransition(
    new FadeTransition(Duration.millis(200), node),
    new TranslateTransition(Duration.millis(300), node),
    new ScaleTransition(Duration.millis(200), node)
);
sequence.play();

// 7. 병렬 애니메이션 (동시에 실행)
ParallelTransition parallel = new ParallelTransition(
    new FadeTransition(Duration.millis(500), node),
    new RotateTransition(Duration.millis(500), node)
);
parallel.play();

JavaFX는 다양한 차트 컴포넌트를 기본으로 제공해!
별도 라이브러리 없이도 멋진 데이터 시각화가 가능함.

import javafx.scene.chart.*;

// 1. 막대 차트 (BarChart)
CategoryAxis xAxis = new CategoryAxis();
NumberAxis yAxis = new NumberAxis();
xAxis.setLabel("월");
yAxis.setLabel("매출 (만원)");

BarChart<String, Number> barChart = new BarChart<>(xAxis, yAxis);
barChart.setTitle("월별 매출 현황");

XYChart.Series<String, Number> series = new XYChart.Series<>();
series.setName("2024년");
series.getData().add(new XYChart.Data<>("1월", 4200));
series.getData().add(new XYChart.Data<>("2월", 3800));
series.getData().add(new XYChart.Data<>("3월", 5100));
series.getData().add(new XYChart.Data<>("4월", 4700));
series.getData().add(new XYChart.Data<>("5월", 5600));

barChart.getData().add(series);

// 2. 파이 차트 (PieChart)
PieChart pieChart = new PieChart();
pieChart.setTitle("기술 스택 분포");
pieChart.getData().addAll(
    new PieChart.Data("Java", 35),
    new PieChart.Data("Python", 25),
    new PieChart.Data("JavaScript", 20),
    new PieChart.Data("기타", 20)
);

// 3. 선 차트 (LineChart)
NumberAxis lineX = new NumberAxis(1, 12, 1);
NumberAxis lineY = new NumberAxis(0, 100, 10);
LineChart<Number, Number> lineChart = new LineChart<>(lineX, lineY);
lineChart.setTitle("성장 추이");

XYChart.Series<Number, Number> lineSeries = new XYChart.Series<>();
lineSeries.setName("사용자 수 (만명)");
for (int i = 1; i <= 12; i++) {
    lineSeries.getData().add(new XYChart.Data<>(i, Math.random() * 50 + 30));
}
lineChart.getData().add(lineSeries);

UI 스레드에서 무거운 작업을 하면 앱이 멈춰버림ㅋㅋ
JavaFX는 Task와 Service 클래스로 백그라운드 작업을 쉽게 처리할 수 있어!

import javafx.concurrent.*;
import javafx.scene.control.*;

// Task - 일회성 백그라운드 작업
Task<String> downloadTask = new Task<>() {
    @Override
    protected String call() throws Exception {
        // 백그라운드에서 실행되는 코드
        updateMessage("다운로드 시작...");
        
        for (int i = 0; i <= 100; i++) {
            Thread.sleep(50); // 시뮬레이션
            updateProgress(i, 100);
            updateMessage("다운로드 중... " + i + "%");
        }
        
        return "다운로드 완료!";
    }
};

// 진행 상황 UI 연결
ProgressBar progressBar = new ProgressBar();
Label statusLabel = new Label();

progressBar.progressProperty().bind(downloadTask.progressProperty());
statusLabel.textProperty().bind(downloadTask.messageProperty());

// 완료 시 처리
downloadTask.setOnSucceeded(e -> {
    String result = downloadTask.getValue();
    statusLabel.textProperty().unbind();
    statusLabel.setText(result + " ✅");
});

downloadTask.setOnFailed(e -> {
    statusLabel.textProperty().unbind();
    statusLabel.setText("오류 발생: " + downloadTask.getException().getMessage());
});

// 백그라운드 스레드에서 실행
Thread thread = new Thread(downloadTask);
thread.setDaemon(true); // 앱 종료 시 같이 종료
thread.start();