public class NoRaeBang_System extends JFrame implements ActionListener
{ 
 // 화면 사이즈 정보
 static final int SCREEN_WIDTH = 640;
 static final int SCREEN_HEIGHT = 480;

 // 파일 저장 정보
 static final String SAVE_FILE = "total.txt";
 static final String SAVE_DATA_HEADER = "TOTAL RECORD NUMBER";
 static final String SAVE_RECORD_HEADER = "RECORD ID";

 // 가격 정보
 static final int NORAEBANG_PRICE = 15000;
 static final int HELPER_PRICE = 20000;
 static final int BEVERAGE_PRICE = 1000;

 // 현재 화면 정보
 int current_state = -1;    

 static final int STATE_INIT_ROOM  = 0x0100;
 static final int STATE_MAIN_SCREEN  = 0x0200;
 static final int STATE_ENTER_ROOM  = 0x0300;
 static final int STATE_OUT_OF_ROOM  = 0x0400;
 static final int STATE_HELPER   = 0x0500;
 static final int STATE_BEVERAGE   = 0x0600;
 static final int STATE_ROOM_INFO = 0x0700;
 static final int STATE_SALES_INFO = 0x0800;
 static final int NEW_SONGS_INFO  = 0x0A00;

 // 방 정보
 int total_room_number = -1;
 RoomInfo ri[] = null;

 // 메시지 팝업창에서 사용할 변수들
 JDialog jpopup = new JDialog(this, "노래방 시스템", true);
 JLabel jpopup_label = new JLabel();
 JPanel jpopup_panel = new JPanel();
 JButton jpopup_button = new JButton("확인"); 
 
 // 숫자 입력창에서 사용할 변수들
 JDialog jinput = new JDialog(this, "노래방 시스템", true);
 JLabel jinput_label = new JLabel();
 JTextField jinput_textfield = new JTextField();
 JButton jinput_button1 = new JButton("확인");
 JButton jinput_button2 = new JButton("취소");
 
 // 다이얼로그 화면 정보
 int dialog_state = -1;
 
 static final int DG_INPUT_ROOM_NUMBER = 0;
 static final int DG_INPUT_ENTER_ROOM = 1;
 static final int DG_INPUT_HELPER = 2;
 static final int DG_INPUT_BEVERAGE = 3;
 
 // 정보 창에서 사용할 변수들
 JDialog jinfo = new JDialog(this, "노래방 시스템", true);
 JTextArea jinfo_jta = new JTextArea();
 JButton jinfo_button = new JButton("확인");
 
 // 방 정보를 표시하는 화면에서 사용할 변수들
 JPanel RoomSelect = null;
 JLabel jl_RoomSelect = new JLabel();
 JButton jb_RoomSelect[] = new JButton[23];
 boolean rs_room_available;
 int room_select_page = 0;
 int selected_room_idx;

 // 메인 메뉴 화면에서 사용할 변수들 
 JPanel MainScreen = null;
 static final String bn_MainScreen[] = {"입  실", "퇴  실", "도우미", "음료수 판매", "방의 정보", "총 매출 확인", "화면 지우기", "신곡 정보", "종  료"};
 JButton jb_MainScreen[] = new JButton[bn_MainScreen.length];
 JTextArea jta_MainScreen = new JTextArea();

 // 세이브 데이터 처리를 위한 HashTable
 Hashtable ht = new Hashtable();

 public NoRaeBang_System()   // 생성자 (변수를 초기화 한다)
 { 
  setTitle("노래방 시스템");
  setSize(SCREEN_WIDTH, SCREEN_HEIGHT);
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  
  loadData();    // 저장한 파일을 읽어온다.
  setVisible(true);   // 프레임을 화면에 띄운다.

  initInputDialog();   // 입력 다이얼로그를 초기화
  initInfoDialog();   // 정보 다이얼로그를 초기화
  initPopup();    // 팝업 창을 초기화

  // 메인 화면에 표시될 정보 입력
  jta_MainScreen.setText(" ******************************\n");
  jta_MainScreen.append(" *    노래방 관리 프로그램    *\n");
  jta_MainScreen.append(" *   만든이 : 박원규 김영철   *\n");
  jta_MainScreen.append(" ******************************\n");
  jta_MainScreen.append(" \n");
  jta_MainScreen.append(" 사용하실 메뉴를 선택해 주세요.\n\n");

  setMainScreen();   // 메인 화면을 세팅
  setInputDialog("방의 수를 입력해 주세요.", false, DG_INPUT_ROOM_NUMBER);
 }
 
 public static void main(String args[])      // 메인 메써드
 {
  NoRaeBang_System nrb = new NoRaeBang_System();
 }

