코마리와 함께하는 개발여행

이벤트, 이벤트 소스, 이벤트 핸들러란?
이벤트(event) : 프로그램과 사용자간의 상호작용을 위해서 사용자가 키보드나 마우스 등의 장치를 통해서 응용 프로그램에 어떤 요구를 하는 사건을 말합니다.
이벤트 리스너(event listener) : 이벤트를 기다렸다가 이벤트가 발생하게 되면 전달되어오는 이벤트 소스 객체로 적당한 처리를 하게 되는 객체를 말합니다.
이벤트 소스(event source) : 버튼(Button)이나 스크롤바(Scrollbar)와 같이 이벤트가 발생한 컴포넌트 객체를 말합니다.

이벤트 처리 방법
1. 이벤트 패키지 임폴트 : import java.awt.event.*;
2. 처리할 이벤트에 대한 이벤트 리스너의 설계
public class ButtonListener implements ActionListener {
}
ActionListener는 이벤트 처리를 담당하는 이벤트 리스너 인터페이스
ButtonListener는 ActionListener 인터페이스를 구현하여 만든 이벤트 리스너 클래스
이벤트 리스너 클래스(ButtonListener)는 인터페이스를 구현한 것이므로 인터페이스 내부의 추상 메서드를 오버라이딩 해서 구현해야 한다.
ActionListener 인터페이스는 actionPerformed 메서드 한개만 추상 메서드로 가진다.
이 메서드는 버튼에 이벤트가 발생하면 호출되는 메서드이다.
3. 이벤트 리스너 객체를 생성한다.
4. 이벤트를 받아들인 컴포넌트 객체에 리스너를 등록한다.

아래는 레드,블루 버튼을 클릭하는 이벤트가 발생하면 배경이미지가 바뀌는 이벤트 처리
소스이다.
===================================================================================
package pack05;
import java.awt.Button;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
// FrameEx가 두가지 역할(프레임으로서, 이벤트처리객체로서)을 하도록
class FrameEx extends Frame implements ActionListener{
 Button redBtn, blueBtn ;
 // actionPerformed의 전달인자인 ActionEvent가 이벤트소스에 정보를 갖고 있다.
 public void actionPerformed(ActionEvent e){
  System.out.println(e.getActionCommand()+"버튼이 눌림");
  if(e.getActionCommand().equals("빨간색")){
   setBackground(Color.RED);
  }
  else if(e.getActionCommand().equals("파란색")){
   setBackground(Color.BLUE);
  }
 }
 FrameEx(){
  // 배치관리자로 플로우 레이아웃 지정
  // 빨간색 버튼을 redBtn으로
  // 파란색 버튼을 blueBtn으로 생성
  // 프레임 크기를 300,200으로 설정
  // 눈에 보이도록 한다.
  setLayout(new FlowLayout());
  redBtn=new Button("빨간색");
  blueBtn=new Button("파란색");
  // 이벤트 소스인 버튼과 이벤트처리객체를 연결해 주어야 한다.
  redBtn.addActionListener(this);
  blueBtn.addActionListener(this);
  add(redBtn);
  add(blueBtn);
  setSize(300,200);
  setVisible(true);
 }
}
public class Ex01 {
 public static void main(String[] args) {
  new FrameEx();
 }
}
===================================================================================
윈도우 창에 X버튼을 누르면 창이 닫히도록 하기(윈도우리스너 인터페이스로 구현)
package training;
import java.awt.Button;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
// [닫기]버튼이 눌리면 창이 닫히도록 WindowListener 인터페이스 상속 받음
class FrameEvent extends Frame implements ActionListener, WindowListener{
 public void windowActivated(WindowEvent arg0) {  
 }
 public void windowClosed(WindowEvent arg0) {
 }
 // [닫기]버튼이 눌러졌을 때 호출되는 메소드
 public void windowClosing(WindowEvent arg0) {
  dispose();
  System.exit(0);
 }
 public void windowDeactivated(WindowEvent arg0) {
 }
 public void windowDeiconified(WindowEvent arg0) {
 }
 public void windowIconified(WindowEvent arg0) {
 }
 public void windowOpened(WindowEvent arg0) {
 }
 public void actionPerformed(ActionEvent e) {
  System.out.println(e.getActionCommand()+"버튼이 눌림");
  Object o=e.getSource();
  if(o==redBtn){
   setBackground(Color.RED);
  }
  else if(o==blueBtn){
   setBackground(Color.BLUE);
  }
 }
 // 클래스 내의 멤버(필드)로 버튼에 대한 레퍼런스 변수를 선언해야 한다.
 Button redBtn, blueBtn;
 FrameEvent(){
  setLayout(new FlowLayout());
  redBtn=new Button("빨간색");
  blueBtn=new Button("파란색");
  // 이벤트 소스인 버튼과 이벤트 처리 객체와 연결
  redBtn.addActionListener(this);
  blueBtn.addActionListener(this);
  // 이벤트 소스인 프레임과 이벤트 처리 객체와 연결
  this.addWindowListener(this);
  add(redBtn);
  add(blueBtn);
  setSize(400,300);
  setVisible(true);
 }
}
public class Ex01 {
 public static void main(String[] args) {
  new FrameEvent();
 }
}
===================================================================================
윈도우 어댑터 클래스를 통한 구현
package pack01;
import java.awt.Button;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
class FrameEvent extends Frame implements ActionListener{
 public void actionPerformed(ActionEvent e) {
  System.out.println(e.getActionCommand()+"버튼이 눌림");
  Object o=e.getSource();
  if(o==redBtn){
   setBackground(Color.RED);
  }
  else if(o==blueBtn){
   setBackground(Color.BLUE);
  }
 }
 // 클래스 내의 멤버(필드)로 버튼에 대한 레퍼런스 변수를 선언해야 한다.
 Button redBtn, blueBtn;
 FrameEvent(){
  setLayout(new FlowLayout());
  redBtn=new Button("빨간색");
  blueBtn=new Button("파란색");
  // 이벤트 소스인 버튼과 이벤트 처리 객체와 연결
  redBtn.addActionListener(this);
  blueBtn.addActionListener(this);
  add(redBtn);
  add(blueBtn);
  setSize(400,300);
  setVisible(true);
  SubClass sc=new SubClass();
  addWindowListener(sc);
 }

