Duritz's Fun Life

3. Socket
  (1) 설명
 <1> 사전적의미 : (전구의) 소켓 -> 꽂는 구멍
 <2> 프로그램적의미 : 네트웍 통신을 위한 디바이스간의 통신 경로(연결객체)
       사용자에게 네트워크에 접근할 수 있게 인터페이스(통로/체널)를 제공하는 클래스

  (2) 종류
 <1> SOCK_STREAM (연결지향 동기통신-전화,채팅,메신져)
  -> 스트림을 주고 받을 수 있게 하는 Socket 으로 양방향 통신이 가능한 소켓
     (기본 프로토콜 : TCP[Transfer Control Protocol]

   [1]java.net.Socket
  1) 주요메소드
   - Socket(String host, int port) : 생성자
     -> 서버의 호스트와, 포트값을 받아서 서버에 연결하기 위한 연결 객체를 생성한다.
   - getInputStream()
     -> 연결된 다른소켓쪽에서 보내진 데이터를 받아들인다.
   - getOutputStream()
     -> 연결된 다른소켓쪽으로 데이터를 보낸다.
   (ex: 002day/NET4~5Client.java)

NET4Client.java

NET5Client.java

NET6Client.java

NET7Client.java

NET8Client.java

NET9Client.java

   [2] java.net.ServerSocket
  1) 설명 : 기다리다가 연결을 시도하는 요청을 받으면 연결지향 Socket(SOCK_STREAM)을
      생성시켜주는 객체를 모델링한 클래스
   - ServerSocket(int port)
     -> 서버소캣 생성자로 파라미터로 포트번호를 받는다. 해당 포트로 연결을 준비한다.
     -> 포트번호는 0~65535 가 사용가능하며 0~1023(Well-Known Port) 까지는
     OS에서 사용하고있는 포트라 사용불가(충돌일어남)
  2) 주요메소드   
   - accept()
     (socket)까지 만들어지는 연결을 듣고 그것을 받아들인다.
     -> 클라이언트와 연결통로를 만들고 연결될때까지 스레드가 대기(sleep).(소켓 객체리턴)
   - close()
     -> 연결객체이므로 close해주어야 한다.
   (ex: 002day/NET4~5Server.java)

NET4Server.java

NET5Server.java

NET6Server.java

NET7Server.java

NET8Server.java

NET9Server.java

 <2> SOCK_DGRAM (비연결지향 비동기 통신-편지,이메일...)
  -> 데이터그램 통신용 소켓으로 양방향 통신이 가능한 소켓
     (기반프로토콜 : UDP[User Datagram Protocol]

 <3> SOCK_RAW (ping 프로그램)
  -> 데이터 전송의 높은 수준의 제어를 필요로 할 때 사용하는 Socket 으로 자바에서는
     보안상 지원하지 않는다.
     (기반프로토콜 : ICMP[Internet Control Messege Protocol])

  (3) 통신방식
    <1> TCP방식의 Socket 통신
   [1] 연결 지향 통신 방식
   [2] 전화에 비유(신뢰적)
   [3] ServerSocket, Socket 을 이용한 프로그램
   [4] 프로그램 절차
  << Server측 >>
   ServerSocket ss 생성
   ss.accept()
   Socket s 생성

  << Client측 >>
   Socket s 생성

  << 통신 >>
   Socket s(서버측) <-- 메세지 --> Socket s(클측)

   cf) 메세지 : 기본형, 레퍼런스형(Serializable - ex:String)
   [5] 사용예
  - 채팅, 실시간 데이터 전송, 메신져, 네트웍게임, PtoP
 
 <2> UDP방식의 DatagramSocket 통신
   [1] 비연결 지향 통신 방식
   [2] 편지에 비유(비신뢰적)
   [3] DatagramSocket, DatagramPacket 을 이용해서 프로그램
   [4] 프로그램 절차
  << Server측 >>
   DatagramSocket ds 생성 // 편지함
   DatagramPacket dp 생성 // 편지(틀)
   ds.receive(dp), ds.send(dp)

  << Client측 >>
   DatagramSocket ds 생성 // 편지함
   DatagramPacket dp 생성 // 편지(틀)
   ds.receive(dp), ds.send(dp)

   [5] 사용예
  - 인터넷방송, 이메일, 뉴스그룹, 쪽지
  (ex: 006day/UDP1~3.java)

UDP01Client.java

UDP01Server.java

