Java - JFrame

package inner_class_stage5;
 
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
public class ExStage1 extends JFrame {
    
    /*
     * 이벤트(Event)
     * 특정 컴포넌트(버튼, 윈도우 등)에 발생한 동작(기능)
     * ex) 버튼 클릭, 창 닫기 버튼클릭, 라디오버튼 선택, 체크박스 체크 등
     * 이벤트가 발생했을 때 어떤 동작을 취하려면, 이벤트 대상과 이벤트 리스너를 연결해야함
     * 
     * 이벤트 리스너(Event Listener)
     * 특정 컴포넌트에 발생한 이벤트를 감지하는 객체
     * 주로 인터페이스로 제공됨(ex, XXXListener 인터페이스)
     * 각 이벤트에 따라 각각의 리스너 인터페이스가 제공
     * ex) 버튼클릭 이벤트=ActionListener, 키보드 입력 이벤트=KeyLisener 등)
     * 
     * 핸들러(Handler) 클래스
     * 이벤트 리스너를 상속받아 구현한 클래스
     * 이벤트 발생 시 처리할 동작을 기술
     * 
     * 이벤트 처리를 위한 핸들러(Handler)클래스 구현
     * 1단계. XXXListener 인터페이스를 구현하는 서브클래스를 정의
     * ->외부 클래스 형태로 별도의 핸들러 클래스 정의
     * -특정 이벤트 처리를 위한 리스너 구현
     */
    
    public ExStage1() {
        showFrame();
    }
    
    private void showFrame() {
        setTitle("이벤트처리1단계");
        setBounds(500, 400, 300, 200);
//        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        /*
         * 1단계 : 현재 윈도우(프레임)의 이벤트 처리를 위해 이벤트 리스너 구현 핸들러 클래스 연결
         * ->addXXXListener() 메서드 호출하여 핸들러 클래스 인스턴스 전달
         * 이때, XXXListener 는 이벤트 리스너 인터페이스명 그대로 사용
         * 메서드는 각 컴포넌트 객체 내에 제공됨
         */
        //핸들러 클래스의 인스턴스 생성
        MyWinListener listener=new MyWinListener();
        //addXXXListener()메서드에 리스너 객체(핸들러 인스턴스) 전달
        addWindowListener(listener);
        
        JButton btn= new JButton("Button");
        add(btn);
        
        setVisible(true);
        
        
    }
 
    public static void main(String[] args) {
        
        new ExStage1();
        
    }
 
}
 
 
//윈도우(프레임)에 대한 동작을 처리하는 리스너를 구현하는 핸들러(MyWindowListener 클래스) 정의
//윈도우에 대한 이벤트를 감지하는 리스너 인터페이스=WindowListener인터페이스 
class MyWinListener implements WindowListener{
    /*
     * 리스너 인터페이스 구현 시, 리스너 내의 추상메서드 오버라이딩 필수
     * 해당 추상메서드 구현 후 , 각 이벤트에 대한 동작을 메서드에 구현
     * 이벤트 발생 시 해당 이벤트에 맞는 메서드가 자동으로 호출됨 
     */
    
    
    @Override
    public void windowActivated(WindowEvent e) {
        System.out.println("windowActivated");
    }
 
    @Override
    public void windowClosed(WindowEvent e) {
        System.out.println("windowClosed");
    }
 
    @Override
    public void windowClosing(WindowEvent e) {
        //프레임의 닫기 버튼 클릭 시 호출되는 메서드
        System.out.println("windowClosing");
        System.exit(0);//현재 프로그램 종료
        //0 은 정상적 종료.
    }
 
    @Override
    public void windowDeactivated(WindowEvent e) {
        System.out.println("windowDeactivated");
    }
 
    @Override
    public void windowDeiconified(WindowEvent e) {
        System.out.println("windowDeiconified");
    }
 
    @Override
    public void windowIconified(WindowEvent e) {
        System.out.println("windowIconified");
    }
 
    @Override
    public void windowOpened(WindowEvent e) {
        System.out.println("windowOpened");
    }
    
}
 
 
package inner_class_stage5;
 
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
public class ExStage2 extends JFrame {
    
