[Java - AWT 학습정리] 자바의 GUI프로그래밍 - (2) 이벤트처리, Adapter클래스, paint()와 Graphics, Image

이 글은 아래 링크 문서를 보며 공부한 것을 요약정리한 것입니다. 감사합니다🙇‍♀️

'자바의 정석' 남궁성 님의 블로그 자료 - AWT

[자바의 정석 2판] 13장 AWT입니다.(PDF)

 

아래 깃허브 링크에서 같은 내용을 더 편하게 볼 수 있습니다.

github.com/bibi6666667/Codesquad-Cocoa-JAVA/blob/main/mission/src/mission6/AWT.md

bibi6666667/Codesquad-Cocoa-JAVA

 

---

---

이벤트 처리 event handling

이벤트 event 란?

• 이벤트 : 사용자 또는 프로그램 코드에 의해 발생할 수 있는 사건.

  • (사용자가 마우스를 움직이거나 클릭함 / 키보드를 누름 / Frame의 크기를 변경 ...)

• 이벤트 소스(event source, 이벤트 발생지)

  • 이벤트가 발생한 컴포넌트. (예시 : 사용자가 버튼을 눌러 이벤트 발생 -> button이 이벤트 소스.)

• 이벤트 핸들러(event handler, 이벤트 처리기)

  • 이벤트가 발생했을 때 실행할 코드를 구현해 놓은 클래스. 주로 함수나 메소드이다.

• 이벤트 리스너(event listener, 이벤트 감지기)

  • 이벤트를 감지하고 처리하는 클래스.

• 이벤트 처리(event handling, 이벤트 핸들링)

  • (이벤트 소스와 이벤트 핸들러를 이벤트 리스너로 연결하는 것?)
  • 이벤트에 대한 수행코드를 작성하여 이벤트 소스에 이벤트 리스너로 등록하는 것.
  • 이벤트가 발생하더라도, 그에 대한 이벤트 처리를 하지 않으면 아무 일도 일어나지 않음.

• 사실 사용자가 AWT프로그램을 사용하면서 하는 모든 동작이 이벤트를 발생시킨다.
  단지 이벤트에 대한 이벤트 처리가 되어있지 않기 때문에 아무 일도 일어나지 않는 것.

이벤트의 발생과 처리

1. 이벤트 발생
   • 이벤트가 발생하면 해당 이벤트 클래스의 인스턴스가 생성됨.
2. 이벤트 처리가 되어 있는지 확인
   • = 이벤트 리스너가 이벤트 소스에 등록되어 있는지 확인.
     3-1. (이벤트 처리가 되어 있다면) 이벤트 리스너가 이벤트를 처리함.
     3-2. (이벤트 처리가 되어 있지 않다면) 아무 일도 일어나지 않음.

• 이벤트 처리는 "예외처리"와 유사하다.
  • 둘 다 클래스의 인스턴스가 생성되고, 일치하는 catch블럭/Listener가 예외/이벤트를 처리함.

이벤트 처리방법

• 이벤트 처리(event handling)

  • (AWT프로그램 실행 중) 사용자의 어떤 동작에 의해 이벤트가 발생했을 때, 이에 대한 어떤 작업이 수행되도록 하는 것.

• 이벤트 처리 방법

  1. (이벤트 리스너 선택) ①이벤트 리스너 추가/제거 메서드들 중에서 필요한 것을 찾는다.
     *(예시)창닫기 버튼 눌림. 마우스 왼쪽 클릭 ..
  2. (이벤트 핸들러 작성) 선택한 메서드가 속해있는 ②이벤트 관련 인터페이스를 구현하는 클래스를 작성한다.
  3. (이벤트 리스너 작성) 위에서 구현한 클래스의 인스턴스를 생성해 이벤트 소스에 Listener로 등록한다.
  • ❗ EventHandler클래스는 WindowListener인터페이스를 구현해야 함.
    • 따라서 WindowListener인터페이스에 정의되어 있는 모든 추상 메서드의 body부분을 만들어 주어야 함.
    • 그래서 아무 내용도 없는 메서드들도 만든 것. (내용은 없지만 메서드 body들이 있어야 한다)
      • 이렇게 body(틀)만 있는 메서드들은 호출되어도 실행할 문장이 없으므로 바로 종료된다.

---

②이벤트 관련 인터페이스 및 AWT이벤트와 주요 메서드

• ※ AWT이벤트들의 최고 조상은 AWTEvent이다.

• ※ 이벤트 관련 클래스들은 java.awt.event 패키지에 속한다.

• 각 Listener들을 추가/제거하는 메서드(공통)

  • 추가 : void add리스너이름(이벤트핸들러이름)
  • 제거 : void remove리스너이름(이벤트핸들러이름)

• ✅ 각 메서드에서는 발생한 이벤트의 인스턴스에 대한 참조를 사용할 수 있다.

• 따라서 이벤트 발생 시 생성된 이벤트 인스턴스들의 메서드 역시 사용할 수 있다!

• 아래는 AWT이벤트 종류, 이벤트별 주요 메서드 및 관련 인터페이스(~Listener) 이다.

  ※ 구분

  • ~Event : AWT이벤트
  • ~Listener : 각 이벤트의 이벤트리스너 = 인터페이스
  • ~Listener 하위 메서드 : 각 이벤트 인터페이스에 속하는 메서드.
  • 굵은글씨 메서드 : 각 이벤트의 주요 메서드.

• 모든 이벤트 공통 주요 메서드

  • Object getSource() : 이벤트 소스를 반환.
    • java.util패키지의 EventObject에 정의되어 있는 메서드
  • String paramString() : 이벤트와 관련된 정보를 문자열로 반환.
    • java.awt패키지의 AWTEvent에 정의되어 있는 메서드

• ActionEvent

  • ActionListener
    • actionPeformed(ActonEvent ae)
  • String getActionCommand() : 이벤트의 ActionCommand를 반환.
  • int getModifiers() : 이벤트 발생 시 누르고 있던 특수키를 반환.
  • long getWhen() : 이벤트가 발생한 시간을 long값으로 반환.

• ComponentEvent

  • ComponentListener
    • componentMoved(ActonEvent ae)
    • componentHidden(ActonEvent ae)
    • componentResized(ActonEvent ae)
    • componentShown(ActonEvent ae)
  • Component getComponent() : 이벤트 소스(컴포넌트)를 반환한다.