1. NET 관련 주요 개념 정리
  (1) 네트웍(network - 일을 위한 그물망?)
 -> 두개 이상의 디바이스가 연결되어 통신을 할 수 있는 환경
 -> 케이블이나 전화선, 무선 링크등으로 연결되어 동일한 프로토콜을 사용해서
   통신할 수 있는 디바이스들의 집합
 (ex: 두대이상의 PC 사이의 Data 통신, 인터넷.....)

  (2) 패킷
 -> 데이터의 전송단위
   (다양한 크기[기본 128Byte], 재사용가능, 해더/데이터/테일러로 구성)
 
  (3) 라우터와 라우터스위치
    -> 라우터는 패킷이 목적지로 가는 길(방향,최적경로)안내자
    라우터 스위치는 라우터에 폼함된 장치로 패킷의 방향타 역활

  (4) 게이트웨이 / 파이어월
    -> 게이트웨이(문)은 내부네트웍과 외부네트웍과 연결된 관문
    -> 파이어월(방화벽)은 내무자우너을 보호하고, 불필요한 외부 자원의 유입을 막는 보안장치
    (하드웨어, 소프트웨어)

  (5) 프록시
    -> 네트웍상에서 Node(연결지점) 간의 통신 중계자
    -> 역할
   <1> 캐쉬
  - 네트웍(인터넷)에서 자주접속하는 URL의 자원을 미리 저장해 놓고, 다음에 또 동일한
    URL자원을 요청할때 프록시 서버에 저장된 자원을 대신 불러온다.(접속 속도 향상)
    (ex: 인기 커뮤니티 site의 main 이미지...)
   <2> 보안
  - 특정한 Client의 요청을 분별해서 해당 요청에 대한 응답을 하지 않는 보안기능

  (6) Address / Port / Socket
    -> Address : 네트웍상의 어느 고유한 위치(IP - Internet Protocol)
    -> Port : Address에서 특정한 정보를 들여보내고 내보내는 통로
     (우리 PC에서 0~65535 번까지의 포트가 존재)
    -> Socket : 두대의 Device 상에서 IP와 PORT를 재료로 해서 만들어지는 가상 통신 경로
    (ex: 전화기-동기통신 or 편지-비동기통신)

  (7) 프로토콜
    -> 네트웍 통신을 할 때에 데이터를 구분하기 위한 통신규약
    (ex: http, ftp, smtp, telnet.....)

  (8) OSI7 Layer
    -> 두 대 이상의 Device 사이에 통신단계를 7단계로 나누어 놓은 것(물리적X, 논리적구분O)
    즉, 데이터를 주고 받는 논리적 경로 단계
 
         # A divice #                                                  # B divice #
 7계층:애 플 리 케 이 션                                  7계층:애 플 리 케 이 션
              │                                                                 │
 6계층:프 리 젠 테 이 션                                  6계층:프 리 젠 테 이 션
              │                                                                 │
 5계층:세             션                                      5계층:세                션
              │                                                                 │
 4계층:트 랜 스    포 트                                   4계층:트 랜 스    포 트
              │                                                                 │
 3계층:네   트   워   크                                    3계층:네   트   워   크
              │                                                                 │
 2계층:데 이 터    링 크                                   2계층:데 이 터    링 크
              │                                                                 │
 1계층:물  리 (랜 카 드)                                  1계층:물  리 (랜 카 드)
              │                                                                 │
              └────────   인 터 넷   ────────┘
 
 cf1) 통신 : 네트웍상의 디바이스끼리의 데이터 교류(Give & Take)
 cf2) OSI7 Layer에서 JAVA프로그램과 관련 있는 계층은 애플리게이션 계층이다.

2. 주요 클래스
  (1) java.net.URL (Union Resource Locator)
    <1> 기능 : 네티웍상에 접속한 디바이스의 프로토콜, 호스트, 포트,
      파일등의 경로를 정보를 알 수 있는 클래스
 <2> 주요 메소드
  - 생성자 6개
  - getProtocol()
  - getHost()
        - getPort()
  - getFile()
  - getPath()
  - getQuery()
  - openStream()
        - openConnection()
        (ex: 001day/NET1.java )

NET1.java

  (2) java.net.URLConnection
 <1> 기능 : 자원의 구체적인 Content 정보와 Post 방식의 정보를 알 수 있다.
 <2> 주요메소드
  - getContent()
  - getContentLength()
  - getContentType()
  - connect()
  - getHeaderFields()
  - getInputStream()
  (ex: 001day/NET2.java)

NET2.java

  (3) java.net.URLEncoder / URLDecoder
 <1> 기능 : 네트웍상으로 URL 의 데이터가 전송될 때 byte 단위로 자르는 것을
      'Encoding', 조합하는것을 'Decoding'이라 하는데, 그 때에 인코딩과
      디코딩관련 메소드를 가진 클래스
 <2> 주요메소드 : encode(), decord()

  (4) java.net.InetAddress
 <1> 기능 : 네트워크 호스트에 대한 IP르르 알아낼 수 있는 클래스
 <2> 주요메소드
  - getAllByName(String host)
  - getHostAddress()
  - getHostName()
  - getCanonicalHostName()
  - getLocalHost()
  (ex: 001day/NET3.java )

NET3.java