 // 창이 닫히도록 하기 위해서 필요한 메소드 : WindowClosing();
 class SubClass extends WindowAdapter{
  public void windowClosing(WindowEvent e) {
   dispose(); // 창(프레임)을 소멸
   System.exit(0); // 프로세스 죽임
  }
 }
} // Frame 클래스의 끝
public class Ex01 {
 public static void main(String[] args) {
  new FrameEvent();
 }
}
===================================================================================
외부 클래스와 내부 클래스
package pack01;
class Outer{ // 외부클래스
 int data=100;
 class Inner{ // 내부클래스 : 외부클래스의 모든 멤버를 가져다 사용할 수 있다.
  int b=200;
  public void printData(){
   System.out.println(data);
  }
 } // inner 클래스의 끝
} // outer 클래스의 끝
public class Ex02 {
 public static void main(String[] args) {
 
 }
}
===================================================================================
package pack01;
import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
class FrameExit extends Frame{
 FrameExit(){
  setSize(400,300);
  setVisible(true);
  // 이벤트 소스와 이벤트 처리 객체와 연결되어야 함
  this.addWindowListener(
   // WindowAdapter를 슈퍼로 갖는 서브클래스 설계 시작
   new WindowAdapter() {
    @Override
    public void windowClosing(WindowEvent e) {
     System.out.println("WindowClosing 메소드 호출");
     dispose();
     System.exit(0);
    }    
   } // 클래스 설계 끝
  ); // addWindowListener 메소드 호출
 }

}
public class Ex03 {
 public static void main(String[] args) {
  new FrameExit();
 }
}
===================================================================================