• MouseEvent

  • MouseMotionListener
    • mouseDragged(MouseEvent me)
    • mouseMoved(MouseEvent me)
  • MouseListener
    • mousePressed(MouseEvent me)
    • mouseReleased(MouseEvent me)
    • mouseEntered(MouseEvent me)
    • mouseExited(MouseEvent me)
    • mouseClicked(MouseEvent me)
  • int getClickCount() : 마우스를 클릭한 횟수를 반환.
  • Point getPoint() : 이벤트가 일어난 위치를 반환.
  • int getX() : 이벤트가 일어난 위치의 x좌표를 반환.
  • int getY() : 이벤트가 일어난 위치의 y좌표를 반환.

• MouseWheelEvent

  • MouseWheelListener
    • mouseWheelMoved(MouseWheelEvent e)
  • int getScrollAmount() : 스크롤되어야 하는 양(amount)을 반환.
  • int getScrollType() : 어떤 스크롤타입에 의해 이벤트가 발생했는지 알려줌.
  • int getUnitsToScroll() : 단위당 스크롤해야 하는 양을 반환.
  • int getWheelRotation() : 마우스 휠이 이동한 방향을 알려줌.

• KeyEvent

  • KeyListener
    • keyPressed(KeyEvent ke)
    • keyReleased(KeyEvent ke)
    • keyTyped(KeyEvent ke)
  • char getKeyChar() : 눌러진 키를 반환.
  • int getKeyCode() : 눌러진 키의 코드를 반환.
  • String getKeyModifiersText(int modifiers) : 눌러진 특수키(Alt, Ctrl) 또는 특수키 조합을 설명하는 문자열을 반환.
  • String getKeyText(int keyCode) : 눌러진 키를 HOME, F1과 같이 키를 설명한느 문자열로 반환.

• TextEvent

  • TextListener
    • textValueChanged(TextEvent te)

• FocusEvent

  • FocusListener
    • focusGained(FocusEvent fe)
    • focusLost(FocusEvent fe)
  • Component getOppositeComponent() : 포커스를 잃은 컴포넌트를 반환.

• ItemEvent

  • ItemListener
    • itemStateChanged(ItemEvent ie)
  • Object getItem() : 이벤트가 발생한 item을 반환.
  • ItemSelectable getItemSelectable() : 이벤트 소스를 반환.
  • int getStateChange() : item의 상태(선택/선택해제)를 반환.

• AdjustmentEvent

  • AdjustmentListener
    • adjustmentValueChanged(AdjustmentEvent ae)
  • Adjustable getAdjustable() : 이벤트 소스를 반환.
  • int getAdjustmentType() : 값을 변경시킨 방법을 알려줌.
  • int getValue() : 이벤트 발생 시의 (스크롤바의)값을 반환.
  • boolean getValueIsAdjusting() : 값이 변경되고 있는 중인지 알려줌.

• WindowEvent

  • WindowListener
    • windowClosing(WindowEvent we)
    • windowOpened(WindowEvent we)
    • windowIconified(WindowEvent we)
    • windowDeiconified(WindowEvent we)
    • windowClosed(WindowEvent we)
    • windowActivated(WindowEvent we)
    • windowDeactivated(WindowEvent we)
  • WindowFocusListener
    • windowGainedFocus(WindowEvent e)
    • windowLostFocus(WindowEvent e)
  • WindowStateListener
    • windowStateChanged(WindowEvent e)
  • int getNewState() : 윈도우의 현재 상태를 반환.
  • int getOldState() : 윈도우의 이전 상태를 반환.
  • Window getOppositeWindow() : 이벤트 발생 전 포커스를 가졌던 윈도우를 반환.
  • Window getWindow() : 이벤트 소스를 반환.

• ContainerEvent

  • ContainerListener
    • componentAdded(ContainerEvent ce)
    • componentRemoved(ContainerEvent ce)
  • Component getChild() : 컨테이너에 추가/삭제된 컴포넌트를 반환.
  • Container getContainer() : 이벤트 소스를 반환.

---

①이벤트 리스너 추가/제거 메서드들

• 이벤트 리스너를 컴포넌트에 추가/제거하는 메서드들이다.

• ②이벤트 관련 인터페이스들 의 메서드들에 대한 설명에 해당한다!

• ※ 윈도우 = 컨테이너인 Window와 그 자손들인 Frame, Dialog, FileDialog를 뜻한다.

  • 활성윈도우 active window : 현재 작업 중인 윈도우 = 가장 위에 나타나는 윈도우
  • 비활성화 deactivated : 사용자가 다른 작업을 위해 다른 윈도우를 선택시, 이전에 작업하던 윈도우는 비활성화됨.

• ※ ActionEvent ae

  • 고수준 이벤트로, 컴포넌트에 정의된 동작이 수행되었을 때 발생함.
  • ActionEvent가 발생하는 경우
    • Button이 눌러졌을 때(클릭/스페이스바)
    • Menu를 클릭했을 때
    • TextField 에서 Enter키를 눌렀을 때
    • List의 item 하나를 선택하여 더블클릭했을 때
  • 이 때는 MouseEvent나 KeyEvent가 발생해도, 최종적으로는 ActionEvent가 발생한 것으로 처리됨.
  • 따라서 ActionListener의 actionPerformed(ActionEvent ae)에 이벤트 발생시 수행할 코드를 작성해야 한다.
  • ActionEvent의 장점 : 버튼을 누르는 여러 방법이 존재하더라도 최종적으로는 ActionEvent만 발생하므로, 이에 대한 처리만 하면 된다.

• 아래는 메서드와, 각 메서드의 호출시기이다.

• actionPeformed(ActonEvent ae)

  • Button이 눌러졌을 때(클릭/스페이스바)
  • Menu를 클릭했을 때
  • TextField 에서 Enter키를 눌렀을 때
  • List의 item 하나를 선택하여 더블클릭했을 때

• componentMoved(ActonEvent ae)

• componentShown(ActonEvent ae)

• componentHidden(ActonEvent ae)

• componentResized(ActonEvent ae)

  • 각각 컴포넌트가 이동되었을 때 / 화면에 보일 떄 / 화면에 보이지 않을 때 / 크기가 변경되었을 때.