★ 조사
  (1) 인코딩(Encoding) 이란?
 데이터를 컴퓨터가 이해할 수 있는 어떠한 기준에 의해 0과 1의 바이너리값
 (연속적인 비트 형태의 데이터)으로 변환시키는것
 - 문자인코딩 : 문자데이터를 문자셋을 기준으로 인코딩하는 것.

  (2) 디코딩(Decoding) 이란?
 전송된 바이너리값을 어떠한 기준에 의해 인간이 이해할 수 있는
 원래의 데이터로 복원시키는 것.
 - 문자디코딩 : 문자셋을 기준으로 디코딩하는 것

  (3) 문자셋(Charactor Set) 이란?
 문자의 표현을 위해서 정의한 문자모양(문자 코드표)의 총칭

  (4) 주요 문자셋의 종류?
 <1> ASCII : 7비트사용(0~127) 문자표현 [128문자]
 <2> ISO8895-1 : 서유럽문자집합, ASCII에 추가, 8피트 사용(0~225) 문자표현[256문자]
 <3> KSC5601 : 한국공업표준, 2바이트 한글 표현(완성형), ASCII문자 제외
 <4> EUC-kr : ASCII 1byte, 한글 2byte로 표현(조합형)
 <5> UTF-8 : ASCII는 1byte, 한글 3byte, 그 외 대부분의 문자는 2byteㄴ
 <6> UTF-16 : 모든 문자를 2b로 표현한 문자셋(ex: a == 0061)
     자바계열의 표준 문자셋 (문자표현 : 05536개)

  (5) 한글 표준 문자셋은?
 EUC-KR

  (6) 유니코드의 탄생배경과 종류?
 - 전세계의 문자들을 깨지지 않게 하기위해 모든 문자들에게 고유한 번호를 부여하게 된 것
 - UTF-8, UTF-16

  (7) 2byte Stream이 존재하는 이유?
 - 해당 문자셋에 맞게 encoding, decoding을 자동으로 해준다.
   (왜냐하면, char 단위로 읽고 쓰기 때문에)

  (8) 문자셋과 인코딩방식의 차이점은?
 - 인코딩방식 : 데이터를 컴퓨터가 이해할 수 있는 어떠한 기준
 - 문자셋 : 문자데이터를 컴퓨터가 이해할 수 있게 변환 하기 위한 기준
 - (문자)인코딩 방식 == 문자셋

  참고) http://ko.wikipedia.org/wiki/

3. Bridge Stream (연결 스트림)
  (1) 설명 : 1byte -> 2byte

  (2) 종류
 <1> InputStreamReader
 <2> OutputStreamWriter

 (ex: 002day/IO17.java)

IO17.java

4. Filter Stream (응용 스트림)
  (1) 설명 : Node Stream과 연걸해서 다양한 기능(메소드/속성)을 쓸 수 있는 Stream!!
    즉, 기능을 향상시킨 스트림..

  (2) 종류
 <1> (내부적으로) 버퍼기능을 강화시킨 1 byte Stream
   [1] BufferedInputStream
   [2] BufferedOutputStream
   (ex: 002day/IO18.java)

IO18.java

 <2> 기본형을 읽고 쓸 수 있는 Stream
   [1] DataInputStream
   [2] DataOutputStream
   (ex: 002day/IO19.java)

IO19.java

 <3> 객체를 읽고 쓸 수 있는 Stream
   [1] ObjectInputStream
   [2] ObjectOutputStream
   (ex: 002day/IO20~21.java)

IO20.java

IO21.java

   cf) 주의
   (ex: 002day/IO20~21.java, Student.java)

Student.java

 <4> 메모리에 읽고 쓸 수 있는 스트림
   [1] byte 배열을 읽고 쓸 수 있는 스트림
  - ByteArrayInputStream
  - ByteArrayOutputStream
  (ex: 002day/IO22~23.java)

IO22.java

IO23.java

   [2] char 배열을 읽고 쓸 수 있는 스트림
  - CharArrayReader
  - CharArrayWriter

 <5> 문자를 powerful하게 읽고 쓸 수 있는 스트림
   [1] BufferedReader
   [2] PrintWriter (다양한 메소드, 오토 플러쉬, 브릿지 필요없다.)
   (ex: 002day/IO24~25.java)

IO24.java

IO25.java

1. 스트림 (Stream)
  (1) 설명 : 데이터의 흐름
 
  (2) 흐름의 예
 Source (Keyboard, File, DataBase, WebPage)
   │
   │ -> 데이터의 흐름(Stream)   
   ↓ 
 Destination (Monitor, File, WebPage, DataBase....)

  (3) 표준 입력 / 출력 스트림
 * Stream은 상대적 (기준에 따라 Source, Destination 이 달라진다.)
 (두뇌) -----> 키보드 -----> 모니터 -----> (눈) -----> (두뇌)
                  (System.in)   (System.out)

  (4) 특징
 <1> FIFO (First In Firts Out)
  -> 흘러가는 데이터의 순서가 바뀔 수 없다.

 <2> 단방향 : 흐름의 방향은 일정하다.

 <3> 지연성 : 스트림(흐름)은 지연될 수 있다. (ex: 커서의 깜빡임...)

 <4> 유연한구조 : 다른 Stream(FilterStream)과 연결해서 쓸 수 있다.
   ex) new BufferedReader(new InputStreamReader(System.in))
 
  (5) 구분 (IO.jpg 참조)
 <1> by byte 수 기준
   [1] 1byte Stream (바이트 스트림 - 음악, 동영상, 그림....)
  (ex: XXXInputStream, XXXOutputStream)
   [2] 2byte Stream (문자 스트림 - 자바에서만 지원)
  (ex: XXXReader, XXXWriter)

 <2> by 입력/출력 기준
   [1] 입력 스트림 : InputStream / Reader
   [2] 출력 스트림 : OutputStream / Writer

 <3> by 기능 기준
   [1] Node Stream : Source or Destination 에 직접 연결된 Stream
  (ex: 수도 꼭지..)
   [2] Bridge Stream : 1byte Stream을 2byte Stream으로 변환하는 스트림
  (ex: Connecting Union - 연결매체)
   [3] Filter Stream : Node Stream을 사용하기에 알맞게 가공한 스트림
  (ex: 샤워기 - 독특한 기능(메소드, 필드)을 가지고 있다)