/*배열은 원소의 자료형태가 결정
int []s=new int[5];
String []name=new String[5];

컬렉션 클래스의 설계 원리
- 자료구조(알고리즘) - 해쉬 테이블 혹은 ArrayList가 일반화되어 정의
- 원소들을 자바의 최상위 클래스 Object 형으로 저장하도록 설계
- 원소가 추가되는 순간에 업캐스팅

ArrayList []s=new ArrayList(); // 점수를 저장하기 위한 용도 : 원소가 Object형
ArrayList []name=new ArrayList(); // 이름을 저장하기 위한 용도 : 원소가 Object형
[1.4버전까지의 컬렉션 클래스의 단점]
1. 하나의 ArrayList 객체의 원소 자료형이 혼합되어서 사용될수 있다는 단점
2. 원소를 추출한 후에는 다운캐스팅을 위한
   명시적인 형변환을 해야함(캐스트 연산자로)
   name.add("이강국");
   name.add(10); // 원소의 자료형이 혼합되어 사용 됨
   String str=(String)name.get(0); // Object 형이므로, 다운캐스팅이 필요하다.

제너릭 클래스 : 컬렉션 클래스에서 사용되는 JDK5.0에서 새롭게 나온 개념
하나의 클래스가 알고리즘을 적용받을 수 있는 원소의 자료형을 다양하게 하기 위해서
제너릭 클래스란 개념을 5.0에서 가져다 사용
제너릭 클래스는 로직만 구현하고 원소들의 자료형태에 대해서는 언급하지 않음

객체를 생성할 때에는 자료형을 언급해야 함.
ArrayList<Integer> []s=new ArrayList<Integer>(); // 원소 : Integer
ArrayList<String> []name=new ArrayList<String>(); // 원소 : String
name.add("조현상");
name.add(10); // 에러 남 : 원소의 자료형이 혼합되어 사용되지 못함
String str=name.get(0); // 다운캐스팅이 필요없다.*/