• mouseDragged(MouseEvent me) : 마우스 버튼을 누른 채로 마우스를 움직였을 때

• mouseMoved(MouseEvent me) : 마우스 포인터를 이동시킬 때

• mousePressed(MouseEvent me) : 마우스 버튼을 눌렀을 때

• mouseReleased(MouseEvent me) : 마우스 버튼을 뗴었을 때

• mouseEntered(MouseEvent me) : 마우스포인터가 이벤트소스 영역 내로 들어왔을 떄

• mouseExited(MouseEvent me) : 마우스포인터가 이벤트소스 영역 밖으로 나갈 때

• mouseClicked(MouseEvent me) : 마우스 버튼을 눌렀다 떼었을 때

• mouseWheelMoved(MouseWheelEvent e) : 마우스 휠을 움직였을 때

• keyPressed(KeyEvent ke) : 키보드 키를 눌렀을 때

• keyReleased(KeyEvent ke) : 키보드 키를 떼었을 때

• keyTyped(KeyEvent ke) : 키보드 키를 눌렀다 떼었을 때

• textValueChanged(TextEvent te) : TextField/TextArea의 내용이 변경되었을 때

• focusGained(FocusEvent fe) : 이벤트 소스로 focus가 이동했을 때

• focusLost(FocusEvent fe) : 이벤트 소스가 갖고 있던 focus가 다른 컴포넌트로 이동했을 때

• itemStateChanged(ItemEvent ie) : Checkbox, CheckboxItem, List, Choice 의 status가 변경되었을 때.

  • (selected <-> unselected 로 status가 전환될 때)

• adjustmentValueChanged(AdjustmentEvent ae) : Scrollbar의 값이 변경되었을 때

• windowOpened(WindowEvent we) : 윈도우가 열렸을 때

• windowClosing(WindowEvent we) : 윈도우가 닫힐 때(닫기 버튼을 눌렀을 때)

• windowClosed(WindowEvent we) : 윈도우가 닫혔을 때(dispose()가 호출되었을 떄)

• windowIconified(WindowEvent we) : 윈도우가 최소화(아이콘화)되었을 때

• windowDeiconified(WindowEvent we) : 윈도우가 최소화 상태에서 원래 크기로 돌아왔을 때

• windowActivated(WindowEvent we) : 윈도우가 활성화 되었을 떄

• windowDeactivated(WindowEvent we) : 윈도우가 비활성화 되었을 때

• windowGainedFocus(WindowEvent e) : 윈도우가 포커스를 얻을 때

• windowLostFocus(WindowEvent e) : 윈도우가 포커스를 잃었을 때

• windowStateChanged(WindowEvent e) : 윈도우의 상태가 변했을 때

• componentAdded(ContainerEvent ce) : 컨테이너에 컴포넌트가 추가되었을 때

• componentRemoved(ContainerEvent ce) : 컨테이너에 컴포넌트가 제거되었을 때

---

각 이벤트의 주요 메서드

---

이벤트 처리 예시 - 닫기 버튼 동작시키기

package mission6.event;

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

public class FrameTest3 {
    public static void main(String[] args) {
        Frame f = new Frame("Login"); // Frame객체를 생성한다
        f.setSize(300, 200); // Frame의 크기를 설정한다

        // EventHandler클래스의 객체를 생성해 Frame의 WindowListener로 등록한다
        f.addWindowListener(new EventHandler());
        f.setVisible(true); // Frame .
    }
}

// 클래스 EventHandler에서,
// 이미 만들어져 있는 WindowListener라는 인터페이스를 구현하게 함.
class EventHandler implements WindowListener
{
    public void windowOpened(WindowEvent e) {}
    // ↓ windowClosing메서드 : Frame의 닫기 버튼을 눌렀을 때 호출된다.
    // 따라서 해당 메서드에 어플리케이션을 종료하는 코드를 추가해야 한다.
    public void windowClosing(WindowEvent e) { // 사용자가 닫기 버튼을 누르는 이벤트
        e.getWindow().setVisible(false); // Frame을 화면에서 보이지 않도록 하고
        e.getWindow().dispose(); // 메모리에서 제거한다
        System.exit(0); // 프로그램을 종료한다
        // ※ 이 메서드 내에서는 이벤트 발생시 생성된 WindowEvent인스턴스의 참조를 사용할 수 있다.
        // 그래서 WindowEvent인스턴스의 메서드들을 사용할 수 있다.
    }
    public void windowClosed(WindowEvent e) {} // 아무내용도 없는 메서드들 구현
    public void windowIconified(WindowEvent e) {}
    public void windowDeiconified(WindowEvent e) {}
    public void windowActivated(WindowEvent e) {}
    public void windowDeactivated(WindowEvent e) {}
}

---

Adapter클래스

• Adapter클래스

  • 이벤트 리스너를 직접 구현하는 대신, Adapter클래스를 상속받아 원하는 메서드만 작성(오버라이딩)할 수 있도록 고안되었다.
  • 이벤트 핸들러를 작성할 때, 해당 이벤트 리스너에 정의된 모든 추상메서드를 구현해야 하는 불편함을 개선하기 위해 고안됨.

• Adapter를 상속받으면, 이벤트리스너(인터페이스)의 모든 추상메서드를 구현하지 않고 원하는 메서드만 작성하면 된다.

  • (Adapter클래스는 그저 이벤트 리스너에 정의된 모든 메서드를 추상메서드로(아무 내용 없이) 구현해 놓은 메서드일 뿐이다.)

• 따라서 이벤트 핸들러를 작성할 때..

  • 이벤트 리스너를 구현하거나 : implements 이벤트리스너
  • Adapter클래스를 상속받으면 된다 : extends Adapter클래스
  • (둘의 차이는 코드 작성의 편리함 외에는 아무 차이가 없다)

Adapter클래스로 구현되어 있는 이벤트 리스너

• 아래는 Adapter클래스로 구현되어 있는 이벤크 리스너의 목록이다.
• (좌)이벤트 리스너(인터페이스) - (우)Adapter 클래스
• ComponentListener - ComponentAdapter
• ContainerListener - ContainerAdapter
• FocusListener - FocusAdapter
• KeyListener - KeyAdapter
• MouseListener - MouseAdapter
• MouseMotionListener - MouseMotionAdapter
• WindowListener - WindowAdapter