 // 이벤트 처리 
 public void actionPerformed(ActionEvent evt)
 {
  if (evt.getSource() == jpopup_button)    // 팝업창을 닫는다.
  {
   jpopup.dispose();
  }
  else if (evt.getSource() == jinput_button1)   // 다이얼로그 확인 버튼 클릭
  {
   int input_number = -1;
  
   // textfield 에 입력된 값을 읽어온다. 
   try {
    input_number = Integer.parseInt(jinput_textfield.getText());
   } catch (Exception e_jb) {}
   
   if (input_number > 0)
   {
    switch(dialog_state)
    {
     case DG_INPUT_ROOM_NUMBER:  // 방의 수 입력 화면 - 입력된 숫자에 따라 방을 생성하고 각 방을 초기화 한다.
      total_room_number = input_number;
      ri = new RoomInfo[total_room_number];
      for(int i=0;i<total_room_number;i++) ri[i] = new RoomInfo(NORAEBANG_PRICE, HELPER_PRICE, BEVERAGE_PRICE);
      initSelectRoom();  // 방 선택 화면 정보를 초기화 한다.
     break;
     case DG_INPUT_ENTER_ROOM:  // 시간 입력
      ri[selected_room_idx].enterRoom(input_number);
      updateSelectRoom();     // 화면 갱신
      updateData(selected_room_idx);    // 세이브 데이터 업데이트
      setPopupLog((selected_room_idx+1)+" 번 방 사용이 시작되었습니다.");
     break;
     case DG_INPUT_HELPER:   // 도우미 추가
      ri[selected_room_idx].addHelper(input_number);  // 도우미 추가
      updateData(selected_room_idx);    // 세이브 데이터 업데이트
      setPopupLog((selected_room_idx+1)+" 번 방에 " + input_number + "명의 도우미가 추가되었습니다.");
     break;
     case DG_INPUT_BEVERAGE:   // 음료 추가
      ri[selected_room_idx].addBeverage(input_number); // 음료 추가
      updateData(selected_room_idx);    // 세이브 데이터 업데이트
      setPopupLog((selected_room_idx+1)+" 번 방에 " + input_number + "개의 음료가 추가되었습니다.");
     break;
    }
    jinput.dispose();   // 다이얼로그 창을 닫는다.
   }
   else
    setPopup("숫자를 올바르게 입력해 주세요.");
  }
  else if (evt.getSource() == jinput_button2)   // 다이얼로그 취소 버튼 클릭
  {
   jinput.dispose();    // 다이얼로그 창을 닫는다.
  }
  else if (evt.getSource() == jinfo_button)   // 방 정보 다이얼로그 확인 클릭
  {
   jinfo.dispose();    // 다이얼로그 창을 닫는다.
  }
  else
  {
   // 메인 화면에 있는 버튼을 처리
   for(int i=0;i<jb_MainScreen.length;i++)
   {
    if (evt.getSource() == jb_MainScreen[i]) event_MainScreen(i);
   }
   
   // 방선택 이벤트 처리  
   for(int i=0;i<jb_RoomSelect.length;i++)
   {
    if (evt.getSource() == jb_RoomSelect[i]) event_RoomSelect(i);
   }
  }
 }

 // 메인화면의 버튼 처리
 public void event_MainScreen(int idx)
 {
  switch(idx)
  {
   case 0:       // 입실
    room_select_page = 0;
    setEnterRoom();
   break;
   case 1:       // 퇴실
    room_select_page = 0;
    setOutofRoom();
   break;
   case 2:       // 도우미
    room_select_page = 0;
    setHelper();
   break;
   case 3:       // 음료수
    room_select_page = 0;
    setBeverage();
   break;
   case 4:       // 방정보
    room_select_page = 0;
    setRoomInfo();
   break;
   case 5:       // 총 매출 확인
    setInfoDialog();
   break;
   case 6:
    jta_MainScreen.setText(" 사용하실 메뉴를 선택해 주세요.\n\n");
   break;
   case 7:       // 신곡 정보
   break;
   case 8:
    System.exit(0);
   break;
  }
 }

 // 방 선택시 이벤트 처리
 public void event_RoomSelect(int idx)
 {
  switch(idx)
  {
   case 20:      // 이전 페이지
    room_select_page = Math.max(0, room_select_page-1);
    updateSelectRoom();
   break;
   case 21:      // 다음 페이지
    room_select_page = Math.min((total_room_number-1)/20, room_select_page+1);
    updateSelectRoom();
   break;
   case 22:      // 메인 화면
    setMainScreen();
   break;
   default:      // 각 방을 선택한 경우
    selected_room_idx = room_select_page * 20 + idx; // 해당 방의 실제 인덱스를 구한다.
    
    switch(current_state)
    {
     case STATE_ENTER_ROOM:
      setInputDialog("몇 시간을 사용하실 건가요?", true, DG_INPUT_ENTER_ROOM);
      break;
     case STATE_OUT_OF_ROOM: 
      ri[selected_room_idx].outofRoom();
      updateSelectRoom();
      setPopupLog((selected_room_idx+1)+" 번 방의 사용이 종료되었습니다.");
      break;
     case STATE_HELPER:
      setInputDialog("몇명의 도우미를 추가하실 건가요?", true, DG_INPUT_HELPER);
      break;
     case STATE_BEVERAGE:
      setInputDialog("몇개의 음료를추가하실 건가요?", true, DG_INPUT_BEVERAGE);
      break;
     case STATE_ROOM_INFO:
      setInfoDialog(selected_room_idx);
      break;
    }
   break;
  }
 }

 // 팝업 다이얼로그 창 초기화
 public void initPopup()
 {
  jpopup.setSize(300,135);  //크기
  //jpopup.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

  Dimension screen = this.getSize();    //화면크기
  Dimension frame = jpopup.getSize();      //다이얼로그 크기
  
  jpopup.setLocation( (int)(screen.getWidth()-frame.getWidth())/2 , (int)(screen.getHeight()-frame.getHeight())/2 );
  jpopup.setLayout(new BorderLayout());

  jpopup.add(jpopup_label);
  jpopup_panel.add("Center", jpopup_button);
  jpopup.add("South", jpopup_panel);
  
  jpopup_label.setHorizontalAlignment(JLabel.CENTER);
  jpopup_button.addActionListener(this);
 }

 // 메인 화면에 text 를 추가하고 팝업을 띄운다.
 public void setPopupLog(String s)
 {
  jta_MainScreen.append(s+"\n");
  setPopup(s);
 }