// 문자를 가져다가 대문자로 출력하기
package training;
import java.util.ArrayList;
public class Ex01 {
 public static void main(String[] args) {
  // JDK 1.4에서 사용되던 컬렉션 클래스
  ArrayList list = new ArrayList();
  list.add("apple"); // 내부적으로 저장될때에는 Object 형으로 업캐스팅됨 
  list.add("banana");
  list.add("orange");
  list.add("3"); // 단점 : 원소들의 자료형이 혼합되어 사용
  // list에 저장된 원소들을 갖다가 대문자로 출력하기
  for(int i=0;i<list.size();i++){
   System.out.println(list.get(i)+" ");
   // 대문자로 변환하기 위한 메소드로 toUpperCase가
   // String 클래스에서 제공된다.
   // 단점 : 다운 캐스팅을 위해 캐스트 연산자를 기술해야 한다.
   String item=(String)list.get(i);
   System.out.println(item.toUpperCase());
  } 
 }
}
===============점수 5개로 총점과 평균을 구하기 1. 배열 ==============================
// 배열 : 배열의 크기가 변경되지 않는다. 배열에 원소를 추가하거나 삭제할 수 없다.
// ArrayList : 배열의 크기가 변경 되고 배열에 원소를 추가하거나 삭제할 수 있다.
public class Ex03 {
 public static void main(String[] args) {
  int [] a={90, 85, 70, 80, 95};
  int tot=0;
  for(int i=0;i<a.length;i++){
   System.out.println(a[i] + " ");
   tot+=a[i];
  }
  System.out.println("\n 총점 : " + tot);
  System.out.println("\n 평균 : " + tot/a.length);
 }
}
===============점수 5개로 총점과 평균을 구하기 2. ArrayList===========================
import java.util.ArrayList;
public class Ex04 {
 public static void main(String[] args) {
  ArrayList list=new ArrayList();
  System.out.println("원소의 갯수 : "+list.size());
  list.add(90);
  list.add(85);
  list.add(70);
  list.add(80);
  list.add(95);
  System.out.println("원소의 갯수 : "+list.size());
  int tot=0;
  for(int i=0;i<list.size();i++){
   System.out.println(list.get(i) + " ");
   tot=tot+(Integer)list.get(i);
   // tot=tot+list.get(i);
  }
  System.out.println("\n 총점 : " + tot);
  System.out.println("\n 평균 : " + tot/list.size());
 }
}
===================================================================================
package training;
import java.util.ArrayList;
public class Ex01 {
 public static void main(String[] args) {
  // JDK 1.4에서 사용되던 컬렉션 클래스
  ArrayList list = new ArrayList();
  list.add("apple"); // 내부적으로 저장될때에는 Object 형으로 업캐스팅됨 
  list.add("banana");
  list.add("orange");
  list.add("3"); // 단점 : 원소들의 자료형이 혼합되어 사용
  // list에 저장된 원소들을 갖다가 대문자로 출력하기
  for(int i=0;i<list.size();i++){
   System.out.println(list.get(i)+" ");
   // 대문자로 변환하기 위한 메소드로 toUpperCase가
   // String 클래스에서 제공된다.
   // 단점 : 다운 캐스팅을 위해 캐스트 연산자를 기술해야 한다.
   String item=(String)list.get(i);
   System.out.println(item.toUpperCase());
  } 
 }
}
===================================================================================
package training;
import java.util.ArrayList;
public class Ex02 {
 public static void main(String[] args) {
  // 단점 : 원소들의 자료형이 혼합되어 사용되지 않도록
  // 단점 : 다운 캐스팅하지 않도록
  // JDK5.0부터 컬렉션 클래스를 제너릭 클래스 형태로 제공
  // 객체 생성 시, 원소의 자료형들을 결정하기
  // 제너릭_컬렉션 클래스 <원소의 자료형>
  ArrayList<String> list = new ArrayList<String>();
  list.add("apple");  
  list.add("banana");
  list.add("orange");
  // list.add(3); // 원소들의 자료형이 혼합되어 사용되지 않도록
  for(int i=0;i<list.size();i++){
   System.out.println(list.get(i)+" ");  
   String item=list.get(i);
   // String형으로 다운캐스팅 하지 않아도 된다.
   System.out.println(item.toUpperCase());
  } 
 }
}
===================================================================================
package training;
import java.util.Enumeration; // import를 하기 위해서 <ctrl>+<shift>+o(영문)
import java.util.Hashtable;
public class Ex03 {
 public static void main(String[] args) {
  // key, value를 쌍으로 저장하는 해쉬 테이블
  // "이강국" 65.5
  Hashtable<String, Double>ht=new Hashtable<String, Double>();
  ht.put("이강국", 63.5);
  ht.put("김재필", 68.5);
  ht.put("김경윤", 70.5);
  System.out.println(ht.get("이강국"));
  // 해쉬 테이블에 저장된 모든 정보를 얻어오기
  Enumeration<String> name=ht.keys();
  while(name.hasMoreElements()){
   String key=name.nextElement();
   Double weight=ht.get(key);
   System.out.println(key + " : " + weight);
  }
 }
}
===================================================================================

자바에는 클래스 수백 개가 내장되어 있습니다. 우리는 필요한 것을 찾는 방법을 알아내어 자신의 애플리케이션에서 사용할 부분만 새로 만들면 됩니다.

자바 API에서 클래스는 패키지 단위로 묶여 있습니다.
API에 들어있는 클래스를 사용하려면 그 클래스가 어떤 패키지에 들어있는지 알아야합니다.
자바 패키지의 종류는
java.lang : 필수 요소
java.util : 자바 유틸리티
java.swing : 스윙 클래스

어떤 클래스를 사용하려면 클래스의 전체 이름을 알아야합니다.
ArrayList 는 java.util 패키지에 들어있으며 java.util.ArrayList 로 쓰면 됩니다.

패키지의 클래스를 사용할지 알려주는 방법은 아래와 같습니다.
1. import 선언문을 쓰는 경우
소스 코드 파일 맨 위에서 import 선언문을 사용합니다.
import java.util.ArrayList;
public class MyClass {...}
2. 일일이 입력합니다.
코드에서 일일이 전체 이름을 입력합니다. 언제,어디서나 직접 타이핑을 해야한다는 단점이 있네요.
객체를 선언하고 인스턴스를 만들 때:
java.util.ArrayList<Dog> list = new java.util.ArrayList<Dog>;
인자 유형으로 사용할 때 :
public void go(java.util.ArrayList<Dog> list) {}
리턴 유형으로 사용할 때 :
public java.util.ArrayList<Dog> foo() {}