---

이벤트 예제 (1) - 로그인 구현하기

• 객체지향적으로 정리된 코드의 예시.
  • Frame을 상속받는 클래스 구현
  • Frame에 포함되는 컴포넌트들을 인스턴스멤버로 선언
  • Frame의 생성자에서 컴포넌트를 생성 및 설정하게 함
• TextField인 tfId, tfPwd에도 EventHandler인스턴스를 이벤트 리스너로 등록한 이유
  • TextField에서 엔터 키를 둘러도 ok버튼을 누른 것과 같게 처리하기 위해.
  • ActionEvent와 같은 고수준 이벤트의 필요성.
• TextField/TextArea/TextComponent의 메서드들 활용
  • requestFocus() : 원하는 컴포넌트가 포커스를 갖게 한다.
  • selectAll() : TextField 또는 TextArea에 입력된 text전체를 선택된 상태로 만든다
  • setEchoChar(char c) : - 실제로 입력된 값을 감추기 위해 화면에 보여질 문자를 지정한다

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

public class TextFieldTest2 extends Frame {
    // Frame클래스를 상속받는다(=Frame클래스의 public/protected 변수 및 메서드 사용가능)
    Label lid;
    Label lpwd;
    TextField tfId;
    TextField tfPwd;
    Button ok;

    TextFieldTest2(String title) { // 생성자
        super(title); // Frame클래스의 생성자를 호출한다.

        lid = new Label("ID :", Label.RIGHT); // Label의 text정렬을 오른쪽으로
        lpwd = new Label("Password :", Label.RIGHT);

        // 약 10개의 글자를 입력할 수 있는 TextField생성
        tfId = new TextField(10);
        tfPwd = new TextField(10);
        tfPwd.setEchoChar('*'); // 입력한 값 대신 '*'이 보이게 한다

        ok = new Button("OK");
        // OK버튼과 TextField에 이벤트처리를 위한 Listener를 추가해준다
        // TextField에 이벤트처리를 하는 이유? 엔터키를 눌렀을 때도 처리되게 하기 위해.
        tfId.addActionListener(new EventHandler());
        tfPwd.addActionListener(new EventHandler());
        ok.addActionListener(new EventHandler());

        setLayout(new FlowLayout()); // LayoutManager를 FlowLayout으로
        add(lid); // 생성한 Component들을 Frame에 포함시킨다
        add(tfId);
        add(lpwd);
        add(tfPwd);
        add(ok);
        setSize(450, 65);
        setVisible(true); // Frame이 화면에 보이게 한다
    }
    public static void main(String args[]) {
        TextFieldTest2 f = new TextFieldTest2("Login");
    }
    class EventHandler implements ActionListener {
        public void actionPerformed(ActionEvent e){
            String id = tfId.getText(); // tfId에 입력되어있는 text를 얻어온다
            String password = tfPwd.getText();
            if (!id.equals("javachobo")){
                System.out.println("입력하신 id가 유효하지 않습니다. 다시 입력해 주세요.");
                // id를 다시 입력할 수 있도록, focus를 tfId로 옮긴다
                tfId.requestFocus();
                tfId.selectAll(); // tfId에 입력된  text가 선택되게 한다
            } else if (!password.equals("asdf")) {
                System.out.println("입력하신 비밀번호가 틀렸습니다. 다시 입력해 주세요.");
                // pwd를 다시 입력할 수 있도록  focus를 tfPwd로 옮긴다
                tfPwd.requestFocus();
                tfPwd.selectAll();
            } else {
                System.out.println( id + "님, 성공적으로 로그인 되었습니다.");
            }
        }
    } // class EventHandler
}

이벤트 예제 (2) - 마우스포인터 좌표 찍기

• Frame 위에서 마우스 포인터를 움직이면 화면에 포인터의 좌표가 나타난다.
• 원리
  • Frame위에서 마우스포인터를 움직이면 MouseEvent가 발생하고 mouseMoved메서드가 호출됨.
  • MouseEvent에는 getX()와 getY() 메서드가 있어 이 메서드들을 활용해 마우스포인터의 좌표를 알 수 있다.
• 이벤트 소스 : Frame
• 이벤트 리스너 : MouseMotionListener
• 이벤트 핸들러 : EventHandler 클래스

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


public class MouseEventTest extends Frame{ // Frame클래스 상속받기
    Label location;

    MouseEventTest (String title) { // 생성자
        super(title); // 부모 클래스인 Frame(String title)호출
        location = new Label("Mouse Pointer Location : ");
        location.setSize(195,15);
        location.setLocation(5,30);
        location.setBackground(Color.yellow);
        add(location);

        //EventHandler의 인스턴스를 Frame의 Listener로 등록.
        // 마우스 모션 이벤트 발생시 addMouseMotionListener가 감지하고, EventHandler가 이벤트 처리.
        addMouseMotionListener(new EventHandler());

        setSize(300,200);
        setLayout(null);
        setVisible(true);
    }

    public static void main(String[] args) {
        MouseEventTest mainWin = new MouseEventTest("MouseEventTest");
    }

    class EventHandler implements MouseMotionListener {
        public void mouseDragged(MouseEvent e) {}
        public void mouseMoved(MouseEvent e) {
            // .setText() Label 내 텍스트를 ()로 바꾸기
            location.setText("Mouse Pointer Location : (" + e.getX()
                                                    + "," + e.getY() + ")");
        }
    } // EventHandler
}

이벤트 예제 (3) - .getSource(), ItemListener 활용

• Checkbox(radio button) 중 하나를 클릭하면 Frame의 배경색이 변경된다.