2. Node Stream (근본 스트림)
  (1) 설명
 Data Source(원천지, 근본지) 또는 Data Destination(목적지)와 직접 연결된 스트림
 
  (2) 종류
 <1> InputStream
   [1] 1byte 입력 스트림의 조상
   [2] 추상클래스이기 때문에 System.in 이나 하위 클래스를 형변환해서 생성
   [3] - read() - 아스키값 리턴
    - read(byte[] b) - 읽은 바이트의 총갯수
    - read(byte[] b, int off, int len) -
   [4] close();
   (ex: 001day/IO1~3.java)

IO1.java

IO2.java

IO3.java

 <2> OutputStream
   [1] 1byte 출력 스트림의 조상
   [2] 추상클래스이기 때문에 System.out 이나 하위 클래스를 형변환해서 생성
   [3] - write(byte[] b) - 아스키값을 char로 출력
    - write(byte[] b, int off, int len) - 배열값 시작부터 원하는 길이만큼 출력
    - write(int b) - 해당 인트값(아스키값)에 대한 char를 출력
   [4] flush(), close()
   (ex: 001day/IO4.java)

IO4.java

IO5.java

 <3> FileInputStream
   [1] 파일에서 읽는 스트림
   [2] InputStream 의 자식 클래스
   [3] 생성자 3개
   (ex: 001day/IO6.java, [Source-파일][Destination-모니터])

IO6.java

 <4> FileOutputStream
   [1] 파일에 쓰는 스트림
   [2] OutputStream 의 자식 클래스
   [3] 생성자 5개
   (ex1: 001day/IO7.java, [Source-키보드][Destination-파일]) 

IO7.java

IO8.java

IO9.java

IO10.java

 <5> Reader
   int read()
   int read(char[] cbuf)
   abstract int read(char[] cbuf, int off, int len)
   int read(CharBuffer target)

   cf) 완성형, 조합형, 공백은 각각 1개의 문자로 간주
    Enter는 2개의 문자(10,13)로 간주..
   (ex: 002day/IO11.java)

IO11.java

 <6> Writer
   write(char[] cbuf)
   write(char[] cbuf, int off, int len)
   write(int c)
   write(String str)
   write(String str, int off, int len) 

 <7> FileReader
   (ex: 002day/IO15.java)

IO15.java

 <8> FileWriter
   (ex: 002day/IO16.java)

IO16.java

JDBC [Java DataBase Connectivity]

1. Driver 로딩
2. Connection 생성
3. Statement 생성
4. ResultSet 생성 / 리턴값
5. 결과 이용
6. Close

(ex : JdbcTest.java )

JdbcTest.java

22. 배열 (Array 여관) -> 배열도 객체다.
   (1) 설명
  - 같은 타입(Type)의 객체 또는 기본자료를 저장하는 저장소로서, 생성될때 그 크기가
    고정되는 저장소 객체.
  
   (2) 선언
  Type 배열변수명[];
  ex) int is[], int[] is, int []is, int [] is, String str[].....

   (3) 생성
  -> new Type[저장소크기]
  ex) new int[5], new String[3]....

   (4) 배열 방의 default 값
  <1> 참조형
    - 방의 기본값  --> null

     <2> 기본형
    - 정수(byte, short, char, int, long) -> 0.0L
    - 실수(float, double) -> 0.01, 0.0
    - 불린(boolean) -> false

   (5) 초기화
  확보된 공간(방)에 데이터를 최초로 넣은것
  ex) strs[0] = "봄", strs[1] = "여름", ... , is[0]=100, ..

  (ex: 005day/ArrayTest.java)

ArrayTest.java

   (6) 선언/생성
  Type 배열변수명[] = new Type[저장소크기];
  ex) String strs[] = String[3], int is[] = new int[2], ..

  (ex: 005day/ArrayTest2.java )

ArrayTest2.java

ArrayTest3.java

   (8) 배열값의 형변환
  ex1) int i =30;
    short ss[] = {10, 20, (short)i};
  ex2) Object obj[] = {new String("감자"), new Object()};

  (ex: 005day/ArrayTest4.java)

ArrayTest4.java

   (9) 이차원 배열
  -> 일차원 배열을 하나의 데이터(배열요소)로 취급하는 배열

   (10) 삼차원 배열
  -> 이차원 배열을 하나의 데이터(배열요소)로 취급하는 배열
  (ex: 005day/ArrayTest5.java)

ArrayTest5.java

23. 쓰레드
   (1) 설명 : 프로세스를 구성하는 제어의 흐름

   (2) Process 와 Thread 의 차이
  <1> Process : 프로그램의 실행 단위
  <2> Thread : Process를 구성하는 작업 단위
  
   (3) 비유 : 고용인.
  ex1) 소리바다에서 다운로드를 받으면서 음악을 듣는 것
  ex2) word에서 입력과 동시에 오타를 처리하는 것
  ex3) 웹브라우저에서 다운로드 받으면서 웹서핑 하는 것
  ex4) Startcraft의 인물들, 배경음악이 동시에 나오는 것
  ex5) 식당 주인(계산) + 서빙(음식배달) + 주방장(음식생산)
 
   (4) 장점
  쓰레드는 경량프로세스라고 일컬어 질 정도로 가볍다.
  이유는 프로세스의 자원(resource)를 공유하기 때문이다.
  
   (5) Thread 를 생성하는 2가지
  <1> java.lang.Thread 클래스를 상속 받는 방법
   (ex: Thread1.java)

Thread1.java