    /*
     * 이벤트(Event)
     * 특정 컴포넌트(버튼, 윈도우 등)에 발생한 동작(기능)
     * ex) 버튼 클릭, 창 닫기 버튼클릭, 라디오버튼 선택, 체크박스 체크 등
     * 이벤트가 발생했을 때 어떤 동작을 취하려면, 이벤트 대상과 이벤트 리스너를 연결해야함
     * 
     * 이벤트 리스너(Event Listener)
     * 특정 컴포넌트에 발생한 이벤트를 감지하는 객체
     * 주로 인터페이스로 제공됨(ex, XXXListener 인터페이스)
     * 각 이벤트에 따라 각각의 리스너 인터페이스가 제공
     * ex) 버튼클릭 이벤트=ActionListener, 키보드 입력 이벤트=KeyLisener 등)
     * 
     * 핸들러(Handler) 클래스
     * 이벤트 리스너를 상속받아 구현한 클래스
     * 이벤트 발생 시 처리할 동작을 기술
     * 
     * 이벤트 처리를 위한 핸들러(Handler)클래스 구현
     * 1단계. XXXListener 인터페이스를 구현하는 서브클래스를 정의
     * ->외부 클래스 형태로 별도의 핸들러 클래스 정의
     * -특정 이벤트 처리를 위한 리스너 구현
     * 
     * 2단계. XXXListener 에 대응하는 XXXAdapter 클래스를 상속받는 서브클래스 정의
     * 추상메서드가 2개 이상인 리스너 인터페이스에는 어댑터 클래스(추상클래스)가 제공됨.
     * 원하는 메서드만 선택해서 오버라이딩 가능
     * 추상메서드가 1개뿐인 리스너 인터페이스(ex, ActionListener)는 어댑터 클래스가 없음.
     */
    
    public ExStage2() {
        showFrame();
    }
    
    private void showFrame() {
        setTitle("이벤트처리 2단계");
        setBounds(500, 400, 300, 200);
//        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        /*
         * 2단계 : 어댑터 클래스를 상속받은 핸들러 클래스의 인스턴스 생성 및 연결
         */
        MyWinAdapter adapter=new MyWinAdapter();
        addWindowListener(adapter);
        
        JButton btn= new JButton("Button");
        add(btn);
        
        
        setVisible(true);
        
        
    }
 
    public static void main(String[] args) {
        
        new ExStage2();
        
    }
 
}
 
 
/*
 * 윈도우(프레임)에 대한 동작을 처리하는 리스너를 구현하는 핸들러(MyWindowListener 클래스) 정의
 * 윈도우에 대한 이벤트를 감지하는 리스너 인터페이스=WindowListener인터페이스
 * 추상메서드가 2개 이상이므로 WindowAdapter 클래스가 별도로 제공됨 
 */
 
    class MyWinAdapter extends WindowAdapter{
        /*
         * 기존 리스너 인터페이스의 추상메서드를 모두 구현한 상태로 가지고 있으므로
         * 추상메서드에 대한 오버라이딩 강제가 발생하지 않는다.-> 메서드 선택 오버라이딩 가능
         */
        
 
        @Override
        public void windowClosing(WindowEvent e) {
            //창 닫기 버튼에 대한 기능 구현
            System.out.println("windowClosing");
            System.exit(0);
        }
}
 
 
package inner_class_stage5;
 
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
public class ExStage3 extends JFrame {
    
    /*
     * 이벤트(Event)
     * 특정 컴포넌트(버튼, 윈도우 등)에 발생한 동작(기능)
     * ex) 버튼 클릭, 창 닫기 버튼클릭, 라디오버튼 선택, 체크박스 체크 등
     * 이벤트가 발생했을 때 어떤 동작을 취하려면, 이벤트 대상과 이벤트 리스너를 연결해야함
     * 
     * 이벤트 리스너(Event Listener)
     * 특정 컴포넌트에 발생한 이벤트를 감지하는 객체
     * 주로 인터페이스로 제공됨(ex, XXXListener 인터페이스)
     * 각 이벤트에 따라 각각의 리스너 인터페이스가 제공
     * ex) 버튼클릭 이벤트=ActionListener, 키보드 입력 이벤트=KeyLisener 등)
     * 
     * 핸들러(Handler) 클래스
     * 이벤트 리스너를 상속받아 구현한 클래스
     * 이벤트 발생 시 처리할 동작을 기술
     * 
     * 이벤트 처리를 위한 핸들러(Handler)클래스 구현
     * 1단계. XXXListener 인터페이스를 구현하는 서브클래스를 정의
     * ->외부 클래스 형태로 별도의 핸들러 클래스 정의
     * -특정 이벤트 처리를 위한 리스너 구현
     * 
     * 2단계. XXXListener 에 대응하는 XXXAdapter 클래스를 상속받는 서브클래스 정의
     * 추상메서드가 2개 이상인 리스너 인터페이스에는 어댑터 클래스(추상클래스)가 제공됨.
     * 원하는 메서드만 선택해서 오버라이딩 가능
     * 추상메서드가 1개뿐인 리스너 인터페이스(ex, ActionListener)는 어댑터 클래스가 없음.
     * 
     * 3단계. 핸들러 클래스를 내부 클래스(Inner Class)형태로 구현
     */
    