• 원리

  • Checkbox를 클릭하면 ItemEvent가 발생한다.
  • itemStateChanged메서드가 호출된다.
    • (itemStateChanged는 Checkbox, CheckboxItem, List, Choice 의 status가 변경되었을 때 호출된다.
      • (selected <-> unselected 로 status가 전환될 때)
  • 이 때 itemStateChanged메서드 내에서 getSource()를 호출하면 이벤트 소스(클릭한 Checkbox)를 얻을 수 있다.
  • getSource()로 얻은 이벤트 소스에서 getLabel()로 Label을 얻는다.
  • if문으로 어떤 체크박스에 체크했는지 확인한 뒤, 각 체크박스 Label에 맞는 배경색을 나타낸다.

• 이벤트 소스 : 클릭한 Checkbox

• 이벤트 리스너 : ItemListener

• 이벤트 핸들러 : EventHandler클래스 (implements ItemListener)

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

public class CheckboxEventTest2 extends Frame { // Frame클래스 상속받아오기
    CheckboxGroup group;
    Checkbox cb1;
    Checkbox cb2;
    Checkbox cb3;

    CheckboxEventTest2 (String title) { // 생성자
        super(title); // 부모 클래스인 Frame의 생성자 호출
        group = new CheckboxGroup();
        cb1 = new Checkbox("red", group, true); // 기본 체크 상태
        cb2 = new Checkbox("green", group, false);
        cb3 = new Checkbox("blue", group, false);

        cb1.addItemListener(new EventHandler());
        cb2.addItemListener(new EventHandler());
        cb3.addItemListener(new EventHandler());

        setLayout(new FlowLayout());
        add(cb1);
        add(cb2);
        add(cb3);
        setBackground(Color.red);
        setSize(300,200);
        setVisible(true);
    }

    public static void main(String[] args) {
        CheckboxEventTest2 mainWin = new CheckboxEventTest2("CheckboxEventTest2");
    }

    class EventHandler implements ItemListener {
        public void itemStateChanged(ItemEvent e) {
            Checkbox cb = (Checkbox)e.getSource();
            String color = cb.getLabel();
            System.out.println(color); // 잘 찍히는지 확인용.
            if(color.equals("red")) {
                setBackground(Color.red);
            } else if (color.equals("green")) {
                setBackground(Color.green);
            } else {
                setBackground(Color.blue);
            }
        }
    }
}

이벤트 예제 (4) - 간단 메모장(파일 편집기) 만들기 (FileDialog, Menu, TextArea)

• 파일 읽기, 쓰기, 저장이 가능한 메모장 만들기

  • fileOpen(), saveAs()메서드 내용들은 나중에 따로 공부해 이해하기.
  • java.io.*; 패키지의 FileReader, BufferedReader, StringWriter / FileWriter, BuffredWriter

• 메뉴 구성하기 (MenuBar, Menu, MenuItem)

• TextEditor 생성자

  • Frame에 MenuComponent들과 TextArea 구성
  • 메뉴 각 기능에 EventHandler(ActionListener) 등록
  • ActionListener가 호출되는 경우 -(2) Menu를 클릭했을 때 에 해당하므로 모두 ActionEvent에 해당.

• MyHandler 클래스 : 이벤트 처리

  • New - .setText("")공백 출력
  • Open - FileDialog 통해 파일을 선택한 뒤, fileOpen() 메서드 호출해 화면에 보여줌.
  • Save As.. - FileDialog 통해 현재 작성된 내용을 선택한 뒤 saveAs() 메서드 호출해 파일로 저장함.
  • Exit - System.exit(0); 으로 프로그램 종료

import java.awt.*;
import java.awt.event.*;
import java.io.*; // 파일IO 패키지?

public class TextEditor extends Frame { // Frame클래스 상속받아오기
    String fileName;
    TextArea content;
    MenuBar  mb;
    Menu     mFile;
    MenuItem miNew, miOpen, miSaveAs, miExit;

    TextEditor (String title) {
        super(title); // 부모클래스 Frame의 생성자 호출
        content = new TextArea();
        add(content);

        mb = new MenuBar();
        mFile = new Menu("File");
        miNew = new MenuItem("New");
        miOpen = new MenuItem("Open");
        miSaveAs = new MenuItem("Save As...");
        miExit = new MenuItem("Exit");

        mFile.add(miNew); // Menu에 MenuItem들 추가
        mFile.add(miOpen);
        mFile.add(miSaveAs);
        mFile.addSeparator(); // 메뉴 분리선(separator) 추가
        mFile.add(miExit);

        mb.add(mFile); // MenuBar에 Menu 추가
        setMenuBar(mb); // (setMenuBar메서드를 통해) Frame에 MenuBar 추가

        // 메뉴에 이벤트핸들러 등록
        MyHandler handler = new MyHandler();
        miNew.addActionListener(handler);
        miOpen.addActionListener(handler);
        miSaveAs.addActionListener(handler);
        miExit.addActionListener(handler);

        setSize(300,200);
        setVisible(true);
    }

    // 선택된 파일 내용을 읽어서 TextArea에 보여주는 메서드
    void fileOpen(String fileName) {
        // java.io.*;의 클래스들
        FileReader fr;
        BufferedReader br;
        StringWriter sw;

        try {
            fr = new FileReader(fileName);
            br = new BufferedReader(fr);
            sw = new StringWriter();

            int ch = 0;
            while ((ch=br.read()) != -1) {
                sw.write(ch);
            }

            br.close();
            content.setText(sw.toString()); // TextArea에 불러온 내용을 적어준다
        } catch (IOException e) {
            e.printStackTrace();
        }
    } // fileOpen()

    // TextArea의 내용을 지정된 파일에 저장하는 메서드
    void saveAs(String fileName) {
        FileWriter fw;
        BufferedWriter bw;
        try {
            fw = new FileWriter(fileName);
            bw= new BufferedWriter(fw);
            bw.write(content.getText()); // TextArea 의 내용을 파일에 저장한다.
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        } // try
    } // saveAs메서드의 끝

    public static void main(String args[]) {
        TextEditor mainWin = new TextEditor("Text Editor");
    } // main메서드의 끝

    // 이벤트 처리 : 메뉴 클릭했을 때 메뉴별 처리코드
    class MyHandler implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            String command = e.getActionCommand(); // ActionEvent에서 발생한 명령 받아오기?

            if (command.equals("New")) {
                content.setText(""); // 공백 출력 (빈 페이지)
            } else if(command.equals("Open")) {
                FileDialog fileOpen =
                        new FileDialog(TextEditor.this, "파일열기");
                fileOpen.setVisible(true);
                fileName = fileOpen.getDirectory() + fileOpen.getFile();
                System.out.println(fileName);
                // fileOpen() 메서드 호출 - 선택된 파일의 내용을 TextArea에 보여준다
                fileOpen(fileName);
            } else if(command.equals("Save As...")) {
                FileDialog fileSave =
                        new FileDialog(TextEditor.this,"파일저장 ",FileDialog.SAVE);
                fileSave.setVisible(true);
                fileName = fileSave.getDirectory() + fileSave.getFile();
                System.out.println(fileName);
                // saveAs() 메서드 호출 - 현재 TextArea의 내용을 선택된 파일에 저장한다
                saveAs(fileName);
            } else if(command.equals("Exit")) {
                System.exit(0); // 프로그램 종료.
            }
        }
    } // class MyHandler
} // class TextEditor