 // 팝업 창에 메시지를 설정하고 화면에 띄운다.
 public void setPopup(String s)
 {
  jpopup_label.setText(s);
  jpopup.setVisible(true);  
 } 

 // 숫자 입력 다이얼로그를 초기화 한다.
 public void initInputDialog()
 {
  jinput.setSize(300, 135);
  jinput.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
  
  // 다이얼로그를 화면 중간에 배치하기 위한 코드
  Dimension screen = this.getSize();    // 화면크기를 얻어옴
  Dimension frame = jinput.getSize();      // 다이얼로그 크기를 얻어옴

  int pos_x = (int) (screen.getWidth() / 2 - frame.getWidth() / 2);
  int pos_y = (int) (screen.getHeight() / 2 - frame.getHeight() / 2);
  jinput.setLocation(pos_x, pos_y);       // 다이얼로그 위치 지정

  // 다이얼로그에 필요한 내용을 추가하는 코드
  jinput.setLayout(null);

  jinput_label.setHorizontalAlignment(JLabel.CENTER);
  jinput_label.setBounds(0, 10, 300, 20);
  jinput_textfield.setBounds(20, 40, 255, 20);
  jinput_button2.setBounds(115+40, 75, 62, 28);
  
  jinput_button1.addActionListener(this);
  jinput_button2.addActionListener(this);
  
  jinput.add(jinput_label);
  jinput.add(jinput_textfield);
  jinput.add(jinput_button1);
  jinput.add(jinput_button2);
 }

 // 숫자 입력 다이얼로그를 띄운다.
 public void setInputDialog(String tf, boolean clr, int dg_idx)
 {
  dialog_state = dg_idx;
  jinput_label.setText(tf);
  jinput_textfield.setText(null);
  
  if (clr)
   jinput_button1.setBounds(115-40, 75, 62, 28);
  else
   jinput_button1.setBounds(115, 75, 62, 28);
  
  jinput_button2.setVisible(clr);
  jinput.setVisible(true);
 }

 // 정보 창 초기화
 public void initInfoDialog()
 {
  jinfo.setSize(300, 235);
  jinfo.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
  
  // 다이얼로그를 화면 중간에 배치하기 위한 코드
  Dimension screen = this.getSize();    // 화면크기를 얻어옴
  Dimension frame = jinfo.getSize();      // 다이얼로그 크기를 얻어옴

  int pos_x = (int) (screen.getWidth() / 2 - frame.getWidth() / 2);
  int pos_y = (int) (screen.getHeight() / 2 - frame.getHeight() / 2);
  jinfo.setLocation(pos_x, pos_y);       // 다이얼로그 위치 지정

  // 다이얼로그에 필요한 내용을 추가하는 코드
  jinfo.setLayout(null);
  
  jinfo_jta.setBounds(10, 10, 272, 160);
  //jinfo_jta.setEnabled(false);
  jinfo.add(jinfo_jta);

  jinfo_button.setBounds(115, 175, 62, 28);
  jinfo_button.addActionListener(this);
  jinfo.add(jinfo_button);
 }
 
 // 방 정보 창을 띄운다.
 public void setInfoDialog(int rn)
 {
  int sub[] = new int[3];

  for(int i=0;i<3;i++)
  {
   sub[i] = ri[rn].sd.sdata[i][0] * ri[rn].sd.sdata[i][1];
  }

  jinfo_jta.setText("방사용료\n");
  jinfo_jta.append("          "+ri[rn].sd.sdata[0][0] + " x " + ri[rn].sd.sdata[0][1] + " = \t" + sub[0] + "\n");
  jinfo_jta.append("도우미\n");
  jinfo_jta.append("          "+ri[rn].sd.sdata[1][0] + " x " + ri[rn].sd.sdata[1][1] + " = \t" + sub[1] + "\n");
  jinfo_jta.append("음료\n");
  jinfo_jta.append("          "+ri[rn].sd.sdata[2][0] + " x " + ri[rn].sd.sdata[2][1] + " = \t" + sub[2] + "\n");
  jinfo_jta.append("\n합계\n");
  jinfo_jta.append("          \t\t"+(sub[0]+sub[1]+sub[2]));
  jinfo.setVisible(true);
 }

 // 총 매출 정보 창을 띄운다.
 public void setInfoDialog()
 {
  int sub[] = new int[3];
  for (Enumeration e = ht.elements() ; e.hasMoreElements() ;) {
   SalesData sd = (SalesData)e.nextElement();

   for(int i=0;i<3;i++)
   {
    sub[i] += sd.sdata[i][0] * sd.sdata[i][1];
   }
  }
  
  jinfo_jta.setText("방사용료\n");
  jinfo_jta.append("          \t\t" + sub[0] + "\n");
  jinfo_jta.append("도우미\n");
  jinfo_jta.append("          \t\t" + sub[1] + "\n");
  jinfo_jta.append("음료\n");
  jinfo_jta.append("          \t\t" + sub[2] + "\n");
  jinfo_jta.append("\n합계\n");
  jinfo_jta.append("          \t\t"+(sub[0]+sub[1]+sub[2]));
  jinfo.setVisible(true);
 }