ArrayList에 들어있는 메소드는 아래와 같습니다.
add(Object elem) : 객체 매개변수(elem)를 목록에 추가합니다. -> 뭔가를 집어넣을 때
romove(int index) : index 매개변수로 지정한 위치에 있는 객체를 제거합니다 -> 뭔가를 제거할 때
indexOf(Object elem) : 객체 매개변수(elem)의 인덱스 또는 -1을 리턴합니다 -> ArrayList에 들어있는 어떤 것의 위치를 확인하거나 알고 싶을 때
isEmpty() : 목록에 아무 원소도 없으면 '참'을 리턴합니다 -> ArrayList가 비어있는지 확인할 때
size() : 현재 목록에 들어있는 원소의 개수를 리턴합니다 -> ArrayList의 크기(원소의 개수)를 알고 싶을 때
length : 일반 배열의 길이(원소의 개수)를 알고 싶을 때
cotains(Object elem) : 객체 매개변수(elem)에 매치되는 것이 있으면 '참'을 리턴합니다.
get(int index) : 주어진 index 매개변수 위치에 있는 객체를 리턴합니다.

1. ArrayList는 필요에 따라 그 크기가 동적으로 바뀝니다. 객체가 추가되면 커지고, 제거되면 작아집니다.
2. ArrayList에 저장할 객체 유형은 유형 이름을 <>안에 집어넣은 형태의 유형 매개변수(type parameter)로 선언합니다. ex : ArrayList <Button> 은 Button(또는 Button의 서브클래스) 유형의 객체만 넣을 수 있는 ArrayList
3. ArrayList에는 원시 유형의 값은 저장할 수 없고 일반 객체만 저장할 수 있지만, 컴파일러에서 원시값을 Object 객체로 감싸고 그 객체를 원시 유형이 아닌 ArrayList에 저장하는(또는 그와 반대로 가는) 일을 자동으로 처리해줍니다.
4. java.lang을 제외한 다른 패키지에 들어있는 클래스를 사용하려면 전체 이름을 알려줘야 합니다.

ArrayList와 일반 배열의 차이점
1. 기존의 일반 배열은 만들어질 때부터 유형과 이름이 정해지지만, ArrayList에서는 ArrayList 유형의 객체만 만들면 됩니다. 객체를 추가하거나 제거하면 자동으로 커지거나 작아지므로 크기를 따로 지정할 필요가 없어요.
ex : new String[2]
      new ArrayList <String>{}
2. 객체를 일반 배열에 집어넣을 때는 위치를 지정해야 합니다.(즉 0이상, 배열의 길이에서 1을 뺀 숫자 이하의 인덱스를 지정해야 합니다) ex : myList[1] = b;
ArrayList는 add(정수,객체) 메소드를 써서 인덱스를 지정하거나 그냥 add(객체)라고만 하면 자동으로 새로 추가된 객체가 들어갈 자리가 만들어집니다. ex : myList.add(b);
3. 배열을 쓸 때는 자바의 다른 부분에서는 쓰지 않는 배열 전용 문법을 써야 합니다.
하지만 ArrayList는 일반 자바 객체기 때문에 특별한 전용 문법을 쓸 필요가 없습니다.
ex : myList[1] -> 배열전용 대괄호([])는 배열에서만 쓰이는 특별한 기호입니다.
4. 자바 5.0에서는 배열이 매개변수화되어 있습니다.
ArrayList<String> : <>안의 String은 "유형 매개변수(type parameter)"입니다.

초강력 부울 표현식
'AND'와 'OR' 연산자 '&&' , '||'
1. 가격이 300달러 이상, 400달러 미만이면 X를 선택한다
if (price >= 300 && price <=400 ) {
camera = X;
}
2. 카메라 브랜드가 총 열개 있는데 그 중 브랜드 몇개에 대해 어떤 작업을 하고 싶을 경우
if (brand.equals("A") || brand.equals("B")) {
A 브랜드 또는 B 브랜드에만 적용할 내용
}
같지 않음 ( != , ! )

