Java 정리 21

// 1. 한 클래스에서 상속으로 Frame을 받고 구현으로 OOOListener를 처리
public class Test extends Frame implements ActionListener { ... }

// 2. 이벤트처리와 관련있는 Component를 선언
Button btn;

// 3. Component를 생성
public Test() {
    btn = new Button();
}

// 4. 컴포넌트가 이벤트를 발생할 수 있도록 등록
// ooo.addOOOListener(이벤트가발생했을때처리될객체);
btn.addActionListener(this); 
// 이벤트가 등록되고 이벤트가 발생하면 입력된 객체의 Override된 추상 method가 호출

// 5. btn 컴포넌트의 이벤트 발생시 Override된 메소드 수행
// ActionListner의 abstract method Override
@Override
public void actionPerformed(ActionEvent ae) {
    // 이벤트가 발생했을 때 처리
}

/**
* ActionEvent를 사용한 Is-A 관계로 이벤트를 처리하는  방법
* 디자인과 이벤트 처리를 하나의 클래스안에서 처리한다.
* (값에 대한 사용이 편하다.)
*/
// 1. 상속으로 Frame을 처리하고, 구현으로 Event Handling  객체를 처리
@SuppressWarnings("serial")
public class EventHandlingIsA extends Frame implements ActionListener {
  
  // 2. 이벤트 처리와 관련이 있는 Component 선언
  private Button btn;
  
  public EventHandlingIsA() {
    super("Is-A 관계로 이벤트 처리방법");
    // 3. Component 생성
    btn = new Button("클릭");
    
    // 4. 생성된 컴포넌트가 이벤트를 발생시킬 수 있도록이벤트에 등록
    btn.addActionListener(this); 
    // Arguments로 입력된 객체의 Override된 method가 호출된다.
    
    Panel panel = new Panel();
    panel.add(btn);
    
    // 5. 생성된 컴포넌트를 배치
    add(BorderLayout.CENTER, panel);
    
    // 6. 윈도우 컴포넌트의 크기를 설정
    setBounds(400, 200, 300, 300);
    
    // 7. 사용자에게 보여주기 (가시화)
    setVisible(true);
    
    // 8. 종료처리
    addWindowListener(new WindowAdapter() {
      @Override
      public void windowClosing(WindowEvent e) {
        dispose();
      }
    });
  }
      
  @Override
  public void actionPerformed(ActionEvent e) {
    System.out.println("버튼이 클릭되었습니다.");
    dispose();
  }
  
  public static void main(String[] args) {
    new EventHandlingIsA();
  }
}

// 1 . Frame 상속받는 클래스 생성
public class Test extends Frame { ... }

// 2. 이벤트 관련 Component를 선언
Button btn;

// 3. 컴포넌트 생성
public Test() {
    btn = new Button();
}

// 4. 이벤트 처리객체 생성하고 Has-A관계 설정
TestImpl ti = new TestImpl(this);

// 5. 이벤트 등록
btn.addActionListener(ti);

// 1. OOOListener를 구현하는 클래스 생성
public class TestImpl implements ActionListener { ... }

// 2. 디자인 클래스를 Has-A 관계로 가지고 사용할 수 있도록 선언
private Test t;

// 3. 생성자에서 디자인 클래스를 받는다.
public TestImpl (Test t) {
    this.t = t;
}

// 4. 추상 method Override
public void actionPerformed(ActionEvent e) { 
    // 이벤트가 발생했을 때 처리
}

/**
* Has-A 관계의 이벤트 처리
* 디자인과 이벤트처리 코드를 분리하여 코드의 복잡도를  낮출 수 있다.
*/
// 1. 윈도우 컴포넌트를 상속
@SuppressWarnings("serial")
public class Design extends Frame {
  // 2. 이벤트처리와 관련있는 Component를 선언
  private Button btn;
  
  public Design() {
    super("디자인");
    // 3. 컴포넌트 생성
    btn = new Button("클릭");
    
    // 4. 배치
    Panel panel = new Panel();
    panel.add(btn);
    
    add(BorderLayout.CENTER, panel);
    
    // 5. 이벤트 등록
    // 이벤트 처리 객체 생성하고 Has-A 관계설정
    EventHandlingHasA ehha = new  EventHandlingHasA(this);
    System.out.println("생성된 디자인 객체 "+this);
    
    // 컴포넌트에 이벤트를 등록
    // 버튼에서 이벤트가 발생하면 ehha객체의  Override된 method에서
    // 이벤트를 처리
    btn.addActionListener(ehha);
    
    // 6. 윈도우 크기 설정
    setBounds(100,100,400,300);
    
    // 7. 가시화
    setVisible(true);
    // 8. 종료처리
    addWindowListener(new WindowAdapter() {
      @Override
      public void windowClosing(WindowEvent e) {
        dispose();
      }
    });
  }
  
  public Button getButton() {
    return btn;
  }
  
  public static void main(String[] args) {
    new Design();
  }
}

