운영 카페 문닫으면서 자료를 옮겨왔습니다.
옛날 자료들이라 자바버전업을 반영안되어 있습니다. 이때 당시 자바 버전은 v1.6정도로 보이네요(2025.5.13글을 옮기며)
자바로 window pc용 프로그램을 만들 경우가 적어서 기억에서 멀어진 라이브러리지만 이참에 다시 복기해봅니다.
AWT와 Swing 클래스 상속 구조 정리(25.05.13)
1. AWT 클래스
AWT는 자바 초기 버전부터 제공된 GUI 툴킷으로, 운영체제의 네이티브 GUI 컴포넌트를 활용합니다.
- Object: 모든 자바 클래스의 최상위 부모 클래스입니다.
- Component: AWT의 모든 시각적인 컴포넌트의 추상적인 부모 클래스입니다.
- Button: 클릭 가능한 버튼입니다.
- Label: 변경 불가능한 텍스트를 표시합니다.
- TextComponent: 텍스트를 편집할 수 있는 컴포넌트의 추상 부모입니다.
- TextArea: 여러 줄의 텍스트 영역입니다.
- TextField: 한 줄의 텍스트 입력 필드입니다.
- Canvas: 그림을 그리거나 사용자 정의 그래픽 출력을 위한 영역입니다.
- Scrollbar: 스크롤 기능을 제공합니다.
- List: 스크롤 가능한 항목 목록입니다.
- Checkbox: 참/거짓을 선택하는 체크박스입니다.
- Choice: 드롭다운 목록입니다.
- Container: 다른 Component들을 담을 수 있는 컴포넌트입니다.
- Panel: 다른 컴포넌트들을 그룹화하는 간단한 컨테이너입니다.
- Window: 독립적인 최상위 윈도우입니다.
- Frame: 제목 표시줄과 경계를 가진 일반적인 애플리케이션 윈도우입니다.
- Dialog: 짧은 상호작용을 위한 팝업 윈도우입니다.
- Font: 텍스트의 글꼴을 정의합니다.
- FontMetrics: 특정 글꼴에 대한 정보를 제공합니다 (크기, 너비 등).
- Dimension: 컴포넌트의 크기 (너비와 높이)를 나타냅니다.
- Color: 색상을 나타냅니다.
- Graphics: 그림 그리기 작업을 수행하는 데 사용됩니다.
- Component: AWT의 모든 시각적인 컴포넌트의 추상적인 부모 클래스입니다.
2. Swing 클래스
Swing은 AWT를 기반으로 구축되었지만, 플랫폼 독립적인 "가벼운(lightweight)" 컴포넌트를 사용하여 더 풍부하고 유연한 GUI를 제공합니다. Swing 클래스 이름은 일반적으로 J로 시작합니다.
- JComponent: 모든 Swing 컴포넌트의 추상적인 부모 클래스입니다. AWT의 Component를 확장하여 Swing의 기능을 추가합니다.
- JLabel: 텍스트 또는 이미지를 표시하는 레이블입니다.
- JList: 스크롤 가능한 항목 목록입니다.
- JComboBox: 드롭다운 목록입니다.
- JSlider: 값을 선택할 수 있는 슬라이더입니다.
- JScrollBar: 스크롤 기능을 제공합니다.
- JPanel: 다른 컴포넌트들을 그룹화하는 컨테이너입니다. AWT의 Panel과 유사합니다.
- JLayeredPane: Z-순서로 컴포넌트를 관리할 수 있는 컨테이너입니다.
- JSplitPane: 두 개의 컴포넌트를 분리하고 크기를 조절할 수 있는 컨테이너입니다.
- JScrollPane: 내용이 클 때 스크롤 막대를 제공하는 컨테이너입니다.
- JTabbedPane: 여러 개의 탭을 가진 패널을 제공합니다.
- JRootPane: JFrame, JDialog, JApplet의 루트 컨테이너입니다.
- JToolBar: 자주 사용되는 액션을 위한 버튼이나 컨트롤을 담는 도구 모음입니다.
- JPopupMenu: 컨텍스트 메뉴를 표시합니다.
- JFileChooser: 파일 선택 대화 상자를 제공합니다.
- JTable: 테이블 형태의 데이터를 표시하고 편집할 수 있습니다.
- JTableHeader: JTable의 헤더입니다.
- JTree: 계층적인 데이터를 트리 형태로 표시합니다.
- JColorChooser: 색상을 선택할 수 있는 대화 상자입니다.
- JProgressBar: 작업 진행 상태를 표시합니다.
- JSpinner: 숫자 또는 객체 목록에서 값을 선택할 수 있는 컨트롤입니다.
- JInternalFrame: 데스크톱 애플리케이션 내부에 표시될 수 있는 프레임입니다.
- JDesktopPane: JInternalFrame들을 관리하는 컨테이너입니다.
- JTextComponent: 텍스트 관련 컴포넌트의 추상 부모입니다 (AWT와 유사한 역할).
- JEditorPane: 다양한 형식의 텍스트를 표시하고 편집할 수 있습니다.
- JTextPane: 스타일이 적용된 텍스트를 표시하고 편집할 수 있습니다.
- JTextField: 한 줄의 텍스트 입력 필드입니다 (AWT의 TextField와 유사).
- JPasswordField: 비밀번호 입력을 위한 텍스트 필드 (문자는 가려짐)입니다.
- JTextArea: 여러 줄의 텍스트 영역입니다 (AWT의 TextArea와 유사).
- AbstractButton: 버튼 종류 컴포넌트의 추상 부모입니다.
- JButton: 일반적인 클릭 가능한 버튼입니다.
- JToggleButton: 두 가지 상태 (눌림/안 눌림)를 갖는 버튼입니다.
- JCheckBox: 참/거짓을 선택하는 체크박스입니다 (AWT의 Checkbox와 유사).
- JRadioButton: 여러 항목 중 하나만 선택할 수 있는 라디오 버튼입니다.
- JMenuItem: 메뉴의 항목입니다.
- JCheckBoxMenuItem: 체크 상태를 갖는 메뉴 항목입니다.
- JRadioButtonMenuItem: 라디오 버튼처럼 동작하는 메뉴 항목입니다.
- JMenu: 다른 JMenuItem들을 포함할 수 있는 메뉴입니다.
- JPopupMenu: 컨텍스트 메뉴로 사용될 수 있습니다.
- JMenuBar: 윈도우의 메뉴 바입니다.
- JApplet: Swing 기반의 애플릿을 만들기 위한 클래스입니다 (AWT의 Applet을 확장).
- JFrame: Swing 기반의 최상위 윈도우입니다 (AWT의 Frame을 확장).
- JDialog: Swing 기반의 대화 상자입니다 (AWT의 Dialog를 확장).
java.awt (2005.04.04) 자료
그래픽 사용자 인터페이스(GUI)를 위해 사용되는 버튼이나 체크박스 또는
레이블과 같은 것들을 컴포너트라고 합니다.
자바에서는 이러한 컴포넌트들을 클래스로 구현하고 있으며 이러한 클래스
들을 java.awt 패키지를 사용하여 제공하고 있습니다.
자바에서는 모든 컴포넌트들은 컴포넌트 클래스를 상속받고 있습니다.
[AWT 클래스 구조도 = 자료가 누실되어 그림이 안보이네요]
위의 그림에서 보듯이 각 컴포넌트들이 컴포넌트 클래스를 상속 받고있습니다.
이것은 각각의 컴포넌트들은 컴포넌트 클래스의 메소드를 사용할 수있다는 것을
말합니다. 따라서 컴포넌트 클래스에는 어떠한 메소드가 있는지 알아야 겠지요...
다음은 컴포넌트 클래스의 메소드 중에서 많이 쓰이는 것들입니다.
Dimension getSize() : 컴포넌트의 크기를 구합니다.
Graphics getGraphics() : 그래픽 컨텍스트를 생성합니다.
Toolkit getToolkit() : 컴포넌트의 Toolkit를 구합니다.
void doLayout() : 컴포넌트의 배치관리자를 실행시킴니다.
void paint() : 컴포넌트를 그립니다.
void repaint() : 컴포넌트를 다시 그립니다.
void setBackground(Color c) : 컴포넌트의 배경색을 바꿈니다.
void setBounds(int x, int y, int width, int height) : 컴포넌트의 위치와 크기를 바꿈니다.
void setCusor(Cusor cusor)
void setEnabled(boolean b) : 컴포넌트의 사용여부를 정합니다.
void setFont(Font f) : 컴포넌트의 폰트를 정합니다.
void setLocation(int x, int y) : 컴포넌트의 위치를 바꿈니다.
void setLocation(Point p) : 컴포넌트의 위치를 바꿈니다.
void setSize(Dimension d) : 컴포넌트의 크기를 정합니다.
void setSize(int width, int height) : 컴포넌트의 크기를 정합니다.
void setVisible(boolean b) : 컴포넌트를 보이게 또는 보이지 않게합니다.
void update(Graphics g) : 컴포넌트를 update 합니다.
AWT(2) 일반컴포넌트 (05.04.04)
xxxx 이미지 깨짐 ========================================
컴포넌트에는 다른 컴포넌트를 자기 안에
배치시키고 정렬시킬수 있는 컨테이너 컴
포넌트와 혼자서는 기능을 발휘할 수없고
컨테이너 컴포넌트에 배치되어 사용되어야
만 제대로 기능을 하는 일반 컴포넌트가
있습니다.
여기에서 설명하는 컴포넌트들은 일반 컴
포넌트들입니다.
실제적인 프로그램 코딩은 컨테이너 컴포
넌트와 이벤트 처리를 설명할 때 하려고
합니다.
여기서는 각 컴포넌트 클래스의 객체를
생성하기 위한 생성자와 컴포넌트처리를
위한 메소드들은 어떤것이 있는지 눈여겨 보십시요...
1. Button 클래스
생성자
public Button()
public Button(String label)
메소드
void addActionListener(ActionListener l)
String getActionCommand()
String getLabel()
void setLabel(String label)
GUI 환경에서 버튼을 사용하려면 버튼 클래스에서 버튼 객체를
생성하여야 합니다.
버튼 객체를 생성하기 위하여 제공되는 생성자는 두개가 있습니다.
Button() : 레이블이 없는 버튼을 생성합니다.
Button(String label) : 레이블이 있는 버튼을 생성합니다.
Button button1 = new Button();
Button button2 = new Button("확인");
Button 클래스의 메소드 중에서
void addActionListener(ActionListener l)
String getActionCommand()
두 개의 메소드는 이벤트 처리에 관계있는 것으로 이벤트 처리 부분에서
설명하겠습니다.
String getLabel() : 버튼의 레이블을 얻을 수있습니다.
void setLabel(String label) : 버튼의 레이블을 바꾸기 위해 사용합니다.
Button button1 = new Button();
Button button2 = new Button("확인");
button1.setLabel("취소");
String str = button2.getLabel();
2. Choice 클래스
생성자
public Choice()
메소드
void add(String item)
void addItem(String item)
void addItemListener(ItemListener l)
int getSelectedIndex()
String getSelectedItem()
Choice 객체를 생성하기 위한 생성자는 하나가 있습니다.
Choice choice = new Choice();
choice.addItem("바나나"); // 또는 choice.add("바나나");
choice.addItem("복숭아"); // 또는 choice.add("복숭아");
choice.addItem("포 도"); // 또는 choice.add("포 도");
choice.addItem("수 박"); // 또는 choice.add("수 박");
xxxx 이미지 깨짐 ========================================
Choice 클래스의 메소드 중에서
void addItemListener(ItemListener l)
메소드는 이벤트 처리에 관계있는 것으로 이벤트 처리 부분에서
설명하겠습니다.
int getSelectedIndex() : 현재 선택된 item을 정수형으로 얻습니다.
String getSelectedItem() : 현재 선택된 item을 문자열로 얻습니다.
Choice choice = new Choice();
choice.addItem("바나나"); // 또는 choice.add("바나나");
choice.addItem("복숭아"); // 또는 choice.add("복숭아");
choice.addItem("포 도"); // 또는 choice.add("포 도");
choice.addItem("수 박"); // 또는 choice.add("수 박");
int item = choice.getSelectedIndex();
String str = choice.getSelectedItem();
3. Label 클래스
클래스 변수
public static final int LEFT
public static final int CENTER
public static final int RIGHT
생성자
public Label()
public Label(String text)
public Label(String text, int alignment)
메소드
int getAlignment()
String getText()
void setAlignment(int alignment)
void setText(String text)
Label 객체를 생성하기 위한 생성자는 세개가 있습니다.
Label la1 = new Label(); : text 없는 Label을 생성합니다.
Label la2 = new Label("찾기:");
: alignment 를 지정하지 않으면 자동으로 좌측정렬합니다.
Label la3 = new Label("Search:",Label.RIGHT);
: RIGHT는 Label 클래스의 상수형 변수로서 클래스 변수이기
때문에 클래스이름.변수이름으로 접근한 것입니다.
: 좌측정렬
: 우측정렬
xxxx 이미지 깨짐 ========================================
int getAlignment() : Label 의 정렬방식을 얻습니다.
String getText() : Label 의 text 값을 얻습니다.
void setAlignment(int alignment) : Label의 정렬방식을 바꿈니다.
void setText(String text) : Label의 text값을 바꿉니다.
Label la1 = new Label();
Label la2 = new Label("찾기:");
Label la3 = new Label("Search:",Label.RIGHT);
la1.setText("바꾸기"); // Label 객체 la1 의 text 값을 '바꾸기'로 바꿈
la2.setAlignment(Label.CENTER); //Label 객체 la2의 정렬방식을 중앙정렬로 바꿈
4. TextField 클래스
생성자
public TextField()
public TextField(int columns)
public TextField(String text)
public TextField(String text, int columns)
메소드
void addActionListener(ActionListener l)
void setEchoChar(Char c)
void setText(String t)
void removeActionListener(ActionListener l)
TextField 객체를 생성하기 위한 생성자는 네개가 있습니다.
TextField tf1 = new TextField();
TextField tf2 = new TextField(10);
TextField tf3 = new TextField("Hi Teacher");
TextField tf4 = new TextField("Hellow Java",20);
: 빈 텍스트 필드 생성
: columns 가 10인 텍스트 필드 생성
: 문자열을 가진 텍스트 필드 생성
: 문자열을가지고 columns 가 20인 텍스트 필드 생성
xxxx 이미지 깨짐 ========================================
TextField 클래스의 메소드 중에서
void addActionListener(ActionListener l)
void removeActionListener(ActionListener l)
메소드는 이벤트 처리에 관계있는 것으로 이벤트 처리 부분에서
설명하겠습니다.
void setEchoChar(Char c) : 암호 문자를 입력할 때 사용하면 좋습니다.
TextField tf = new TextField(15);
tf.setEchoChar('*');
xxxx 이미지 깨짐 ========================================
void setText(String txt) : 텍스트 필드의 문자열을 txt로 바꿈니다.
TextField tf = new TextField(15);
tf.setText("Hellow Java");
5. TextArea 클래스
클래스 변수
public static final int SCROLLBARS_BOTH
public static final int SCROLLBARS_VERTICAL_ONLY
public static final int SCROLLBARS_HORIZONTAL_ONLY
public static final int SCROLLBARS_NONE
생성자
public TextArea()
public TextArea(int rows, int columns)
public TextArea(String text)
public TextArea(String text, int rows, int columns)
public TextArea(String text, int rows, int columns, int scrollbars)
메소드
void append(String str)
void insert(String str, int pos)
void setColumns(int columns)
void setRows(int rows)
TextArea 객체를 생성하기 위한 생성자는 다섯개가 있습니다.
TextArea ta1 = new TextArea();
// 문자열이 없는 빈 TextArea 생성. 기본적으로 수직,수평 스크롤바 생성됩니다.
TextArea ta2 = new TextArea(5, 15); // rows 가 5, columns 가 15인 TextArea 생성
TextArea ta3 = new TextArea("Hellow Java"); // 문자열이 있는 TextArea 생성
TextArea ta4 = new TextArea("Hellow Java", 5, 15);
// 문자열이 있고, rows 가 5,columns 가 15인 TextArea 생성
TextArea ta5 = new TextArea("SCROLLBARS_HORIZONTEL_ONLY", 5, 15, TextArea.SCROLLBARS_HORIZONTEL_ONLY);
// 문자열이 있고, rows 가 5,columns 가 15, 그리고 수평 스크롤바만 있는 TextArea 생성
xxxx 이미지 깨짐 ========================================
void append(String str) : TextArea 에 문자열을 추가합니다.
void insert(String str, int pos) : TextArea 의 지정된 위치에 문자열을 삽입합니다.
void setColumns(int columns) : TextArea 의 columns을 바꿈니다.
void setRows(int rows) : TextArea 의 rows을 바꿈니다.
6. Checkbox 클래스
생성자
public Checkbox()
public Checkbox(String label)
public Checkbox(String label, boolean state)
public Checkbox(String label, boolean state, CheckboxGroup g)
public Checkbox(String label, CheckboxGroup g, boolean state)
메소드
void addItemListener(ItemListener I)
boolean getState()
void setCheckboxGroup(CheckboxGroup g)
void setState(boolean state)
void removeItemListener(ItemListener I)
Checkbox 객체를 생성하기 위한 생성자는 다섯개가 있습니다.
Checkbox cb1 = new Checkbox();
Checkbox cb2 = new Checkbox("체크1");
Checkbox cb3 = new Checkbox("체크2",true);
그룹으로 묶이진 않은 체크박스는 하나이상 선택이 가능합니다
CheckboxGroup grp = new CheckboxGroup();
Checkbox cb4 = new Checkbox("체크1", false, grp);
Checkbox cb5 = new Checkbox("체크2", grp, true);
그룹으로 묶인 체크박스는 하나만 선택할 수있습니다.
xxxx 이미지 깨짐 ========================================
Checkbox 클래스의 메소드 중에서
void addItemListener(ItemListener I)
void removeItemListener(ItemListener I)
메소드는 이벤트 처리에 관계있는 것으로 이벤트 처리 부분에서
설명하겠습니다.
boolean getState() : 체크박스의 현재 상태를 얻기 위해 사용됩니다.
void setCheckboxGroup(CheckboxGroup g) : 체크박스의 그룹을 설정합니다.
void setState(boolean state) : 현재 체크박스의 상태를 바꿈니다.
7. List 클래스
생성자
public List()
public List(int rows)
public List(int rows, boolean multipleMode)
메소드
void add(String item)
void add(String item, int index)
void addActionListener(ActionListener l)
void addItemListener(ItemListener I)
int getSelectedIndex()
String getSelectedItem()
String[] getSelectedItems()
boolean isIndexSelected(int index)
void remove(int position)
void remove(String item)
void removeAll()
void removeActionListener(ActionListener l)
void removeItemListener(ItemListener l)
void select(int index)
void setMultipleMode(boolean b)
List 객체를 생성하기 위한 생성자는 세개가 있습니다.
List ls1 = new List();
ls1.add("바나나");
ls1.add("복숭아");
ls1.add("포 도");
ls1.add("사 과");
ls1.add("수 박");
ls1.add("딸 기");
하나만 선택할 수있습니다.
xxxx 이미지 깨짐 ========================================
List ls2 = new List(5);
ls2.add("바나나");
ls2.add("복숭아");
ls2.add("포 도");
ls2.add("사 과");
ls2.add("수 박");
ls2.add("딸 기");
rows 가 5개인 List 생성. 하나만 선택가능합니다.
xxxx 이미지 깨짐 ========================================
List ls3 = new List(5, true);
ls3.add("바나나");
ls3.add("복숭아");
ls3.add("포 도");
ls3.add("사 과");
ls3.add("수 박");
ls3.add("딸 기");
하나이상 선택가능합니다.
xxxx 이미지 깨짐 ========================================
List 클래스의 메소드 중에서
void addActionListener(ActionListener l)
void addItemListener(ItemListener I)
void removeActionListener(ActionListener l)
void removeItemListener(ItemListener I)
메소드는 이벤트 처리에 관계있는 것으로 이벤트 처리 부분에서
설명하겠습니다.
void add(String item) : list에 item을 추가합니다.
void add(String item, int index) : index 위치에 item을 추가합니다.
int getSelectedIndex() : 현재 선택된 list 의 index를 얻습니다.
String getSelectedItem() : 현재 선택된 list 의 item를 얻습니다.
String[] getSelectedItems() : 현재 선택된 list 의 item들을 배열로 얻습니다.
boolean isIndexSelected(int index): 현재 index가 선택되어 있는지를 알기위해 사용합니다.
void remove(int position) : List에서 position 위치의 item을 제거합니다.
void remove(String item) : List에서 item 을 제거합니다.
void removeAll() : List 의 모든 item을 제거합니다.
void select(int index) : index 를 선택합니다.
void setMultipleMode(boolean b) : List 를 다중선택이 가능하도록 또는 다중선택할 수
없도록 합니다.
8. Scrollbar 클래스
클래수 변수
public static final int HORIZONTAL
public static final int VERTICAL
생성자
public Scrollbar()
public Scrollbar(int oriantation)
public Scrollbar(int oriantation, int value, int visible, int min, int max)
메소드
void addAdjustmentListener(AdjustmentListener l)
int getValue()
void removeAdjustmentListener(AdjustmentListener l)
void setBlockIncrement(int unit)
void setUnitIncrement(int unit)
Scrollbar 객체를 생성하기 위한 생성자는 세개가 있습니다.
Scrollbar sb1 = new Scrollbar(); // 수직 스크롤바 생성
Scrollbar sb2 = new Scrollbar(Scrollbar.VERTICAL); // 수직 스크롤바 생성
Scrollbar sb3 = new Scrollbar(Scrollbar.HORIZONTAL, 0, 30, 0, 300);
// 초기값 0, size는 30, 값의 범위(0,300) 인 수평 스크롤바 생성
xxxx 이미지 깨짐 ========================================
Scrollbar 클래스의 메소드 중에서
void addAdjustmentListener(AdjustmentListener l)
void removeAdjustmentListener(AdjustmentListener l)
메소드는 이벤트 처리에 관계있는 것으로 이벤트 처리 부분에서
설명하겠습니다.
int getValue() : Scrollbar 의 현재 값을 얻습니다.
void setBlockIncrement(int unit) : Scrollbar 의 range 클릭시 Scrollbar의 증감값을
unit로 설정합니다.
void setUnitIncrement(int unit) : Scrollbar 의 화살표 클릭시 Scrollbar의 증감값을
unit로 설정합니다.
awt(3) 컨테이너 컴포넌트 (05.04.04)
앞서 설명했던 버튼과 같은 일반 컴포넘트들은 독립적으로 사용하지
못하고 컨테이너 컴포넌트안에서 배치되어 사용되어야만 그 기능을
발휘할 수있습니다.
컨테이너 컴포넌트들은 Contener 클래스를 상속 받고 있습니다.
따라서 컨테이너 컴포넌트를 제대로 사용하려면 컨테이너 클래스
의 메소드들을 잘 알고 있어야 합니다.
다음은 컨테이너 클래스의 메소드 들입니다.
Component add(Component comp) : 컴포넌트를 컨테이너 컴포넌트에 추가합니다.
Component add(String name, Component comp) : 컴포넌트를 컨테이너 컴포넌트에 추가합니다.
void paint(Graphics g) : 컴포넌트를 그립니다.
void remove(Component comp) : 컴포넌트를 컨테이너 컴포넌트에서 제거합니다.
void setFont(Font f) : 폰트를 설정합니다.
void setLayout(LayoutManger mgr) : 배치관리자를 설정합니다.
void update(Graphics g) : 컴포넌트를 update 합니다.
1.Frame 클래스
생성자
Frame()
Frame(String title)
메소드
Image getIconImage()
void setIconImage(Image image)
void setMenuBar(MenuBar mb)
void setResizable(boolean resizable)
void setTitle(String title)
프레임을 만드는 방법은 두가지가 있습니다.
첫번째 방법은 프레임을 구현할 클래스에서 프레임 클래스를 상속 받아서 프레임을
만드는 방법입니다.
import java.awt.*; // 컴포넌트를 사용하기 위해 import
class testFrameOne extends Frame{ // 프레임 클래스 상속
public testFrameOne(){ // 생성자
setTitle("Frame Test"); // Frame 의 Title 설정
setSize(200,150); // 프레임의 크기를 폭:200, 높이:150으로 설정
setVisible(true); // 생성된 프레임 객체를 화면에 보이게 함
}
/*
setSize(int width, int height), setVisible(boolean b) 는 컴포넌트
클래스의 메소드입니다.
*/
public static void main(String args[]) // 메인 메소드 (실제적으로 프로그램 실행)
{
new testFrameOne(); //testFrameOne 객체 생성
}
}
두번째 방법은 프레임을 구현할 클래스에서 프레임 객체를 생성하는 방법입니다.
import java.awt.*; // 컴포넌트를 사용하기 위해 import
class testFrameTwo{
public testFrameTwo() // 생성자
{
Frame frm = new Frame("Frame Test"); // 객체 생성
frm.setSize(200,150); // 객체 frm 의 크기를 폭:200, 높이:150으로 설정
frm.setVisible(true); // 생성된 프레임 객체를 화면에 보이게 함
}
public static void main(String args[]) // 메인 메소드 (실제적으로 프로그램 실행)
{
new testFrameTwo(); //testFrameTwo 객체 생성
}
}
이렇게 프로그램을 코딩하고 실행시키면 다음과 같은 프레임이 만들어 집니다.
두가지 모두 결과는 같이 나왔지만 약간(?)의 차이가 있습니다.
첫번째 방법의 testFrameOne 는 Frame 클래스를 상속 받았기 때문에 testFrameOne
클래스 자체가 Frame이 되었지만, 두번째 방법의 testFrameTwo 클래스는 단지 Frame
객체를 생성하여 사용하므로 testFrameTwo 클래스는 Frame 객체를 생성하여 사용하는
일반적인 클래스입니다.
프레임과 같은 컨테이너 컴포넌트에는 버튼과 같은 일반 컴포넌트를 배치할 수있다고
하였습니다.
Button과 TextArea 그리고 TextField를 프레임에 배치해 보겠습니다.
Frame 클래스를 상속받아서 만드는 방법과 Frame 객체를 생성해서 만드는 방법 두가지
모두 코딩해 보겠습니다.
먼저, 프레임을 상속받아 만들어 보지요..
import java.awt.*;
class testFrameOne extends Frame{ // 플레임 클래스 상속
public testFrameOne() // 생성자
{
setTitle("Frame Test"); // 플레임 클레스의 메소드
Button bt = new Button("버튼"); // Button 객체 생성
TextArea ta = new TextArea("TextArea"); // TextArea 객체 생성
TextField tf = new TextField("TextField"); // TextField 객체생성
add("North",bt); // Button 을 프레임의 상부에 배치
add("Center",ta); // TextArea 를 프레임의 중앙에 배치
add("South",tf); // TextField 를 프레임의 하부에 배치
/*
add(String str, Component comp)메소드는 컨테이너 클래스의 메소드이고,
이 메소드를 사용하여 컴포넌트를 컨테이너에 배치합니다.
*/
setSize(300,200); // 프레임의 크기를 폭:300,높이:200 으로 설정
setVisible(true); // 프레임을 화면에 보이게 함
}
public static void main(String args[]) // 메인 메소드 (실제적으로 프로그램 실행)
{
new testFrameOne();
}
}
다음에 프레임 객체를 생성해서 만들어 보겠습니다.
import java.awt.*;
class testFrameTwo{
public testFrameTwo()
{
Frame frm = new Frame("Frame Test"); // 프레임 객체 생성
Button bt = new Button("버튼"); // Button 객체 생성
TextArea ta = new TextArea("TextArea"); // TextArea 객체 생성
TextField tf = new TextField("TextField"); // TextField 객체생성
frm.add("North",bt); // Button 을 프레임의 상부에 배치
frm.add("Center",ta); // TextArea 를 프레임의 중앙에 배치
frm.add("South",tf); // TextField 를 프레임의 하부에 배치
frm.setSize(300,200); // 프레임의 크기를 폭:300,높이:200 으로 설정
frm.setVisible(true); // 프레임을 화면에 보이게 함
}
public static void main(String args[]) // 메인 메소드 (실제적으로 프로그램 실행)
{
new testFrameTwo();
}
}
혹시 위의 프로그램 코드를 보고
'어! 위의 프로그램은 컴포넌트를 컨테이너에 배치하는데 add("North",bt);게 하고
아래의 프로그램은 frm.add("North",bt); 했네~. 프로그램을 잘못 한게 아닌가.'
라고 생각하는 사람이 있을지 모르겠네요...
만약 이런 생각을 하시는 분이 있으면 '클래스와 객체'부분을 다시한번 차근히 읽어
보세요. (노파심에서... ^_^)
마뭇튼 위와 같이 코딩하고 실행시키면 다음과 같은 프레임이 생길것입니다.
그런데 실행시키고 버튼을 누른다거나 프레임 오른쪽 상부의 x를 마우스로 클릭해도
전혀 반응을 보이지 않습니다. 그것은 각 컴포넌트에 이벤트 처리를 하지 않았기
때문이지요...
이러한 문제는 이벤트 처리 부분에서 설명하기로 하고 간단히 위의 프로그램을 이벤트
처리한 프로그램을 보여 드리겠습니다. ( 대충 보기만 하세요... )
이벤트 처리한 내용은 다음과 같습니다.
아래의 TextField 에 글을 입력하고 엔터키를 치면 바로위의 TextArea에 TextField 내용
이 추가 됩니다. 그리고 상부의 버튼을 누르면 프로그램이 종료하고 프레임은 화면에서
사라집니다.
import java.awt.*;
import java.awt.event.*;
class testFrame implements ActionListener{
Frame frm;
Button bt;
TextArea ta ;
TextField tf ;
public testFrame()
{
frm = new Frame("Frame Test");
bt = new Button("Exit");
ta = new TextArea();
tf = new TextField();
bt.addActionListener(this);
tf.addActionListener(this);
frm.add("North",bt);
frm.add("Center",ta);
frm.add("South",tf);
frm.setSize(300,200);
frm.setVisible(true);
}
public void actionPerformed(ActionEvent e){
if(bt.equals(e.getSource())){
frm.setVisible(false);
System.exit(0);
}
else if(tf.equals(e.getSource())){
String s = tf.getText();
ta.append(s +"\n");
tf.setText(" ");
}
}
public static void main(String args[])
{
new testFrame();
}
}
2.Panel 클래스
Panel 컨테이너 컴포넌트는 다른 컴포넌트를 배치하기 위해 사용됩니다.
생성자
Panel()
Panel(LayoutManager layout)
Frame과 마찬가지로 Panel도 컨테이너 컴포넌트입니다.
따라서 Panel에 일반 컴포넌트를 배치할 수있습니다. 또한 Panel을 사용하면
Frame안에 컴포넌트를 다양하게 배치할 수있습니다.
Panel 클래스의 생성자는 두개가 있습니다.
Panel pnlone = new Panel(); : 기본 배치관리자를 가진 Panel 생성
기본 배치관리자는 FlowLayout 입니다.
Panel pnltwo = new Panel(new BorderLayout()); : Panel생성시 배치관리자 지정
배치관리자는 컴포넌트를 컴포넌트를 컨테이너 컴포넌트에 추가할 때 컴포넌트를
적당히 배치하는 역할을 합니다. 배치관리자는 다음에 다시 설명하겠습니다.
일반적으로 Panel도 Frame안에 배치해서 사용하는데, 일반 컴포넌트를 Panel에 배치
한후에 다시 Panel을 Frame에 배치하는 방법으로 사용됩니다.
무슨 말인지 모르겠죠... ( 제가 원래 설명을 잘 못해요. ^_^ )
다음의 코드를 보세요.
일단 Panel을 만들고나서 Button 두개와 Choice 하나를 생성하여 Panel에 배치해
보겠습니다.
Panel pnlOne = new Panel(); // 기본 배치관리자(FlowLayout)를 가진 Panel 생성
Button bt1 = new Button("확인"); // Button bt1 생성
Button bt2 = new Button("취소"); // Button bt2 생성
Choice ch = new Choice(); // Choice ch 생성
ch.addItem("바나나"); // item 을 Choice ch 에 추가
ch.addItem("복숭아"); // item 을 Choice ch 에 추가
pnlOne.add(bt1); // Button bt1 을 Panel pnlOne 에 배치
pnlOne.add(bt2); // Button bt2 을 Panel pnlOne 에 배치
pnlOne.add(ch); // Choice ch 를 Panel pnlOne 에 배치
'어! Frame 에서 Button을 배치할 때는 frm.add("North",bt) 라고 했는데 Panel에서는
pnl.add(bt)라고 썼네~ ' 맞습니다. 배치관리자가 FlowLayout이란 놈일 때는 이렇게
컴포넌트를 배치할 때 pnl.add(bt) 방법으로 컴포넌트를 컨테이너에 추가합니다.
참고로 Frame의 기본 배치관리자는 BorderLayout 입니다.
여하튼 이렇게 하면 Panel pnl의 중앙에 Button 두개와 Choice 하나가 나란히 배치됩니다.
위의 그림에서 녹색 부분이 Panel 입니다.
다음에 Panel을 하나 더 생성해서 Label과 TextField 그리고 Checkbox를 배치해
보겠습니다.
Panel pnlTwo = new Panel(); // 기본 배치관리자(FlowLayout)를 가진 Panel 생성
Label lb = new Label("찾기:",Label.RIGHT); // Label lb 생성
TextField tf = new TextField("Hellow java"); // TextField tf 생성
Checkbox ck1 = new Checkbox("사과",true); // Checkbox ck1 생성
Checkbox ck2 = new Checkbox("포도"); // Checkbox ck2 생성
pnlTwo.add(lb); // Label lb 를 Panel pnlTwo 에 배치
pnlTwo.add(tf); // TextField tf 를 Panel pnlTwo 에 배치
pnlTwo.add(ck1); // Checkbox ck1 를 Panel pnlTwo 에 배치
pnlTwo.add(ck2); // Checkbox ck2 를 Panel pnlTwo 에 배치
위의 그림에서 회색 부분이 Panel 입니다.
그러면 TextArea 를 하나 더 만들고 Panel pnlOne과 Panel pnlTwo 그리고 TextArea를
Fream에 배치해 보겠습니다.
TextArea ta = new TextArea(); // TextArea ta 생성
add("North",pnlOnw); // Panel pnlOne 를 Frame 의 상부에 배치
add("Center",ta); // TextArea ta 를 Frame 의 중앙에 배치
add("South",pnlTwo); // Panel pnlTwo 를 Frame 의 하부에 배치
자, 이제 전체적인 프로그램 코드를 보겠습니다.
Frame 클래스를 상속받아 만들어 보겠습니다.
import java.awt.*; // 컴포넌트를 사용하기 위하여 import
class Test extends Frame{ // Frame 클래스 상속
public Test() // 생성자
{
setTitle("Panel Example"); // Frame 의 Title 설정
Panel pnlOne = new Panel();
Button bt1 = new Button("확인");
Button bt2 = new Button("취소");
Choice ch = new Choice();
ch.addItem("바나나");
ch.addItem("복숭아");
pnlOne.setBackground(Color.green); // Panel pnlOne의 배경색을 녹색으로 설정
pnlOne.add(bt1);
pnlOne.add(bt2);
pnlOne.add(ch);
Panel pnlTwo = new Panel();
Label lb = new Label("찾기:",Label.RIGHT);
TextField tf = new TextField("Hellow java");
Checkbox ck1 = new Checkbox("사과",true);
Checkbox ck2 = new Checkbox("포도");
pnlTwo.setBackground(Color.gray); // Panel pnlTwo의 배경색을 회색으로 설정
pnlTwo.add(lb);
pnlTwo.add(tf);
pnlTwo.add(ck1);
pnlTwo.add(ck2);
TextArea ta = new TextArea();
add("North",pnlOne);
add("Center",ta);
add("South",pnlTwo);
setSize(300,200); // Frame 의 크기를 폭:300,높이:200으로 설정
setVisible(true); // Frame 을 화면에 보이게함
}
public static void main(String args[]) // 메인 메소드
{
new Test();
}
}
이렇게 하면 아래와 같은 프레임이 만들어 집니다.
awt(4) 컨포넌트 배치 (05.04.04)
각각의 컨테이너 컴포넌트들은 각자 자신들만의 배치관리자를 가지고 있습니다.
배치관리자가 하는 역할은 컴포넌트가 추가되면 추가된 컴포넌트를 컴테이너에
적당히 배치하고 컨테이너의 크기가 바뀌는 것과 같이 컨테이너에 변화가 생겼을
때 컴포넌트를 재 배치하는 일을 담당합니다.
컨테이너 컴포넌트의 배치관리자는 컨테이너 클래스에서 선언한 setLayout() 메소드를
사용하여 다른 배치관리자로 바꿀수도 있으며 배치관리자를 설정하지 않을 수도 있습
니다.
자바에서 컴포넌트 배치를 위해 사용되는 배치 관리자는 클래스로 되어있으며 다음과 같이
모두 다섯 가지가 있습니다.
FlowLayout, BorderLayout, GridLayout, GridBagLayout, CardLayout
그러면 배치관리자를 하나씩 살펴보겠습니다.
1. FlowLayout 클래스
FlowLayout 은 Panel 클래스의 기본 배치관리자이며 컴포넌트를 좌에서 우로
차례대로 배치합니다.
클래스 변수상수
public static final int CENTER
public static final int LEFT
public static final int RIGHT
생성자
public FlowLayuot()
public FlowLayuot(int align)
public FlowLayuot(int align, int hgap, int vgap)
메소드
public void setAlignment(int align) : 컴포넌트의 배치하기 위한 위치를 설정
align 에 올 수있는 값으로는 다음과 같습니다.
FlowLayout.CENTER, FlowLayout.LEFT, FlowLayout.RIGHT
public void setHgap(int hgap) : 수평 간격을 설정합니다.
public void setVgap(int vgap) : 수직 간격을 설정합니다.
FlowLayout 클래스는 생성자가 세개 있습니다.
FlowLayout flone = new FlowLayout();
: 기본 설정으로 컴포넌트를 중앙에 차례로 배치
FlowLayout fltwo = new FlowLayout(FlowLayout.LEFT);
: 컴포넌트를 컨테이너의 왼쪽에서부터 차례로 배치
FlowLayout fltwo = new FlowLayout(FlowLayout.CENTER, 20,10);
: 컴포넌트를 중앙에 차례로 배치하며 각 컴포넌트들
사이의 간격을 수평:20, 수직:10 으로 설정.
아시겠지만 컴포넌트의 위치 정렬을 위해 사용된 FlowLayout 클래스의 클래스 변수 상수에
접근하기 위해서는 '클래스명.변수명' 으로 접근합니다.
예를 들면 FlowLayout.CENTER, FlowLayout.LEFT, FlowLayout.RIGHT 하는 식으로 사용합니다.
이해가 않되시면 '클래스 메소드/변수' 부분을 다시한번 읽어 보세요.
아래의 그림은 위의 세개의 생성자를 사용하여 배치를 한 내용을 보여주는 것입니다.
다음에 보여주는 것은 기본 생성자를 사용하여 컴포넌트를 중앙에 배치하는 프로그램입니다.
import java.awt.*;
public class myButtons extends Frame{
public myButtons()
{
super("FlowLayout Example"); // 상위 클래스(Frame 클래스)의 생성자 호출
FlowLayout flone = new FlowLayout(); // FlowLayout 객체 생성
setLayout(flone); // 배치관리자를 FlowLayout 으로 설정
Button button1 = new Button("Ok"); // 버튼 객체 생성
Button button2 = new Button("Open");
Button button3 = new Button("Close");
add(button1); // 버튼을 Frame에 배치
add(button2);
add(button3);
setSize(200,150); // Frame 의 크기를 폭:200, 높이:150으로 설정
setVisible(true); // Frame 을 화면에 보이게함
}
public static void main(String args[])
{
new myButtom(); // 객체 생성
}
}
2. BorderLayout 클래스
BorderLayout 은 window 클래스,Frame 클래스와 Dialog 클래스의 기본 배치관
리자이며, 컴포넌트의 배치는 동,서,남,북 그리고 중앙 이렇게 다섯가지의 위치
를 정하여 배치합니다.
클래스 변수상수
public static final String CENTER : 컨테이너의 중앙 배치
public static final String EAST : 컨테이너의 오른쪽 배치
public static final String NORTH : 컨테이너의 상부 배치
public static final String SOUTH : 컨테이너의 하부 배치
public static final String WEST : 컨테이너의 왼쪽 배치
생성자
public BorderLayout()
public BorderLayout(int hgap, int vgap)
메소드
public void setHgap(int hgap) : 컴포넌트들간의 수평 간격을 설정합니다.
public void setVgap(int vgap) : 컴포넌트들간의 수직 간격을 설정합니다.
BorderLayout 클래스는 생성자가 두개 있습니다.
BorderLayout bl1 = new BorderLayout();
BorderLayout bl2 = new BorderLayout(10, 10);
아래의 그림은 위의 두개의 생성자를 사용하여 배치를 한 내용을 보여주는 것입니다.
다음에 보여주는 것은 기본 생성자를 사용하여 컴포넌트를 배치하는 프로그램입니다.
import java.awt.*;
class buttonDir extends Frame{
public buttonDir()
{
super("BorderLayout Exam"); // 상위클래스 (Frame 클래스) 의 생성자 호출
setLayout(new BorderLayout()); // 배치관리자를 BorderLayout 으로 설정
Button bt1 = new Button("North");
Button bt2 = new Button("South");
Button bt3 = new Button("East");
Button bt4 = new Button("West");
Button bt5 = new Button("Center");
add("North", bt1); // 또는 add(bt1, BorderLayout.NORTH);
add("South", bt2); // 또는 add(bt2, BorderLayout.SOUTH);
add("East" , bt3); // 또는 add(bt3, BorderLayout.EAST);
add("West", bt4); // 또는 add(bt4, BorderLayout.WEST);
add("Center", bt5); // 또는 add(bt5, BorderLayout.CENTER);
setSize(200,150);
setVisible(true);
}
public static void main(String args[])
{
new buttonDir();
}
}
3. GridLayout 클래스
GridLayout 은 컨테이너 컴포넌트를 가로,세로로 일정한 개수로 나누고 나누
어진 격자안에 컴포넌트를 배치합니다.
생성자
public GridLayout(int rows, int cols)
public GridLayout(int rows, int cols, int hgap, int vgap)
메소드
setColumns(int cols)
setHgap(int hgap)
setRows(int rows)
setVgap(int vgap)
GridLayout 클래스는 생성자가 두개 있습니다.
GridLayout gl1 = new GridLayout(3,2); :col(줄):3, row(칸):2으로 컴포넌트를 배치
GridLayout gl2 = new GridLayout(3,2,5,5);
: col(줄):3, row(칸):2으로 컴포넌트를 배치하고 컴포넌트의 간격을 수평:5, 수직:5로 설정
아래의 그림은 위의 두개의 생성자를 사용하여 배치를 한 내용을 보여주는 것입니다.
다음에 보여주는 것은 col은 3, row은 2 로 설정하여 컴포넌트를 배치하는 프로그램입니다.
import java.awt.*;
class ButtonGrid extends Frame{
public ButtonGrid()
{
super("GridLayout Exam"); // 상위클래스 (Frame 클래스) 의 생성자 호출
setLayout(new GridLayout(3,2)); // 배치관리자를 GridLayout 으로 설정
add(new Button("1")); // 버튼 객체를 생성하고 배치
add(new Button("2"));
add(new Button("3"));
add(new Button("4"));
add(new Button("5"));
add(new Button("6"));
setSize(200,150);
setVisible(true);
}
public static void main(String args[])
{
new ButtonGrid();
}
}
4. GridBagLayout 클래스
GridBagLayout은 GridLayout 과 같이 격자에 컴포넌트를 배치하는 것은 같으나
GridLayout 이 하나의 격자에 하나의 컴포넌트가 배치되는 것과는 달리 GridBagLayout
은 하나의 컴포넌트가 여러개의 격자를 차지할 수있습니다.
GridBagLayout 을 사용하여 컴포넌트를 배치하려면 GridBagConstraints 객체를
생성해서 같이 사용합니다.
죄송!! GridBagLayout 은 여기까지만 설명하겠습니다.
5. CardLayout
CardLayout은 동일한 컨테이너에 서로 다른 컨테이너를 배치하여 상황에 따라서
필요한 컴포넌트를 선택하여 사용하고자 할 때 사용됩니다.
다시말하면 하나의 컨테이너에 두개 이상의 컴포넌트를 사용하고자 할 때 사용
되는 배치관리자 입니다.
생성자
public CardLayout() // 기본 배치관리자 생성
public CardLayout(int hgap, int vgap)
// 컴포넌트의 간격이 hgap, vgap인 배치관리자 생성
메소드
public void first(Container parent) // 컨테이너에 첫번째 컴포넌트를 보여줍니다
public void last(Container parent) // 컨테이너에 마지막 컴포넌트를 보여줍니다
public void next(Container parent) // 컨테이너에 다음 컴포넌트를 보여줍니다
public void previous(Container parent) // 컨테이너에 이전의 컴포넌트를 보여줍니다
public void setHgap(int hgap) // 컴포넌트의 수평 간격을 설정합니다.
public void setVgap(int vgap) // 컴포넌트의 수직 간격을 설정합니다.
public void show(Container parent, String name)
// 문자열 name으로 지정한 컴포넌트를 보여줍니다.
CardLayout을 사용하여 컴포넌트를 배치할 경우, add() 메소드에는 각 컴포넌트를 구별할 수
있는 문자열을 메소드의 인자값으로 넣어 주어야 합니다. 그리고 show()메소드에 이 문자열을
인자값으로 넣어서 해당 컴포넌트가 보이게 합니다.
.....
Panel cardpnl = new Panel();
.....
cardpnl.add("버튼",pnl1); // 컴포넌트를 구별 할 수있도록 문자열 '버튼'을 인자값으로
..... // 넣어줌
CardLayout clt = new CardLayout();
.....
clt.show(cardpnl, "버튼"); // 문자열을 인자값으로 넣어서 해당 컴포넌트가 보이게 함.
.....
아래의 그림은 CardLayout 을 사용하여 구현한 것입니다.
위의 녹색 부분이 FlowLayout 을 사용한 Panel 이고, 아래의 노란색 부분이 CardLayout
을 사용한 Panel 입니다.
왼쪽에 보이는 것이 녹색 Panel 의 '버튼' 레이블이 붙은 버튼을 눌렀을 경우 보이는 상태이며
중앙에 보이는 것은 녹색 Panel 의 '체크박스' 레이블이 붙은 버튼을 눌렀을 경우 보이는 상태
이고 오른쪽에 보이는 것이 '텍스트 필드' 레이블이 붙은 버튼을 눌렀을 경우 보이는 상태입니다.
그러면 프로그램을 만들어 보겠습니다.
프로그램을 만들고 실행시키려면 아직 배우지 않은 이벤트 처리 부분을 만들어야 합니다.
이벤트 처리 부분은 이벤트 처리에서 다시 설명하겠으니 이해가 않되더라도 그냥 넘어 가세요.
프레임의 위쪽에 있는 버튼 세개를 만들어 보겠습니다.
먼저 Panel 객체를 생성하고 버튼 객체 세개를 만들어서 Panel에 배치하겠습니다.
Panel menupnl = new Panel(); // 기본 배치관리자(FlowLayout)를 가진 Panel 생성
Button bt1 = new Button("버튼"); // 버튼 객체 bt1 생성
Button bt2 = new Button("체크박스"); // 버튼 객체 bt2 생성
Button bt3 = new Button("텍스트 필드"); // 버튼 객체 bt3 생성
menupnl.add(bt1); // 버튼 bt1 을 Panle menupnl 에 배치
menupnl.add(bt2); // 버튼 bt2 을 Panle menupnl 에 배치
menupnl.add(bt3); // 버튼 bt3 을 Panle menupnl 에 배치
Panel 을 세개 생성해서 각각의 Panel에 버튼과 체크박스 그리고 텍스트 필드를
배치하겠습니다.
Panel pnl1 = new Panel(); // 기본 배치관리자(FlowLayout)를 가진 Panel pnl1생성
Button btn1 = new Button("버튼하나"); // 버튼 객체 btn1 생성
Button btn2 = new Button("버튼둘"); // 버튼 객체 btn2 생성
Button btn3 = new Button("버튼셋"); // 버튼 객체 btn3 생성
pnl1.add(btn1); // 버튼 btn1 을 Panle pnl1 에 배치
pnl1.add(btn2); // 버튼 btn2 을 Panle pnl1 에 배치
pnl1.add(btn3); // 버튼 btn3 을 Panle pnl1 에 배치
Panel pnl2 = new Panel(); // 기본 배치관리자(FlowLayout)를 가진 Panel pnl2생성
Label lb = new Label("찾기:",Label.RIGHT); // 레이블 객체 lb 생성
TextField tf = new TextField("TextField"); // 텍스트 필드 객체 tf 생성
pnl2.add(lb); // 레이블 lb 를 Panle pnl2 에 배치
pnl2.add(tf); // 텍스트 필드 tf 를 Panle pnl2 에 배치
Panel pnl3 = new Panel(); // 기본 배치관리자(FlowLayout)를 가진 Panel pnl3생성
Checkbox ck1 = new Checkbox("사과",true); // 체크박스 객체 ck1 생성
Checkbox ck2 = new Checkbox("포도"); // 체크박스 객체 ck2 생성
pnl3.add(ck1); // 체크박스 ck1 을 Panle pnl3 에 배치
pnl3.add(ck2); // 체크박스 ck2 을 Panle pnl3 에 배치
다음에는 Panel cardpnl 을 생성해서 배치관리자를 CardLayout 로 설정하고 위의
Panel pnl1, Panel pnl2, Panel pnl3 를 Panel cardpnl에 배치하겠습니다.
CardLayout clt = new CardLayout(); // CardLayout 객체 clt 생성
Panel cardpnl = new Panel(); // 기본 배치관리자(FlowLayout)를 가진 Panel cardpnl생성
cardpnl.setLayout(clt); // panel cardpnl의 배치관리자로 CardLayout 설정
cardpnl.add("버튼",pnl1); // Panel pnl1 을 Panle cardpnl 에 배치
cardpnl.add("텍스트 필드",pnl2); // Panel pnl2 을 Panle cardpnl 에 배치
cardpnl.add( "체크박스",pnl3); // Panel pnl3 을 Panle cardpnl 에 배치
마지막으로 Panel menupnl과 cardpnl을 Frame 에 배치하겠습니다.
add("North", menupnl); // Panel menupnl 을 Frame 의 상부에 배치
add("Center", cardpnl); // Panel cardpnl 을 Frame 의 중앙에 배치
여기까지 이해되시죠....
그러면 전체 코드를 보겠습니다.
이 프로그램은 본인이 직접 프로그램을 작성하시고 실행시켜 보세요.
프로그램만 보고서는 이해가 될까몰라..???
import java.awt.*; // 컴포넌트를 사용하기 위하여 import
import java.awt.event.*; // 이벤트 처리를 위하여 import
class CltExam extends Frame implements ActionListener {
// 버튼 이벤트 처리를 위한 ActionListener는 인터페이스임
Panel cardpnl;
CardLayout clt;
/*
cardpnl와 clt를 actionPerformed(ActionEvent e)메소드에서도 사용해야 하므로
인스턴스 변수로 선언한 것임.
참고로 메소드 안에서 선언한 로칼 변수는 해당 메소드 에서만 사용. 메소드가
소멸하면 로칼 변수도 함께 소멸함
*/
public CltExam () // 생성자
{
super("CardLayout Example"); // 상위 클래스 생성자 호출
Panel menupnl = new Panel(); // default (Panel:FlowLayout)
menupnl.setBackground(Color.green); // Panel 의 배경색을 녹색으로 설정
Button bt1 = new Button("버튼");
Button bt2 = new Button("체크박스");
Button bt3 = new Button("텍스트 필드");
menupnl.add(bt1);
menupnl.add(bt2);
menupnl.add(bt3);
bt1.addActionListener(this);
bt2.addActionListener(this);
bt3.addActionListener(this);
Panel pnl1 = new Panel();
Button btn1 = new Button("버튼하나");
Button btn2 = new Button("버튼둘");
Button btn3 = new Button("버튼셋");
pnl1.add(btn1);
pnl1.add(btn2);
pnl1.add(btn3);
Panel pnl2 = new Panel();
Label lb = new Label("찾기:",Label.RIGHT);
TextField tf = new TextField("TextField");
pnl2.add(lb);
pnl2.add(tf);
Panel pnl3 = new Panel();
Checkbox ck1 = new Checkbox("사과",true);
Checkbox ck2 = new Checkbox("포도");
pnl3.add(ck1);
pnl3.add(ck2);
clt = new CardLayout(); // CardLayout 객체 생성
cardpnl = new Panel(); // panel 생성
cardpnl.setBackground(Color.yellow); // Panel 의 배경색을 노란색으로 설정
cardpnl.setLayout(clt);
cardpnl.add("버튼",pnl1);
cardpnl.add("텍스트 필드",pnl2);
cardpnl.add( "체크박스",pnl3);
add("North", menupnl);
add("Center", cardpnl);
setSize(200, 150); // Frame 의 크기를 폭:200, 높이:150으로 설정
doLayout(); // 배치관리자 실행
setVisible(true); // Frame 을 화면에 보이게 함
}
public static void main (String args[])
{
new CltExam();
}
public void actionPerformed(ActionEvent e) // 이벤트 처리부분입니다.
{
if ("버튼".equals(e.getActionCommand())) // 눌려진 버튼의 레이블이 '버튼'이면
clt.show(cardpnl, "버튼"); // Panel cardpnl에서 Panel pnl1을 보여줌
else if ("텍스트 필드".equals(e.getActionCommand())) // 눌려진 버튼의 레이블이 '텍스트 필드'이면
clt.show(cardpnl, "텍스트 필드"); // Panel cardpnl에서 Panel pnl2을 보여줌
else if ("체크박스".equals(e.getActionCommand())) // 눌려진 버튼의 레이블이 '체크박스'이면
clt.show(cardpnl, "체크박스"); // Panel cardpnl에서 Panel pnl3을 보여줌
}
}
6.배치 관리자를 사용하지 않고 배치하기
?蝸“桓?자를 사용하지 않고 컴포넌트를 배치하려면 setLayout()메소드의 인자값에 'null'값을
넣어 주면 됩니다.
'setLayout(null)'을 사용하여서 배치관리자를 지정하지 않은 경우에는 프로그래머가 컴포넌트의
위치와 크기를 지정해 주어야 하지요..
그리고 컴포넌트가 배치되어 있는 컨테이너에 크기 변경등과 같은 변화가 생기 더라도 컴포넌트는
재 배치되지 않습니다.
컴포넌트의 크기와 위치를 지정하기 위해서 setBounds(int x, int y, int width, int height)라는
메소드를 사용합니다.
setBounds() 메소드는 컴포넌트 클래스의 메소드 이지요...
이 말은 컴포넌트 클래스를 상속받은 버튼과 같은 일반 컴포넌트와 컨테이너 컴포넌트들 모두는
이 메소드를 사용할 수있다는 것입니다.
인자값으로는 컴포넌트의 x 좌표, y 좌표, 폭, 높이 가 들어가네요..
다음의 코드는 배치관리자를 지정하지 않고 프로그래머가 버튼 세개를 Frame에 배치하는 것입니다.
컴포넌트의 위치와 크기를 따로 지정해 주어야 하지요...
import java.awt.*;
class Test extends Frame{ // Frame 클래스 상속
public Test()
{
super("Null Layout Exam");
setLayout(null); // 배치관리자를 null 로 지정
Button bt1 = new Button("버튼하나");
Button bt2 = new Button("버튼둘");
Button bt3 = new Button("버튼셋");
add(bt1);
add(bt2);
add(bt3);
bt1.setBounds(20,30,70,20); // 버튼 bt1의 위치는 x:20,y:30 크기는 폭:70,높이:20으로 지정
bt2.setBounds(100,60,100,20); // 버튼 bt2의 위치는 x:100,y:60 크기는 폭:100,높이:20으로 지정
bt3.setBounds(50,110,150,20); // 버튼 bt3의 위치는 x:50,y:110 크기는 폭:150,높이:20으로 지정
setSize(200,150);
doLayout();
setVisible(true);
}
public static void main(String args[])
{
new Test();
}
}
위의 프로그램을 실행시키면 다음과 같은 프레임이 만들어 집니다.
awt(5)메뉴 (http://my.netian.com/~regento/에서 펌글) (05.04.04)
위의 그림을 뚫어지게 보시면 메뉴가 어떻게 구성되어 있는지를 알 수있습니다.
MenuBar가 어떤 것이고 , 무엇을 MenuItem이라고 하는지 위 그림을 보고 머리속에
쑤욱 집어 넣으세요.
그러면 메뉴를 구성하기 위한 클래스들을 살펴보겠습니다.
(여기서 설명하는 클래스의 메소드들은 일부만 소개하는 것입니다.)
1. MenuBar 클래스
생성자
public MenuBar() : MenuBar를 생성합니다.
메소드
public Menu add(Menu m) : Menu를 MenuBar에 추가합니다.
2. Menu 클래스
생성자
public Menu(String label) : label 을 가진 Menu를 생성합니다.
메소드
public MenuItem add(MenuItem mi) : MenuItem을 Menu에 추가합니다.
public void add(String label) : label 을 가진 MenuItem 을 Menu에 추가합니다.
public void addSeparator() : Separator 을 Menu에 추가합니다.
public void insert(String label, int index) : label 을 가진 MenuItem을 index 위치에 삽입합니다.
public void insertSeperator(int index) : Serapater 를 index 위치에 삽입합니다.
3. MenuItem 클래스
생성자
public MenuItem() : label 이 없는 MenuItem을 생성합니다.
public MenuItem(String label) : label 을 가진 MenuItem을 생성합니다.
public MenuItem(String label, MenuShortcut s) : label 과 단축키가 있는 MenuItem을 생성합니다.
메소드
public void addActionListener(ActionListener l) : 이벤트 처리와 관련된 메소드입니다.
public void deleteShortcut() : 단축키를 제거합니다.
public String getActionCommand() : 이벤트 처리와 관련된 메소드입니다.
public void setEnabled(boolean b) : MenuItem을 사용여부를 설정합니다.
public void removeActionListener(ActionListener l) : 이벤트 처리와 관련된 메소드 입니다.
이벤트 처리와 관련된 메소드는 이벤트 처리 부분에서 설명하겠습니다.
4. MenuShortcut 클래스
생성자
public MenuShortcut(int key) : 단축키를 설정할 수있도록 객체를 생성합니다.
public MenuShortcut(int key, boolean useShiftModifier) : Shift 키 와 함께 사용할 수있도록 설정합니다.
5. CheckboxMenuItem 클래스
생성자
public CheckboxMenuItem(String label) : label 이 있는 CheckboxMenuItem을 생성합니다.
public CheckboxMenuItem(String label, boolean b) : label 과 함께 체크 여부를 함께 설정합니다. .
메소드
public void addItemListener(ItemListener l) : 이벤트 처리와 관련된 메소드입니다.
public void setState(boolean b) : CheckboxMenuItem 현재 상태를 설정합니다.
public boolean getState() : CheckboxMenuItem 현재 상태를 얻습니다..
public removeItemListener(ItemListener l) : 이벤트 처리와 관련된 메소드입니다.
그러면 메뉴를 만들어 볼까요...
먼저 MenuBar 를 생성하고 Menu를 두개 생성해서 MenuBar에 올려 놓겠습니다.
MenuBar menubar = new MenuBar(); // MenuBar 생성
Menu filemenu = new Menu("File"); // label 이 'File'인 Menu 생성
Menu editmenu = new Menu("Edit"); // label 이 'Edit'인 Menu 생성
menubar.add(filemenu); // Menu 를 MenuBar 에 추가
menubar.add(editmenu); // Menu 를 MenuBar 에 추가
다음에 MenuItem을 네개 CheckboxMenuItem하나 생성해서 MenuItem과 CheckboxMenuItem 그리고
Separator을 Menu에 올려 놓겠습니다.
MenuItem newItem = new MenuItem("New"); // MenuItem newItem 생성
MenuItem openItem = new MenuItem("Open"); // MenuItem openItem 생성
MenuItem closeItem = new MenuItem("Close"); // MenuItem closeItem 생성
MenuItem saveasItem = new MenuItem("Save as.."); // MenuItem saveasItem 생성
MenuShortcut shexit = new MenuShortcut('x'); // 단축키를 위한 MenuShortcut 생성
MenuItem exitItem = new MenuItem("Exit",shexit); // 단축키가 'Ctrl+x'인 MenuItem 생성
CheckboxMenuItem saveall = new CheckboxMenuItem("save all", true);
//CheckboxMenuItem saveall 을 체크된 상태로 생성
filemenu.add(newItem); // MenuItem을 Menu에 추가
filemenu.add(openItem); // MenuItem을 Menu에 추가
filemenu.add(closeItem); // MenuItem을 Menu에 추가
filemenu.addSeparator(); // Separator 을 Menu에 추가
filemenu.add(saveasItem); // MenuItem을 Menu에 추가
filemenu.add(saveall); // CheckboxMenuItem을 Menu에 추가
filemenu.addSeparator(); // Separator 을 Menu에 추가
filemenu.add(exitItem); // MenuItem을 Menu에 추가
다음에 'save'의 submenu를 만들겠습니다.
Menu savemenu = new Menu("Save"); // label 이 'Save'인 Menu 생성
savemenu.add("Default"); // label 이 'Default'인 MenuItem 을 Menu에 추가
savemenu.add("Search"); // label 이 'Search'인 MenuItem 을 Menu에 추가
filemenu.add(savemenu); // Menu savemenu를 Menu filemenu에 추가
마지막으로 MenuBar 를 Frame에 올려 놓겠습니다.
( setMenuBar(MenuBar mb) 메소드는 Frame 클래스의 메소드입니다. )
setMenuBar(menubar);
그러면 전체 코드를 볼까요..
복잡하게 보일뿐 어려운 것은 없습니다.
import java.awt.*; // 컴포넌트를 쓰기위해 import
class menuExam extends Frame{ // Frame 클래스 상속
public menuExam() // 생성자
{
super("Menu Exam..."); // 상위 클래스(Frame 클래스) 생성자 호출
MenuBar menubar = new MenuBar(); // MenuBar 객체 생성
Menu filemenu = new Menu("File"); // Menu 생성
Menu editmenu = new Menu("Edit");
Menu savemenu = new Menu("Save");
menubar.add(filemenu); // menu 를 MenuBar 에 추가
menubar.add(editmenu);
MenuShortcut shexit = new MenuShortcut('x'); // 단축키 'Ctrl+x' 객체 생성
MenuItem newItem = new MenuItem("New"); // MenuItem 생성
MenuItem openItem = new MenuItem("Open");
MenuItem closeItem = new MenuItem("Close");
MenuItem saveasItem = new MenuItem("Save as..");
MenuItem exitItem = new MenuItem("Exit",shexit); // 단축키를 가진 MenuItem 생성
CheckboxMenuItem saveall = new CheckboxMenuItem("save all", true);
// CheckboxMenuItem 생성 (check 값은 true)
MenuItem cutItem = new MenuItem("Cut");
MenuItem copyItem = new MenuItem("Copy");
MenuItem pasteItem = new MenuItem("Paste");
savemenu.add("Default"); // savemenu의 서브메뉴
savemenu.add("Search"); // savemenu의 서브메뉴
filemenu.add(newItem); // MenuItem 을 Menu에 추가
filemenu.add(openItem);
filemenu.add(closeItem);
filemenu.addSeparator(); // Separator 을 Menu에 추가
filemenu.add(savemenu); // 서브메뉴를 가진 메뉴 savemenu를 Menu에 추가
filemenu.add(saveasItem);
filemenu.add(saveall);
filemenu.addSeparator();
filemenu.add(exitItem);
editmenu.add(cutItem); // MenuItem을 Menu에 추가
editmenu.add(copyItem);
editmenu.add(pasteItem);
setMenuBar(menubar); // MenuBar 를 Frame에 추가
setSize(300,200);
setVisible(true);
}
public static void main(String args[])
{
new menuExam();
}
}이벤트처리
[1] 이벤트 / 리스너
지금부터 중요한 이벤트 처리를 설명하겠습니다.
프로그램을 처음하시는 분들은 다소 어려울지 모르겠네요..
이해가 않되는 부분이 있으면 설명을 여러번 읽어보고 코드를 직접 입력하고
실행을 시켜보세요. 그리고 코드를 여러가지로 바꿔가며 실행을 시켜보세요.
마우스를 움직인다거나 마우스를 사용하여 버튼을 클릭하는 경우 , 또는 텍스트
필드에 글을 입력하기 위하여 키보드를 누르는 경우 등은 모두 이벤트를 발생
시킴니다.
앞서 설명한 거의 모든 컴포넌트들은 이벤트를 발생시킬수 있습니다.
그리고 발생하는 이벤트는 컴포넌트에 따라서 다르지요...
자바에서는 각 컴포넌트에서 발생되는 이벤트를 처리하기 위하여 각 컴포넌트에서
이벤트가 발생되기를 기다렸다가 이벤트가 발생되면 발생된 이벤트를 처리해
주는 Listener(리스너) 라는 것이 있습니다.
발생되는 이벤트에 따라서 Listener(리스너)도 서로 다릅니다.
이벤트는 클래스로 되어있으며 Listener(리스너)는 인터페이스로 되어 있습니다.
Listener(리스너)가 인터페이스로 되어 있다는 것은 Listener(리스너)에는
메소드 선언부만 있다는 것입니다. 따라서 Listener(리스너)를 구현하는 클래스
에서는 Listener(리스너)에서 선언한 메소드들을 모두 재 정의 하여야 합니다.
( 이해가 않되시면 '인터페이스' 부분을 다시 한번 읽어보세요..)
그러면 왜..?? Listener(리스너)가 인터페이스로 되어 있을까요...
Listener(리스너)는 각 컴포넌트에서 이벤트가 발생되기를 기다렸다가 이벤트가
발생되면 발생된 이벤트를 처리한다고 했습니다.
그런데 처리되어야 할 내용은 같은 컴포넌트라고 하더라도 프로그램에 따라서
또는 프로그램을 만드는 프로그래머에 따라서 다르겠지요..
예를들어 버튼을 클릭하여 이벤트를 발생시켰을 경우 이 버튼의 이벤트를
처리하는 내용은 프로그램에 따라서 서로 다를 것입니다.
따라서 이벤트 처리를 위한 메소드를 추상 메소드로 만들어 프로그래머가 적당히
메소드를 재 정의하여 사용하도록 한 것입니다.
제가 설명을 잘 못하는데 이해가 되셨는지 모르겠네요..
이해가 않되더라도 걱정하지 마세요..
이벤트 관련 예제를 보시면 금방 이해하실 겁니다.
이벤트 클래스와 리스너 인터페이스는 모두 'java.awt.event' 패키지에서 공급하고
있습니다. 따라서 이벤트 처리를 위해서는 java.awt.event 를 import 해야합니다.
그리고 Listener(리스너)에서 제공하는 메소드들은 이벤트가 발생되면 자동으로
호출되어 실행 됩니다.
그러면 이벤트는 어떤 것이 있고 Listener(리스너)는 어떤것이 있는지 살펴보겠습니다.
1. 이벤트 클래스
ActionEvent 클래스 : 버튼을 누르거나 텍스트 필드에 글을 입력하고 엔터키를
누르는 경우에 발생됩니다.
( 관련 컴포넌트: Button, TextField, List, MenuItem )
MouseEvent 클래스 : 마우스 버튼을 누르거나 움직일때 등 마우스와 관련된
동작을 했을 경우 발생됩니다.
(관련 컴포넌트: Button,Canvas,Checkbox,Choice,Container,
Dialog,Frame,Label,List,Panel,Scrollbar,
TextArea,TextField,Window )
AdjustmentEvent 클래스 : 스크롤바 등이 스크롤되어 값이 변할 때 발생됩니다
(관련 컴포넌트: Scrollbar )
FocusEvent 클래스 : 해당 컴포넌트가 포커스를 얻거나 잃었을 때 발생됩니다.
(관련 컴포넌트: Button,Canvas,Checkbox,Choice,Container,
Dialog,Frame,Label,List,Panel,Scrollbar,
TextArea,TextField,Window )
TextEvent 클래스 : TextArea또는 TextField의 Text 가 변할 때 발생됩니다.
(관련 컴포넌트: TextArea,TextField )
KeyEvent 클래스 : 키를 누르거나 놓을 때 발생합니다.
(관련 컴포넌트: Button,Canvas,Checkbox,Choice,Container,
Dialog,Frame,Label,List,Panel,Scrollbar,
TextArea,TextField,Window )
WindowEvent 클래스 : 윈도우가 활성화되거나 아이콘화 될 때 또는 종료될 때 발생 합니다.
(관련 콤포넌트: Dialog, Frame,Window )
2. Listener(리스너) 인터페이스
ActionListener 인터페이스
메소드
public void actionPerformed(ActionEvent e) : ActionEvent 가 발생 하였을 때 수행합니다.
AdjustmentListener 인터페이스
메소드
public void adjustmentValueChanged(AdjustmentEvent e) : AdjustmentEvent 가 발생 하였을 때 수행합니다.
ComponentListener 인터페이스
메소드
public void componentResized(ComponentEvent e) : component의 size가 변했을 때 수행합니다.
public void componentMoved(ComponentEvent e) : component 의 위치가 변했을 때 수행합니다
public void componentShown(ComponentEvent e) : component 가 보여지게 될 때 수행합니다.
public void componentHidden(ComponentEvent e) : component 가 숨겨지게 될 때 수행합니다.
ContainerListener 인터페이스
메소드
public void componentAdded(ContainerEvent e) : 컨테이너에 컴포넌트가 추가될 때 수행됩니다.
public void componentRemoved(ContainerEvent e) :컨테이너에서 컴포넌트가 제거될 때 수행합니다.
FocusListener 인터페이스
메소드
public void focusGained(FocusEvent e) : 컴포넌트가 focus를 얻었을 때 수행합니다.
public void focusLost(FocusEvent e) : 컴포넌트가 focus를 잃었을 때 수행합니다.
ItemListener 인터페이스
메소드
public void itemStateChanged(ItemEvent e) : item 이 선택 되었거나 선택이 취소 되었을 때 수행됩니다.
KeyListener 인터페이스
메소드
public void keyTyped(KeyEvent e) : 키보드의 문자 키(엔터,스페이스,탭 키 포함)를 눌렀을 때 수행됩니다.
public void keyPressed(KeyEvent e) : 키보드 키를 눌렀을 때 수행됩니다.
public void keyReleased(KeyEvent e) : 키보드 키를 눌렀다가 놓을 때 수행됩니다.
MouseListener 인터페이스
메소드
public void mouseClicked(MouseEvent e) : 컴포넌트에서 마우스 버튼을 눌렀다 놓은 이후에 수행합니다.
public void mousePressed(MouseEvent e) : 컴포넌트에서 마우스를 눌렀을 때 수행됩니다.
public void mouseReleased(MouseEvent e) : 컴포넌트에서 마우스버튼을 눌렀다 놓았을 때 수행됩니다.
public void mouseEntered(MouseEvent e) : 마우스 커서가 컴포넌트 경계 안으로 들어갈 때 수행됩니다.
public void mouseExited(MouseEvent e) : 마우스 커서가 컴포넌트 경계 밖으로 나올 때 수행됩니다.
MouseMotionListener 인터페이스
메소드
public void mouseDragged(MouseEvent e) : 마우스 버튼을 누른 상태로 마우스를 움직였을 때 수행합니다.
public void mouseMoved(MouseEvent e) : 마우스 버튼을 누르지 않은 상태에서 마우스를 움직였을 때 수행합니다.
TextListener 인터페이스
메소드
public void textValueChanged(TextEvent e) : TextArea 또는 TextField의 Text 값이 변할 때 수행됩니다.
WindowListener 인터페이스
메소드
public void windowOpened(WindowEvent e) : 윈도우가 처음 열리고 보여질 때 수행됩니다.
public void windowClosing(WindowEvent e) : 사용자가 윈도우의 종료를 요청할 때 수행됩니다.
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) : 윈도우가 비활성화 될 때 수행합니다.
[2] Action 이벤트
ActionEvent 는 버튼을 마우스로 클릭한다거나, TextField 에 글을 입력하고 엔터키를
누르는 경우 또는 List 박스나 Menu 의 MenuItem을 클릭하였을 경우에 발생되는 이벤트
입니다.
일반적으로 버튼을 만들고 버튼을 클릭하면 이벤트가 발생됩니다.
그런데 그 발생된 이벤트에 아무도 관심을 가져주지 않는다면 버튼을 누르는 행위는 아무런
의미가 없겠지요.
그런데 그 버튼에 몸종을 하나 주어서 버튼의 행동을 계속 주시하고 있다가 버튼이 눌러지면
프로그래머가 작성한 프로그램을 수행하도록 하면 어떨까요...
자바에는 이 몸종에 해당하는 것이 있습니다.
Listener(리스너)라는 놈이지요.
그러면 버튼에게 몸종(리스너)을 어떻게 주면 될까요...
이렇게 하면 됩니다.
Button bt = new Button("끝내기");
bt.addActionListener(this);
간단하죠..
이렇게 하면 버튼 'bt'에 몸종(리스너)이 하나 생긴 것이 됩니다.
이러한 종놈(리스너)에는 이놈 말고도 여러 놈이있습니다.
마우스가 움직이는지 또는 마우스를 클릭 되었는지를 주시하는 놈이 있는가 하면
키보드가 눌렸는지... 아뭏튼 여러놈이 있지요.
이놈들은 나중에 차차 설명할 것입니다.
하여간 ActionListener라는 놈은 버튼 'bt' 를 계속 주시하고 있다가 버튼이 클릭되면
이놈이 가지고 있는 actionPerformed(ActionEvent e)라는 메소드를 호출하여 실행
시킴니다.
그런데 이 ActionListener 라는 놈(다른 리스너도 마찬가지..)이 가지고 있는 메소드
actionPerformed(ActionEvent e)는 빈 껍데기 뿐이지요..
왜냐하면 ActionListener 는 인터페이스 이기 때문이래요...
그러니 actionPerformed(ActionEvent e)메소드는 선언만 했겠지요...
그런데 이 리스너라는 놈들은 뻔뻔스럽기가 말도 못해요.
이놈들은 메소드를 하나만 가지고 있는 놈도 있지만 메소드를 여러개 가지고 있는 놈도
있거든요. 그런데 이놈들은 자기의 주인장(리스너를 implements 하는 클래스)에게
자기를 사용하려면 자기가 가지고 있는 모든 메소드를 꽉꽉 채워(구현)달라고 떼를 쓴답
니다. 실제로 주인장이 필요로 하지 않는 메소드들도 말예요...
그래서 주인장은 필요한 것만 꽉꽉 채워(구현)주고 나머지는 슬쩍 건드려만 준답니다.
이렇게 하지 않으면 이놈들은 컴파일러가 일을 못하도록 데모까지 불사한데요.
여기에서 슬쩍 건드려만 준다는 것은 다음과 같이 하는 것을 말해요.
actionPerformed(ActionEvent e){}
아뭏튼 주인장으로서는 무척 귀찮은 일이지요...
그래서 주인장은 Adapter 라는 클래스를 불러와서 사용하기도 하는데 이 Adapter 는
클래스이기 때문에 사용하는데 편하지가 않아요. 이 Adapter 클래스는 다음에 설명
하겠습니다.
그런데 각각의 리스너들은 각자 전문 분야가 따로 있데요...
ActionListener 는 ActionEvent만 전문이고요, KeyListener 는 KeyEvent 전문이래요.
그리고 MouseListener 는 MouseEvent 전문이지요..
어! 그런데 이름들을 자세히 보니 공통점들이 있네요..
ActionListener ==== ActionEvent
KeyListener ==== KeyEvent
MouseListener ==== MouseEvent
:
어때요 공통점들이 보이지요..
자, 그러면 ActionListener가 가지고 있는 메소드를 볼까요...
actionPerformed(ActionEvent e)
ActionListener 는 다행히 메소드가 이것 하나 뿐입니다.
그런데 메소드의 인자(매개변수)가 클래스형 이네요.. (ActionEvent 는 클래스임)
지금까지 보아온 것들은 Label(String text) 또는 List(int rows) 같은 문자열이나
정수형이었는데 이 놈은 좀 다르네요...
자바 고수들이야 다 알겠지만 우리는 초보자니까 한번 짚어보고 넘어 가자고요.
예제를 하나 보겠습니다. (갈 길이 바쁘니 하나만 보기로 하죠.)
class TestOne{ // TestOne 클래스
private int x, y;
public TestOne(int a, int b) // 생성자
{
x = a;
y = b;
}
public int getValueX() // x 값을 얻기 위한 메소드
{
return x;
}
public int getValueY() // y 값을 얻기위한 메소드
{
return y;
}
}
class TestTwo{ // TestTwo 클래스
int i, j; // 인스턴스 변수 : 클래스 안의 모든 메소드에서 사용가능
public TestTwo(int x, int y) // 생성자
{
i = x;
j = y;
}
public void sum(TestOne f) // 메소드 : TestOne 클래스 형으로 인자(매개변수)를 받음
{
int result; // 지역변수 : 지역변수를 선언한 메소드안 에서만 사용가능
result = f.getValueX() * i + f.getValueY() * j;
System.out.println(result);
}
public static void main(String args[])
{
TestOne one = new TestOne(10,20);
TestTwo two = new TestTwo(30,40);
two.sum(one);
}
}
결과
1100
위의 프로그램에서 sum(TestOne f) 메소드를 보면 TestOne 클래스형을 매개변수로 받고 있습니다.
sum() 메소드에서 TestOne 클래스의 메소드 getValueX(), getValueY()에 어떻게 접근했는지
자세히 보세요. 앞으로 많이 보게 될 것입니다.
클래스형을 매개 변수로 받는 메소드는 actionPerformed(ActionEvent e)와 같은 리스너에 선언한
메소드들 외에도 많이 쓰이는 Paint(Grapphics g), update(Graphics g) 등 상당히 많이 있습니다.
위의 프로그램에서는 프로그래머가 two.sum(one)와 같이 메소드를 호출하였지만 actionPerformed(ActionEvent e)
를 포함한 다른 모든 리스너에 선언한 메소드들은 각각의 해당 이벤트가 발생하면 프로그래머가
호출하지 않아도 자동으로 호출되어 실행 됩니다. 물론 클래스형 매개변수에는 발생된 이벤트에
대한 정보가 담겨져 메소드에 전달 되겠지요. 예를들면 어느 놈이 이벤트를 발생시켰는지...
메소드에 전달되는 정보를 알기 위해서는 매개변수를 조사해야 합니다.
actionPerformed(ActionEvent e)메소드인 경우는 ActionEvent 클래스를 조사해 보아야 겠지요.
변수는 어떤 것이 있고, 메소드는 어떤 것이 있는지 또 그 역할은 무엇인지.....
ActionEvent 클래스의 메소드 중에서 getActionCommand()라는 메소드가 있습니다.
메소드의 이름에서 보듯이 ActionCommand(실행명령)을 얻는 메소드입니다. 버튼에서는 일반적으로
버튼의 레이블이 실행명령이 됩니다.
따라서 이 메소드를 사용하면 여러개의 버튼에서 어느 버튼에서 이벤트가 발생했는지 알 수있습니다.
actionPerformed(ActionEvent e) 메소드 안에서 getActionCommand()메소드에 접근하기 위해서는
actionPerformed(ActionEvent e){
:
e.getActionCommand();
:
}
이런 식으로 접근하겠지요...
자, 그러면 Action 이벤트 처리를 예제를 통해서 알아 보겠습니다.
(프로그램 1)
먼저 간단한 것부터 시작하겠습니다.
위의 그림은 프레임에 버튼이 딸랑 하나 놓여져 있습니다.
버튼의 레이블이 '끝내기' 이네요.
사용자들은 이 버튼을 클릭하면서 윈도우가 종료되기를 기대하겠지요...
사용자의 기대에 어긋나지 않게 프로그램을 작성해 보도록 하죠.
먼저 이벤트 클래스와 리스너 인터페이스를 사용하기위해서 java.awt.event를 import해야
합니다. (이벤트 클래스와 리스너 인터페이스는 모두 java.awt.event 패키지에서 공급하고
있습니다.)
버튼을 클릭하면 발생되는 Action 이벤트를 처리하기 위해서 ActionListener 인터페이스를
implements 해야합니다.
그리고 Button 클래스의 메소드인 addActionListener(ActionListener l)을 사용하여 리스너를
버튼에 등록해야 합니다.
마지막으로 ActionListener 인터페이스의 메소드 actionPerformed(ActionEvent e)를 프로그램에
맞게 재 정의 하면 됩니다.
아래의 코드를 보세요.
import java.awt.*;
import java.awt.event.*;
class exitTest extends Frame implements ActionListener{
public exitTest(String title) // 생성자
{
setTitle(title);
Panel pnl = new Panel();
Button bt1 = new Button("끝내기");
bt1.addActionListener(this);
pnl.setBackground(Color.gray);
pnl.add(bt1);
add("South",pnl);
setSize(200,150);
setVisible(true);
}
public void actionPerformed(ActionEvent e) // Action 이벤트가 발생되면 실행될 프로그램
{
setVisible(false); // Frame 을 보이지 않게 함
System.exit(0); // 프로그램 종료
}
public static void main(String args[])
{
new exitTest("ActionEvent Exam");
}
}
위의 프로그램에서 bt1.addActionListener(this); 부분을 보시면 this가 보이시죠.
this 는 클래스 자신을 의미합니다. 이 exitTest 클래스에서 ActionListener를 구현하고
있지요.. 따라서 exitTest 클래스 자신이 리스너가 된 것입니다.
그래서 addActionListener(ActionListener l)의 ActionListener l의 자리에 this가 들어
가는 거래요. 다시 말하면 this 는 exitTest 클래스 자신입니다.
(프로그램 2)
위의 프로그램에 버튼 두개와 TextField 하나를 추가해 보겠습니다.
위의 그림에서 프레임 상부의 'Hellow everyone' 이라고 적힌 부분이 TextField 입니다.
프레임의 하부에 버튼이 3개 있네요.
레이블이 '인사하기' 인 버튼을 클릭하면 TextField 에 'Hellow everyone'이 보이게 하고
레이블이 '지우기' 인 버튼을 클릭하면 TextField의 내용이 지워지며, 레이블이 '끝내기'
인 버튼을 클릭하면 프로그램을 종료하라는 것입니다.
아래 코드에 사용된 setText(String txt) 메소드는 TextField 클래스의 메소드로서 TextField
내의 text를 setText(String txt)메소드의 매개변수인 문자열 txt로 바꾸어 주는 역할을 합니다.
import java.awt.*;
import java.awt.event.*;
class exitTest extends Frame implements ActionListener{
TextField tf = new TextField();
public exitTest(String title)
{
setTitle(title);
Button bt1 = new Button("인사하기");
Button bt2 = new Button("지우기");
Button bt3 = new Button("끝내기");
Panel pnl = new Panel();
bt1.addActionListener(this);
bt2.addActionListener(this);
bt3.addActionListener(this);
pnl.setBackground(Color.gray);
pnl.add(bt1);
pnl.add(bt2);
pnl.add(bt3);
add("North",tf);
add("South",pnl);
setSize(200,150);
setVisible(true);
}
public void actionPerformed(ActionEvent e)
{
String str = e.getActionCommand(); // 이벤트를 발생시킨 버튼의 레이블을 str에 저장
if(str == "인사하기") // 버튼의 레이블이 '인사하기' 이면
tf.setText("Hellow everyone"); // TextField tf에 'Hellow everyone'로 세팅
else if(str == "지우기") // 버튼의 레이블이 '지우기' 이면
tf.setText(""); // TextField tf의 text 를 지워라
else if(str == "끝내기"){
setVisible(false);
System.exit(0);
}
}
public static void main(String args[])
{
new exitTest("ActionEvent Exam");
}
}
(프로그램 3)
다음은 여기에다 그룹화된 체크박스를 세개 추가하겠습니다.
그룹화된 체크박스는 하나만 선택할 수있지요...
프로그램의 내용은 다음과 같습니다.
체크박스에서 '아침'을 선택하고 '인사하기' 버튼을 클릭하면 'Good Morning'이
체크박스에서 '점심'을 선택하고 '인사하기' 버튼을 클릭하면 'Good Afternoon'이 그리고
체크박스에서 '저녁'을 선택하고 '인사하기' 버튼을 클릭하면 'Good Evening'이 TextField에
나타납니다. 그리고 '지우기' 버튼을 클릭하면 TextField의 내용이 지워지며, '끝내기' 버튼
을 클릭하면 프로그램이 종료합니다.
아래의 코드에서는 선택된 체크박스가 어떤 것인지 알기 위해서 CheckboxGroup 클래스의 메소드인
getSelectedCheckbox() 를 사용하였습니다. 이 메소드는 체크박스 그룹에서 체크된 체크박스를
알아내기 위해 사용합니다.
public Checkbox getSelectedCheckbox() 메소드의 리턴값이 Checkbox type이지요...
리턴값이 int 이면 int 형으로 받고, String 형이면 String 로 받지요.
getSelectedCheckbox() 메소드는 리턴값이 Checkbox 형입니다. 따라서 Checkbox 형으로 받아야지요..
CheckboxGroup grp = new CheckboxGroup();
Checkbox ch1 = new Checkbox("아침",grp,true);
Checkbox ch2 = new Checkbox("점심",grp,false);
Checkbox ch3 = new Checkbox("저녁",grp,false);
Checkbox ch_box = grp.getSelectedCheckbox();
그러면 전체 코드를 보겠습니다.
import java.awt.*;
import java.awt.event.*;
class exitTest extends Frame implements ActionListener{
CheckboxGroup grp = new CheckboxGroup();
Checkbox ch1 = new Checkbox("아침",grp,true);
Checkbox ch2 = new Checkbox("점심",grp,false);
Checkbox ch3 = new Checkbox("저녁",grp,false);
TextField tf = new TextField();
public exitTest(String title)
{
setTitle(title);
Button bt1 = new Button("인사하기");
Button bt2 = new Button("지우기");
Button bt3 = new Button("끝내기");
bt1.addActionListener(this); // 버튼 bt1 에 ActionListener 등록(ActionListener는 클래스 자신)
bt2.addActionListener(this); // 버튼 bt2 에 ActionListener 등록(ActionListener는 클래스 자신)
bt3.addActionListener(this); // 버튼 bt3 에 ActionListener 등록(ActionListener는 클래스 자신)
Panel pnlOne = new Panel();
Panel pnlTwo = new Panel();
pnlOne.add(ch1);
pnlOne.add(ch2);
pnlOne.add(ch3);
pnlTwo.setBackground(Color.gray);
pnlTwo.add(bt1);
pnlTwo.add(bt2);
pnlTwo.add(bt3);
add("North",tf);
add("Center",pnlOne);
add("South",pnlTwo);
setSize(200,150);
setVisible(true);
}
public void actionPerformed(ActionEvent e)
{
String str = e.getActionCommand(); // 이벤트를 발생한 버튼의 레이블을 str 에 저장
if(str == "인사하기"){ // 눌려진 버튼이 '인사하기' 이면
Checkbox ch_box = grp.getSelectedCheckbox(); // 선택된 체크박스를 알아냄
if(ch_box == ch1) // 선택된 체크박스가 ch1 이면
tf.setText("Good Morning"); // TextField tf 의 Text 값에 'Good Morning' 설정
else if(ch_box == ch2) // 선택된 체크박스가 ch2 이면
tf.setText("Good Afternoon"); // TextField tf 의 Text 값에 'Good Afternoon' 설정
else if(ch_box == ch3) // 선택된 체크박스가 ch3 이면
tf.setText("Good Evening"); // TextField tf 의 Text 값에 'Good Evening' 설정
}
else if(str == "지우기") // 눌려진 버튼이 '지우기'이면
tf.setText(""); // // TextField tf 의 Text 값을 지움
else if(str == "끝내기"){ // 눌려진 버튼이 '끝내기'이면
setVisible(false); // 프레임을 보이지 않게 함
System.exit(0); // 프로그램 종료
}
}
public static void main(String args[])
{
new exitTest("ActionEvent Exam");
}
}
마지막으로 간단한 계산기 프로그램을 만들어 보겠습니다.
잘 만들어진 프로그램은 아니지만 그런대로 사칙연산은 할 수있습니다.
프로그램을 실행 시켜보시고 잘못된 부분이 있으면 본인이 직접 수정해서 실행 시켜
보세요. 급하게 만든거라 수정하고 추가해야할 부분이 있을 겁니다.
TextField 의 Text 값은 String 입니다. 따라서 사칙연산을 하기 위해서는 String 을
정수형(또는 실수형)으로 바꾸어야 합니다.
이것을 위해서 사용한 메소드가 Long.parseLong(String str)입니다. 이 메소드는 문자열을
Long 형의 정수형으로 바꾸어 줍니다.
import java.awt.*;
import java.awt.event.*;
class Calculator extends Frame implements ActionListener{
String strOne=""; // 피연자
String strTwo=""; // 피연산자
String state1=""; // 여기에 '+,-,*,/'가 들어감
String state2=""; // '=' 이 눌려졌는지 알기 위해 사용
TextField tf = new TextField("0",18); // cols 이 18인 텍스트 필드 tf 생성
Label lb = new Label("[?]"); // 현재 어떤 연산자가 눌려졌는지 화면에 표시
public Calculator()
{
super("Calculator Exam");
Panel pnlOne = new Panel(new GridLayout(4,4,2,2));
Panel pnlTwo = new Panel();
Button bt = new Button("끝내기");
Button btn[] = new Button[16];
String label[] = {"7","8","9","+","4","5","6","-","1","2","3","*","0","=","C","/"};
for(int i = 0; i < label.length; i++){
btn[i] = new Button(label[i]); // 버튼 객체 생성
btn[i].addActionListener(this); // 각 버튼에 ActionListener 등록
pnlOne.add(btn[i]); // pnlOne 에 각 버튼을 추가
}
bt.addActionListener(this); // 버튼 bt 에 ActionListener 등록
pnlTwo.add(tf);
pnlTwo.add(lb);
add("North",pnlTwo);
add("Center",pnlOne);
add("South",bt);
setSize(200,200);
setVisible(true);
bt.requestFocus(); // Focus를 버튼 bt 에 맞춤
}
public static void main(String args[])
{
new Calculator();
}
public void actionPerformed(ActionEvent e)
{
String str = e.getActionCommand(); // 눌려진 버튼의 레이블을 str 에 저장
if(str == "+" || str == "-" || str == "*" || str == "/" ){ // 눌려진 버튼이 연산자 이면
if(strOne != "") state1 = str; // 첫번째 피연산자 값이 있어야만 연산자를 받음
strTwo = ""; // 두번째 피연산자 지움
lb.setText("["+state1+"]"); // 레이블에 선택된 연산자 표시
}
else if(str == "="){ // 눌려진 버튼이 '=' 이면
if( strOne != "" && strTwo != ""){ // 첫번째와 두번째 피연산자가 모두 있는 경우에만...
long value = 0; // value 0 으로 초기화
if(state1=="+") // 더하기를 선택하였으면
value = Long.parseLong(strOne) + Long.parseLong(strTwo);
else if(state1=="-") // 빼기를 선택하였으면
value = Long.parseLong(strOne) - Long.parseLong(strTwo);
else if(state1=="*") // 곱하기를 선택하였으면
value = Long.parseLong(strOne) * Long.parseLong(strTwo);
else if(state1=="/" && strTwo != "0") // 나누기를 선택하였고 두번째 피연산자가 0이 아니면
value = Long.parseLong(strOne) / Long.parseLong(strTwo);
strOne= String.valueOf(value); // 계산되어진 결과 value (Long 형)을 다시 문자열로 바꾸고
// 첫번째 피연산자에 대입
tf.setText(strOne); // 텍스트 필드에 계산된 결과값을 표시
state2 = "="; // state2에 '=' 을 대입
}
}
else if(str == "C"){ // 눌려진 버튼이 'C'이면
tf.setText("0"); // 모두 초기값으로...
strOne="";
strTwo="";
state1 = "";
state2 = "";
lb.setText("[?]");
}
else if(str == "끝내기"){ // 눌려진 버튼이 '끝내기 이면
setVisible(false); // 프레임을 감춤
System.exit(0); // 프로그램 종료
}
else { // 그 밖에 눌려진 버튼이 숫자버튼이면
if(state2 == "=" ) { // 현재 state2의 값이 '='이면
state1 = ""; // 모두 초기값으로...
state2 = "";
strOne = "";
lb.setText("[?]");
}
if(state1=="") { // 현재 연산자 '+,-,*,/'가 선택되기 전이면
strOne += str; // 눌려진 숫자 버튼의 label을 첫번째 피연산자에 계속 추가
tf.setText(strOne); // 현재 눌려진 키값들을 텍스트 필드에 세팅
}
else { // 현재 연산자 '+,-,*,/'가 선택된 후면
strTwo += str; // 눌려진 숫자 버튼의 label을 두번째 피 연산자에 계속 추가
tf.setText(strTwo); // 현재 눌려진 키값들을 텍스트 필드에 세팅
}
}
}
}
[3] Mouse 이벤트
Mouse 이벤트는 마우스 버튼을 누르거나 놓을 때 또는 마우스를 움직일때 등 마우스와
관련된 동작을 했을 경우 발생됩니다.
다음의 컴포넌트들은 Mouse 이벤트를 발생시킬 수있는 컴포넌트들입니다.
Button,Canvas,Checkbox,Choice,Container,Dialog,Frame,Label,List,Panel,Scrollbar,
TextArea,TextField,Window
거의 모든 컴포넌트가 Mouse 이벤트를 발생시킨다는 것을 알 수있지요...
그런데 Mouse 이벤트는 특이하게도 Mouse 이벤트를 감시하는 리스너가 두개가 있습니다.
MouseListener 와 MouseMotionListener 가 바로 Mouse 이벤트의 리스너입니다.
그러면 각각의 리스너 인터페이스에서 제공하는 메소드들은 무엇이며, 어떤 이벤트가
발생되었을 때, 어느 메소드가 호출되는지 알아보겠습니다.
MouseListener 인터페이스
메소드 (5 개)
public void mouseClicked(MouseEvent e) : 컴포넌트에서 마우스 버튼을 눌렀다 놓은 이후에 수행합니다.
public void mousePressed(MouseEvent e) : 컴포넌트에서 마우스를 눌렀을 때 수행됩니다.
public void mouseReleased(MouseEvent e) : 컴포넌트에서 마우스버튼을 눌렀다 놓았을 때 수행됩니다.
public void mouseEntered(MouseEvent e) : 마우스 커서가 컴포넌트 경계 안으로 들어갈 때 수행됩니다.
public void mouseExited(MouseEvent e) : 마우스 커서가 컴포넌트 경계 밖으로 나올 때 수행됩니다.
MouseMotionListener 인터페이스
메소드 (2 개)
public void mouseDragged(MouseEvent e) : 마우스 버튼을 누른 상태로 마우스를 움직였을 때 수행합니다.
public void mouseMoved(MouseEvent e) : 마우스 버튼을 누르지 않은 상태에서 마우스를 움직였을 때 수행합니다.
리스너에서 제공하는 메소드들이 많이 있지요...
그러면 먼저 MouseListener 인터페이스부터 살펴보겠습니다.
위의 그림을 보시면 아래쪽에 버튼이 두개 있습니다.
오른쪽의 레이블이 '끝내기'인 버튼은 프로그램을 종료하기 위한 버튼이고, 왼쪽에 있는
레이블이 '마우스시험용'인 버튼은 어떤 마우스 이벤트가 발생하였을 때 어떤 메소드가
호출되는 지를 알아보기 위하여 사용되어지는 버튼입니다. 버튼 위쪽의 TextArea 부분에서
볼 수있는 텍스트들은 '마우스시험용' 버튼을 사용하여 테스트한 결과입니다.
1. '마우스시험용' 버튼의 경계안으로 마우스 커서를 올려 놓으면 mouseEntered(MouseEvent e)
메소드가 호출됩니다.
2. 버튼을 누르면 mousePressed(MouseEvent e)메소드가 호출됩니다.
3. 버튼을 놓으면 mouseReleased(MouseEvent e)메소드가 호출됩니다.
4. 이어서 mouseClicked(MouseEvent e)메소드가 호출됩니다.
5. 마지막으로 마우스 커서가 버튼의 경계밖으로 나오면 mouseExited(MouseEvent e)메소드가
호출됩니다.
아래의 프로그램은 위에서 설명한 내용을 확인해 보기 위한 프로그램입니다.
본인이 직접 입력하시고 확인해 보세요. (처음 보시는 분은 반드시 확인해 보시기 바람.)
아래의 프로그램에서 사용한 append() 메소드는 TextArea 클래스의 메소드로서 TextArea에
문자열을 추가하기 위하여 사용합니다.
메소드의 원형은 다음과 같습니다.
public void append(string str)
자, 그러면 전체 프로그램을 볼까요..
화일명 : mouseTest.java
import java.awt.*;
import java.awt.event.*;
class mouseTest extends Frame implements MouseListener,ActionListener{
TextArea ta = new TextArea();
public mouseTest(String title) // 생성자
{
setTitle(title);
Panel pnl = new Panel();
Button bt1 = new Button("마우스시험용");
Button bt2 = new Button("끝내기");
bt1.addMouseListener(this); // 버튼 bt1 에 MouseListener 등록
bt2.addActionListener(this); // 버튼 bt2 에 ActionListener 등록
pnl.setBackground(Color.gray);
pnl.add(bt1);
pnl.add(bt2);
add("Center",ta);
add("South",pnl);
setSize(250,200);
setVisible(true);
}
public void mouseClicked(MouseEvent e)
{
ta.append("Mouse-Clicked \n");
}
public void mousePressed(MouseEvent e)
{
ta.append("Mouse-Pressed \n");
}
public void mouseReleased(MouseEvent e)
{
ta.append("Mouse-Released \n");
}
public void mouseEntered(MouseEvent e)
{
ta.append("Mouse-Entered \n");
}
public void mouseExited(MouseEvent e)
{
ta.append("Mouse-Exited \n");
}
public void actionPerformed(ActionEvent e)
{
setVisible(false);
System.exit(0);
}
public static void main(String args[])
{
new mouseTest("MouseEvent Exam");
}
}
전에도 설명했지만 모든 리스너는 인터페이스입니다. 따라서 리스너를 구현하는 클래스는
리스너 인터페이스에서 제공하는 모든 메소드들을 재정의해야 합니다.
그러면 간단한 예제를 하나 보겠습니다.
아래 그림은 Action 이벤트 예제에 보았던 프레임이지요...
윈도우 종료 프로그램을 Mouse 이벤트를 사용하여 작성할 것입니다.
그런데 혹시 위 그림의 버튼에 마우스 커서를 대고 열심히 마우스 버튼을 누르시는 분이
있는지 모르겠습니다. 이런 분이 계시면 제발 참아 주세요.
위의 그림은 어플리케이션으로 작성된 프로그램을 실행시키고 나서 화면 캡쳐를 하여
붙여 넣은 것입니다.
import java.awt.*;
import java.awt.event.*;
class mouseTest3 extends Frame implements MouseListener{
public mouseTest3(String title) // 생성자
{
setTitle(title);
Panel pnl = new Panel();
Button btExit = new Button("끝내기");
btExit.addMouseListener(this); // 버튼 btExit에 MouseListener 등록
pnl.setBackground(Color.gray);
pnl.add(btExit);
add("South",pnl);
setSize(200,150);
setVisible(true);
}
public static void main(String args[])
{
new mouseTest3("MouseEvent Exam");
}
public void mouseClicked(MouseEvent e)
{
setVisible(false);
System.exit(0);
}
public void mousePressed(MouseEvent e){}
public void mouseReleased(MouseEvent e){}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
}
위의 프로그램에서는 Mouse 리스너에서 제공하는 메소드 중에서 mouseClicked(MouseEvent e)
라는 메소드를 사용하여 프로그램을 종료하고 있습니다.
그런데 사용되지 않는 메소드들도 보기 싫게 죽 늘어 놓은 것을 볼수 있습니다.
이것은 물론 Mouse 리스너가 인터페이스이기 때문에 할수없이 이렇게 사용하지도 않는
메소드들도 모두 재정의 한 것이지요.
무슨 해결방법이 없을까요...
우선 Mouse 리스너의 메소드들을 다른 클래스를 사용하여 밖으로 끌어내 보겠습니다.
그리고 그 클래스에 MouseListener를 implements하고 MouseListener안의 모든 메소드
들을 프로그램 내용없이 재정의해 놓겠습니다.
class listenerClass implements MouseListener{
public void mouseClicked(MouseEvent e){}
public void mousePressed(MouseEvent e){}
public void mouseReleased(MouseEvent e){}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
}
(위의 listenerClass 클래스는 MouseListener의 모든 메소드를 재정의 하였기 때문에
인터페이스나 추상 클래스가 아닙니다.)
위와 같이하면 다음과 같이 되겠지요...
import java.awt.*;
import java.awt.event.*;
class mouseTest extends Frame{
public mouseTest(String title) // 생성자
{
setTitle(title);
Panel pnl = new Panel();
Button btExit = new Button("끝내기");
btExit.addMouseListener(this); // 버튼 btExit에 MouseListener 등록
pnl.setBackground(Color.gray);
pnl.add(btExit);
add("South",pnl);
setSize(200,150);
setVisible(true);
}
public static void main(String args[])
{
new mouseTest("MouseEvent Exam");
}
}
class listenerClass implements MouseListener{
public void mouseClicked(MouseEvent e){}
public void mousePressed(MouseEvent e){}
public void mouseReleased(MouseEvent e){}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
}
자, 위의 코드에서 mouseTest 클래스에서 두번째 클래스인 listenerClass 클래스를
상속받아 필요한 메소드만 다시 재정의하여 사용하면 될것 같지요... (NO !)
그러나 mouseTest 클래스에서는 Frame 클래스를 상속받고 있네요.
자바에서는 클래스의 다중상속이 허용되지 않지요...
어떻게 해야 할까요...
이럴때는 mouseTest 클래스안에 클래스를 만들어 사용하면됩니다.
mouseTest 안에 만들어진 클래스를 내부 클래스라고 부르지요.
그리고 mouseTest 클래스는 외부 클래스 라고 부릅니다.
class 외부클래스{
........
class 내부클래스{
.........
}
.........
}
아래의 프로그램은 내부 클래스를 사용하여 작성한 프로그램입니다.
import java.awt.*;
import java.awt.event.*;
class mouseTest3 extends Frame{
Button btExit = new Button("끝내기");
public mouseTest3(String title) // 생성자
{
setTitle(title);
Panel pnl = new Panel();
mouse_Clicked mcl = new mouse_Clicked();
btExit.addMouseListener(mcl); // 버튼 btExit에 MouseListener 등록
pnl.setBackground(Color.gray);
pnl.add(btExit);
add("South",pnl);
setSize(200,150);
setVisible(true);
}
class mouse_Clicked extends listenerClass{ // 내부 클래스
// (listenerClass 클래스를 상속 받고 있슴)
public void mouseClicked(MouseEvent e) // 메소드 재정의
{
setVisible(false);
System.exit(0);
}
}
public static void main(String args[])
{
new mouseTest3("MouseEvent Exam");
}
}
class listenerClass implements MouseListener{
public void mouseClicked(MouseEvent e){}
public void mousePressed(MouseEvent e){}
public void mouseReleased(MouseEvent e){}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
}
위의 프로그램에서
mouse_Clicked mcl = new mouse_Clicked();
btExit.addMouseListener(mcl);
를 보시면 btExit.addMouseListener(mcl); 의 this 부분이 mouse_Clicked 객체 인스턴스인
mcl로 바뀌었습니다.
위 프로그램에서 MouseListener 는 mcl 입니다.
왜? mouseListener 가 mcl 일까요...
위의 프로그램에서는 listenerClass 클래스가 MouseListener 인터페이스를 구현하고
있습니다. 그리고 다시 내부 클래스 mouse_Clicked 가 listenerClass 클래스를 상속받고
있지요... 그러니 mouse_Clicked에서 생성된 객체가 리스너가 되지요.
그런데 위의 프로그램 중에서 listenerClass 클래스 부분은 이미 자바 개발자들이 Adapter
클래스라는 이름으로 제공한답니다.
MouseListener 인터페이스 에 대응되는 Adapter 클래스는 MouseAdapter 클래스입니다.
그리고 Adapter 클래스는 java.awt.event 패키지에 있습니다.
그렇다면 위의 프로그램을 MouseAdapter 클래스를 사용하여 작성해 보겠습니다.
위의 프로그램에서 listenerClass 클래스는 필요없겠지요.
그리고 내부 클래스
class mouse_Clicked extends listenerClass{
public void mouseClicked(MouseEvent e)
{
setVisible(false);
System.exit(0);
}
에서 listenerClass 를 MouseAdapter로 바꾸어야지요.
그러면 다시 MouseAdapter 를 사용한 전체 코드를 보겠습니다.
import java.awt.*;
import java.awt.event.*;
class mouseTest extends Frame{
Button btExit = new Button("끝내기");
public mouseTest(String title) // 생성자
{
setTitle(title);
Panel pnl = new Panel();
mouse_Clicked mcl = new mouse_Clicked();
btExit.addMouseListener(mcl); // 버튼 btExit에 MouseListener 등록
pnl.setBackground(Color.gray);
pnl.add(btExit);
add("South",pnl);
setSize(200,150);
setVisible(true);
}
class mouse_Clicked extends MouseAdapter{ // 내부 클래스
// (MouseAdapter 클래스를 상속 받고 있슴)
public void mouseClicked(MouseEvent e) // 메소드 재정의
{
setVisible(false);
System.exit(0);
}
}
public static void main(String args[])
{
new mouseTest("MouseEvent Exam");
}
}
Mouse 리스너를 이용한 예제를 하나 더 보겠습니다.
위의 그림을 보시면 제일 윗부분에 초록이라고 적힌 Label 이 있고, 그 아래에 버튼이
세개 있습니다. 그리고 아래쪽에 버튼이 하나 있네요.
프로그램의 내용은 다음과 같습니다.
초록이라고 적힌 Label에 마우스 커서를 가져가면 Label 의 글자가 '노랑'으로 바뀌면서
Label 의 바탕색이 노란색으로 바뀝니다. 그리고 마우스를 빼면 원래의 상태로 돌아
옵니다. 바로 밑의 버튼중에서 빨강이라고 적힌 버튼에 마우스를 가져가면 빨강이라고
적힌 버튼의 색이 빨간색으로 바뀌고 마우스를 빼면 원래의 색으로 돌아옵니다. (다른
버튼도 마찬가지..) 그리고 아래쪽의 '끝내기'버튼을 누르면 프로그램이 종료합니다.
아래의 프로그램에서는 이벤트를 발생시킨 컴포넌트를 알아내기 위해서 getSource()
메소드를 사용하였습니다. getSource()메소드는 EventObject 클래스의 메소드입니다.
모든 Event 클래스는 EventObject 클래스를 상속받고 있습니다.
getSource() 메소드는 이벤트를 발생시킨 객체(근원)을 리턴해 줍니다.
getSource() 메소드의 원형은 다음과 같습니다.
public Object getSource()
참고로 MouseEvent 클래스의 상속 구조를 보면 다음과 같습니다.
EventObject -> AWTEvent -> ComponentEvent -> InputEvent -> MouseEvent
그리고 getSource()에서 리턴된 객체와 MouseListener 를 등록한 객체를 비교하기 위하여
String 클래스의 메소드인 equals(String str)메소드를 사용하였습니다.
사용방법은 다음과 같습니다.
문자열1.equals(문자열2) : 문자열1 과 문자열2 가 같으면 true 를 리턴해 주고
문자열1 과 문자열2 가 다르면 false 를 리턴합니다.
btRed.equals(e.getSource()) : 이벤트를 발생시킨 객체가 btRed 이면 true 를 리턴합니다.
그러면 전체 코드를 보겠습니다.
import java.awt.*;
import java.awt.event.*;
class mouseTest extends Frame{
Button btRed = new Button("빨강");
Button btBlue = new Button("파랑");
Button btGreen= new Button("초록");
Button btExit = new Button("끝내기");
Label lb = new Label("초록",Label.CENTER);
public mouseTest(String title) // 생성자
{
setTitle(title);
Panel pnlOne = new Panel();
Panel pnlTwo = new Panel();
Panel pnlThree = new Panel();
lb.setBackground(Color.green);
mouseAction mcl = new mouseAction(); // 내부 클래스 객체 생성
lb.addMouseListener(mcl); // Label 에 MouseListener 등록
btRed.addMouseListener(mcl); // 버튼 btRed 에 MouseListener 등록
btBlue.addMouseListener(mcl); // 버튼 btBlue 에 MouseListener 등록
btGreen.addMouseListener(mcl); // 버튼 btGreen 에 MouseListener 등록
btExit.addMouseListener(mcl); // 버튼 btExit 에 MouseListener 등록
pnlOne.add(lb);
pnlTwo.add(btRed);
pnlTwo.add(btBlue);
pnlTwo.add(btGreen);
pnlThree.setBackground(Color.gray);
pnlThree.add(btExit);
add("North",pnlOne);
add("Center",pnlTwo);
add("South",pnlThree);
setSize(200,150);
setVisible(true);
}
class mouseAction extends MouseAdapter{ // 내부 클래스
public void mouseClicked(MouseEvent e)
{
if(btExit.equals(e.getSource())){ // 이벤트를 발생시킨 객체가 btExit 이면
setVisible(false);
System.exit(0);
}
}
public void mouseEntered(MouseEvent e) 마우스 커서가 컴포넌트의 경계안으로 들어가면 호출
{
if(lb.equals(e.getSource())){ // 이벤트를 발생시킨 객체가 Label 이면
lb.setBackground(Color.yellow); // Label lb 의 배경색을 노란색으로...
lb.setText("노랑"); // Label lb 의 Text 를 '노랑' 으로 바꿈
}
else if(btRed.equals(e.getSource())) // 이벤트를 발생시킨 객체가 버튼 btRed 이면..
btRed.setBackground(Color.red); // 버튼의 배경색을 빨간색으로...
else if(btBlue.equals(e.getSource())) // 이벤트를 발생시킨 객체가 버튼 btBlue 이면..
btBlue.setBackground(Color.blue); // 버튼의 배경색을 파란색으로...
else if(btGreen.equals(e.getSource())) // 이벤트를 발생시킨 객체가 버튼 btGreen 이면..
btGreen.setBackground(Color.green); // 버튼의 배경색을 초록색으로...
}
public void mouseExited(MouseEvent e) // 마우스의 커서가 컴포넌트의 경계를 벗어나면 호출
{
if(lb.equals(e.getSource())){
lb.setBackground(Color.green);
lb.setText("초록");
}
else if(btRed.equals(e.getSource()))
btRed.setBackground(Color.lightGray);
else if(btBlue.equals(e.getSource()))
btBlue.setBackground(Color.lightGray);
else if(btGreen.equals(e.getSource()))
btGreen.setBackground(Color.lightGray);
}
}
public static void main(String args[])
{
new mouseTest("MouseEvent Exam");
}
}
지금까지 Mouse 리스너를 사용한 프로그램을 작성해 보았습니다.
Mouse 이벤트 처리를 위한 리스너는 하나 더 있지요...
MouseMotionListener라는 것이 있어요.
이 리스너는 마우스의 이동이나 드래그를 감시하지요.
MouseMotionListener에서 제공하는 메소드는 두개가 있습니다.
mouseDragged(MouseEvent e) : 마우스 버튼을 누른 상태로 마우스를 이동시키면 호출됩니다.
mouseMoved(MouseEvent e) : 마우스 버튼을 누르지 않고 이동시키면 호출됩니다.
그러면 MouseMotionListener 를 사용한 프로그램을 보겠습니다.
위의 그림을 보면 버튼이 하나있고, 리이블이 두개 있습니다.
'끝내기' 버튼을 누르면 프로그램이 종료합니다.
마우스 버튼을 누르고 마우스를 움직이면 'Drag'라고 적힌 레이블이 마우스 커서를 따라 움직입니다.
마우스 버튼을 누르지 않고 마우스를 움직이면 'Move'라고 적힌 레이블이 마우스 커서를 따라 움직입니다.
레이블을 마음대로 움직이게 하기 위해서 프레임의 배치관리자를 'null'로 설정했습니다.
마우스 이벤트가 발생된 위치를 알아내기 위하여 Mouse 이벤트 클래스의 메소드인 getPoint() 메소드를
사용하였습니다. getPoint() 메소드의 원형은 다음과 같습니다.
public Point getPoint()
되돌림형이 Point 이네요. 그러니 getPoint()메소드에서 되돌려 주는 값을 Point 로 받아야지요..
public void mouseDragged(MouseEvent e)
{
Point p = e.getPoint();
}
그리고 Label 을 마우스 이벤트가 발생된 위치로 이동시키기 위해서 setLocation(Point p)메소드를
사용하였습니다. 매개변수가 Point 형이지요.
이 메소드는 Component 클래스의 메소드입니다.
(모든 컴포넌트(Button,Label...)들은 Component 클래스를 상속받고 있습니다.)
자, 그럼 전체 코드를 볼까요...
import java.awt.*;
import java.awt.event.*;
class mouseTest extends Frame implements ActionListener,MouseMotionListener{
Label lbDrag = new Label("Drag",Label.CENTER);
Label lbMove = new Label("Move",Label.CENTER);
public mouseTest(String title) // 생성자
{
setTitle(title);
setLayout(null); // 배치관리자를 null 로 지정
Button btExit = new Button("끝내기");
btExit.setBounds(100,50,50,30); // 배치관리자를 지정하지 않았으므로
lbDrag.setBounds(100,100,50,30); // 프로그래머가 직접 위치와 크기를
lbMove.setBounds(100,150,50,30); // 지정해 주어야함
lbDrag.setBackground(Color.green);
lbMove.setBackground(Color.red);
addMouseMotionListener(this); // 프레임에 MouseMotionListener 등록
btExit.addActionListener(this); // 버튼 btExit에 ActionListener 등록
add(btExit);
add(lbDrag);
add(lbMove);
setSize(250,200);
doLayout();
setVisible(true);
}
public void actionPerformed(ActionEvent e) // 버튼에 Action 이벤트 발생시 호출
{
setVisible(false);
System.exit(0);
}
public void mouseDragged(MouseEvent e) // 마우스의 버튼을 누른 상태로 움직이면 호출
{
Point p = e.getPoint(); // 이벤트가 발생된 위치를 알아냄
lbDrag.setLocation(p); // 이벤트가 발생된 위치로 Label lbDrag 이동
}
public void mouseMoved(MouseEvent e) // 마우스의 버튼을 누르지 않고 이동할 때 호출
{
Point p = e.getPoint(); // 이벤트가 발생된 위치를 알아냄
lbMove.setLocation(p); // 이벤트가 발생된 위치로 Label lbMove 이동
}
public static void main(String args[])
{
new mouseTest("MouseEvent Exam");
}
}
[4] Adjustment 이벤트
Adjustment 이벤트는 스크롤바가 스크롤되어 값이 변할 때 발생됩니다.
Adjustment 이벤트와 관련된 컴포넌트는 Scrollbar 입니다.
Adjustment 이벤트를 감시하는 리스너는 AdjustmentListener 인터페이스입니다.
이 AdjustmentListener 인터페이스는 메소드를 하나만 가지고 있습니다.
public void adjustmentValueChanged(AdjustmentEvent e)
이 메소드는 Scrollbar 컴포넌트의 값이 변할 때 호출되어 실행됩니다.
다음은 AdjustmentEvent 클래스의 메소드입니다.
public int getValue() : Adjustment 이벤트가 발생하였을 때의 현재값을 리턴합니다.
public int getAdjustmentType() : Adjustment 이벤트를 발생시킨 형태(Adjustment type)를
리턴합니다.
다음은 AdjustmentEvent 클래스의 클래스 변수로서 Adjustment type(5가지)들 입니다.
UNIT_INCREMENT, UNIT_DECREMENT, BLOCK_INCREMENT, BLOCK_DECREMENT, TRACK
Adjustment 이벤트를 설명하기 위한 프로그램에서는 윈도우에 문자열이나 채워진 사각형을
그리기 위해 paint(Graphics g)메소드를 사용했습니다.
여기서 paint(Graphics g)메소드를 잠깐 살펴보겠습니다.
paint(Graphics g) 메소드는 프로그래머가 직접 호출할 수가 없습니다.
리스너 인터페이스의 메소드들도 프로그래머가 직접 호출하지 않았지요...
이벤트가 발생되면 자동으로 호출되었습니다.
paint()메소드도 마찬가지로 커포넌트를 다시 그려야 할 경우 자동으로 호출됩니다.
컴포넌트를 다시그려야 하는 경우는 윈도우가 아이콘화 되었다가 복귀될 때, 또는
윈도우가 다른 윈도우에 가려져 있다가 복귀될 때... 등입니다.
프로그래머가 이 메소드를 호출하여 사용하기 위해서는 repaint()메소드를 사용하여
간접적으로 호출해야 합니다.
프로그래머가 repaint()메소드를 호출하면 repaint()메소드는 update(Graphics g)
메소드를 호출합니다.
update()메소드는 윈도우의 배경색으로 윈도우를 깨끗이 지우고 나서 paint(Graphics g)
메소드를 호출합니다.
paint(Graphics g), update(Graphics g), repaint() 메소드는 모두 Component 클래스의
메소드들입니다.
잠깐 아래의 두 프로그램을 비교해 보세요.
하나는 프레임 클래스를 상속 받아 프레임을 만들었고, 다른 하나는 프레임 객체를
생성해서 프레임을 만들었습니다.
두 프로그램 모두 똑같이 paint()메소드를 정의 하고 있습니다.
그러나 각각의 paint()메소드는 그 성질이 다르지요..
< 프로그램 1 >의 testFrameOne 클래스는 Frame 클래스를 상속받고 있습니다.
따라서 testFrameOne 클래스안의 paint()메소드는 Component 클래스에 정의되어있는
paint(Graphics g)메소드를 재정의(Overriding)하고 있는 것입니다.
그러므로 프레임에 변화가 생겨서 프레임을 다시 그려야 하는 경우 자동으로 paint()
메소드는 호출됩니다.
<프로그램 2>의 testFrameTwo 클래스는 Frame 객체를 생성해서 프레임을 만들었습니다.
따라서 testFrameTwo 클래스안의 paint()메소드는 Component 클래스의 paint()메소드를
재정의하고 있는 것이 아닙니다. ( 이것은 당연하지요... 괜히 쑥스럽네.. ^_^ )
이 클래스에서 정의한 paint()메소드는 프로그래머가 정의한 일반 메소드입니다.
그러므로 testFrameTwo 클래스 안의 paint()메소드는 자동으로 호출되지 않습니다.
< 프로그램 1 >
import java.awt.*; // 컴포넌트를 사용하기 위해 import
class testFrameOne extends Frame{ // 프레임 클래스 상속
public testFrameOne() // 생성자
{
setTitle("Frame Test");
setSize(200,150);
setVisible(true);
}
public static void main(String args[])
{
new testFrameOne(); //testFrameOne 객체 생성
}
public void paint(Graphics g)
{
g.setColor(Color.blue); // 전경색을 파란색으로 설정
g.drawString("안녕하세요",50,50); // 위치(x:50, y:50)에 문자열을 그린다.
}
}
< 프로그램 2 >
import java.awt.*; // 컴포넌트를 사용하기 위해 import
class testFrameTwo{
public testFrameTwo() // 생성자
{
Frame frm = new Frame("Frame Test"); // 객체 생성
frm.setSize(200,150);
frm.setVisible(true);
}
public static void main(String args[])
{
new testFrameTwo(); //testFrameTwo 객체 생성
}
public void paint(Graphics g)
{
g.setColor(Color.blue); // 전경색을 파란색으로 설정
g.drawString("안녕하세요",50,50); // 위치(x:50, y:50)에 문자열을 그린다.
}
}
자, 그럼 간단한 예제를 보겠습니다.
다음의 예제는 스크롤바의 움직임에 따라서 문자열이 상,하로 스크롤되어지는
프로그램입니다.
import java.awt.*;
import java.awt.event.*;
class
[5] Item 이벤트
ItemEvent는 Checkbox, List, Choice 컴포넌트 또는 메뉴의 CheckboxMenuItem과 관련된
이벤트로서 아이템이 선택되었거나 해제되었을 때 발생되는 이벤트입니다.
그리고 ItemEvent를 감시하는 리스너는 ItemListener 인터페이스입니다.
다음은 ItemEvent 클래스의 메소드입니다.
public ItemSelectable getItemSelectable() : 이벤트를 발생시킨 객체에 관련된 정보를 리턴합니다.
public Object getItem() : 이벤트에 영향을 받은 item을 리턴합니다.
( List 컴포넌트는 List의 index를 리턴함. )
public int getStateChange() : 선택 또는 선택해제와 같은 상태변화의 형태를 리턴합니다.
item이 선택되었을 경우 : ItemEvent.SELECTED 를 리턴
item이 해제되었을 경우 : ItemEvent.DESELECTED를 리턴
다음은 ItemListener 인터페이스의 메소드입니다.
ItemListener 인터페이스에서 정의한 메소드는 다음과 같은 메소드 하나뿐입니다.
public void itemStateChanged(ItemEvent e)
: Item 이 선택되었거나 또는 선택되었다가 해제 되었을 때 호출됩니다.
ItemListener 인터페이스를 implements하는 클래스에서 이 메소드를 프로그램에 맞게 재정의
하면 되지요...
자, 그러면 프로그램을 만들어 볼까요...
위의 그림을 보시면 위에 체크박스가 세개 있습니다.
그리고 TextArea 가 중간에 있고, 그 아래에 버튼이 있지요...
프로그램의 내용은 다음과 같습니다.
위의 체크박스를 선택하거나 해제하면 TextArea안에 변경된 체크박스의 상태를 표시하고 현재
선택되어 있는 체크박스들이 어떤 것이 있는지 표시합니다.
그리고 하단의 버튼을 클릭하면 프로그램은 종료합니다.
아래의 코드에서는 체크박스가 선택된 상태인지 또는 해제된 상태인지를 알아내기 위해서
Checkbox 클래스의 메소드인 getState()메소드를 사용하였습니다.
이 메소드는 체크박스가 선택어져 있으면 true를 해제된 경우는 false를 리턴해 줍니다.
public boolean getState()
그러면 전체 코드를 볼까요...
import java.awt.*;
import java.awt.event.*;
class itemEventTest extends Frame implements ActionListener,ItemListener{
TextArea tf = new TextArea();
Checkbox ch1 = new Checkbox("사과",true);
Checkbox ch2 = new Checkbox("포도",false);
Checkbox ch3 = new Checkbox("수박",false);
public itemEventTest(String title) // 생성자
{
setTitle(title);
Button bt = new Button("끝내기");
Panel pnlOne = new Panel();
Panel pnlTwo = new Panel();
bt.addActionListener(this); // 버튼 bt에 리스너 등록
ch1.addItemListener(this); // 체크박스 ch1에 리스너 등록
ch2.addItemListener(this); // 체크박스 ch2에 리스너 등록
ch3.addItemListener(this); // 체크박스 ch3에 리스너 등록
pnlOne.add(ch1);
pnlOne.add(ch2);
pnlOne.add(ch3);
pnlTwo.setBackground(Color.gray);
pnlTwo.add(bt);
add("North",pnlOne);
add("Center",tf);
add("South",pnlTwo);
setSize(250,200);
setVisible(true);
}
public void actionPerformed(ActionEvent e) // 버튼이 클릭될 경우 호출
{
setVisible(false);
System.exit(0);
}
public void itemStateChanged(ItemEvent e) // item이 선택되었거나 해제되었을 때 호출
{
String str="";
if(e.getStateChange() == ItemEvent.SELECTED) // item이 선택되었으면
tf.append(e.getItem()+"을 추가하셨습니다 \n\n");
else if(e.getStateChange() == ItemEvent.DESELECTED) // item이 해제되었으면
tf.append(e.getItem()+"을 취소하셨습니다 \n\n");
if(ch1.getState()) str += "사과 "; //체크박스 ch1이 선택되어 있으면 변수 str에 문자열 '사과'추가
if(ch2.getState()) str += "포도 "; //체크박스 ch2가 선택되어 있으면 변수 str에 문자열 '포도'추가
if(ch3.getState()) str += "수박 "; //체크박스 ch3이 선택되어 있으면 변수 str에 문자열 '수박'추가
if(str != "") // 체크박스가 하나이상 선택되었다면...
tf.append(str+"을 좋아하시는군요..^_^.\n\n");
else // 체크박스가 선택된 것이 없으면...
tf.append("좋아하는 과일이 없으세요 ?\n\n");
}
public static void main(String args[])
{
new itemEventTest("ItemEvent Exam");
}
}
프로그램이 어렵게 보이나요....
어렵다고 생각하시는 분은 코드를 차근히 살펴보세요.
자, 그럼 다음 프로그램으로 넘어 갈까요...
프로그램의 내용은 다음과 같습니다.
상단에 체크박스가 3개있고 중간에 파란색 사각형이 보이지요...
그리고 그 아래에 '파랑을 선택하셨습니다'라는 글자가 보입니다.
상단의 체크박스 중에서 '빨강'이라는 레이블이 붙은 체크박스를 선택하면
파란색 사각형이 빨간색으로 바뀌고 그 아래에 '빨강을 선택하셨습니다'라는
글자가 나타납니다. 이하 다른 체크박스도 마찬가지....
그리고 하단의 버튼을 클릭하면 프로그램이 종료합니다.
프로그램의 코드는 다음과 같습니다.
import java.awt.*;
import java.awt.event.*;
class itemEventTest extends Frame implements ActionListener,ItemListener{
Color color = new Color(255,0,0); // 빨간색 Color 객체 생성
String str = "초기값은 빨강입니다.";
public itemEventTest(String title)
{
setTitle(title);
Button bt = new Button("끝내기");
CheckboxGroup grp = new CheckboxGroup();
Checkbox ch1 = new Checkbox("빨강",grp,true);
Checkbox ch2 = new Checkbox("파랑",grp,false);
Checkbox ch3 = new Checkbox("초록",grp,false);
Panel pnlOne = new Panel();
Panel pnlTwo = new Panel();
bt.addActionListener(this); // 버튼 bt에 리스너 등록
ch1.addItemListener(this); // 체크박스 ch1 에 리스너 등록
ch2.addItemListener(this); // 체크박스 ch2 에 리스너 등록
ch3.addItemListener(this); // 체크박스 ch3 에 리스너 등록
pnlOne.add(ch1);
pnlOne.add(ch2);
pnlOne.add(ch3);
pnlTwo.setBackground(Color.gray);
pnlTwo.add(bt);
add("North",pnlOne);
add("South",pnlTwo);
setSize(200,150);
setVisible(true);
}
public void actionPerformed(ActionEvent e) // 버튼을 클릭했을 때 호출
{
setVisible(false);
System.exit(0);
}
public void itemStateChanged(ItemEvent e) // item이 선택되었거나 해제되었을 때 호출
{
if("빨강".equals(e.getItem())) color = Color.red;
else if("파랑".equals(e.getItem())) color = Color.blue;
else if("초록".equals(e.getItem())) color = Color.green;
str = e.getItem()+"을 선택하셨습니다"; // 선택된 객체의 레이블을 변수 str에 대입
repaint(); // 윈도우를 다시 그리기위해서 호출
}
public void paint(Graphics g)
{
g.setColor(color); // 전경색 설정
g.fillRect(85,50,30,30); // (x:85,y:50)위치 부터 폭:30 ,높이:30 로
// 채워진 사각형을 그린다.
g.drawString(str,40,100); // x:40 , y:100 위치에 문자열을 그립니다.
}
public static void main(String args[])
{
new itemEventTest("ItemEvent Exam");
}
}
다음 프로그램을 보겠습니다.
프로그램 내용은 다음과 같습니다.
위의 '과일'레이블이 붙은 체크박스를 선택하면 옆의 초이스박스의 아이템들이 과일이름들로
바뀜니다. 그리고 '채소'레이블이 붙은 체크박스를 선택하면 초이스박스의 아이템들이 채소
이름들로 바뀜니다.
초이스박스의 아이템을 선택하면 'ooo을 선택하셨습니다'라는 메시지가 텍스트영역에 표시됩니다.
하단의 버튼을 클릭하면 프로그램이 종료합니다.
아래의 코드에서 사용된 removeAll()메소드는 Choice 클래스의 메소드로서 초이스박스의 모든
아이템을 제거합니다.
public void removeAll()
자, 그러면 전체 코드를 보겠습니다.
import java.awt.*;
import java.awt.event.*;
class itemEventTest extends Frame implements ActionListener,ItemListener{
TextArea tf = new TextArea();
CheckboxGroup grp = new CheckboxGroup();
Checkbox ch1 = new Checkbox("과일",grp,true);
Checkbox ch2 = new Checkbox("채소",grp,false);
Choice choice = new Choice();
String itemOne[] = {"바나나","복숭아","포 도","수 박"}; // 과일 배열
String itemTwo[] = {"배 추","시금치","호 박"}; // 채소 배열
public itemEventTest(String title)
{
setTitle(title);
Button bt = new Button("끝내기");
Panel pnlOne = new Panel();
Panel pnlTwo = new Panel();
bt.addActionListener(this); // 버튼 bt에 리스너 등록
ch1.addItemListener(this); // 체크박스 ch1 에 리스너 등록
ch2.addItemListener(this); // 체크박스 ch2 에 리스너 등록
choice.addItemListener(this); // 초이스박스 choice 에 리스너 등록
for(int i = 0; i < itemOne.length; i++) // itemOne.length 는 배열의 크기
choice.addItem(itemOne[i]); // 초이스박스에 아이템(과일) 추가
pnlOne.add(ch1);
pnlOne.add(ch2);
pnlOne.add(choice);
pnlTwo.setBackground(Color.gray);
pnlTwo.add(bt);
add("North",pnlOne);
add("Center",tf);
add("South",pnlTwo);
setSize(250,200);
setVisible(true);
}
public void actionPerformed(ActionEvent e) // Action 이벤트가 발생되면 호출
{
setVisible(false);
System.exit(0);
}
public void itemStateChanged(ItemEvent e) // item이 선택되었거나 해제되었을 때 호출
{
if("과일".equals(e.getItem())){ // 레이블이 '과일'인 체크박스가 선택되었으면..
choice.removeAll(); // 초이스박스의 모든 아이템을 지운다.
for(int i = 0; i < itemOne.length; i++)
choice.addItem(itemOne[i]); // 초이스박스에 새로운 아이템을 추가
}
else if("채소".equals(e.getItem())){ // 레이블이 '채소'인 체크박스가 선택되었으면..
choice.removeAll(); // 초이스박스의 모든 아이템을 지운다.
for(int i = 0; i < itemTwo.length; i++)
choice.addItem(itemTwo[i]); // 초이스박스에 새로운 아이템을 추가
}
else // 선택된 것이 초이스박스의 아이템이면...
tf.append(e.getItem()+"을 선택하셨습니다 \n"); // 텍스트 영역에 문자열 출력
}
public static void main(String args[])
{
new itemEventTest("ItemEvent Exam");
}
}
마지막으로 조금 복잡한 프로그램을 보겠습니다.
그러나 지금까지 배운 것을 바탕으로 작성한 것이기 때문에 코드를 자세히 보시면
금방 이해하실 것입니다.
프로그램의 내용은 다음과 같습니다.
처음 실행시키면 '삭제'와 '모두삭제' 버튼은 비활성 상태입니다.
이 상태에서 하단의 텍스트 필드에 글을 입력하고 '추가' 버튼을 누르면 리스트 박스에
아이템이 추가되며 '삭제'버튼과 '모두삭제'버튼은 활성 상태가 됩니다.
텍스트 필드에 글을 입력하고 '추가' 버튼을 클릭하여 리스트 박스에 아이템을 계속 추가
할 수있습니다.
'모두삭제' 버튼을 클릭하면 리스트박스의 모든 아이템이 삭제되며, '삭제'와 '모두삭제'
버튼은 다시 비활성 상태로 됩니다. 즉 리스트 박스에 아이템이 없으면 '삭제'와'모두삭제'
버튼은 비활성 상태가 됩니다.
리스트박스의 아이템을 선택하면 텍스트영역에 'ooo를 선택하셨습니다'라는 메시지가 나타
나며 이 상태에서 선택된 아이템은 '삭제'버튼을 클릭하여 제거할 수있습니다.
아이템을 삭제하면 'ooo'을 삭제하셨습니다'라는 메시지가 텍스트영역에 표시됩니다.
메뉴의 체크박스메뉴아이템을 체크 해제하면 하단의 텍스트 필드가 보이지 않게되며, '추가'
버튼은 비활성 상태가 됩니다.
프로그램을 종료하려면 메뉴에서 Exit 를 선택하거나 ctrl키를 누르고 x키를 누르면 됩니다.
그러면 전체코드를 보겠습니다.
import java.awt.*;
import java.awt.event.*;
class itemEventTest extends Frame implements ActionListener,ItemListener{
TextArea ta = new TextArea();
TextField tf = new TextField();
Button bt1 = new Button("추가");
Button bt2 = new Button("삭제");
Button bt3 = new Button("모두삭제");
List lst = new List();
MenuShortcut shexit = new MenuShortcut('x');
MenuItem exitItem = new MenuItem("Exit",shexit); // 단축키를 가진 MenuItem 생성
CheckboxMenuItem itemOne = new CheckboxMenuItem("텍스트필드선택", true);
public itemEventTest(String title) // 생성자
{
setTitle(title);
MenuBar menubar = new MenuBar(); // MenuBar 객체 생성
Menu itemmenu = new Menu("Item"); // Menu 생성
menubar.add(itemmenu); // menu 를 MenuBar 에 추가
itemmenu.add(itemOne); // MenuItem 을 Menu에 추가
itemmenu.addSeparator(); // Separator 을 Menu에 추가
itemmenu.add(exitItem);
setMenuBar(menubar); // MenuBar 를 Frame에 추가
exitItem.addActionListener(this); // 메뉴아이템 exitItem에 리스너 등록
bt1.addActionListener(this); // 버튼 bt1에 리스너 등록
bt2.addActionListener(this); // 버튼 bt2에 리스너 등록
bt3.addActionListener(this); // 버튼 bt3에 리스너 등록
tf.addActionListener(this); // 텍스트필드 tf에 리스너 등록
itemOne.addItemListener(this); // 메뉴아이템 itemOne에 리스너 등록
lst.addItemListener(this); // 리스트 lst에 리스너 등록
bt2.setEnabled(false); // 버튼 bt2 를 비활성 상태로...
bt3.setEnabled(false); // 버튼 bt3 를 비활성 상태로...
Panel pnlOne = new Panel(new FlowLayout(FlowLayout.RIGHT));
Panel pnlTwo = new Panel(new BorderLayout());
Panel pnlThree = new Panel(new BorderLayout());
Panel pnlFour = new Panel(new BorderLayout());
pnlOne.setBackground(Color.gray);
pnlOne.add(bt1);
pnlOne.add(bt2);
pnlOne.add(bt3);
pnlTwo.add("North",new Label("텍스트창:",Label.LEFT));
pnlTwo.add("Center",ta);
pnlThree.add("North",new Label("목록:",Label.LEFT));
pnlThree.add("Center",lst);
pnlFour.add("West",new Label("목록입력:",Label.CENTER));
pnlFour.add("Center",tf);
add("North",pnlOne);
add("Center",pnlTwo);
add("East",pnlThree);
add("South",pnlFour);
setSize(300,200);
setVisible(true);
}
public void actionPerformed(ActionEvent e) // Action 이벤트가 발생되면 호출
{
if(exitItem.equals(e.getSource())){ // 메뉴 아이템 exitItem 을 선택했다면..
setVisible(false);
System.exit(0);
}
else if(bt1.equals(e.getSource())){ // '추가' 버튼을 클릭했다면
String str = tf.getText(); // 텍스트 필드의 텍스트를 변수 str에 저장
if( str.length() != 0){ // 변수 str이 비어있지 않다면
lst.add(str); // 리스트에 아이템 추가
tf.setText(""); // 텍스트 필드의 내용을 지운다.
bt2.setEnabled(true); // '삭제','모두삭제' 버튼을 활성상태로...
bt3.setEnabled(true);
}
else ta.append("추가할 목록을 입력하세요. \n"); // 텍스트필드에 내용을 입력하지 않고
} // 추가 버튼을 눌렀다면..
else if(bt2.equals(e.getSource())){ // '삭제' 버튼을 클릭했다면
if(lst.getSelectedItem() != null){ // 리스트의 아이템을 선택한 경우에만..
ta.append(lst.getSelectedItem()+"을 삭제하셨습니다. \n"); // 문자열을 텍스트 영역에...
lst.remove(lst.getSelectedItem()); // 선택한 아이템을 지운다.
if(lst.getItemCount()==0){ // 리스트에 아이템이 없다면
bt2.setEnabled(false); // '삭제','모두삭제' 버튼을 비활성 상태로
bt3.setEnabled(false);
}
}
else ta.append("삭제할 목록을 선택하세요. \n"); // 리스트의 아이템을 선택하지 않고
} // '삭제' 버튼을 눌렀다면..
else if(bt3.equals(e.getSource())){ // '모두삭제' 버튼을 눌렀다면
lst.removeAll(); // 리스트의 모든 아이템을 제거..
ta.append("모두 삭제하셨습니다. \n");
bt2.setEnabled(false); // '삭제','모두삭제' 버튼을 비활성 상태로
bt3.setEnabled(false);
}
else if(tf.equals(e.getSource())){ // 텍스트필드에 커서가 있는 상태에서 엔터치면...
ta.append("추가버튼을 클릭하세요. \n");
}
tf.requestFocus(); // 포커스를 텍스트 필드에 맞춤
}
public void itemStateChanged(ItemEvent e) // item이 선택되었거나 해제되었을 때 호출
{
if("텍스트필드선택".equals(e.getItem())){ // 메뉴의 체크박스메뉴아이템을 선택한 경우..
if(e.getStateChange() == ItemEvent.SELECTED){ // 메뉴아이템이 체크된 상태로 바뀌면
bt1.setEnabled(true); // '추가' 버튼을 활성화 상태로
tf.setVisible(true); // 텍스트 필드를 보이게 함
tf.requestFocus(); // 포커스를 텍스트필드에 맞춤
}
else if(e.getStateChange() == ItemEvent.DESELECTED){ // 메뉴아이템이 체크 해제 상태로 바뀌면..
bt1.setEnabled(false); // '추가' 버튼을 비활성 상태로..
tf.setVisible(false); // 텍스트 필드 숨김
}
}
else // 리스트의 아이템을 선택하였다면...
ta.append(lst.getSelectedItem()+"을 선택하셨습니다. \n");
}
public static void main(String args[])
{
new itemEventTest("ItemEvent Exam");
}
}'프로그램 > java' 카테고리의 다른 글
| 자바 스크립트 내장함수(06.08.11)(2025.5.20 update) (0) | 2025.05.20 |
|---|---|
| rmi+mysql (06.02.07) (0) | 2025.05.13 |
| 자바 기초(2) 클래스 (2005.04.04)(2025.05.13 Update) (0) | 2025.05.13 |
| 자바기초(1) 자료형,연산자,제어문 (2005.04.04) (2025.5.13update) (0) | 2025.05.13 |
| java 강좌 초안 (0) | 2023.04.13 |