P.S 소스 코드를 이해하는 부분은 2차 개정판에서 다룰 예정입니다.
Heas First 자바를 두번이상 읽을수 있는 시간을 꼭 내겠습니다. ^^;

클래스 개발 일반론

1. 클래스에서 어떤 것을 해야 하는지 파악한다.
2. 인스턴스 변수와 메소드 목록을 작성합니다.
3. 메소드를 만들기 위한 준비 코드를 만듭니다.
4. 메소드에 대한 테스트 코드를 만듭니다.
5. 클래스를 구현합니다.
6. 메소드를 테스트합니다.

각 클래스별로 준비 코드, 테스트 코드, 실제 코드
준비 코드 : 논리 위주의 유사코드를 표현한다. (어떻게 해야할지가 아니라 무엇을 해야할지를 기술한다.)
테스트 코드 : 실제 코드를 테스트하고 작업이 제대로 처리되는지 확인하기 위한 클래스 또는 메소드(준비 코드를 기준으로 작성한다.)
실제 코드 : 클래스를 실제로 구현한 코드

익스트림 프로그래밍 방법(XP)
조금씩, 하지만 자주 발표한다.
사이클을 반복해서 돌리면서 개발한다.
스팩에 없는 것은 절대 집어넣지 않는다.
테스트 코드를 먼저 만든다.
모든 테스트를 통과하기 전에는 어떤 것도 발표하지 않는다.
조금씩 발표하는 것을 기반으로 하여 현실적인 작업 계획을 만든다.
모든 일을 단순하게 처리한다.
두 명씩 팀을 편성하고 모든 사람이 대부분의 코드를 알 수 있도록 돌아가면서 작업한다.
효과
야근을 안한다. 항상 정규 일과 시간에만 작업을 할 수 있다.
기회가 생기는 족족 언제 어디서든 코드를 개선 할 수 있다.

for 순환문

for ( int i=0 ; i < 100 ; i++ ) { }
이 코드는 정수형 변수 i를 0으로 초기화하고 i가 100보다 작을 경우 i를 후증가연산자로 계속해서 순환하라는 뜻

int i = 0
초기화 : 변수를 선언하는 부분
i < 100
부울 테스트 : 조건 테스트가 들어가는 자리(부울값을 리턴하는 메소드가 들어가는 경우도 있다.)
i++
반복 표현식 : 순환문이 한 번 반복될때마다 실행할 내용이 들어감

for와 while의 차이점
while 순환문은 부울 테스트만 들어갈 수 있다. 초기화 및 반복 표현식을 내장 시킬 수 없다.
반복 횟수를 알 수 없을 때 어떤 조건이 만족되는 동안 계속 반복하는 경우에 유용하다.

for 순환문은 반복 횟수를 알고 있을 경우 유용하다.

++ , -- : 선/후 증가/감소 연산자
변수의 앞 뒤에서 쓰일 경우 변수 +1, -1 의 효과를 가져온다.
int x = 0 ; int z = ++x ;
int x = 0 ; int z = x++ ;

향상된 for 순환문
" String[] nameArray = { " ", " ", " " }; "
for (String name : nameArray) { }
위 코드는 nameArray에 들어 있는 각 원소에 대해서 각각의 원소를 name 변수에 저장한 다음 순환문을 실행시킨다.

String name : 선언된 변수(nameArray) 유형인 String와 반드시 동일해야 한다.
: -> in의 의미
nameArray : 반복 작업의 대상이 되는 원소들의 컬렉션

String을 int로 변환하는 방법
Integer.parseInt("3")
Integer : 자바 클래스 라이브러리에 있는 클래스로 숫자를 나타내는 String을 받아서 그 문자열을 진짜 숫자로 변환 해 주는 기능이 있는 클래스
parseInt : String을 그 문자열이 나타내는 int로 '파싱하는' 방법을 알고 있는 Integer 클래스 안에 들어있는 메소드