/**
* Has-A 관계로 이벤트 처리
*/
// 1. 이벤트 처리 객체를 구현
public class EventHandlingHasA implements ActionListener  {

  // EventHandlingHasA는 Design을 가지고 있다.
  // 2. Has-A 관계로 저장하고 사용할 객체 선언
  private Design design;
  
  public EventHandlingHasA(Design design) {
    this.design = design;
  }
  
  @Override
  // 3. abstract method를 Override
  public void actionPerformed(ActionEvent e) {
    // 이벤트가 발생했을 때 처리할 코드
    System.out.println("전달받은 Design객체 :  "+design);
    design.dispose();
  }
}

// 1. 윈도우 컴포넌트를 상속
public class Test extends Frame { ... }

// 2. 이벤트 처리와 관계된 컴포넌트 선언
Button btn;

// 3. 생성
public Test() {
    btn = new Button("버튼");
}

// 4. 이벤트를 처리하기 위한 inner class를 작성
public class Inner implements ActionListener {

// 5. 추상 메소드 Override
  @Override
  public void actionPerformed(ActionEvent e) {
    // 이벤트가 발생했을 때 처리할 코드 
  }
}

// 6. 이벤트 등록
// Inner Class를 객체화
Test.Inner in = this.new Inner();

// Component가 이벤트를 발생할 수 있도록 등록
btn.addActionListener(in);

/**
* inner class를 사용한 이벤트 처리 :
* 디자인에 해당하는 이벤트처리 코드 코드가 매우 적거나
* 특정디자인에 해당하는 이벤트만 처리할 때
*/
// 1. 윈도우 컴포넌트를 상속
public class EventHandlingInnerClass extends Frame {
  
  // 2. 이벤트처리 관련 컴포넌트를 객체화
  private Button btn;
  
  public EventHandlingInnerClass() {
    super("Inner class로 이벤트 처리");
    
    // 3. 컴포넌트 생성
    btn = new Button("클릭");
    
    // 4. 배치
    Panel panel = new Panel();
    panel.add(btn);
    add(BorderLayout.CENTER, panel);
    
    // 5. 이벤트 등록
    // inner class 생성.
    EventHandlingInnerClass.InnerActionImpl iai =
              this.new InnerActionImpl();
    
    // 컴포넌트에 이벤트에 등록
    btn.addActionListener(iai);
    
    // 6. 윈도우 크기 설정
    setBounds(100, 100, 300, 300);
    // 7. 가시화
    setVisible(true);
    addWindowListener(new WindowAdapter() {
      @Override
      public void windowClosing(WindowEvent e) {
        dispose();
      }
    });
  }
  
  public Button getBtn() {
      return btn;
  }
  //////////////// inner class 시작 //////////////////
  // 5-1. inner class로 이벤트처리 리스너를 구현
  public class InnerActionImpl implements  ActionListener {
    
    @Override
    public void actionPerformed(ActionEvent e) {
      System.out.println("버튼을 클릭하였습니다. "
                + "o(>.<)o 꺄~~~");
      // 안쪽클래스에서는 바깥클래스의 자원을  내 것처럼 사용가능
      dispose();
    }
  }
  //////////////// inner class 끝 ////////////////////
  
  public static void main(String[] args) {
    new EventHandlingInnerClass();
  }
}

// 1. Window Component를 상속
public class Test extends Frame { ... }

// 2. Component를 선언
Button btn;

// 3. 생성
public Test() {
    btn = new Button();
}

// 4. 이벤트 등록
// anonymous inner class
btn.addActionListener(new ActionListener() {
    
  @Override
  public void actionPerformed(ActionEvent e) {
    // 이벤트가 발생했을 때 처리할 코드
  }
});

// anonymous inner class로 이벤트 처리
// 1. 윈도우 컴포넌트 상속
public class EventHandlingAnonymous extends Frame {
  // 2. 이벤트처리에 사용할 Component 선언
  private Button btn;
  
  public EventHandlingAnonymous() {
    super("click!");
    
    // 3. 컴포넌트 생성
    btn = new Button("버튼");
    
    // 4. 배치
    Panel panel = new Panel();
    panel.add(btn);
    add("Center",panel);
    
    // 5. 이벤트 등록 : anonymous inner class
    btn.addActionListener(new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent e)  {
        System.out.println("버튼 클릭!");
      }
    });
    
    // 6. 윈도우 크기 설정
    setBounds(200, 100, 400, 200);
    // 7. 가시화
    setVisible(true);
  }
  public Button getBtn() {
    return btn;
  }
  public static void main(String[] args) {
    new EventHandlingAnonymous();
  }
}

// OOOAdapter class가 사용되어야 하는 이유
@SuppressWarnings("serial")
public class UseWindowEvent extends Frame implements  WindowListener {
  public UseWindowEvent() {
    super("윈도우 이벤트 연습");
    
    setBounds(100, 100, 400, 400);
    setVisible(true);

    addWindowListener(this);
  }
  
  public static void main(String[] args) {
    new UseWindowEvent();
  }