 // 방 선택 부분 UI 초기화
 public void initSelectRoom()
 {
  if (RoomSelect == null)
  {
   RoomSelect = new JPanel();

   RoomSelect.setLayout(null);
 
   jl_RoomSelect.setBounds(10, 10, SCREEN_WIDTH, 30);
   RoomSelect.add(jl_RoomSelect);
 
   jb_RoomSelect[20] = new JButton("이전 페이지");
   jb_RoomSelect[20].setBounds(SCREEN_WIDTH-300, SCREEN_HEIGHT-60, 128, 28);
   jb_RoomSelect[20].addActionListener(this);
   
   jb_RoomSelect[21] = new JButton("다음 페이지");
   jb_RoomSelect[21].setBounds(SCREEN_WIDTH-150, SCREEN_HEIGHT-60, 128, 28);
   jb_RoomSelect[21].addActionListener(this);

   jb_RoomSelect[22] = new JButton("메인 메뉴");
   jb_RoomSelect[22].setBounds(SCREEN_WIDTH-150, 10, 128, 28);
   jb_RoomSelect[22].addActionListener(this);

   RoomSelect.add(jb_RoomSelect[20]);
   RoomSelect.add(jb_RoomSelect[21]);
   RoomSelect.add(jb_RoomSelect[22]);

   int wspan = (SCREEN_WIDTH-27)/5 -1;
   int hspan = (SCREEN_HEIGHT-115)/4 -1;

   for(int i=0;i<20;i++)
   {
    jb_RoomSelect[i] = new JButton("");
    jb_RoomSelect[i].setBounds(10 + (wspan+1)*(i%5), 45 + (hspan+1)*(i/5), wspan, hspan);
    jb_RoomSelect[i].addActionListener(this);
    RoomSelect.add(jb_RoomSelect[i]);
   }
  }
 }

 // 방 선택 세팅 : 빈방이 선택될때도 있고, 사람이 있는 방이 선택될 수도 있기 때문에 rs_room_available을 플래그로 넣는다.
 public void setSelectRoom(String title, boolean room_status)
 {
  jl_RoomSelect.setText(title);
  rs_room_available = room_status;
  updateSelectRoom();
 }
 
 // 방 선택 부분 화면 업데이트 처리
 public void updateSelectRoom()
 { 
  jb_RoomSelect[20].setEnabled(room_select_page > 0);
  jb_RoomSelect[21].setEnabled(room_select_page < (total_room_number - 1)/20);
  
  for(int i=0;i<20;i++)
  {
   jb_RoomSelect[i].setText( (room_select_page * 20 + 1 + i) + "번 방" );
   if (room_select_page * 20 + i < total_room_number)
   {
    jb_RoomSelect[i].setVisible(true);
    jb_RoomSelect[i].setEnabled( rs_room_available^ri[room_select_page * 20 + i].room_available );
   } else jb_RoomSelect[i].setVisible(false);
  }
 }
 
 // 기존 패널을 프레임에서 제거해 주는 매써드
 public void removePreviousScreen()
 {
  switch(current_state)
  {
   case STATE_MAIN_SCREEN:  remove(MainScreen); break;
   case STATE_ENTER_ROOM:
   case STATE_OUT_OF_ROOM:
   case STATE_HELPER:
   case STATE_BEVERAGE:
   case STATE_ROOM_INFO:  remove(RoomSelect); break;
  }
 }

 // 메인 화면 꾸며주는 메써드
 public void setMainScreen()
 {
  if (current_state > 0) removePreviousScreen();
  
  if (MainScreen == null)
  {
   MainScreen = new JPanel();
   MainScreen.setLayout(null);
   
   int num_button = bn_MainScreen.length;
   int span = (SCREEN_HEIGHT - 45 - 2 * num_button) / num_button + 2;
   for(int i=0;i<num_button;i++)
   {
    jb_MainScreen[i] = new JButton(bn_MainScreen[i]);
    jb_MainScreen[i].setBounds(10, 10+span*i, SCREEN_WIDTH/4-11, span-2);
    jb_MainScreen[i].addActionListener(this);
    MainScreen.add(jb_MainScreen[i]);
   }

   jta_MainScreen.setBorder(new LineBorder(Color.GRAY));
   jta_MainScreen.setBounds(10+SCREEN_WIDTH/4, 10, SCREEN_WIDTH*3/4-26, span*num_button-2);
   //jta_MainScreen.setEnabled(false);
   MainScreen.add(jta_MainScreen);

  }
  
  add(MainScreen);
  setVisible(true);
  repaint();

  current_state = STATE_MAIN_SCREEN;
 }

 // 입실
 public void setEnterRoom()
 {
  if (current_state > 0) removePreviousScreen();
  setSelectRoom("입실할 방을 선택해 주세요", false); // 사용가능한 방을 체크
  
  add(RoomSelect);
  setVisible(true);
  repaint();
  current_state = STATE_ENTER_ROOM;
 }

 // 퇴실
 public void setOutofRoom()
 {
  if (current_state > 0) removePreviousScreen();
  setSelectRoom("퇴실할 방을 선택해 주세요", true); // 사용 중인 방을 체크
  
  add(RoomSelect);
  setVisible(true);
  repaint();
  current_state = STATE_OUT_OF_ROOM;
 }

 // 도우미 추가
 public void setHelper()
 {
  if (current_state > 0) removePreviousScreen();
  setSelectRoom("도우미를 추가할 방을 선택해 주세요.", true); // 사용 중인 방을 체크
  
  add(RoomSelect);
  setVisible(true);
  repaint();
  current_state = STATE_HELPER;
 }

 // 음료수 추가
 public void setBeverage()
 {
  if (current_state > 0) removePreviousScreen();
  setSelectRoom("음료수를 주문한 방을 선택해 주세요.", true); // 사용 중인 방을 체크
  
  add(RoomSelect);
  setVisible(true);
  repaint();
  current_state = STATE_BEVERAGE;
 }