---

---

AWT의 그래픽 - AWT로 그림 그리기

• 이제 AWT에서 선과 도형이 어떻게, 어떤 과정으로 그려지는지 배워볼 것이다.
• 자바를 이용해서 이미지 처리, 게임 등 높은 수준의 그래픽기능이 필요한 어플리케이션을 만드는 것도 가능하다.
  • 자바의 그래픽처리 API - Java2D. JDK API의 일부로 java.awt패키지에 포함되어 있다
• AWT는 자바 초기의 GUI프로그래밍 도구로, JDK버전이 높아지며 더 높은 기능의 API인 Swing, Java2D, 최근엔 JavaFX까지 개발되었다.
  • 그럼에도 AWT가 Swing과 Java2D의 뿌리이기 때문에, AWT를 통해 자바 GUI프로그래밍을 배우는 것이 좋다.

paint()와 Graphics

• paint() : 컴포넌트에 그림을 그리기 위한 메서드.

  • Component클래스에 정의되어 있어, 모든 컴포넌트에서 사용 가능하다.
  • Frame, Canvas, Panel 등 그림을 그리려는 컴포넌트의 paint()를 오버라이딩 하면 된다.

• paint() 선언

  • public void paint (Graphics g) { ... }
  • Graphics를 매개변수로 정의함.
  • paint()를 작성하면 Graphics가 가진 다양한 그래픽 메서드를 이용해 그림을 그린다.

• Graphics

  • 모든 컴포넌트는 Graphics 객체를 가지고 있다.
  • Graphics객체에는 각 컴포넌트의 그래픽 관련정보가 담겨져 있다.
  • 따라서 컴포넌트에 그림을 그리려면..
  1. getGraphics()를 호출해 컴포넌트의 Graphics객체에 대한 참조를 얻어낸다
  2. Graphics객체가 가진 다양한 그래픽 메서드를 이용해 그림을 그린다.
  • Graphics객체 = 추상클래스인 Graphics를 완전히 구현한 클래스의 객체를 말함.

Graphics가 제공하는 주요 메서드

1. 문자출력 관련 메서드
   • 문자열을 출력할 수 있으며, 출력할 문자열의 font를 지정할 수 있다.
   • void drawString(String str, int x, int y) : x, y 위치에 문자열을 출력한다.
   • Font getFont() : 현재 설정되어 있는 Font를 얻는다.
   • void setFont(Font font) : 출력할 문자열의 폰트를 지정한다.
   • FontMetrics getFontMetrics() : FontMetrics객체를 반환한다.
     • FontMetrics객체는 지정된 폰트에 대한 상세한 정보를 제공한다.
2. 색 관련 메서드
   • 출력할 그림의 색을 지정하거나, 지정된 색의 정보를 얻을 수 있다.
   • Color getColor() : 현재 설정되어 있는 Color를 얻는다.
   • void setColor(Color c) : 출력할 색을 지정한다.
3. 도형 관련 메서드
   • 다양한 도형을 그리는 메서드.
   • draw~() : 도형의 선만 그린다.
   • fill~() : 도형 내부를 선의 색으로 채운다.
   • 선(line)을 그리는 메서드
     • void drawLine(int x1, int y1, int x2, int y2)
   • 타원(oval)을 그리는 메서드
     • void drawOval(int x, int y, int width, int height)
     • void fillOval(int x, int y, int width, int height)
   • 사각형(rectangle)을 그리는 메서드
     • void drawRect(int x, int y, int width, int height)
     • void fillRect(int x, int y, int width, int height)
   • 둥근 사각형(roundrectangle)을 그리는 메서드
     • void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
     • void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
   • 입체 사각형(3Drectangle)을 그리는 메서드
     • void draw3DRect(int x, int y, int width, int height, boolean raised)
     • void fill3DRect(int x, int y, int width, int height, boolean raised)
   • 호(arc, 부채꼴)를 그리는 메서드
     • void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)
     • void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle)
       • startAngle : 부채꼴을 그리기 시작하는 각도
       • arcAngle : 부채꼴을 표현하는 각도
   • 다각형(polygon)을 그리는 메서드
     • void drawPolygon(int[] xPoints, int[] yPoints, int nPoints)
     • void fillPolygon(int[] xPoints, int[] yPoints, int nPoints)
     • void drawPolyline(int[] xPoints, int[] yPoints, int nPoints)
       • int[] xPoints : 점들의 x좌표 모음 배열
       • int[] yPoints : 점들의 y좌표 모음 배열
       • int nPoints : 점들의 갯수
4. 기타 메서드
   • void clearRect(int x, int y, int width, int height) : 지정된 영역을 지운다.
   • boolean drawImage(Image img, int x, int y, ImageObserver observer) : x,y의 위치에 이미지를 그린다.

Graphics메서드로 도형 그리기

• 선, 원, 둥근 사각형, 다각형, 호 그리기

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

public class GraphicsEx1 extends Frame{ // Frame클래스를 상속받음
    public static void main(String[] args) {
        new GraphicsEx1("GraphicsEx1");
    }