  // WindowListener interface를 구현한 class는
  // 사용하지 않는 method일지라도 모두 Override  해야한다.
  @Override
  public void windowOpened(WindowEvent e) {
    System.out.println("windowOpened");
  }
  @Override
  public void windowClosing(WindowEvent e) {
    System.out.println("windowClosing");
    dispose();
  }
  @Override
  public void windowClosed(WindowEvent e) {
    // windowClosing에서 dispose()가 호출되면 그때  windowClosed가 호출
    System.out.println("windowClosed");
  }
  @Override
  public void windowIconified(WindowEvent e) {
    System.out.println("windowIconified");
  }
  @Override
  public void windowDeiconified(WindowEvent e) {
    System.out.println("windowDeiconified");
  }
  @Override
  public void windowActivated(WindowEvent e) {
    System.out.println("windowActivated");
  }
  @Override
  public void windowDeactivated(WindowEvent e) {
    System.out.println("windowDeactivated");
  }
}

@SuppressWarnings("serial")
public class UseWindowAdapter extends Frame {
  public UseWindowAdapter() {
    super("윈도우 이벤트 연습");
    
    setBounds(100, 100, 400, 400);
    setVisible(true);

    UseWindowAdapter.WindowImpl wi = this.new  WindowImpl();
    addWindowListener(wi);
  }
  
  public static void main(String[] args) {
    new UseWindowAdapter();
  }

  // WindowAdapter class를 상속받으면 필요한 method만  Override하면 된다.
  public class WindowImpl extends WindowAdapter {
    
    @Override
    public void windowClosing(WindowEvent e) {
        dispose();
    }
  }
}

// ActionListener를 사용한 이벤트 처리
// is-a 관계로 이벤트를 처리
@SuppressWarnings("serial")
public class UseActionListener extends Frame implements ActionListener {

  // 다른 메소드에서 사용해야 하므로 지역변수에서 인스턴스변수로 옮김
  private TextField tfName;
  private TextArea taDisplay;
  
  public UseActionListener() {

    super("ActionEvent 사용");
    
    Label lblName = new Label("이름");
    Button btnAdd = new Button("추가");
    Button btnClose = new Button("종료");
    Panel panelNorth = new Panel();
    tfName = new TextField(20);
    taDisplay = new TextArea();
    
    panelNorth.add(lblName);
    panelNorth.add(tfName);
    panelNorth.add(btnAdd);
    panelNorth.add(btnClose);
    setLayout(new BorderLayout());
    add(BorderLayout.NORTH, panelNorth);
    add(BorderLayout.CENTER, taDisplay);
    
    // 이벤트 등록
    btnAdd.addActionListener(this); // 버튼에서 이벤트 등록(클릭)
    tfName.addActionListener(this); //  텍스트필드에서 이벤트 등록(엔터)
    btnClose.addActionListener(new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent e) {
        dispose();
      }
    });
    
    setBounds(200, 150, 400, 250);
    setVisible(true);
    addWindowListener(new WindowAdapter() {
      @Override
      public void windowClosing(WindowEvent e) {
        dispose();
      }
    });
  }
  
  public static void main(String[] args) {
    new UseActionListener();
  }
  
  @Override
  public void actionPerformed(ActionEvent e) {
    // TextField의 값을 받아와서, TextArea에 추가
    String name = tfName.getText();
    if (!name.isEmpty()) {  // 입력문자열이 비어있지 않다면
      taDisplay.append(name+"\n");
      
      // TextField의 값을 초기화
      tfName.setText("");
    }
    // 커서를 TextField에 재설정
    tfName.requestFocus();
  }
}

/**
* ItemEvent를 처리하는 ItemListener의 사용
*/
@SuppressWarnings("serial")
public class UseItemListener extends Frame implements ItemListener {

  private List list;
  private Label lbl;

  public UseItemListener() {
    
    list = new List();
    list.add("이재찬/27");
    list.add("정택성/26");
    list.add("공선의/27");
    lbl = new Label("이름 :                           나이 : ");
    
    add(BorderLayout.CENTER, list);
    add(BorderLayout.SOUTH, lbl);
    
    list.addItemListener(this);
    
    addWindowListener(new WindowAdapter() {
      @Override
      public void windowClosing(WindowEvent e) {
        dispose();
      }
    });
    
    setBounds(300, 200, 300, 300);
    setVisible(true);
  }
  public static void main(String[] args) {
    new UseItemListener();
  }

  @Override
  public void itemStateChanged(ItemEvent e) {
    // 리스트의 아이템이 선택되면 선택한 아이템을 가져와서
    // 라벨의 값 변경
    String[] nameAndAge = list.getSelectedItem().split("/");
    String name = nameAndAge[0];
    String age = nameAndAge[1];
    // 긴 문자열이기 때문에 StringBuilder로 처리
    StringBuilder viewData = new StringBuilder();
    viewData.append("이름 : ").append(name).append("              나이 : ").append(age);
    lbl.setText(viewData.toString());
  }
}