 // 방 정보 보기
 public void setRoomInfo()
 {
  if (current_state > 0) removePreviousScreen();
  setSelectRoom("정보를 확인할 방을 선택해 주세요.", true); // 사용 중인 방을 체크
  
  add(RoomSelect);
  setVisible(true);
  repaint();
  current_state = STATE_ROOM_INFO;
 }
 
 
 // hex 데이터를 long 데이터로 바꿔주는 매써드
 public long getLong(String h)
 {
  String t = h.toLowerCase();
  long rv = 0l;
  
  for(int i=0;i<t.length();i++)
  {
   if (t.charAt(i) <= '9')
   {
    rv = (rv << 4) | (t.charAt(i)-'0');
   }
   else
   {
    rv = (rv << 4) | (t.charAt(i)-'a'+10);
   }
  }
  
  return rv;
 }
 
 // HashTable 에 저장된 데이터를 업데이트 하고 파일에 기록한다.
 public void updateData(int rn)
 {
  // HashTable 에서 같은 키 값이 존재하는지 체크해서 있으면 삭제
  if (ht.containsKey(ri[rn].sd.start_time))
  {
   ht.remove(ri[rn].sd.start_time);
  }
  
  // HashTable에 등록한다.
  ht.put(ri[rn].sd.start_time, ri[rn].sd);
  saveData();
 }
 
 // 파일에 저장하는 매써드
 public void saveData()
 {
  try {
   PrintWriter pw = new PrintWriter(SAVE_FILE);

   pw.println(SAVE_DATA_HEADER+" : "+ht.size());   // 파일에 데이터 개수를 저장
   pw.println("-------------------------------");   //

   int g_total = 0;
   for (Enumeration e = ht.elements() ; e.hasMoreElements() ;) { // HashTable의 객체들을 읽어옴
    SalesData sd = (SalesData)e.nextElement();
    int sub[] = new int[3];
    
    int sub_total = 0;
    for(int i=0;i<3;i++)
    {
     sub[i] = sd.sdata[i][0] * sd.sdata[i][1];
     sub_total += sub[i];
    }
    g_total += sub_total;
    
    pw.println(SAVE_RECORD_HEADER+" : "+Long.toHexString(sd.start_time));  // HashTable에 저장된 키값

    SimpleDateFormat formatter = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
    Date nnn = new Date(sd.start_time);
    pw.println("Time : " + formatter.format(nnn));     // 날짜를 기록한다.

    pw.println("방사용료");
    pw.println("\t"+sd.sdata[0][0]+" x "+sd.sdata[0][1] + " =\t" + sub[0]);
    pw.println("도우미");
    pw.println("\t"+sd.sdata[1][0]+" x "+sd.sdata[1][1] + " =\t" + sub[1]);
    pw.println("음료수");
    pw.println("\t"+sd.sdata[2][0]+" x "+sd.sdata[2][1] + " =\t" + sub[2]);
    pw.println("합계\t\t\t" + sub_total);
    pw.println("-------------------------------");
   }
   pw.println("총합계\t\t\t" + g_total);
   
   pw.flush();
   pw.close();
  } catch (Exception err) {}
 }
 
 // 저장된 파일을 읽어온다.
 // 처음에 헤더를 읽어서 데이터 개수를 읽고,
 // 나머지는 해당 데이터들을 파싱해서 처리한다.
 public void loadData()
 {
  try {
   FileReader fr = new FileReader(SAVE_FILE);
   BufferedReader br = new BufferedReader(fr);
   
   int data_num = 0;
   int counter = 0;
   
   while(true)
   {
    String line = br.readLine();
    if (line == null) break;
    
    if (data_num == 0)
    {
     if (line.indexOf(SAVE_DATA_HEADER) > -1)
     {
      data_num = Integer.parseInt(line.substring(line.indexOf(":")+1).trim());
     }
    }
    else
    {
     // 새로운 레코드의 시작
     if (line.indexOf(SAVE_RECORD_HEADER) > -1)
     {
      SalesData sd = new SalesData();
      
      // 키 값을 읽어온다.
      sd.start_time = getLong(line.substring(line.indexOf(":")+1).trim());
      line = br.readLine();
      
      // 수량 과 단가를 읽어온다.
      for(int i=0;i<3;i++)
      {
       line = br.readLine();
       line = br.readLine().trim();
       sd.sdata[i][0] = Integer.parseInt(line.substring(0, line.indexOf("x")).trim());
       sd.sdata[i][1] = Integer.parseInt(line.substring(line.indexOf("x")+1, line.indexOf("=")).trim());
      }
      
      // HashTable에 저장한다.
      ht.put(sd.start_time, sd);

      counter ++;
      if (counter == data_num) break;
     }
    }
   }
   
   br.close();
   fr.close();
  } catch (Exception e) {}
 }
}

// 세이브 데이터로 사용될 데이터 객체
class SalesData
{
 long start_time;   // 방 사용 시작 시간
 int sdata[][] = new int[3][2];  // 사용시간, 요금, 도우미, 요금, 음료수, 요금
}

// 방 정보에 해당하는 객체
class RoomInfo
{
 boolean room_available = true;  // 방이 비었는지 여부
 SalesData sd = new SalesData();

 // 방 객체를 생성할 때, 가격 정보를 기록한다.
 public RoomInfo(int c1, int c2, int c3)
 {
  sd.sdata[0][1] = c1;
  sd.sdata[1][1] = c2;
  sd.sdata[2][1] = c3;
 }

 // 입실을 처리한다.
 // 입실시 시간을 기록하는데, 이 시간은 HashTable의 키로 사용된다.
 public void enterRoom(int t)
 {
  room_available = false;
  sd.start_time = System.currentTimeMillis();
  sd.sdata[0][0] = t;
 }
 