Thread2.java

   (6) 실행법
  쓰레드객체.start();

   (7) Thread 의 Priority (우선순위)
  <1> 설명
   Ready 상태의 쓰레드 중에서, 우선적으로 CPU를 점유할 수 있는
   쓰레드를 판별하기 위한 LEVEL값.
  <2> 범위 : 1~10
  <3> 상수
   (ex: Thread3.java)

Thread3.java

   (8) Thread 의 LifeCycle (ppt참조)

   (9) 주요메소드
  <1> sleep();
  <2> join();
  <3> yield();

   (10) 쓰레드의 동기화
  <1> 설명
   두 개 이상의 쓰레드가 어떤 연산에 동시에 접근했을 때 그 연산에
   대한 값(데이타)의 무결성을 보장하기 위해서 수행 영역에 대한
   lock을 걸어주는 것.

   ex) i++; // 현재 i값은 0
    methodA() // 비동기 메소드
    {
   - 1단계 : 기존의 i값을 읽는다.
   - 2단계 : 그 값을 1 증가 시킨다.
   - 3단계 : 증가된 값을 i에 대입시킨다.
    } i == 2 //정답, 오류 : i == 1

  <2> 비유 : 화장실사용

  <3> 방법
   synchronized 예약어를 메소드나 어떤 영역(블럭)에 써주면 된다.

   ex1) public synchronized void methodA(){연산}
   ex2) public void methodA()
     {
      synchronized(this){연산}
     }
   cf) synchronized 로 감싸진 영역을 동기화 블럭이라하고 동기화 블럭에서는
    동시에 오직 하나의 쓰레드만이 작업을 수행 한다.
    (ex: 005day/Thread4.java)

Thread4.java

OwnerThread.java

Calculator.exe