    public ExStage3() {
        showFrame();
    }
    
    private void showFrame() {
        setTitle("이벤트처리 3단계");
        setBounds(500, 400, 300, 200);
//        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        
        //3단계. 핸들러 클래스를 내부 클래스(Inner Class)형태로 구현
        //-> 다른 외부클래스들과 이름이 중복되어도 무관함(외부클래스명$내부클래스명.class로 클래스파일 생성됨)
        //로컬내부 클래스형태로 정의(메서드 내에 내부 클래스 형태로 정의)
        //로컬 변수처럼 메서드 내에서만 접근 가능 = 다른 메서드에서 인스턴스 생성 X
 
//        class MyInnerWinAdapter extends WindowAdapter{
//                @Override
//                public void windowClosing(WindowEvent e) {
//                    //창 닫기 버튼에 대한 기능 구현
//                    System.out.println("windowClosing");
//                    System.exit(0);
//                }
//        }
//        
        /*
         * 2단계 : 어댑터 클래스를 상속받은 핸들러 클래스의 인스턴스 생성 및 연결
         */
        MyInnerWinAdapter adapter=new MyInnerWinAdapter();
        addWindowListener(adapter);
        
        JButton btn= new JButton("Button");
        add(btn);
        
        
        setVisible(true);
        
        
    }
 
    public static void main(String[] args) {
        
        new ExStage3();
        
    }
    
//    //3단계. 핸들러 클래스를 내부 클래스(Inner Class)형태로 구현
//    //-> 다른 외부클래스들과 이름이 중복되어도 무관함(외부클래스명$내부클래스명.class로 클래스파일 생성됨)
//    // 인스턴스 내부 클래스 형태로 정의(클래스 내, 메서드바깥에 정의)
    //클래스 내의 여러 메서드에서 접근 가능(=인스턴스 생성 가능)
    class MyInnerWinAdapter extends WindowAdapter{
            @Override
            public void windowClosing(WindowEvent e) {
                //창 닫기 버튼에 대한 기능 구현
                System.out.println("windowClosing");
                System.exit(0);
            }
    }
 
 
}
//ExStage3 끝
 
 
package inner_class_stage5;
 
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
public class ExStage4 extends JFrame {
    
    /*
     * 이벤트(Event)
     * 특정 컴포넌트(버튼, 윈도우 등)에 발생한 동작(기능)
     * ex) 버튼 클릭, 창 닫기 버튼클릭, 라디오버튼 선택, 체크박스 체크 등
     * 이벤트가 발생했을 때 어떤 동작을 취하려면, 이벤트 대상과 이벤트 리스너를 연결해야함
     * 
     * 이벤트 리스너(Event Listener)
     * 특정 컴포넌트에 발생한 이벤트를 감지하는 객체
     * 주로 인터페이스로 제공됨(ex, XXXListener 인터페이스)
     * 각 이벤트에 따라 각각의 리스너 인터페이스가 제공
     * ex) 버튼클릭 이벤트=ActionListener, 키보드 입력 이벤트=KeyLisener 등)
     * 
     * 핸들러(Handler) 클래스
     * 이벤트 리스너를 상속받아 구현한 클래스
     * 이벤트 발생 시 처리할 동작을 기술
     * 
     * 이벤트 처리를 위한 핸들러(Handler)클래스 구현
     * 1단계. XXXListener 인터페이스를 구현하는 서브클래스를 정의
     * ->외부 클래스 형태로 별도의 핸들러 클래스 정의
     * -특정 이벤트 처리를 위한 리스너 구현
     * 
     * 2단계. XXXListener 에 대응하는 XXXAdapter 클래스를 상속받는 서브클래스 정의
     * 추상메서드가 2개 이상인 리스너 인터페이스에는 어댑터 클래스(추상클래스)가 제공됨.
     * 원하는 메서드만 선택해서 오버라이딩 가능
     * 추상메서드가 1개뿐인 리스너 인터페이스(ex, ActionListener)는 어댑터 클래스가 없음.
     * 
     * 3단계. 핸들러 클래스를 내부 클래스(Inner Class)형태로 구현
     * 
     * 4단계. 익명 내부 클래스(Anonymous Inner Class)형태로 구현
     * 별도의 핸들러 클래스를 정의하지 않고, 리스너(또는 어댑터)이름을 사용하여
     * 변수 선언과 동시에 클래스를 정의 및, 인스턴스 생성까지 한 번에 수행하는 것
     * -> 리스너인터페이스명 변수명= new 리스너인터페이스명(){
     *                 리스너에 정의된 추상메서드 오버라이딩
     *         };
     */
    