 // 퇴실 처리
 public void outofRoom()
 {
  room_available = true;
  for (int i=0;i<sd.sdata.length;i++) sd.sdata[i][0] = 0;  
 }
 
 // 도우미 추가
 public void addHelper(int num)
 {
  sd.sdata[1][0] += num;
 }
 
 // 음료 추가
 public void addBeverage(int num)
 {
  sd.sdata[2][0] += num;
 }
}

이렇게 프로젝트가 완성 되었네여 ㅎㅎ
제가 모자른 부분이 많아서 같은조 형한테 도움을 많이 받았습니다.
그래도 뿌듯하네여 ㅎㅎ
그럼 과제 발표 때 뵙겠씁니다.

이것을 이용하면 Ipv6용 프로그램으로 포팅 할 때 투명성을 유지할 수 있다.

서버
import java.net.*;  <- Socket을 사용함으로
import java.io.*;  <-Input ,OutStream을 사용함으로

class JavaServer{

private int port; 
private ServerSocket servSocket;
private Socket clntSocket;

public JavaServer(int port){  <- 메인에서 인수를 받아서 결정
 this.port = port;
}
public void listen(){  <- 연결을 기다리는 메소드
 try{
  servSocket = new ServerSocket (port);
  clntSocket = servSocket.accept(); 
 }catch (IOException e){
  System.out.println ("IOExceptiob : " + e.getMessage());
 }
}

public void handleConnection(){  <- 데이터를 주고 받는 메소드
 try{
  BufferedReader in = new BufferedReader(new InputStreamReader(clntSocket.getInputStream()));
  PrintWriter out = new PrintWriter (clntSocket.getOutputStream(),true);
  System.out.println ("Java Server가"+clntSocket.getInetAddress().getHostName()+"와 연결되었습니다.");
  System.out.println ("첫 입력라인은"+in.readLine()+"입니다.");  //in.readLine()을 출력
  out.println ("Java Server에 잘 연결되었습니다.");
   clntSocket.close();  //Socket을 종료
 }catch(IOException e){
  System.out.println ("IOException:"+e.getMessage());
 }
}
 public static void main (String []args){
  int port = 8088; //디폴트값
  if (args.length>0){  //인수르 받은 숫자가 있으면
   port = Integer.parseInt(args[0]); // 그 값을 숫자로 바꿔서 포트에 넣는다 인수는 스트링이다!!
  }
 
  JavaServer jServer = new JavaServer(port);
  jServer.listen();
  jServer.handleConnection();
 }
}

클라이언트 
import java.net.*;  //위와 동일
import java.io.*;

class JavaClient{
private Socket cSocket;

public JavaClient(String addr, int port){
 try{
  cSocket = new Socket (addr, port);  //서버의 주소와 포트를 가지고 객체를 만듬
 }catch (IOException e){
 System.out.println ("IOException :"+e.getMessage());
 }
 }

public void handleConnection(){
 try{
  BufferedReader in = new BufferedReader(new InputStreamReader(cSocket.getInputStream()));
  PrintWriter out = new PrintWriter (cSocket.getOutputStream(), true);
 System.out.println ("Java Client가"+cSocket.getInetAddress().getHostName()+"와 연결되었습니다.");
 out.println ("여기는 Java Client입니다.");
 System.out.println ("서버로 부터의 첫입력라인은"+in.readLine()+"입니다.");
 BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
  cSocket.close();
 }catch (IOException e){
 System.out.println ("IOException : "+ e.getMessage());
 }
}
 public static void main (String []args){
 String addr = "203.237.163.173";  //이 주소는 내 컴퓨터 주소를 사용한다.
 int port = 8088;  //위와 동일
 if (args.length>0){
 addr = args[0];
 port = Integer.parseInt(args[1]);
 }
 JavaClient jClient = new JavaClient (addr, port);
 jClient.handleConnection();
 }
}
네트워크 프로그램이 좀 힘드네여 ㅠㅠ
더 공부 해봐야 겠습니다
더 열심히 ^^

 

설치 방법
www.mysql.com에서 다운로드 클릭

mysql-nt.exe
mysql서버 프로그램

mysqladmin.exe
명령 프롬프트상에서 서버의 시작 및 종료, 데이터베이스의 생성및 삭제등을 하는 관리자
프로그램

mysql.exe
sql을 불러오는것을 사용

서버 종료
mysqladmin -u root -p shutdown 서버의 종료

서버의 재시작
mysqladmin -u root -p reload

새로운 데이터베이스 생성
mysqladmin -u root create dbname

기존의 데이터베이스 삭제
mysqladmin -u root drop dbname

데이터베이스 계층적 구조
데이터베이스 <- 테이블 <- 레코드 <- 자료형

CHAR(M) - 고정길이 문자열 ex)string_var1 char(10); 변수명을 먼저 쓰고 그 다음 자료형을 씀
VARCHAR(M) -  가변길이 문자열 ex)string_var2 VARCHAR(10); //차이점 5개를 저장할때
CHAR은 5를 억지로 채우고 VARCHAR은 억지로 채우지 않음 속도면에서 차이가 나서
CHAR은 빠르고 VARCHAR은 느림 메모리에 따라 사용
INT = 정수형 (4바이트)
INT unsigned - 부호없는 정수형
FLOAT[(M,D)] = 소수 M =전체숫자개수 D=소수점아래 최대 숫자개수
ex)float_var FLOAT (4,2); (42.35은 유효, 324.45 324.5가 됨)

대소문자를 가리지 않음

명령어를 실행할려면 세미콜론 (;)을 써야 한다.

-> 중간에 길어질때 이 표시로 계속 쳐서 한다.