Calculator.java

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Calculator implements ActionListener
{
 JButton bt_1, bt_2, bt_3, bt_4, bt_5, bt_6, bt_7, bt_8, bt_9, bt_0,
   bt_Plus, bt_Minus, bt_Multiplication, bt_Division, bt_Dot, bt_Cal,
   bt_BackSpace, bt_C;
 JTextField tf_Display;
 StringBuffer tf_getText;
 String getText;
 
 double cal_Buffer1, cal_Buffer2, cal_Buffer3;
 final byte PLUS = 1, MINUS = 2, MULTIPLICATION = 3, DIVISION = 4;
 byte cal_Check, numberIn;

 public Calculator()
 {
  tf_getText = new StringBuffer();
  frameSetting();
 }

 public void frameSetting()
 {
  tf_Display = new JTextField("0");
  tf_Display.setHorizontalAlignment(JTextField.RIGHT);
  tf_Display.setFont(new Font("font", Font.BOLD, 16));
  tf_Display.setEditable(false);
  
  bt_1 = new JButton("1");
  bt_1.setFont(new Font("font", Font.BOLD, 16));
  bt_2 = new JButton("2");
  bt_2.setFont(new Font("font", Font.BOLD, 16));
  bt_3 = new JButton("3");
  bt_3.setFont(new Font("font", Font.BOLD, 16));
  bt_4 = new JButton("4");
  bt_4.setFont(new Font("font", Font.BOLD, 16));
  bt_5 = new JButton("5");
  bt_5.setFont(new Font("font", Font.BOLD, 16));
  bt_6 = new JButton("6");
  bt_6.setFont(new Font("font", Font.BOLD, 16));
  bt_7 = new JButton("7");
  bt_7.setFont(new Font("font", Font.BOLD, 16));
  bt_8 = new JButton("8");
  bt_8.setFont(new Font("font", Font.BOLD, 16));
  bt_9 = new JButton("9");
  bt_9.setFont(new Font("font", Font.BOLD, 16));
  bt_0 = new JButton("0");
  bt_0.setFont(new Font("font", Font.BOLD, 16));
  bt_Plus = new JButton("＋");
  bt_Plus.setFont(new Font("font", Font.BOLD, 16));
  bt_Minus = new JButton("－");
  bt_Minus.setFont(new Font("font", Font.BOLD, 16));
  bt_Multiplication = new JButton("×");
  bt_Multiplication.setFont(new Font("font", Font.BOLD, 16));
  bt_Division = new JButton("÷");
  bt_Division.setFont(new Font("font", Font.BOLD, 16));
  bt_Dot = new JButton(".");
  bt_Dot.setFont(new Font("font", Font.BOLD, 16));
  bt_Cal = new JButton("=");
  bt_Cal.setFont(new Font("font", Font.BOLD, 16));
  bt_BackSpace = new JButton("←");
  bt_BackSpace.setFont(new Font("font", Font.BOLD, 14));
  bt_C = new JButton(" C ");
  bt_C.setFont(new Font("font", Font.BOLD, 14));
  JPanel panel_North = new JPanel(new GridLayout(1,1,5,5));
  JPanel panel_Center = new JPanel(new BorderLayout());
  JPanel panel_C_North = new JPanel();
  JPanel panel_C_Center = new JPanel(new GridLayout(4,4,5,5));
  JLabel lb_Info = new JLabel("Copyright(c) 2007. Dscythe(Paik Seung Ik)", SwingConstants.CENTER);

  try {
   UIManager.setLookAndFeel(
    UIManager.getCrossPlatformLookAndFeelClassName());
  } catch (Exception e) { }

  JFrame.setDefaultLookAndFeelDecorated(true);
  JFrame frame = new JFrame(" Swing Calendar");

  frame.add(panel_North, "North");
  panel_North.add(tf_Display);

  frame.add(panel_Center, "Center");
  panel_Center.add(panel_C_North, "North");
  panel_C_North.add(bt_BackSpace);
  panel_C_North.add(bt_C);
  panel_Center.add(panel_C_Center, "Center");
  panel_C_Center.add(bt_7);
  panel_C_Center.add(bt_8);
  panel_C_Center.add(bt_9);
  panel_C_Center.add(bt_Division);
  panel_C_Center.add(bt_4);
  panel_C_Center.add(bt_5);
  panel_C_Center.add(bt_6);
  panel_C_Center.add(bt_Multiplication);
  panel_C_Center.add(bt_1);
  panel_C_Center.add(bt_2);
  panel_C_Center.add(bt_3);
  panel_C_Center.add(bt_Minus);
  panel_C_Center.add(bt_0);
  panel_C_Center.add(bt_Dot);
  panel_C_Center.add(bt_Cal);
  panel_C_Center.add(bt_Plus);
  panel_Center.add(lb_Info, "South");

  eventListener();

  frame.setSize(250,250);
  frame.setLocation(300,300);
  frame.setVisible(true);
  frame.setResizable(false);
  frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE);
 }

 public void eventListener()
 {
  bt_1.addActionListener(this);
  bt_2.addActionListener(this);
  bt_3.addActionListener(this);
  bt_4.addActionListener(this);
  bt_5.addActionListener(this);
  bt_6.addActionListener(this);
  bt_7.addActionListener(this);
  bt_8.addActionListener(this);
  bt_9.addActionListener(this);
  bt_0.addActionListener(this);
  bt_Plus.addActionListener(this);
  bt_Minus.addActionListener(this);
  bt_Multiplication.addActionListener(this);
  bt_Division.addActionListener(this);
  bt_Dot.addActionListener(this);
  bt_Cal.addActionListener(this);
  bt_BackSpace.addActionListener(this);
  bt_C.addActionListener(this);
  tf_Display.addKeyListener(new keyAdapter()
   {
    public void keyTyped (KeyEvent ke)
    {
     char key_Cr = ke.getKeyChar();
     //System.out.println(key_Cr);
     if ('1' == key_Cr){
      numberIn = 1;
      numberInput();
     } else if ('2' == key_Cr){
      numberIn = 2;
      numberInput();
     } else if ('3' == key_Cr){
      numberIn = 3;
      numberInput();
     } else if ('4' == key_Cr){
      numberIn = 4;
      numberInput();
     } else if ('5' == key_Cr){
      numberIn = 5;
      numberInput();
     } else if ('6' == key_Cr){
      numberIn = 6;
      numberInput();
     } else if ('7' == key_Cr){
      numberIn = 7;
      numberInput();
     } else if ('8' == key_Cr){
      numberIn = 8;
      numberInput();
     } else if ('9' == key_Cr){
      numberIn = 9;
      numberInput();
     } else if ('0' == key_Cr){
      zero();
     } else if ('+' == key_Cr){
      calculate(PLUS);
     } else if ('-' == key_Cr){
      calculate(MINUS);
     } else if ('*' == key_Cr){
      calculate(MULTIPLICATION);
     } else if ('/' == key_Cr){
      calculate(DIVISION);
     } else if ('.' == key_Cr){
      dotCheck();
     } else if ('' == key_Cr){
      backSpace();
     }
    }
   });
 }

 public void actionPerformed(ActionEvent e)
 {
  Object obj = e.getSource();
  if (bt_1 == obj){
   numberIn = 1;
   numberInput();
  } else if (bt_2 == obj){
   numberIn = 2;
   numberInput();
  } else if (bt_3 == obj){
   numberIn = 3;
   numberInput();
  } else if (bt_4 == obj){
   numberIn = 4;
   numberInput();
  } else if (bt_5 == obj){
   numberIn = 5;
   numberInput();
  } else if (bt_6 == obj){
   numberIn = 6;
   numberInput();
  } else if (bt_7 == obj){
   numberIn = 7;
   numberInput();
  } else if (bt_8 == obj){
   numberIn = 8;
   numberInput();
  } else if (bt_9 == obj){
   numberIn = 9;
   numberInput();
  } else if (bt_0 == obj){
   zero();
  } else if (bt_Plus == obj){
   calculate(PLUS);
  } else if (bt_Minus == obj){
   calculate(MINUS);
  } else if (bt_Multiplication == obj){
   calculate(MULTIPLICATION);
  } else if (bt_Division == obj){
   calculate(DIVISION);
  } else if (bt_Dot == obj){
   dotCheck();
  } else if (bt_C == obj){
   tf_Display.setText("0");
   tf_getText.delete(0,tf_getText.length());
   cal_Buffer1 = 0;
   cal_Buffer2 = 0;
   cal_Check = 0;
   numberIn = 0;
  } else if (bt_BackSpace == obj){
   backSpace();
  } else if (bt_Cal == obj)
  {
   result();
  }
 }

 public void numberInput()
 {
  getText = tf_getText.toString();
  if (getText.length() == 1 && getText.indexOf("0") == 0)
  {
   tf_getText.delete(0,tf_getText.length());
  }
  tf_getText.append("" + numberIn);
  tf_Display.setText(tf_getText.toString());
 }

 public void zero()
 {
  getText = tf_getText.toString();
  if (0 <= getText.indexOf("."))
  {
   tf_getText.append("0");
   tf_Display.setText(tf_getText.toString());
  } else {
   if (getText.length() == 1 && getText.indexOf("0") == 0)
   {
    tf_Display.setText("0");
   }else
   {
    tf_getText.append("0");
    tf_Display.setText(tf_getText.toString());
   }
  }
 }

 public void dotCheck()
 {
  getText = tf_getText.toString();
  if (0 <= getText.indexOf("."))
  {
   tf_getText.append("");
   tf_Display.setText(tf_getText.toString());
  } else {
   tf_getText.append(".");
   tf_Display.setText(tf_getText.toString());
  }
 }

 public void backSpace()
 {
  try
  {
   tf_getText.delete(0,tf_getText.length());
   tf_getText.append(tf_Display.getText());
   getText = tf_getText.delete(tf_getText.length()-1, tf_getText.length()).toString();
   if (getText.length() == 0)
   {
    getText = "0";
   }
   tf_getText.delete(0,tf_getText.length());
   tf_getText.append(getText);
   tf_Display.setText(tf_getText.toString());
  }
  catch (StringIndexOutOfBoundsException se){}
 }

 public void calculate(byte cal_Check)
 {
  try
  {
   switch (cal_Check)
   {
    case PLUS:
     cal_Buffer1 = Double.parseDouble(tf_Display.getText());
     cal_Buffer2 = cal_Buffer1 + cal_Buffer2;
     tf_getText.delete(0,tf_getText.length());
     tf_Display.setText("" + cal_Buffer2);
     break;
    case MINUS:
     cal_Buffer1 = Double.parseDouble(tf_Display.getText());
     if (cal_Buffer2 == 0)
     {
      cal_Buffer2 = cal_Buffer1;
     } else
     {
      cal_Buffer2 = cal_Buffer2 - cal_Buffer1;
     }
     tf_getText.delete(0,tf_getText.length());
     tf_Display.setText("" + cal_Buffer2);
     break;
    case MULTIPLICATION:
     cal_Buffer1 = Double.parseDouble(tf_Display.getText());
     if (cal_Buffer2 == 0)
     {
      cal_Buffer2 = cal_Buffer1;
     } else
     {
      cal_Buffer2 = cal_Buffer2 * cal_Buffer1;
     }
     tf_getText.delete(0,tf_getText.length());
     tf_Display.setText("" + cal_Buffer2);
     break;
    case DIVISION:
     cal_Buffer1 = Double.parseDouble(tf_Display.getText());
     if (cal_Buffer2 == 0)
     {
      cal_Buffer2 = cal_Buffer1;
     } else
     {
      cal_Buffer2 = cal_Buffer2 / cal_Buffer1;
     }
     tf_getText.delete(0,tf_getText.length());
     tf_Display.setText("" + cal_Buffer2);
     break;
 
    default :
   }
  } catch(NumberFormatException ne) {}
  this.cal_Check = cal_Check;
 }

 public void result()
 {
  try
  {
   if (cal_Check == PLUS)
   {
    String result = cal_Buffer2 + Double.parseDouble(tf_Display.getText()) + "";
    tf_Display.setText(result);
   } else if (cal_Check == MINUS)
   {
    String result = cal_Buffer2 - Double.parseDouble(tf_Display.getText()) + "";
    tf_Display.setText(result);
   } else if (cal_Check == MULTIPLICATION)
   {
    String result = cal_Buffer2 * Double.parseDouble(tf_Display.getText()) + "";
    tf_Display.setText(result);
   } else if (cal_Check == DIVISION)
   {
    String result = cal_Buffer2 / Double.parseDouble(tf_Display.getText()) + "";
    tf_Display.setText(result);
   }
  }
  catch (NumberFormatException ne){}
  tf_getText.delete(0,tf_getText.length());
  cal_Buffer1 = 0;
  cal_Buffer2 = 0;
 }

 public static void main(String[] args)
 {
  new Calculator();
 }
}