    public ExStage4() {
        showFrame();
    }
    
    private void showFrame() {
        setTitle("이벤트처리 3단계");
        setBounds(500, 400, 300, 200);
//        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        //4단계. 익명 내부 클래스(Anonymous Inner Class)형태로 구현
        // 로컬 익명내부클래스
        WindowAdapter adapter=new WindowAdapter() {
 
            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("windowClosing");
                System.exit(0);
            }
            
        };
        
        //4단계. 익명 내부 클래스 형태로 구현된 핸들러 객체 바로 전달 가능
        
        addWindowListener(adapter);
//        addWindowListener(listener);
        
        JButton btn= new JButton("Button");
        add(btn);
        
        
        setVisible(true);
        
        
    }
 
    public static void main(String[] args) {
        
        new ExStage4();
        
    }
    
 
    //4단계. 익명 내부 클래스(Anonymous Inner Class)형태로 구현
    //1) 익명 내부클래스로 사용할 리스너(또는 어댑터)클래스의 변수 선언과 동시에
    //  new 키워드를 사용하여 해당 객체생성(원래는 객체생성이 불가능한 타입)
    //2) 객체 생성시 추가되는 중괄호{} 내부에 추상메서드를 오버라이딩하여 구현
//    WindowAdapter adapter=new WindowAdapter() {
//
//        @Override
//        public void windowClosing(WindowEvent e) {
//            System.out.println("windowClosing");
//            System.exit(0);
//        }
//        
//    };
    //인스턴스 익명 내부 클래스
    WindowListener listener=new WindowListener() {
        
        @Override
        public void windowOpened(WindowEvent e) {
            // TODO Auto-generated method stub
            
        }
        
        @Override
        public void windowIconified(WindowEvent e) {
            // TODO Auto-generated method stub
            
        }
        
        @Override
        public void windowDeiconified(WindowEvent e) {
            // TODO Auto-generated method stub
            
        }
        
        @Override
        public void windowDeactivated(WindowEvent e) {
            // TODO Auto-generated method stub
            
        }
        
        @Override
        public void windowClosing(WindowEvent e) {
            System.out.println("windowClosing");
            System.exit(0);
            
        }
        
        @Override
        public void windowClosed(WindowEvent e) {
            // TODO Auto-generated method stub
            
        }
        
        @Override
        public void windowActivated(WindowEvent e) {
            // TODO Auto-generated method stub
            
        }
    };
 
 
}
//ExStage4 끝
 
package inner_class_stage5;
 
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JRadioButton;
 
public class ExStage5 extends JFrame {
    