SHOW DATABASE 데이터베이스 확인

USE dbname; 데이터를 사용할것을 알려줌

DESC tablename; 테이블 상태를 확인
INSERT INTO tablename VALUES (값1, 값2...) - 레코드 값 입력 (n개의 필드를 다)
또는
INSERT INTO tablename VALUES (필드명 1, 필드명 2)VALUES(값1, 값2) (필드를 정해서)

우리가 하던 싱글 쓰레드 프로그램 을 실행시킬 때

Java CanvasExam을 실행시키면 이 클래스에서
메인을 찾은다음
프레임을 만들고 캔버스를 만들고 (위에꺼 실행) 사이즈정하고 더해주고 끝냄
차례대로 실행이 된다. (하나의 흐름만 존재함)

멀티 쓰레드란???
동시에 두 가지 일을 진행시키는 프로그램이 필요할 때 사용하는 것.
ex)게임에서 두 캐릭터가 대결하는 경우같은 것을 말함

동시에 두 개 이상의 실행흐름을 갖는 것을 멀티 쓰레딩이라고 하며 이 프로그램을
멀티 쓰레드 프로그램이라고 한다

싱글쓰레드는 쓰레드가 시작해서 한줄로 싱글쓰레드가 종료된다.

메인 쓰레드가 시작한다음 쓰레드를 생성하고 자신의 업무를 시작
그리고 또 하나의 쓰레드를 사용하고 또 시작 이 때 3개의 작업이 동시에 시작됨.
프로그램은 모든 프로그램이 종료가 되어야 끝난다.

2가의 방법 (쓰레드는 만드는)
java.lang.Thread  //클래스를 상속
java.lang.Runnable을 //인터페이스를 구현  (2개의 클래스를 상속하는 것을 자바에서는 금지하기
때문에 상속을 하면서 인터페이스를 할 때 이것을 씀)

class CountThread extends Thread  //Thread를 클래스를 상속한 카운트 쓰레드
{

 public void run(){  //쓰레드가 할일을 runmethod에서 구현
  for (int i = 100;i<110 ;i++ )  //100부터 109까지 증가시키기 위해 for문 돌림
  {
   System.out.println ("지금은"+i+"입니다.");
  }  //여기까지 runmethod이다. 그다음 메인 클래스를 구현
 }
  
 public static void main (String []args){
  Thread thread1 = new CountThread();  //객체 만들고
  thread1.start(); //객체 스타트 시킴
  //CountThread객체를 만들고 시작하기 위해서
  for (int i = 0;i<10 ;i++ )
  {
   System.out.println ("지금은"+i+"입니다.");
  }
 
}
}

동시에 수행되는것이 아니고 작은 시간간격으로 교대로 실행시키는 것이다.

실행 천천히 하기

class CountThread extends Thread  //Thread를 클래스를 상속한 카운트 쓰레드
{

 public void run(){  //쓰레드가 할일을 runmethod에서 구현
  for (int i = 100;i<110 ;i++ )  //100부터 109까지 증가시키기 위해 for문 돌림
  {
   System.out.println ("지금은"+i+"입니다.");
   try {Thread.sleep(1000);
   }catch (InterruptedException e){System.out.println (e.getMessage());}
  }  //여기까지 runmethod이다. 그다음 메인 클래스를 구현
 }
  
 public static void main (String []args){
  Thread thread1 = new CountThread();  //객체 만들고
  thread1.start(); //객체 스타트 시킴
  //CountThread객체를 만들고 시작하기 위해서
  

  for (int i = 0;i<10 ;i++ )
  {
   System.out.println ("지금은"+i+"입니다.");
   try {Thread.sleep(1000);
   }catch (InterruptedException e){System.out.println (e.getMessage());}

  }
 
}
}

느리게 천천히 올라가는게 보였습니다.

Runnable구현 방법

쓰레드가 해야할일을 runmethod에서 시작 클래스를 생성한다음 이 객체를 생성자는 인수로 하여 Thread객체 생성
쓰레드 객체를 start method에서 호출하여 시작

class CountRunnable implements Runnable
{
 public void run(){
  for (int i =100;i<110 ;i++ )
  {
   System.out.println ("지금은"+i+"입니다");
  }
 }
}

public class MultiCounter
{
 public static void main (String []args){
  CountRunnable cr = new CountRunnable();  //Countrunnable인수를 만든다음
  Thread thread1 = new Thread(cr); //쓰레드에 실행시키고
  thread1.start();  //start1실행
  for (int i = 0;i<10 ;i++ )
  {
   System.out.println ("지금은"+i+"입니다");
  }
}
}

후~~아직 더 해야 되네여 빨리 빨리 더 공부해야겠습니다

        JFrame frm = new JFrame("Swing 예제"); //JFrame을 만들어주고
        frm.setSize(200,200);  //사이즈
        Container contentPane = frm.getContentPane();
       
        JPanel pane = new JPanel();
        pane.setLayout(new GridLayout(3, 2));
  
        String[] data = {"one", "two", "three", "four"};
            
        contentPane.add(pane, "Center");
        contentPane.add(new JButton("Button 2"),"South");
        frm.setVisible(true);
    }
}

수업시간에 풀어본 문제 지금 풀고 있는데 잘 안되네여 ㅠㅠ
다른 사람꺼 보구서 맹연습중!!
아 그리고 교수님 제가 교수님 제가 담주에 회사 4박5일연수를 가는데
자바 수업에 빠질것 같습니다.
근데 말씀 못드려서 ㅠㅠ
죄송합니다. 교수님 여기서에서 말씀 드려서 일기도 하루 빼먹겠네여 ㅠㅠ
죄송합니다.