class keyAdapter implements KeyListener
{
 public void keyPressed (KeyEvent e){}
 public void keyReleased (KeyEvent e){}
 public void keyTyped (KeyEvent e){}
}

15. 인터페이스 (interface)
   (1) 설명
  모든 메소드가 추상메소드, 모든 속성이 상수(대문자)로 구성된 틀
  즉, 추상 메소드와 상수로만 구성된 껍대기.
   (2) 생김새 (ex: 004day/Inter.java)

Inter1.java

16. 인터페이스와 추상클래스를 사용하는 목적 (다형성)
  - 구현 메소드의 내용을 알 필요가 없이 인터페이스나 추상 클래스의 내용만 알면
    개발자가 구현 클래스를 이용해서 프로그램을 작성할 수 있다.
 즉, 타 소프트웨어와 독립적인 프로그램을 작성할 수 있다. (ex: JDBC)
 (ex: 004day/Term.java)

Term.java

 cf) 인터페이스는 '통로'다. - GUI
 cf) 인터페이스는 '껍대기'다. - 추상메소드/상수

17. 연산자 (Operator)
   (1) 설명 : 변수들을 연산하게 하는 기호
   (2) 종류
     <1> 산술연산자
   ex) +, -, *, /, %
   cf) java에서 +연산자는 String에 사용시 +연산자 오버라이딩 된다.
 
  <2> 증감연산자
   ex) ++, --
   - 앞에 붙으면 모든 연산자보다 우선순위가 높고 뒤에 붙으면 우선순위가 가장 낮아진다.
 
  <3> 대입연산자.
   ex) =
 
  <4> 산술 할당(대입) 연산자.
   ex) +=, -=, *=, /=, %=

  <5> 비트연산자
   ex) &, |, ^, ~, shift연산자(<<, >>, <<<)

  <6> 비교연산자 (true/false)
   ex) ==, !=, <, >, <=, >=

  <7> 논리연산자
   ex) &&, ||, &, |, !

  <8> 논리 할당(대입) 연산자)
   ex) &=, |=

  <9> 조건 연산자
   ex) 삼항 연산자 (A? B:C)

    int a=(3<4)? 1:2;

    int a = 0;
    if(3<4) a = 1;
    else a = 2;
    //System.out.println("a : " + a);

  <10> instanceof 연산자 (true/false)
   ex) 객체이름 instanceof 클래스이름
   // 연산자 우선순위를 인식해야 한다.
  
   (ex: 004day/OperTest.java)