    public GraphicsEx1 (String title) { // 생성자
        super(title); // Frame의 생성자 호출
        addWindowListener(new WindowAdapter() {
            // 창닫기 버튼 구현
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        setBounds(100, 100, 400, 300);
        setVisible(true);
    }

    public void paint (Graphics g) {
        g.setFont(new Font("Serif", Font.PLAIN, 15));
        g.drawString("Graphics를 이용해 그림을 그립니다.", 10, 50);

        // 원 그리기
        g.drawOval(50,100, 50,50); // 일반 원
        // 파란색 원 그리기
        g.setColor(Color.BLUE);//( 색 설정 -> 그리기 : 그 색깔로 그려짐 )
        g.fillOval(100,100, 50,50); // 파란색 원

        // 선 그리기
        g.setColor(Color.red);
        g.drawLine(100,100, 150,150);

        // 둥근 사각형 그리기
        g.fillRoundRect(200, 100, 120, 80, 30, 30);
        // 다각형 그리기
        g.setColor(Color.orange);
        g.fillPolygon(new int[]{50, 100, 150, 200}, new int[]{250, 200, 200, 250}, 4);

        // 호 그리기
        g.setColor(Color.cyan);
        g.fillArc(250, 200, 100, 100, 0, 120);
        // startAngle : 부채꼴을 그리기 시작하는 각도
        // arcAngle : 부채꼴을 표현할 각도
    }
}

---

AWT쓰레드와 repaint()

❓ paint()를 호출한 적이 없는데 어떻게 그림이 그려졌을까?
❗ paint()는 직접 호출하지 않아도, AWT쓰레드에 의해 자동으로 호출되는 메서드이기 때문이다.

• AWT쓰레드
  • GUI어플리케이션을 실행하면 자동으로 생성되는 데몬 쓰레드이다.
  • 평소에는 대기상태에 있다.
  • 화면이 갱신되어야 할 때가 되면, paint() 또는 update()를 호출하여 화면을 다시 그린다.
    • (AWT쓰레드에 의해) 자동으로 화면이 갱신되는 상황
      • 처음 화면에 나타날 때
      • 다른 화면에 가려져 있던 부분이 다시 화면에 나타날 때
      • 아이콘화(최소화) 되어 있다가, 원래 크기로 화면에 나타날 때
  • 위의 상황 외에도 화면을 갱신하려면 repaint()를 호출하면 된다.
    • repaint() -> update(Graphics g) -> paint(Graphics g)
    • repaint()는 AWT쓰레드에게 화면을 갱신할 것을 요청하고,
    • AWT쓰레드는 0.1초마다 확인해 요청이 있으면 update()를 호출하고,
    • update()는 화면을 지운 뒤 paint()를 호출한다.

repaint() 예제 - 마우스 포인터 위치에 * 출력하기

• Frame 내의 마우스 포인터의 위치에 "*"을 출력하는 예제.

• Frame영역 내에서 마우스포인터를 움직이면 "*"도 따라 움직인다.

  • repaint()를 이용해, 마우스포인터가 움직일 떄마다 xy좌표를 받아 "*" 새로 그리는 것이다.

• 원리

  • 마우스를 움직이면 MouseEvent가 발생하고, EventHandler의 mouseMoved()가 호출된다.
  • MouseEvent의 getX(), getY()를 통해 현재 마우스포인터의 위치를 얻어 인스턴스변수 x,y에 저장한다.
  • repaint()를 통해 AWT쓰레드에게 Frame을 화면을 갱신하도록 요청한다.
  • AWT쓰레드는 0.1초마다 확인해 요청이 있으면 update()를 호출해 화면을 지우고, paint()로 "*"를 새로 그린다.

• 만약 repaint()가 없으면 마우스를 움직여도 "*"이 이동하지 않는다!

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

public class GraphicsEx2 extends Frame implements MouseMotionListener {
 // Frame클래스 상속받고 MouseMotionListener구현.
    int x = 0;
    int y = 0;

    public static void main(String[] args) {
        new GraphicsEx2("GraphicsEx2");
    }

    public GraphicsEx2(String title) { // 생성자
        super(title); // 부모클래스 Frame의 생성자 호출
        addMouseMotionListener(this);//GraphicsEx2 객체에 MouseMotionListener 연결
        addWindowListener(new WindowAdapter() { // 종료기능 - Adapter클래스 활용
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

        setBounds(100, 100, 500, 500);
        setVisible(true);
    }

    public void paint(Graphics g) {
        g.drawString("마우스를 움직여보세요.", 10, 50);
        g.drawString("*", x, y);
    }

    // MouseMotionListener 이벤트처리 메서드
    public void mouseMoved(MouseEvent me) {
        x = me.getX(); // MouseEvent의 getX()메서드를 이용해 현재 마우스포인터의 x좌표를 얻어옴
        y = me.getY(); // MouseEvent의 getY()메서드를 이용해 현재 마우스포인터의 y좌표를 얻어옴
        repaint(); // 마우스 움직일 때마다 x,y좌표에 "*"가 있도록 새로 그리기.
    }
    public void mouseDragged(MouseEvent me){}
}

• ※ 위의 소스코드에 아래 코드블럭을 추가하면 마우스포인터의 자취가 남게 된다.
  • update()는 원래 컴포넌트영역을 지우고(배경색으로 채우고) paint()를 호출하는데,
  • 아래 코드블럭으로 update()를 재정의해 컴포넌트영역을 지우지 않고 paint()만 호출하도록 오버라이딩했기 때문.

/* 
    public void update(Graphics g){
        paint(g);
    }
    */

---

Image를 이용해서 이미지 출력하기

• Image 클래스

  • gif, jpg와 같은 형식의 이미지 파일을 보여주거나 가상화면(off-screen)을 생성하는 데 사용된다.

• GUI프로그램에서 이미지 파일을 보여주려면 Toolkit, .getImage(File img), .drawImage() 등을 활용한다.

  • drawImage(Image img, int x, int y, ImageObserver obj)
    • Graphics가 제공하는 메서드로, 이미지(img)를 지정된 위치(x,y)에 출력한다.
    • ImageObserver obj
      • 이미지가 로딩되는 데 시간이 걸리기 떄문에, 로딩이 진행되는 상태에 따라 화면에 다시 그려줘야 한다.
      • "이미지가 로딩되고 있는 상태를 알려줄 대상"을 ImageObserver로 지정한다.
      • 보통은 컴포넌트 자신(this)을 ImageObserver로 지정한다.
        • 왜? 모든 AWT컴포넌트는 ImageObserver인터페이스를 구현했기 떄문이다.

• GUI프로그램에서 그림을 그릴 때는 보통..

  • 실제 화면에 직접 그림을 그리는 대신,
  • 가상화면에 그림을 그린 다음 → 실제화면으로 복사해 보여준다.
  • 왜? 실제화면에 직접 그림을 그리면 깜빡거림이 발생하고, 실행 시 그린 그림이 보존되지 않기 때문.

Image로 가상화면 사용하기 예제 - 마우스로 그림 그리기

마우스로 그림 그리기 (1) - drawString()으로 그리기

• Image(img)와 Image의 Graphics(gImg)를 멤버변수로 정의
• 생성자에서 createImage()를 통해 Frame과 같은 크기의 Image를 생성해 img에 저장.
• 생성된 Image에서 getGraphics()를 통해 Image에 대한 Graphics를 얻는다.
  • 이렇게 얻어진 Graphics에 drawString()과 같은 메서드를 호출해 작업.
  • 작업한 내용은 Image에 그려지게 된다.
• paint()에서는 단순히 가상화면(Image img)에 그려진 내용을 Frame에 복사하기만 하면 된다.
• int getModifiers() : 이벤트 발생 시 누르고 있던 특수키를 반환.

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

public class GraphicsEx4 extends Frame implements MouseMotionListener{
    // Frame클래스 상속받고 MouseMotionListener구현.
    int x = 0;
    int y = 0;

    Image img = null; // Image객체 선언
    Graphics gImg = null; //

    public static void main(String[] args) {
        new GraphicsEx4("GraphicsEx4");
    }

    public GraphicsEx4(String title) { // 생성자
        super(title); // 부모클래스 Frame의 생성자 호출
        addMouseMotionListener(this);//GraphicsEx2 객체에 MouseMotionListener 연결
        addWindowListener(new WindowAdapter() { // 종료기능 - Adapter클래스 활용
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

        setBounds(100, 100, 500, 500);
        setVisible(true);

        img = createImage(500, 500); //createImage()로 Image객체를 생성
        gImg = img.getGraphics(); //getGraphics()를 통해 Image객체의 Graphics객체를 얻음
        gImg.drawString("왼쪽 버튼을 누른 채로 마우스를 움직여 보세요.", 10, 50);
        repaint();
    }

    public void paint(Graphics g) {
        if(img != null) {
            g.drawImage(img,0,0,this);
            // 가상화면에 그려진 그림을 Frame에 복사
        }
    }

    // MouseMotionListener 이벤트처리 메서드
    public void mouseMoved(MouseEvent me) {}
    // 마우스를 클릭해서 움직일(=드래그) 때만 그려지므로 mouseDragged()에 이벤트처리를 해 준다.
    public void mouseDragged(MouseEvent me){
        if (me.getModifiersEx() == MouseEvent.BUTTON1_DOWN_MASK) {
            // MouseEvent발생 시 누르고 있던 키 값 == 마우스 왼쪽 버튼 이면.
            x = me.getX();
            y = me.getY();
            gImg.drawString("*", x, y);
            repaint();
        }
    }
} // class GraphicsEx4

마우스로 그림 그리기 (2) - drawLine()으로 그리기

• 위 예제의 drawString() 대신 drawLine()을 사용해 더 자유롭게 선을 그릴 수 있다.
• 차이점 : paint(), mouseMoved(), mouseDragged() 부분이 다르다.
  • ❓ 왜 다를까?..

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

public class GraphicsEx5 extends Frame implements MouseMotionListener {
    // Frame클래스 상속받고 MouseMotionListener구현.
    int x = 0;
    int y = 0;

    Image img = null; // Image객체 선언(가상화면)
    Graphics gImg = null; // img의 Graphics객체를 담을 변수 선언 

    public static void main(String[] args) {
        new GraphicsEx5("GraphicsEx5");
    }

    public GraphicsEx5(String title) { // 생성자
        super(title); // 부모클래스 Frame의 생성자 호출
        addMouseMotionListener(this);//GraphicsEx2 객체에 MouseMotionListener 연결
        addWindowListener(new WindowAdapter() { // 종료기능 - Adapter클래스 활용
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

        setBounds(100, 100, 500, 500);
        setVisible(true);

        img = createImage(500, 500); // (가상화면) createImage()로 Image객체 생성
        gImg = img.getGraphics(); //getGraphics()를 통해 Image객체의 Graphics객체를 얻음
        gImg.drawString("왼쪽 버튼을 누른 채로 마우스를 움직여 보세요.", 10, 50);
        repaint();
    }

    public void paint(Graphics g) {
        if (img == null) return; // 가상화면에 그려진 게 없으면 paint() 종료
        g.drawImage(img, 0, 0, this);
        // 가상화면에 그려진 그림을 Frame에 복사

    }

    // MouseMotionListener 이벤트처리 메서드
    public void mouseMoved(MouseEvent me) {
        x = me.getX(); //MouseEvent 발생했을 때, 마우스포인터의 x좌표
        y = me.getY();
    }

    public void mouseDragged(MouseEvent me) {
        if (me.getModifiersEx() != MouseEvent.BUTTON1_DOWN_MASK) return;
        // MouseEvent발생했을 때 누르고 있던 키 값이 마우스 왼쪽 버튼이 아니면 종료.
        gImg.drawLine(x, y, me.getX(), me.getY());
        x = me.getX();
        y = me.getY();

        repaint();
    }
} // class GraphicsEx5

---

이미지 삽입하기 예제

• 이미지(img)를 화면 중앙에 보여주는 예제.
• 파일명은 경로를 함께 지정해주는 것이 좋다.
  • 이미지파일이 예제의 클래스파일과 같은 경로에 있는 경우, 경로명은 생략할 수 있다.

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

class GraphicsEx6 extends Frame {
    Image img = null;

    public GraphicsEx6(String title) {//생성자
        super(title);
        addWindowListener(new WindowAdapter() {// 이벤트 - 창닫기 버튼
            public void windowClosing(WindowEvent we) {
                System.exit(0);
            }
        });

        Toolkit tk = Toolkit.getDefaultToolkit();
        img = tk.getImage("sampleBibiImg.jpg");

        setBounds(100, 100, 400, 300);
        setVisible(true);
    }

    public static void main(String[] args) {
        new GraphicsEx6("GraphicsEx6");
    }

    public void paint(Graphics g) {
        if (img == null) return;

        // Image의 크기를 얻는다
        int imgWidth = img.getWidth(this); // getWidth(ImageObserver obj)
        int imgHeight = img.getHeight(this); // getHeight(ImageObserver obj)

        //이미지를  Frame의 중앙에 출력한다
        g.drawImage(img, (getWidth() - imgWidth) / 2,
                (getHeight() - imgHeight) / 2, this);
    }
} // class