    /*
     * 이벤트(Event)
     * 특정 컴포넌트(버튼, 윈도우 등)에 발생한 동작(기능)
     * ex) 버튼 클릭, 창 닫기 버튼클릭, 라디오버튼 선택, 체크박스 체크 등
     * 이벤트가 발생했을 때 어떤 동작을 취하려면, 이벤트 대상과 이벤트 리스너를 연결해야함
     * 
     * 이벤트 리스너(Event Listener)
     * 특정 컴포넌트에 발생한 이벤트를 감지하는 객체
     * 주로 인터페이스로 제공됨(ex, XXXListener 인터페이스)
     * 각 이벤트에 따라 각각의 리스너 인터페이스가 제공
     * ex) 버튼클릭 이벤트=ActionListener, 키보드 입력 이벤트=KeyLisener 등)
     * 
     * 핸들러(Handler) 클래스
     * 이벤트 리스너를 상속받아 구현한 클래스
     * 이벤트 발생 시 처리할 동작을 기술
     * 
     * 이벤트 처리를 위한 핸들러(Handler)클래스 구현
     * 1단계. XXXListener 인터페이스를 구현하는 서브클래스를 정의
     * ->외부 클래스 형태로 별도의 핸들러 클래스 정의
     * -특정 이벤트 처리를 위한 리스너 구현
     * 
     * 2단계. XXXListener 에 대응하는 XXXAdapter 클래스를 상속받는 서브클래스 정의
     * 추상메서드가 2개 이상인 리스너 인터페이스에는 어댑터 클래스(추상클래스)가 제공됨.
     * 원하는 메서드만 선택해서 오버라이딩 가능
     * 추상메서드가 1개뿐인 리스너 인터페이스(ex, ActionListener)는 어댑터 클래스가 없음.
     * 
     * 3단계. 핸들러 클래스를 내부 클래스(Inner Class)형태로 구현
     * 
     * 4단계. 익명 내부 클래스(Anonymous Inner Class)형태로 구현
     * 별도의 핸들러 클래스를 정의하지 않고, 리스너(또는 어댑터)이름을 사용하여
     * 변수 선언과 동시에 클래스를 정의 및, 인스턴스 생성까지 한 번에 수행하는 것
     * -> 리스너인터페이스명 변수명= new 리스너인터페이스명(){
     *                 리스너에 정의된 추상메서드 오버라이딩
     *         };
     * 
     * 5단계. 익명 내부 클래스의 임시 객체 형태로 구현 및 사용
     * 익명 내부 클래스의 변수를 별도로 선언하지 않고 객체 생성 부분만 사용하기 위해
     * 파라미터에 변수 대신 객체 생성 부분을 그대로 전달하여
     * 객체 생성및 메서드 오버라이딩까지 한번에 수행하는 형태
     * 
     * ->addXXXListener(new 리스너인터페이스명(){추상메서드구현});
     * 구현된 객체는 1회용으로, 다른 곳에서 접근 불가능(=레퍼런스 변수가 없기 때문에)
     * 
     */
    
    public ExStage5() {
        showFrame();
    }
    
    private void showFrame() {
        setTitle("이벤트처리 5단계");
        setBounds(500, 400, 300, 200);
//        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        
        //5단계. 익명 내부 클래스의 임시 객체 형태로 구현 및 사용
        //메서드파라미터에 바로 익명 클래스 객체 생성하면서 구현
        
        addWindowListener(new WindowAdapter() {
 
            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("windowClosing");
                System.exit(0);
            }
            
        });
//        addWindowListener(listener);
        
        JButton btn= new JButton("Button");
        getContentPane().add(btn);
        
        
        setVisible(true);
        
        
    }
 
    public static void main(String[] args) {
        
        new ExStage5();
        
    }
    
 
    //4단계. 익명 내부 클래스(Anonymous Inner Class)형태로 구현
    //1) 익명 내부클래스로 사용할 리스너(또는 어댑터)클래스의 변수 선언과 동시에
    //  new 키워드를 사용하여 해당 객체생성(원래는 객체생성이 불가능한 타입)
    //2) 객체 생성시 추가되는 중괄호{} 내부에 추상메서드를 오버라이딩하여 구현
//    WindowAdapter adapter=new WindowAdapter() {
//
//        @Override
//        public void windowClosing(WindowEvent e) {
//            System.out.println("windowClosing");
//            System.exit(0);
//        }
//        
//    };
    
    
 
 
}
//ExStage5 끝
 
 
 

 

JFrame을 활용하기 위한 여러 방법을 배워보았는데 간단하게 창을 닫았을 때 작동하는 메서드를 오버 라이딩해서 사용해 보았는데 1단계~5단계까지의 순서로 방법이 있는데 4,5단계를 가장 많이 사용하는데 5단계는  new 생성을 1회용으로 사용하고 다른 곳에서는 사용을 못하기 때문에 다른 곳에서도 다시 new 생성을 해줘야 하지만 간단하게 필요한 기능을 넣어줄 수 있고, 4단계의 방법으로는 클래스를 따로 생성하기 때문에 간단하게 불어와서 여러 군데에 적용을 할 수 있다는 장점이 있다. 4,5단계를 잘 기억해두자!