OperTest.java

18. 조건문
   (1) if(boolean형){}문
   (2) if(boolean형){} else if(boolean형){}...문
   (3) if(boolean형){} else if(boolean형){}... else{} 문

   (4) switch(정수형){case : ... default : }문
     - 정수형, break, default 위치에 관계 없다.
  - case 에게 {}이 필요가 없다.
  (ex: 004day/ConTest.java)

ConTest.java

19. 반복문
   -> 구성요소 : 초기식, 조건식, 증감식
   (1) while(boolean형)
     - 초기값은 out of Loop, 증감식은 in of Loop
   (2) do{} while(boolean형);
     - 적어도 한번은 실행된다.
   (3) for (초기식; 조건식; 증감식){}
     (ex: 004day/LoopTest.java)

LoopTest.java

20. 제어의 이동 ( * * * )
  (1) 제어란? : 시간의 개념이 들어간 프로그램의 흐름
 (제어점 : 시간을 정지한다면 그때의 프로그램 실행점)
 
  (2) 제어의 특징
 자기를 호출한 메소드나 소프트웨어(JVM)에 다시 돌아오는 성격

  (3) 제어핸들링 keyword
  <1> return
  호출한 놈/곳(소프트웨어/메소드)에게 제어권을 넘긴다.
  (ex: ControlTest.java)

ControlTest.java

ControlTest2.java

ControlTest3.java

21. 예외처리
   (1) 예외(Exception)
  프로그램이 정상적으로 진행하지 못하게 하는 돌발상황
  ex) 전원이 갑자기꺼짐, 파일 읽다가중단, 숫자가아닌 문자를 숫자로 바꿀려 할때
   채팅하다가 상대방이 나가버린 경우, (채팅)서버가 다운.....
  
   (2) 예외처리 계층도
              Object
                 │
           Throwable
  ┌────┴────┐
Error                   Exception
                       ┌──┴──┐
      RuntimeException       CheckedException
 
  cf) Error 는 자바 시스템관련 문제시에 발생되는 예외이기때문에 프로그래머가
   잡을수 없고 Exception 만 프로그래머가 잡을 수 있는데, CheckedException은
   컴파일시 체킹하는 예외이고 RuntimeException 은 실행시 체킹하는 예외로써
   잡지 않아도 컴파일은 정상적으로 실행된다.

   (3) 예외처리의 목적
  프로그램 진행시 발생할 수 있는 돌발상황을 예외로 미리 정해놓고, 해당하는 상황의
  예외가 발생했을 경우 적절한 조치를 취해서 프로그램이 정상적으로 작동하도록 하기
  위함이다.

   (4) 예외처리의 특징
  <1> 예외는 메소드 또는 생성자에서만 발생
  <2> 클래스 설계시 예외를 발생시킬 때에는 throw 라는 예약어 사용
  <3> 예외가 발생되는 메소드 또는 생성자에는 throws 예약어로 호출한 놈/곳으로 넘기거나
   (== 처리가 되어야 함을 명시하거나) try~catch 절로 직접 잡는다.
  <4> 예외는 자신의 Exception 또는 그 상위(부모) Exception 으로 잡을 수 있다.
  
   (5) 예외처리 방법
  <1> try{
    예외를 발생시키는 구문
   }catch (발생된 예외객체){
   예외가 발생했을 때의 로직 처리
   }
  <2> 예외를 호출한 놈/곳으로 넘긴다. throws  절로 점기는 방법

  (ex : ExceptionTest1.java)

   (6) 하나의 메소드/생성자에서 같은 try블록에 두개 이상의 Exception이 발생할 경우 처리
  <1> 상속관계 Exception 이라면
    -> (더욱 구체적인 Exception 처리를 위해서) 하위 Exception 부터 잡아준다.
  <2> 상속관계가 아닌 Exception 이라면
    -> catch() 절의 위치가 상관이 없다.

   (7) finally 절
  <1> 설명 : (try{} 나 catch(){} 가 수행되고 나서) 항상 수행되는 절이다.
  <2> 특징
    - try{}이 먼저 기술되어야 나올 수 있다.
    - try{} 나오면 반드시 catch(){} 또는 finally{}가 나오던지 아니면
      둘다 나와야 한다.
    - return 을 만나도 항상 수행된다.

    예외) 제어가 try{}나 catch(){}절에서 System.exit();를 만나면 finally 절은 수행되지 않는다.

  (ex : ExceptionTest2.java)

ExceptionTest1.java

ExceptionTest2.java