컨테이너
AWT와 비슷하나
JFrame, JDialog, JWindow, JApplet, JInternalFrame은 직접 add()메서드를 호출해 컴포넌트를 추가할수 없다.

public class SwingExam
{
 public static void main (String args[]){
  JFrame j = new JFrame("Swing예제"); //J프레임 만들기
  j.setSize (200,200);
  Container contentPane = j.getContentPane();  //컨테이너 가져오기
  JPanel pane = new JPanel();
  pane.setLayout(new GridLayout(3,2));  //GridLayout으로
  pane.add(new JTextField(10));
  pane.add(new JPasswordField(10));
  pane.add(new JRadioButton("Radio"));
  pane.add(new JButton("Button"));
  String []data = {"one", "two", "three", "four"};
  pane.add(new JList(data));
  pane.add(new JCheckBox("Checkbox"));
  contentPane.add(pane,"Center");  //결과를 contentPane에 저장
  contentPane.add(new JButton("Button2"),"South");
  j.setVisible(true);
 }
}

우선 스윙에 대해서 조금 공부해 봣는데 AWT랑 많이 비슷한대 더 어려워 진듯 하네여 ㅠㅠ
지금 계속 공부하고 있겠습니다.
그럼 교수님 내일 뵙겠습니다.

class Mycanvas extends Canvas{
 public void paint (Graphics g){  //paint의 먼저 이름을 정해줌 이제 그림을 그리기 시작하면됨
  g.drawString ("김영철입니다!!!",200,200);  //글자를 적어줌
  g.drawRect (100,100,100,100); //사각형을 만들어줌
  g.fillRect (10,20,50,50);  //색이 입혀진 사각형을 만들어줌
  int xPos[] = {300,200,500,400,100};  
  int yPos[] = {30,20,50,40,10};
  g.drawPolygon (xPos, yPos, 5);  //다각형 그리기
  g.drawRoundRect (11,22,33,44,55,66); //둥근 사각형 그리기
  g.drawOval (20,30,100,100); //원그리기
  g.drawArc (100,200,100,200,50,-50); //호그리기 마지막 50 -50 은 각도를 지정해줌
 }
}

class Kim {
 public static void main (String args[]){
  Mycanvas mc = new Mycanvas();
  Frame f = new Frame();
  f.setSize (1000,1000);
  f.add (mc);
  f.setVisible(true);
 }
}

색채우기 (예습문제)
import java.awt.*;

class Kk extends Canvas{
 public void paint (Graphics g){
  g.setColor (new Color (0,0,255));  //RGB로 색을 입히고
  g.fillRect (100,100,100,100);  //색이 채워진 사각형
  g.setColor (new Color (255,0,0));  //빨간색으로 채움
  g.fillRoundRect (200,100,100,100,10,10); //둥근 모서리를 만들어야되서 이렇게 해주고 크기를 좀 크게함
  g.fillRect (300,100,100,100);  //같은 색으로 더 크게함 그래야지 3개가 같이 보임
 }
}
class Kim{
 public static void main (String args[]){
  Kk k = new Kk();
  Frame f = new Frame();
  f.setSize (1000,1000);
  f.add (k,"Center");
  f.setVisible(true);
 }
}

그리기가 재미있는대 먼가 어려우네여 ㅠㅠ
지금 교수님이 내주신 문제 풀고 있습니다. 힘차게!!
그럼 내일 뵙겠습니다.

2. 프로젝트 개요
AWT를 이용, 글씨가 아닌 화면 (이미지)를 통한 노래방 관리 프로그램

3. 구현 기능
- 화면 배치를 통한 깔끔한 화면 구성
- ActionListener를 이용한 노래방 계산
- 영엽 관리 기능

4. 클래스 설계
- AWT를 이용한 레이아웃 클래스
- 각 기능별 이벤트 클래스
- 영업 관리 클래스

5. 조원별 구현 클래스 및 업무분담
- 레이아웃 클래스 : 김영철
- 각 기능별 이벤트 클래스 : 박원규
- 영업 관리 클래스 : 박원규, 김영철

6. 조원간 업무협력 방안
- 각자 집에서 클래스를 구성한 뒤 일주일에 1~2번 모여서 프로젝트 구성
- 불가피한 경우 메신저를 이용해서 프로젝트 구성

6. 개발 일정 (주별 진행 계획)
1주차
10월  6일 ~ 10월 11일  AWT를 이용한 레이아웃 클래스, 각 기능별 이벤트 클래스 구성 (AWT, ActionListener)

2주차
10월 13일 ~ 10월 18일  AWT를 이용한 레이아웃 클래스, 각 기능별 이벤트 클래스 구성 (AWT, ActionListener)

3주차
10월 20일 ~ 10월 25일  AWT를 이용한 레이아웃 클래스, 각 기능별 이벤트 클래스 구성 (AWT, ActionListener)

4주차
10월 27일 ~ 11월 1일   중간 점검

5주차
11월 3일 ~ 11월  8일   영업 관리 클래스 (파일 입출력)

6주차
11월 10일 ~ 11월 15일  영업 관리 클래스 (파일 입출력)

7주차
11월 17일 ~ 11월 22일  과제 제출 전 작동 및 오류 검출

8주차
11월 24일 ~ 11월 29일  과제 제출 전 작동 및 오류 검출

11월 30일              과제제출 마감일

6. 참고 문헌 및 Website
- 자바 누리 http://javanuri.devpia.com/
- 자바 스터디 네트워크 http://www.javastudy.co.kr/
- 프로그래밍 왕기초 java2            영진.COM

열심히 한번 해보겠습니다!!!