Hello, World ♡.♡

윈도우 핸들이란 무엇인지 알아봅시다

겨울에 — Sat, 15 Nov 2014 10:02:40 +0900

출처 : http://cluster1.cafe.daum.net/_c21_/bbs_search_read?grpid=qvQp&fldid=8mOp&datanum=23&openArticle=true&docid=qvQp8mOp2320060320174013

비베전문가되기 - [API 응용 팁] 윈도우 핸들이란 무엇인지 알아봅시다

글쓴이 : 서당개3년

'먼저 프로젝트 --> 모듈 추가 를 눌러서 표준 모듈을 하나 생성합니다.

'폼에는 ListBox 한개를 그립니다.

'표준모듈에서 프로시져를 하나 작성합니다

'Public Sub Main()

'아래 그림과 같이 시작개체를 변경합니다.

Option Explicit -표준 모듈 부분 -

'외부적인 프로그램 제어를 할때 우리는 흔히 "핸들을 얻는다" 라는 표현을 쓴다.
'핸들이란 무엇인가? 자동차에도 핸들이 있다
'우리가 원하는 방향으로 자유로운 이동을 가능하게 해주는 도구이다
'그럼 윈도우 핸들이란 무엇인가?
'멀티태스킹이 가능한 윈도우 체제로 넘어오면서 동시에 여러가지 작업이 가능하다보니
'우리의 화면에는 수많은 윈도우들이 보여질때가 있다
'이때 시스템에서는 이들을 구분할수 있는 무언가가 필요하게 되었고
'간략하게 말하면 구분이 되는 근거가 바로 핸들이란것이다
'우리는 이 핸들이란걸 구해서 많은 일들을 할수 있게 된다
'내가 만든 프로그램이 아니어도 내가 원하는 방식으로 재 동작할수 있게끔 유도할수도 있는것이다.
'오늘은 이 핸들이란걸 구하는 많은 방식중의 한가지를 알아본다

Public Declare Function FindWindow Lib "user32" Alias "FindWindowA" ( _
ByVal lpClassName As String, _
ByVal lpWindowName As String) As Long
'FindWindow : 현재 실행중인 윈도우에서 특정윈도우를 찾는다
'lpClassName : 클래스명
'lpWindowName : 캡션명

Public Declare Function EnumChildWindows Lib "user32" ( _
   ByVal hWndParent As Long, _
   ByVal lpEnumFunc As Long, _
   ByVal lParam As Long) As Long

'EnumChildWindows : 부모윈도우의 핸들값을 근거로 모든 자식 윈도우를 반환한다
'hWndParent :부모 윈도우 핸들
'lpEnumFunc : 부모 윈도우가 소유한 모든 자식윈도우를 콜백함수로 전달한다(프로시져의 주소)
'lParam : 콜백함수가 참조할 값

Public Declare Function GetClassName Lib "user32" Alias "GetClassNameA" ( _
   ByVal hwnd As Long, _
   ByVal lpClassName As String, _
   ByVal nMaxCount As Long) As Long

'GetClassName : 핸들값을 근거로 해당 윈도우의 클래스명을 얻는다
'hwnd : 핸들
'lpClassName : 구한 클래스명을 담게될 문자변수
'nMaxCount : 문자의 범위 지정

Public lngParent As Long
Public sClass As String
Public Const iBuff As Integer = 255

Public Sub main()

   '프로젝트가 시작하면서 Daum 사이트에 연결된 브라우져를 찾습니다
   lngParent = FindWindow("IEFrame", "Daum - 우리 인터넷, Daum - Microsoft Internet Explorer")
   If lngParent <> 0 Then '찾았으면 핸들값을 찾지 못하면 0 을
      '부모 윈도우의 핸들값을 넘겨주면 모든 자식 윈도우를 찾는 API 함수
      'EnumChildWindows 함수는 모든 자식윈도우를 처리하기 전까지는 True 를 갖게되고
      '모든 처리가 완료되면 False 를 반환하며 이때 함수가 종료됩니다.
      '프로시져의 주소를 넘겨주었고 함수는 해당 프로시져를 실행하고 옵니다.
      '해당 프로시져는 Function 이므로 실행하고 올때는 반환값을 가지고 오겠죠
      EnumChildWindows lngParent, AddressOf EnumChild, 0
      'AddressOf 연산자는 프로시져의 주소를 넘겨줍니다
      '넘어가는 프로시져는 반드시 "표준 모듈" 의 프로시져이어야 합니다.
      '그래서 시작개체를 Form1 이 아닌 sub main() 으로 변경해 준겁니다.
   End If
   '모든 처리가 끝났으니 폼1을 보이고
   frmHandle.Show
   '폼1의 캡션을 찾은 자식윈도우 갯수로 바꾼다.
   frmHandle.Caption = CStr(frmHandle.List1.ListCount)
End Sub

Public Function EnumChild(ByVal hwnd As Long, ByVal lp As Long) As Boolean
   Dim tmp As String * 255 '문자변수가 갖을수 있는 문자의 범위를 255로 지정
   Dim ret As Long

   '넘겨받은 자식윈도의 핸들값으로 클래스명을 갖는다
   'hwnd : 자식윈도 핸들값
   'tmp : 클래스명을 받아올 문자변수
   'iBuff : 문자가 최대수용가능한 길이를 지정한 숫자변수
   ret = GetClassName(hwnd, tmp, iBuff)
   '최대공간을 255문자로 지정해서 클래스명을 받아오는 문자변수에는
   'Null 값이 포함되서 넘어온다 Null 값을 찾아서 걸러주는 역활을 한다
   sClass = Left(tmp, InStr(tmp, Chr(0)) - 1)
   '폼1 의 리스트박스에 해당 값을 쓴다
   frmHandle.List1.AddItem sClass & "     " & CStr(hwnd)
   EnumChild = True
End Function

'바로 이어서 이렇게 구해진 핸들을 가지고 많은 일들을 할수가 있는데

'그중 간단한 예제를 하나 들어보겠습니다

'폼에 커맨드버튼 하나를 생성해주고 아래와 같이 코딩해 줍니다.

Option Explicit -폼 모듈 부분-
'특정 윈도우의 문자를 바꾸어주는 함수

Private Declare Function SetWindowText Lib "user32" Alias "SetWindowTextA" ( _
ByVal hwnd As Long, _
ByVal lpString As String) As Long

Private Sub Command1_Click()
   '이전 글 에서 설명한데로 FindWindow 함수로 구해진 부모핸들을 이용해
   '익스플로러 제목 표시줄에 뜬 문자를 바꾸어줍니다
   SetWindowText lngParent, "내맘데로 원하는데로"
End Sub

'아래와 같이 바뀌는걸 확인할수 있습니다.

'비슷한 방법으로 자동 접속을 시도한다던지 마우스나 키보드를 직접 제어하지 않고도

'API 함수를 이용해서 클릭효과나 이벤트 발생등등 여러가지를 할수가 있게 됩니다

'그건 다음에 또 기회가 되면 올리도록 하지요

'그럼 즐공하세요

프로세스 이름으로 검색 & 종료

겨울에 — Sun, 10 Jun 2012 11:59:21 +0900

//프로세스 이름으로 현재 프로세스 목록을 검색하여 일치하는 프로세스를 찾으면 핸들을 얻어 죽이는 방법입니다.

//첨부파일을 다운받아 해당 프로젝트 풀더에 압축을 풀어야 프로세스 관련 API를 사용하실 수 있습니다.

#include <Tlhelp32.h>
#include "Psapi.h"
#pragma comment (lib, "psapi.lib")

CString ProcessName; //종료할 프로세스 이름

ProcessName.MakeUpper();

HANDLE hSnapshot = CreateToolhelp32Snapshot ( TH32CS_SNAPPROCESS, 0 );

if ( (int)hSnapshot != -1 )
{
    PROCESSENTRY32 pe32 ;
    pe32.dwSize=sizeof(PROCESSENTRY32);
  BOOL bContinue ;
  CString tempProcessName;

if ( Process32First ( hSnapshot, &pe32 ) )
{

        //프로세스 목록 검색 시작
        do
        {
            tempProcessName = pe32.szExeFile; //프로세스 목록 중 비교할 프로세스 이름;
            tempProcessName.MakeUpper();
            if( ( tempProcessName.Find(ProcessName, 0) != -1 ) )
            {
                HANDLE hProcess = OpenProcess( PROCESS_ALL_ACCESS, 0, pe32.th32ProcessID ); //프로세스 핸들 얻기
                if( hProcess )
                {
                    if (/*프로세스 종료 조건*/)
                    {

//프로세스 종료
DWORD dwExitCode;

GetExitCodeProcess(hProcess, &dwExitCode);
TerminateProcess(hProcess, dwExitCode);

                    }
                    CloseHandle(hProcess);
                }
            }
            bContinue = Process32Next ( hSnapshot, &pe32 );
        } while ( bContinue );
    }
    CloseHandle( hSnapshot );
}

//pe32.th32ProcessID 즉 PID를 얻으면 프로세스 핸들을 얻을 수 있고 이 핸들을 이용하여 메모리 정보나 프로세스 실행 시간등의 정보를 얻을 수 있습니다.

//프로세스 정보에 관한 내용은 다음 글에 이어서 올리도록 하겠습니다.

출처 : 데브피아

psapi-my1over.zip

HTML 색 이름(color name)

겨울에 — Fri, 2 Dec 2011 08:57:21 +0900

출처 : http://blog.naver.com/popssong?Redirect=Log&logNo=70108789183
HTML 색 이름(color name)|작성자 뱃놀이

색상명을 클릭하면, 클릭한 색상을 배경으로 다른 색과의 조화를 볼수 있습니다.

[출처] HTML 색 이름(color name)|작성자 뱃놀이

Color Names Supported by All Browsers

147 color names are defined in the HTML and CSS color specification (17 standard colors plus 130 more). The table below lists them all, along with their hexadecimal values.

Tip: The 17 standard colors are: aqua, black, blue, fuchsia, gray, grey, green, lime, maroon, navy, olive, purple, red, silver, teal, white, and yellow.

Click on a color name (or a hex value) to view the color as the background-color along with different text colors:

Color Name	HEX	Shades	Mix
AliceBlue	#F0F8FF	Shades	Mix
AntiqueWhite	#FAEBD7	Shades	Mix
Aqua	#00FFFF	Shades	Mix
Aquamarine	#7FFFD4	Shades	Mix
Azure	#F0FFFF	Shades	Mix
Beige	#F5F5DC	Shades	Mix
Bisque	#FFE4C4	Shades	Mix
Black	#000000	Shades	Mix
BlanchedAlmond	#FFEBCD	Shades	Mix
Blue	#0000FF	Shades	Mix
BlueViolet	#8A2BE2	Shades	Mix
Brown	#A52A2A	Shades	Mix
BurlyWood	#DEB887	Shades	Mix
CadetBlue	#5F9EA0	Shades	Mix
Chartreuse	#7FFF00	Shades	Mix
Chocolate	#D2691E	Shades	Mix
Coral	#FF7F50	Shades	Mix
CornflowerBlue	#6495ED	Shades	Mix
Cornsilk	#FFF8DC	Shades	Mix
Crimson	#DC143C	Shades	Mix
Cyan	#00FFFF	Shades	Mix
DarkBlue	#00008B	Shades	Mix
DarkCyan	#008B8B	Shades	Mix
DarkGoldenRod	#B8860B	Shades	Mix
DarkGray	#A9A9A9	Shades	Mix
DarkGrey	#A9A9A9	Shades	Mix
DarkGreen	#006400	Shades	Mix
DarkKhaki	#BDB76B	Shades	Mix
DarkMagenta	#8B008B	Shades	Mix
DarkOliveGreen	#556B2F	Shades	Mix
Darkorange	#FF8C00	Shades	Mix
DarkOrchid	#9932CC	Shades	Mix
DarkRed	#8B0000	Shades	Mix
DarkSalmon	#E9967A	Shades	Mix
DarkSeaGreen	#8FBC8F	Shades	Mix
DarkSlateBlue	#483D8B	Shades	Mix
DarkSlateGray	#2F4F4F	Shades	Mix
DarkSlateGrey	#2F4F4F	Shades	Mix
DarkTurquoise	#00CED1	Shades	Mix
DarkViolet	#9400D3	Shades	Mix
DeepPink	#FF1493	Shades	Mix
DeepSkyBlue	#00BFFF	Shades	Mix
DimGray	#696969	Shades	Mix
DimGrey	#696969	Shades	Mix
DodgerBlue	#1E90FF	Shades	Mix
FireBrick	#B22222	Shades	Mix
FloralWhite	#FFFAF0	Shades	Mix
ForestGreen	#228B22	Shades	Mix
Fuchsia	#FF00FF	Shades	Mix
Gainsboro	#DCDCDC	Shades	Mix
GhostWhite	#F8F8FF	Shades	Mix
Gold	#FFD700	Shades	Mix
GoldenRod	#DAA520	Shades	Mix
Gray	#808080	Shades	Mix
Grey	#808080	Shades	Mix
Green	#008000	Shades	Mix
GreenYellow	#ADFF2F	Shades	Mix
HoneyDew	#F0FFF0	Shades	Mix
HotPink	#FF69B4	Shades	Mix
IndianRed	#CD5C5C	Shades	Mix
Indigo	#4B0082	Shades	Mix
Ivory	#FFFFF0	Shades	Mix
Khaki	#F0E68C	Shades	Mix
Lavender	#E6E6FA	Shades	Mix
LavenderBlush	#FFF0F5	Shades	Mix
LawnGreen	#7CFC00	Shades	Mix
LemonChiffon	#FFFACD	Shades	Mix
LightBlue	#ADD8E6	Shades	Mix
LightCoral	#F08080	Shades	Mix
LightCyan	#E0FFFF	Shades	Mix
LightGoldenRodYellow	#FAFAD2	Shades	Mix
LightGray	#D3D3D3	Shades	Mix
LightGrey	#D3D3D3	Shades	Mix
LightGreen	#90EE90	Shades	Mix
LightPink	#FFB6C1	Shades	Mix
LightSalmon	#FFA07A	Shades	Mix
LightSeaGreen	#20B2AA	Shades	Mix
LightSkyBlue	#87CEFA	Shades	Mix
LightSlateGray	#778899	Shades	Mix
LightSlateGrey	#778899	Shades	Mix
LightSteelBlue	#B0C4DE	Shades	Mix
LightYellow	#FFFFE0	Shades	Mix
Lime	#00FF00	Shades	Mix
LimeGreen	#32CD32	Shades	Mix
Linen	#FAF0E6	Shades	Mix
Magenta	#FF00FF	Shades	Mix
Maroon	#800000	Shades	Mix
MediumAquaMarine	#66CDAA	Shades	Mix
MediumBlue	#0000CD	Shades	Mix
MediumOrchid	#BA55D3	Shades	Mix
MediumPurple	#9370D8	Shades	Mix
MediumSeaGreen	#3CB371	Shades	Mix
MediumSlateBlue	#7B68EE	Shades	Mix
MediumSpringGreen	#00FA9A	Shades	Mix
MediumTurquoise	#48D1CC	Shades	Mix
MediumVioletRed	#C71585	Shades	Mix
MidnightBlue	#191970	Shades	Mix
MintCream	#F5FFFA	Shades	Mix
MistyRose	#FFE4E1	Shades	Mix
Moccasin	#FFE4B5	Shades	Mix
NavajoWhite	#FFDEAD	Shades	Mix
Navy	#000080	Shades	Mix
OldLace	#FDF5E6	Shades	Mix
Olive	#808000	Shades	Mix
OliveDrab	#6B8E23	Shades	Mix
Orange	#FFA500	Shades	Mix
OrangeRed	#FF4500	Shades	Mix
Orchid	#DA70D6	Shades	Mix
PaleGoldenRod	#EEE8AA	Shades	Mix
PaleGreen	#98FB98	Shades	Mix
PaleTurquoise	#AFEEEE	Shades	Mix
PaleVioletRed	#D87093	Shades	Mix
PapayaWhip	#FFEFD5	Shades	Mix
PeachPuff	#FFDAB9	Shades	Mix
Peru	#CD853F	Shades	Mix
Pink	#FFC0CB	Shades	Mix
Plum	#DDA0DD	Shades	Mix
PowderBlue	#B0E0E6	Shades	Mix
Purple	#800080	Shades	Mix
Red	#FF0000	Shades	Mix
RosyBrown	#BC8F8F	Shades	Mix
RoyalBlue	#4169E1	Shades	Mix
SaddleBrown	#8B4513	Shades	Mix
Salmon	#FA8072	Shades	Mix
SandyBrown	#F4A460	Shades	Mix
SeaGreen	#2E8B57	Shades	Mix
SeaShell	#FFF5EE	Shades	Mix
Sienna	#A0522D	Shades	Mix
Silver	#C0C0C0	Shades	Mix
SkyBlue	#87CEEB	Shades	Mix
SlateBlue	#6A5ACD	Shades	Mix
SlateGray	#708090	Shades	Mix
SlateGrey	#708090	Shades	Mix
Snow	#FFFAFA	Shades	Mix
SpringGreen	#00FF7F	Shades	Mix
SteelBlue	#4682B4	Shades	Mix
Tan	#D2B48C	Shades	Mix
Teal	#008080	Shades	Mix
Thistle	#D8BFD8	Shades	Mix
Tomato	#FF6347	Shades	Mix
Turquoise	#40E0D0	Shades	Mix
Violet	#EE82EE	Shades	Mix
Wheat	#F5DEB3	Shades	Mix
White	#FFFFFF	Shades	Mix
WhiteSmoke	#F5F5F5	Shades	Mix
Yellow	#FFFF00	Shades	Mix
YellowGreen	#9ACD32	Shades	Mix

[출처] HTML 색 이름(color name)|작성자 뱃놀이

LPSTR, LPCSTR, LPTSTR, LPCTSTR, LPWSTR, LPCWSTR

겨울에 — Mon, 26 Sep 2011 22:21:51 +0900

출처 : http://beggu84.blog.me/90098891240

[출처] LPSTR, LPCSTR, LPTSTR, LPCTSTR, LPWSTR, LPCWSTR |작성자 헐쿠

LP: long pointer (.Net에선 64bit, VC++에선 32bit)

STR: string 자료형 (NULL값을 가진 char* 배열)

T: unicode

W: wide(2byte) char

C: constant

LPSTR = long pointer + string = char*

LPCSTR = long pointer + constant + string = const char*

LPCTSTR = long pointer + constant + t_char + string = const char* 혹은 const w_char*

LPTSTR = long pointer + t_char + string = char* 혹은 w_char*

LPWSTR = long pointer + wide + string = w_char*

LPCWSTR = long pointer + constant + wide + string = const w_char*

windows 환경에서 유니코드를 표현하기 위해 TCHAR, t_char를 쓰는데

컴파일러 운영체제에서 멀티바이트 환경이면 char형으로,

unicode 환경이면 w_char, wide char 형으로 type casting 한다.

LPWSTR에 W는 멀티바이트, unicode 두 환경에서 모두 unicode 문자열을 쓴다

하지만 LPCTSTR에 T는 환경설정에 따라서 선택해서 쓸 수 있다.

그러므로 언어에 좀 더 자유롭게 개발하려면 T를 사용하는 것이 좋을 것이다.

흔히 CString을 char*로 캐스팅할 때 (LPSTR)(LPCTSTR)string을 쓴다.

(LPCTSTR)은 연산자 오버로딩(operator overloading)으로 const char*를 반환한다.

그리고 const char*를 char*에 대입할 수 없기 때문에

(LPSTR) 강제 캐스팅으로 const를 날린다.

[출처] LPSTR, LPCSTR, LPTSTR, LPCTSTR, LPWSTR, LPCWSTR|작성자 헐쿠

[EnumWindows()]

겨울에 — Mon, 26 Sep 2011 13:05:44 +0900

출처 : http://blog.naver.com/ratmsma?Redirect=Log&logNo=40027853699

>FindWindow는 탐색기건 뭐건간에 타이틀 바만 동일한 것의 윈도우 핸들을 반환하므로

>FindWindow()해서 가져온 것이 제가 작성한 프로그램이 아닐수가 있지 않습니까?

FindWindow는 타이틀 바(FindWindow의 두번째 인자, 즉 윈도우 네임) 뿐 아니라,
클래스 네임(첫번째인자)으로도 윈도우 탐색 작업이 가능합니다.

그러나 정작 FindWindow를 사용할 때의 문제점은 동일 클래스명, 동일 윈도우명을 가진 윈도우가
두 개 이상 다수 존재할 때, 그 중 첫번째 윈도우 만을 검색한 후 바로 탐색 작업을 중지한다는 데 있습니다.

즉, FindWindow를 for나 while 루프로 감싸 반복실행시켜도 언제나 똑같은 윈도우 핸들만을
리턴할 우려가 다분하다는 거지요.

해서, 이럴 경우엔 EnumWindows나 때에 따라서는 EnumChildWindows를 곁들여 사용하시는 것이
가장 속편할 듯 싶습니다.

// EnumWindows 사용법.

::EnumWindows (hWnd, EnumProc, NULL);

BOOL CALLBACK EnumProc(HWND hwnd, LPARAM lParam)
{
TCHAR buf[100];

GetClassName (hwnd, (LPTSTR)&buf, 100);
if ( _tcscmp( buf, _T("class_name") ) != 0 ) return TRUE;

// 타이틀바에 쓰여진 문자열 비교시엔 GetClassName대신 GetWindowText 사용.

// 원하는 코드 수행
return FALSE;
}

위 콜백함수에서 TRUE를 리턴하면 데스크탑 상의 모든 윈도우가 조회될 때까지
콜백 루프가 반복해서 돌아갑니다. 반면 FALSE를 리턴하면 그 순간 탐색작업은 중단되지요.

만일 자작 윈도우와 기존 윈도우의 클래스 네임과 타이틀 네임이 정확하게 일치한다 했을 때는
두 윈도우(혹은 다수 윈도우)의 핸들이 모두 리턴되는데, 이때 특정 윈도우의 구별을 위해선
생각하기에 따라서 여러 방법을 다양하게 구사하실 수 있을 듯 싶습니다.

이를 테면, 윈도우 사이즈 비교라든가 아니면 윈도우들간 zorder 상의 위치,
혹은 어떤 child widnow나 parent 윈도우를 포함하고 있는지 등등...

만일 자작 윈도우인 경우라면, 클래스 네임을 타 윈도우와 구별가능하게끔 독특하게 지어보세요.
그럼 EnumWindows까지 사용하실 필요없이 FindWindow로도 쉽게 검색하실 수 있을 듯 싶은데요.

[사용예]

탐색기를 닫는걸로 예를 들겠습니다...

dlg에서 예를 들자면,,,,,

initdlg()에서, 함수를 호출해주죠...

EnumWindows(CloseExplorer, 0);

고럼 이 함수는,,,,

BOOL CALLBACK CTest ::CloseExplorer(HWND hwnd, LPARAM lParam)

{

       TCHAR buf[100];

      GetClassName (hwnd, (LPTSTR)&buf, 100);
       if ( _tcscmp( buf, _T("ExplorerwClass") ) != 0 )

PostMessage(hwnd, WM_CLOSE, 0, 0); //ExplorerwClass는 스파이+에서 찾으셈..

return true;

}

요래하면 되겠죵?? ^ㅡ^

음... 난 또 다른 방법으로..탐색기를 죽였는데요...아래처럼.. ㅎ

bool CTEst::KillExplorer()
{
       char  szClass[MAX_PATH];
       HWND  hParent, hChild;

       hParent = GetWindow(GetDesktopWindow(), GW_CHILD);//차일드 윈도우나 컨트롤의 윈도우 포인터를 얻는다.
        hChild = GetWindow(hParent, GW_HWNDFIRST);
        while (hChild != NULL)
        {
                GetClassName(hChild, szClass, MAX_PATH);
                if (strcmp(szClass, "ExploreWClass") == 0)
                PostMessage(hChild, WM_CLOSE, 0, 0);
                hChild = GetWindow(hChild, GW_HWNDNEXT);
         }

return true;

}

===>정리하자면,

탐색기창 클래스명 : ExploreWClass
내 컴퓨터 창 클래스명 : CabinetWClass
인터넷 창 클래스명 : IEFrame
static BOOL CALLBACK CloseExplorer(HWND hwnd, LPARAM lParam);//선언

EnumWindows(CloseExplorer, 0);//init()등 필요 함수에서 호출

BOOL CALLBACK CTest ::CloseExplorer(HWND hwnd, LPARAM lParam)
{
     TCHAR buf[100];
     GetClassName (hwnd, (LPTSTR)&buf, 100);
     if ( _tcscmp( buf, _T("ExplorerwClass") ) != 0 )
        PostMessage(hwnd, WM_CLOSE, 0, 0); //ExplorerwClass는 스파이+에서 찾으셈..
     return true;

=>또는 ,
    CWnd* pdw;
    pdw=CWnd::FindWindow(_T("ExploreWClass"), NULL);
    if(pdw && ::IsWindow(*pdw))
       pdw->PostMessage(WM_CLOSE);
    return TRUE;
}

[출처] [EnumWindows()]탐색기 죽이기, 프로그램 죽이기|작성자 헤더막스

현재 실행중인 프로세스를 종료하는 C언어, C++

겨울에 — Mon, 26 Sep 2011 12:58:43 +0900

출처 : http://kin.naver.com/qna/detail.nhn?d1id=1&dirId=1040101&docId=65945187&qb=YysrIOyLpO2WiSDspJHsnbg=&enc=utf8&section=kin&rank=1&search_sort=0&spq=0&pid=gF/3%2BU5Y7tossvFdbPCssc--046408&sid=Tn-3tEfuf04AAEGeLMM

현재 실행중인 프로세스를 종료하는 소스좀 얻을수없을까요?

만약 a.exe라는 게 실행되고 있다면 어떤 소스를이용하여 그것을 종료하는 프로그램요..

만약 cmd.exe 를 종료하고싶다면 종료할수있는 소스.. 예제 나 참고 할만한것좀 알려주세요!!

해당프로세스의 핸들을 얻어서 TerminateProcess()를 날리는 복잡(?)한 방법보다.

운영체제에서 기본적으로 제공하는 기능을 이용하면 굉장히 간단합니다-

(정렬같은것도 기본적으로 명령을 제공한답니다-)

윈도우에서 TASKKILL이라는 명령이 기본적으로 제공되는데요

TASKKILL /F /IM cmd.exe /T

라는 명령을 실행하면 cmd.exe와 거기 종속된 모든 자식 프로세스들이 강제로 종료됩니다.

즉- 저 명령을 코드상에서 ShallExecute()등을 이용해서 호출하면 됩니다-

FindWindow, FindWindowEx, WindowFromPoint

겨울에 — Mon, 26 Sep 2011 10:42:34 +0900

출처 : http://blog.naver.com/nawoo?Redirect=Log&logNo=80103648279

윈도우 찾기

윈도우 간의 상호작용을 위해서는 우선 윈도우의 핸들을 알아야지 윈도우 관련 함수들을 사용할 수 있다.

원하는 윈도우의 핸들을 조사하는 기본적인 함수는 FindWindow이다.

1. FindWindow

HWND FindWindow(

LPCTSTR lpClassName, //조사할 윈도우의 클래스 이름
LPCTSTR lpWindowName //조사할 윈도우의 캡션
);

조건에 맞는 윈도우를 찾으면 윈도우의 핸들을 리턴해 주고 못찾을경우 NULL을 리턴해준다.

ex)

HWND h1 = FindWindow(NULL, L"NateOn");

HWND h2 = FindWindow(L"My_Class", NULL);

2. FindWindowEx

HWND FindWindowEx(

    HWND hwndParent,      //hwndParent에 속한 차일드 윈도우를 검색해낸다. NULL이면 데스크탑 윈도우의 차일드를 검색한다.
    HWND hwndChildAfter, //검색을 시작할 차일드 윈도우를 지정한다. NULL이면 첫번째 차일드부터 검색한다.
    LPCTSTR lpszClass,    //조사할 윈도우의 클래스 이름
    LPCTSTR lpszWindow    //조사할 윈도우의 캡션
);

ex)

HWND h1 = FindWindowEx(hWnd, NULL, NULL, L"에디트");

결과 : 메인 윈도우 아래 캡션이 "에디트"라는 컨트롤이 존재할 경우 그 컨트롤의 윈도우 핸들을 반환해준다.

3. WindowFromPoint

HWND WindowFromPoint(

POINT Point
);

: 화면 좌표로 윈도우를 검색하는 함수로 인수로 화면 좌표를 POINT형으로 넣어주면 된다.

: 조건에 맞는 윈도우를 찾으면 윈도우의 핸들을 리턴해 주고 못찾을경우 NULL을 리턴해준다.

ex)

POINT pt;

GetCursorPos(&pt);
HWND h2 = WindowFromPoint(pt);

결과 : 마우스의 스크린좌표를 가져오는 GetCursorPos 함수로 마우스 좌표를 얻고 그 좌표를 인수로 넘겨주었다.

마우스 아래 있는 윈도우의 핸들을 가져오게 된다.

* 스파이 같은 윈도우의 속성을 조사하는 유틸리티나 드래그 & 드랍시 드랍 윈도우를 조사할 때 등 여러모로 쓸모가 많다.

부모 윈도우의 차일드 윈도우를 조사하는 함수 ( 나중에 사용할 일 있으면 다시 정리)

4. ChildWindowFromPoint

HWND ChildWindowFromPoint(
    HWND hWndParent,
    POINT Point
);

5. ChildWindowFromPointEx

HWND ChildWindowFromPointEx(

    HWND hwndParent,
    POINT pt,
    UINT uFlags
);

윈도우 핸들 가져오기

겨울에 — Mon, 26 Sep 2011 09:19:00 +0900

출처 : http://www.devpia.com/MAEUL/Contents/Detail.aspx?BoardID=50&MAEULNO=20&no=724063&ref=724063

CWnd* p = CWnd::FromHandle((HWND)0x????????);

WPARAM w = 0;

LPARAM l = 0;

CPoint pt(0,0);

GetCursorPos(&pt);

p->ScreenToClient(&pt);

l = MAKELONG(pt.x,pt.y);

p->SendMessage(WM_LBUTTONDOWN,w,l);

p->SendMessage(WM_LBUTTONUP,w,l);

////////////////////////////////////////////////////////

먼저 위의 코드를 봐주시기 바랍니다.

특정 윈도우의 핸들을 가져다가 자동으로 왼쪽 마우스가

한번 클릭 되도록 유도하는 코딩입니다.

예를 들어 IE를 열어서 "www.google.com"를 열람한 후에,

해당 IE창의 윈도우 핸들값을 위의 "(HWND)0x????????"에 대체 합니다.

이제, 검색창에 "데브피아"라고 입력하고

마우스를 "Google Search"단추에 올려놓은 다음

위의 코드를 실행하면, 자동으로 검색 단추가 눌러집니다.

질문:

현재 WindowFinder.exe를 써서 핸들 값을 찾고 있는데...

WindowFinder.exe를 사용안하고, html페이지의 title이나

title의 일부만 가지고 해당 IE창의 윈도우 핸들값을

찾을 수 있는 방법이 있을까요?

예를 들어서 구글은 www.google.com으로 title를 시작하고

네이버는 www.naver.com으로 title를 시작합니다.

그런데 www.goo라던가, www.nav라는 스티링 값만 가지고

열람 되어져 있는 IE창의 윈도우 핸들값을 가져올 수 있는

방법이 있을까요?

고수님들의 조언 부탁드립니다.

감사합니다.

FindWindow(LPCTSTR szClass, LPCTSTR szName);

두번째 인자값이 윈도우의 캡션 영역의 타이틀 이름입니다.

예를 들어서

을 찾고자 한다면

FindWindow(NULL, _T("제목 없음 - 메모장"));

하시면 윈도우 핸들을 구하실 수 있습니다.

타이틀 바의 일부만 가지고 찾으 실꺼면

프로세스 목록을 얻어와서 각각의 프로세스의 캡션 이름을 얻은 후에 문자열 비교를 하시면 되실겁니다.

실행된 프로그램의 특정 버튼을 누르게

겨울에 — Mon, 26 Sep 2011 09:08:58 +0900

[출처 : 데브피아 http://www.devpia.com/Forum/BoardView.aspx?no=15684&ref=15684&page=1&forumname=MOBILE_QA&stype=&KeyW=%b9%f6%c6%b0+%c5%ac%b8%af+%b8%de%bc%bc%c1%f6&KeyR=titlecontent ]

실행된 프로그램의 특정 버튼을 눌르게 법은 ??

안녕하세요.

얼마전에 실행파일의 특정 버튼 클릭에 대해서 질문을 했었는데, 결국 해결하지는 못했습니다.

몇일 삽질 끝에 데브님들의 도움을 받고자 이렇게 몇자 끄적입니다.

제가 실행하고 싶은 프로그램은 공개버전인 SJphone입니다.

여기 보면 통화마크 버튼과 통화끈기 버튼 2개가 있는데, 이 버튼에 대한 이벤트 처리입니다.

인스톨버젼은 올려두겠고요.

제가 테스트한 소스는

void CTESTDlg::OnBtn1()

{

// TODO: Add your control notification handler code here

HWND hSjPhone = ::FindWindow(L"Dialog", L"sjphone"); // <--- sjphone 헨들 검사

if(hSjPhone == NULL) // <--- sjphone이 떠있지 않다면..

{

SHELLEXECUTEINFO shellInfo;

memset( &shellInfo, 0, sizeof(SHELLEXECUTEINFO ));

shellInfo.cbSize= sizeof(SHELLEXECUTEINFO);

shellInfo.fMask = SEE_MASK_NOCLOSEPROCESS;

shellInfo.hwnd = hWnd;

shellInfo.lpVerb = L"Open";

shellInfo.nShow = SW_SHOW;

shellInfo.lpFile = L"\\program files\\sjphone\\sjphone.exe";

ShellExecuteEx(&shellInfo);

Sleep(1000);

SipFindExe(hWnd, pwText);

return;

}

::ShowWindow(hSjPhone, SW_SHOW);

::SetForegroundWindow(hSjPhone);

//<----------- 이곳에서부터 의문..

HWND hTemp = ::GetNextDlgTabItem(hSjPhone, NULL, FALSE); // <----- TAB Order값을 가져옴

WCHAR wszClassName[255] = {0};

int nCompare = 1;

for(int nCount = 0; hTemp != NULL; nCount++)

{

GetClassName(hTemp, wszClassName, 255);

nCompare = wcscmp(wszClassName, L"Button");

if(nCompare == 0)

{

break;

}

else

{

hTemp = ::GetNextDlgTabItem(hSjPhone, hTemp, FALSE);

}

::SendMessage(hTemp, WM_LBUTTONDOWN, NULL, (LPARAM)pwText);

}

소스를 보시면 아시겠지만, sjphone의 클래스헨들값을 가져와서 비교한후 WM_LBUTTONDOWN 메세지로 클릭이

되게 하였습니다.

spy++로 다이얼로그를 보니 Button이 무지많더군요. ㅡㅡ;

제가 원하는 것은 통화 버튼과 통화 끈기 버튼인데, 우선 버튼 클릭이라도 성공하고자 위와같이 처리했습니다.

저리하면 어떤 버튼이 될지는 모르겠지만 하나는 눌리까 햇는데, 버튼 자체를 찾지 못하더군요.

디버깅을 해보니 SJphone 헬들을 가져와서 GetclassName 비교하느곳을 보니 WCE_edit, ListSystem32 이것만

계속 가져옵니다.

sjphone의 통화버튼, 통화끈기 버튼 둘중에 하나라도 눌리게좀 수정좀 해주세요ㅜㅜ

부탁드립니다.

Re: ...

::SendMessage(hTemp, WM_LBUTTONDOWN, NULL, (LPARAM)pwText);

이부분을 이렇게 바꿔보시는건 어떨까요?

::PostMessage(hTemp, WM_KEYDOWN, (WPARAM)VK_RETURN, (LPARAM)0);

::PostMessage(hTemp, WM_KEYUP, (WPARAM)VK_RETURN, (LPARAM)0);

그럼 성공하시길...

[출처] [펌] 실행된 프로그램의 특정 버튼을 누르게...|작성자 프라이데이

C 에서 Dos 명령어 실행하기

겨울에 — Wed, 14 Sep 2011 16:36:40 +0900

출처 : 네이트 지식
http://ask.nate.com/qna/view.html?n=3209219

Q.
c언어에서 O/S 내부명령어를 쓸려면 어떻게 해요?
어떤 함수를 써야하나요 예를 들어서 갈쳐주세요??

maildown

님의 답변
형식 : int _Cdecl system(const char *command);

헤더 : <process.h>, <stdlib.h>
기능 : C 프로그램의 실행하에서 DOS 명령 배치 화일등을 실행하기 위해 command.com을 호출한다.

예)
     system("dir > abc.txt"); // 현위치 파일 목록을 abc.txt에 저장한다.
     system("copy lim.dat cho.txt"); // lim.dat파일을 cho.txt로 복사한다.
     system("cls"); //화면을 지운다.
등등등...입니다.

Windows에 GCC 컴파일러 설치하기

겨울에 — Wed, 14 Sep 2011 13:32:47 +0900

출처 : 네이버 지식인
http://kin.naver.com/qna/detail.nhn?d1id=1&dirId=104&docId=70675829&qb=Z2NjIOy7tO2MjOydvOufrA==&enc=utf8&section=kin&rank=1&search_sort=0&spq=0

Q. gcc 컴파일러 설치법 or 사용법 좀 가르쳐주세요.

http://sourceforge.net/project/showfiles.php?group_id=2435&package_id=240780&release_id=529741

위 사이트에 들어가시면 MinGW-5.1.3 파일을 다운 받을 수 있습니다.

다운 받은 파일을 실행시키면, 설치할 경로를 지정할 수 있는데요..

(저는 C:\Windows\MinGW 에 설치했습니다.)

설치가 모두 끝나면

내 컴퓨터 -> (마우스 오른쪽 클릭) 속성 -> 고급 -> 환경변수 -> 사용자 변수 -> PATH (더블클릭)

모두 지우면 안됩니다. .. 마지막 부분에 아래 내용 추가

;c:\windows\mingw\bin

(사용자가 설치한 위치를 넣어주셔도 됩니다. 그리고 마지막에 \bin 추가)

** bin 디렉터리에는 gcc 를 비롯하여 실행파일이 모두 들어있습니다.

확인을 누르고 나온 다음..

시작 -> 실행 -> cmd를 입력하면 검은 창이 나올텐데요..

그 곳에 gcc 라고 쳐보세요.. no input file 이라고 나오면 정상 작동하는 것입니다.

visual studio에 연결해서 사용할 수 있는지는 모르겠고요..

java와 비슷한 환경설정을 하시면 사용할 수 있습니다.

개인서버에서 메일설정과 SSL설정 FTP설정 XE core버전업방법 텍스트큐브 openid오류

겨울에 — Mon, 5 Sep 2011 15:31:18 +0900

출처 : NAVER 지식IN
http://kin.naver.com/qna/detail.nhn?d1id=1&dirId=10302&docId=105448729&qb=c3NsIOyxhQ==&enc=utf8&section=kin&rank=1&search_sort=0&spq=0

제가 집에서 개인서버를 돌리고있는데 몇가지 문제가 있어서 질문드립니다..

일단 서버환경은

아톰 D510 1.66Ghz (2코어 4쓰레드)

DDR2 2G x2 (총 4G) RAM

1TB 삼성 F3 HDD

인터넷환경: QOOK 100M (유동IP)

공유기: IPTime N6004

공유기 옵션 -- Twin-IP 기능으로 서버에 공인IP 물림

OS: Fedora 12

PHP 버전 : 5.3.1

MySQL 버전 : 5.1.42

Apache 버전 : 2.2.14

PHP info page--> http://skyserv.kr

일단 서버환경은 위와같습니다..

httpd.conf에서 버츄얼호스트로 블로그와 제로보드 홈페이지를 돌리고 있구요..

http://blog.skyserv.kr --->텍스트큐브 블로그

http://web.skyserv.kr ---->제로보드 XE 사이트

제로보드XE버전은 1.2.4입니다... full버전은 그것뿐이더군요;;(설치경로 /home/web/xe)

네임서버는 DNSEver네임서버 쓰고있습니다

질문내용은

1.메일문제입니다...

회원가입시 인증메일발송체크하고 testid로 가입하니 인증메일을 발송하였습니다 확인해주십시오 라고 뜨고나서

메일은 안오더군요;;;; 로그인하려니 메일확인하라고 뜨고......

메일서버를 설치해야하나요??;;

설치해야한다면 Qmail로 해야하나요 sendmail로 해야하나요;;(XE setting에는 Qmail과 연동이라는 체크가 있어서 혼동됩니다;;)

또 제가 리눅스사용은 처음이라서 명령어도 아직모르거든요;;;ㅠㅠ;;

설치법,XE와 연동하는법좀 가르쳐 주셨으면 합니다

안된다면 관련 게시글링크나 어디에 나와있다 이것만이라도 적어주시면 감사하겠습니다..

sendmail은 설치되있습니다... 설정법이랑 연동법을 모르겠네요;;;

-----------------------------------------------------------------------------------------

[root@localhost skyserv]# telnet localhost 25
Trying ::1...
telnet: connect to address ::1: Connection refused
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
220 localhost.localdomain ESMTP Sendmail 8.14.3/8.14.3; Tue, 23 Feb 2010 15:06:25 +0900

-----------------------------------------------------------------------------------------

telnet점검 결과입니다...

2.SSL설정 XE setting중 SSL설정 사용으로 놓으면 페이지를 찾을수 없습니다가 떠버리더군요;;;;;;

왜이런지......해결책좀 알려주셨으면합니다....

정안되면 SSL설정 안하고 운영해야겠죠;;

3.FTP설정..

아이디/비번은 mysql db 아이디/비번을 입력하고 포트는 개방했는데 접속확인하면

"localhost로의 FTP 접속 오류가 발생하였습니다. ftp 포트 번호를 확인해주시거나 ftp 서비스가 가능한지 확인해주세요"

라고 뜹니다;;;

FTP서버는 vsFTP쓰고.....아직 아무설정도 안했습니다;;

----------------------------------------------------------------------------------------

[root@localhost skyserv]# /etc/init.d/vsftpd start
vsftpd에 대한 vsftpd을 시작합니다: [ OK ]
[root@localhost skyserv]# telnet localhost 21
Trying ::1...
telnet: connect to address ::1: Connection refused
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
220 (vsFTPd 2.2.0)
-----------------------------------------------------------------------------------------

telnet 점검 결과구요;;

FTP사용법 설정법좀 가르쳐주셨으면합니다;;; 안된다면 역시 링크나 관련사이트,게시글좀;;;

4.XE core업데이트 하는법 질문드리겠습니다;;

너무 많은걸 요구해서 죄송합니다;;;;

추가로 텍스트큐브에서 openid가 안되더군요 로그인하려면 자꾸 애러나서 추가질문 드립니다;;

직접확인하시는게 나을것 같네요;; http://blog.skyserv.kr

해결방법좀 가르쳐주세요;;;

"http500 내부서버오류"

안녕하세요.

1. 센드메일은 뭐 설정할 것도 없이 바로 메일이 오갑니다.
서비스 데몬만 살아 있다면 말이죠.
mx 레코드로 인한 문제로 보입니다.
일단 센드메일은 이분만큼 설명 잘한 사이트를 본적이 없습니다.
http://oops.org/
센드메일 관련 부분은 http://oops.org/?t=lecture&s=sendmail
이 부분입니다.

하지만 제가 봤을 때 이문제는 메일 서버의 mx 레코드가 없으니까, 발송 자체가 안되는 것으로 보입니다.
테스트 해보실려면, 센드메일 스크립트를 이용해서 개인계정 이를테면 다음이나 네이버로 메일 발송을 해보시기 바랍니다.
스펨메일함으로 가겠지만, 일단 메일은 발송이 됩니다.

[root@]# nslookup
> set type=mx
> yourdamain.pe.kr
Server:         168.126.63.1
Address:        168.126.63.1#53

Non-authoritative answer:
yourdamain.pe.kr mail exchanger = 20 mail2.yourdamain.pe.kr.
yourdamain.pe.kr mail exchanger = 10 mail.yourdamain.pe.kr.

Authoritative answers can be found from:
yourdamain.pe.kr      nameserver = ns.yourdamain.pe.kr.
yourdamain.pe.kr      nameserver = ns2.yourdamain.pe.kr.
mail.yourdamain.pe.kr internet address = your ip address
mail2.yourdamain.pe.kr        internet address = your ip addres
ns.yourdamain.pe.kr   internet address = your ip addres

이렇게 정상적으로 박혀 있어야, 테스트가 진행이 될꺼에요...

2. 개인 서버 운영하실려고 해도, ssl키는 발행하는 것이 좋다고 생각합니다.
키교환 프로토콜을 이용해서 운영하시는 개인서버가 CA(인증 및 발행기관)가 되면 가능한 부분인데,
이 부분은 그렇게 신경 쓰시는 부분이 아닌것 같네요.
괜찮은 책이 있어서 말씀드립니다.
제가 애독하는 책인데요..
centos 리눅스 구축 관리 실무라고 김태용씨가 저술한 책이 있습니다.
이 부분에 개인 ssl 발급 과정이 언급되어 있습니다.

3. 위에 언급한 사이트에 보면 http://oops.org/?t=lecture&s=ftpd
ftp에 관한 자세한 설정이 언급되어 있습니다.

4. 제가 잘 모르는 부분이라 패스하겠습니다.

My sql encode, decode, password로 암호화 하긔

겨울에 — Mon, 5 Sep 2011 09:07:17 +0900

출처 : http://woodair.blog.me/100019460633
작성자 : 나무실

Mysql 패스워드 암호화 기법

[출처] Mysql 패스워드 암호화 기법|작성자 나무실

mysql> INSERT INTO member_1 (id,passwd) VALUES ('id',encode('abcdefg','13579'))";

위에 encode('abcdefg','13579')중 passwd는 가입시 회원이 입력한 패스워드고 뒤에 '13579'는 암화호 시킬 코드 값입니다.

그러니까 13579라는 값으로 회원이 입력한 패스워드를 우리가 알수 없는 값으로 암호화 시키는 것입니다.

mysql> select decode(passwd,'13579') from member_1 WHERE id = '$id' and jumin = '$jumin;

decode(passwd, '13579')는 우리가 알수 없는 암호값을 13579라는 암호 키값을 풀어 줍니다. 그러면 결과는 abcdefg라고 나옵니다..

결론은 다른 사람이 암화 키값인 13579라는 값을 모르면 암호를 볼수가 없다는 겁니다.. 이부분은 여러분이 각자의 실력으로 해결 하세요..

----------------------------------------------------------

위의 방법도 괜찮지만.. -_-;

password() 함수를 써서 암호화를 하면 더욱 보안이 됩니다.

mysql> INSERT INTO user_table (id, pwd) VALUES ('$id', PASSWORD('$pwd'));

위와같이 입력하면 $pwd 부분이 암호화되어 DB 에 저장됩니다.
물론... 길게~ 바뀌게 됩니다. (mysql reference 참고)

mysql> SELECT * FROM user_table WHERE id = '$id' AND pwd = PASSWORD('$pwd');

이렇게 해서 회원 아이디와 비번을 비교할 수 있습니다.

물론.. 회원아이디를 먼저 검사하고 비밀번호를 검사해두 되겠졈.

password() 함수를 사용하게되면 위의 encode, decode 함수에서의 문제인

키값의 노출로 인한 걱정을 안해두 되겠죠.

단, 비밀번호를 분실했을때 본인조회후 비밀번호를 새로 입력받아야 하는

문제가 있긴해여. 글치만.. 보안은 되져.. 헤~

질문이나 위에서 틀린점은 댓글 부탁해여~

추가

공개키 암호화 알고리즘이 적용된 암호화 기법이네요...

┏다음은 암호화에 사용되는 SQL문입니다.
┃
┃INSERT INTO Member
┃(ID, Pass)
┃VALUES
┃('MyID', encode('MyPass','MyKey'))
┃
┃encode() 함수가 암호화하는 일을 합니다.
┗인수중 'MyPass'가 암호화할 문자열이고 'MyKey'가 함호화에 사용되는 키입니다.

┏다음은 복호화에 사용되는 SQL문입니다.
┃
┃SELECT
┃decode(Pass,'MyKey')
┃FROM Member
┃WHERE ID = 'MyID'
┃
┃decode()함수가 복호화하는 일을 합니다.
┃암호화에 사용된 키를 인수로 주면 암호화되어 저장되었던 값이
┗복호화되서 반환됩니다.

사용자 정보에 민감한 사이트에서 사용하면 뛰어난 보안이 이루어지겠습니다.
암호화에 사용되는 키는 세션ID와 같은 난수를 사용하면 좋을 것 같군요.

[출처] Mysql 패스워드 암호화 기법|작성자 나무실

Oracle NVL, DECODE 함수

겨울에 — Thu, 7 Jul 2011 13:03:45 +0900

출처 : http://blog.naver.com/chocolleto/30099301093 Oracle NVL, DECODE 함수|작성자 외계인셩

Oracle NVL, DECODE 함수

▫ NVL()

▪ 정의

NVL(string1, replace_with)

- string1 : null값을 포함할 수 있는 값이나 표현식.

- replace_with : nll값을 전환시 사용할 값.

▪ 특징

- NULL 값을 다른 값으로 바꿀 때 사용.

- 모든 데이터 타입에 적용 가능. 단, 전환되는 값의 데이터 타입을 일치시켜야 함;

- row 가 없는 값에 대해서도 값을 얻고 싶을 경우에는 숫자관련 함수와 같이 사용.

Ex> select nvl(max(sal), 0) from emp where type=’Z’;

▪ 예제

// desc emp;

// select * from emp;

/* type이 null이면 ‘D’로 바꾸어 출력. */

select nvl(type, 'D'), name, sal, logday from emp;

/* sal이 null이면 ‘20000’으로 바꾸어 출력. */

select type, name, nvl(sal,20000), logday from emp;

/* logday가 null이면 to_date(’11-12-2010’, ‘DD-MM-YYYY’)로 바꾸어 출력. */

select type, name, sal, nvl(logday, to_date('11-12-2010', 'DD-MM-YYYY')) from emp;

▫ DECODE()

▪ 정의

DECODE({column | expression}, search1, result1 [, search2, result2] ... [, default])

- column | expression : 조건을 수행해야 할 컬럼 혹은 표현식.

- search : 조건.

- result : 해당 조건이 참일 경우 수행하는 부분.

- default : else에 해당할 경우 수행하는 부분.

▪ 특징

- 특정 컬럼의 값을 기준으로 마치 switch case문을 사용하는 것과 같은 효과를 내는 함수.

- 해당 컬럼의 값이 ‘A’이면 지정한 특정한 값을 출력하교, ‘B’이면 또 다른 값을 출력.

- 기본값을 정해서 조건을 만족하지 않는 경우의 출력 제어 가능.

▪ 예제

/* type에 따라 직업명 출력(A:개발,B:기획,C:디자인, default:인사) */

select type, name, sal, logday, decode(type, 'A', '개발', 'B', '기획', 'C', '디자인', ‘인사’) as job from emp;

/* type별 count 하기. */

select

count(decode(type, 'A', name)) as A_cnt,

count(decode(type, 'B', name)) as B_cnt,

count(decode(type, 'C', name)) as C_cnt,

count(decode(type, '', name)) as default_cnt

from emp;

/* type에 따른 인상급여 출력. */

select type, name, sal, decode(type, 'A', sal*2, 'B', sal*1.05, 'C', sal*1.1, sal*1.15) as newsal from emp;

▫ 참고 자료

- http://yagi815.tistory.com/467

- http://luckys.tistory.com/35

[JAVA] File과 Directory 접근

겨울에 — Thu, 7 Jul 2011 12:57:02 +0900

원본 출처 : http://blog.naver.com/lovesw3896/30004527429

출처 : http://wearekorean.co.kr/zbxe/645

1. File 객체로 작업하기

1> File 객체의 정의

* File객체는 하드디스크에 존재하는 실제 파일이나 디렉토리가 아니고 그것에 대한 경

로(Pathname) 또는 참조(reFerence)를 추상화한 객체이다. 파일 객체는 새 파일에

대한 경로나 만들고자하는 디렉토리를 캡슐화한 것이다.

2> File 객체의 용도

* 물리적 파일 시스템에 대해 캡슐화한 경로명을 확인하고 실제의 파일이나 디렉토리

와 대응되는지 알아볼 때.

* 파일 스트림객체를 생성하고자 할 때.

2. File 객체 생성하기

1>File 객체를 생성하는 데에는 네 개의 생성자를 사용할 수 있다.

* 인자로 String 객체를 전달하는 것.

File mtDir - new File("c:/j2SDK 1.4.0/src/java/io");

File 클래스의 생성자는 인자로 전달된 경로를 확인하지 않는다 .

File 클래스의 생성자로 어떤 문자열을 넘겨도 된다는 것을 알 수 있다.

File 객체는 불변적이므로 객체를 생성하고 나면 그것이 가진 경로를 바꿀 수 없다

* 첫번째 인자로 부모 디렉토리를 가진 File객체 전달, 두번째 인자로 String객체 전달.

부모 디렉토리 - 해당 파이을 가지고 있는 디렉토리.

* 첫번째 인자로 부모 디렉토리의 경로를 String객체로 전달, 두번째 인자로 String객체

전달.

* URL이용.

2>경로에 대한 이식성을 고려

* 경로 이름을 만드는 것은 시스템에 의존적이지만 File 클래스의 separator 변수를 사

용함으로써 좀 더 시스템에 독립적으로 myFile에 대한 경로를 지정 가능.

3>절대경로와 상대경로

* 절대 경로 : 접두사(c:\, c://)를 포함하는 경로.

ex) cd c:\java\API 이런 식의 경로 이동을 하는 방법이 절대 경로.

* 상대 경로 : 접두사가 없는 경로.

ex) cd java 이런 식의 경로 이동을 하는 방법이 상대 경로.

4>시스템 속성에 접근하기

* 파일에 대한 상대 경로를 지정하는 것이 시스템 독립적이긴 하지만 현재의 환경에 독

립적인 경로를 지정하고자 하는데, 현재 디렉토리 또는 현재 디렉토리의 하위 디렉토

리는 데이터 파일을 저장하기에 적합하지 않은 상황도 있을 수 있다. 이런 경우에 시스

템 속성에 접근하는 것이 도움이 될 수 있다.

3. File 객체를 확인하고 테스트하기

1> File 객체에 대한 정보를 얻을 수 있는 메서드

getName() - 경로를 제외한 파일의 이름. 즉, 경로의 가장 마지막 부분을 String 객체로

리턴한다.

getPath() - 파일이나 디렉토리 이름을 포함한 File 객체의 경로를 String으로 리턴한다.

isAbsolute() - File 객체가 절대경로를 참조하고 있다면 true, 아니라면 false를 리턴한

다.

getParent() - 현재 File 객체가 나태내는 파일 EH는 디렉토리의 부모 디렉토리의 이름

을 String으로 리턴한다. 이때 리턴되는 경로는 파일 이름을 포함하지 않

은 순수한 경로명이다. 만약 File 객체가 현재 디렉토리에서 단순히 파일

이름만을 사용해서 만들어져 부모 디렉토리가 명시되어 있지 않을 경우

에는 null을 리턴한다.

toString() - 현재 File 객체의 String표현을 리턴하며 File 객체가 String 객체로 변환될

필요가 있을 때 자동으로 호출된다.

hashCode() - 현재 File 객체의 해시코드 값을 리턴한다.

equals() - 두 개의 File 객체가 동일한 것인지 비교할 때 사용되는 메소드이다. 인자로

넘겨지는 File 객체가 현재의 객체와 같은 경로를 가지고 있으면 true를 그렇

지 않으면 false를 리턴한다.

2> File 객체가 참조하는 파일이나 디렉토리를 테스트하기 위한 메서드

exist() - File 객체가 참조하는 파일 또는 디렉토리가 실제로 존재하면 true를, 그렇지

않으면 false를 리턴한다.

isDirectory() - File 객체가 디렉토리를 참조하는 경우 true를, 그렇지 않으면 false를

리턴한다.

isFile() - File 객체가 파일를 참조하는 경우 true를, 그렇지 않으면 false를 리턴한다.

isHidden() - File 객체가 숨김 속성이 있는 파일을 참조하는 경우 true를, 그렇지 않으

면 false를 리턴한다.

canRead() - File 객체가 참조하는 파일 또는 디렉토리를 읽을 권한이 있다면 true를,

없다면 false를 리턴한다. 만약 권한이 없는데 읽으려고 시도하면

SecurityException이 발생한다.

canWrite() - File 객체가 참조하는 파일 또는 디렉토리에 쓰기 권한이 있다면 true를,

없다면 false를 리턴한다. 만약 권한이 없는데 읽으려고 시도하면

SecurityException이 발생한다.

getAbsolutePath() - 현재의 File 객체가 참조하는 파일 또는 디렉토리의 절대경로를

리턴한다. 만약 객체가 절대경로를 포함하고 있다면 getPath() 메

소드에 의해 리턴되는 것과 동일한 문자열을 리턴할 것이다. 그렇

지 않다면 윈도우즈 환경에서는 현재 디렉토리가 나타내는 경로

의 드 라이브 이름을 사용하거나 경로에 드라이브 이름이 명시되

어 있지 않다면 현재 사용자 디렉토리에 대해서 절대경로가 결정

된다. 유닉스 환경에서는 현재 사용자 디렉토리에 대해서 절대 경

로가 결정된다.

getAbsoluteFile() - 현재 File 객체가 참조하는 파일 또는 디렉토리의 절대경로를 포함

한 File 객체를 리턴한다.

=======================================소스 코드=======================================

import java.io.File;

public class TryFile {
public static void main(String[] args) {

    // 디렉토리를 참조하는 객체 생성
    File myDir = new File("C:/javaex1");
    System.out.println(myDir + (myDir.isDirectory() ? " is" : " is not")
                       + " a directory.");

    // 파일을 참조하는 객체 생성
    File myFile = new File(myDir, "TryFile3.java");
    System.out.println(myFile + (myFile.exists() ? " does" : " does not")
                       + " exist");
    System.out.println(myFile + (myFile.isFile() ? " is" : " is not")
                       + " a file.");
    System.out.println(myFile + (myFile.isHidden() ? " is" : " is not")
                       + " hidden");
    System.out.println("You can" + (myFile.canRead() ? " " : "not ")
                       + "read " + myFile);
    System.out.println("You can" + (myFile.canWrite() ? " " : "not ")
                       + "write " + myFile);
    return;
}

}

결과 1.

결과 2.

=======================================소스 코드=======================================

3> 존재하는 파일 또는 디렉토리에 대해 더 많은 정보를 제공해주는 메서드

list() - 현재 File 객체가 디렉토리를 나태내고 있다면 디렉토리 내의 파일 이름과하위

디렉토리의 이름들을 담고 있는 String 배열이 리턴된다. 만일 디렉토리가 비어

있다면 배열도 비어있을 것이다. 또한 File 객체가 파일을 나태내고 있다면 null

을 리턴할 것이다. 이 메소드는 허가되지 않은 디렉토리를 접근하려 할 경우

SecurityException을 발생시킨다.

listFiles() - 이 메소드를 호출한 객체가 디렉토리라면, 그 디렉토리 내의 파일과 하위

디렉토리에 대응되는 File 객체 배열이 리턴된다. 빈 디렉토리라면 빈 배열

이 리턴될 것이다. 호출된 객체가 디렉토리가 아니거나 입출력 오류가 발

생한다면 null을 리턴할 것이다. 이 메소드는 허가되지 않은 디렉토리에 접

근하려 할 때 SecurityException을 발생시킨다.

length() - 현재 File 객체가 참조하는 파일의 길이를 바이트 단위로 표현한 long 형의

값을 리턴한다. 현재 File 객체의 경로가 존재하지 않는 파일을 참조하고 있

다면 0을 리턴할 것이다. 만약 그 경로가 디렉토리를 참조한다면, 정의되지

않은 값이 리턴된다.

lastModified() - 현재 File 객체가 나타내는 파일 또는 디렉토리가 마지막으로 수정된

시각을 나타내는 long형의 값을 리턴한다. 이때 시각은 그리니치 표준

시(GMT)로 1970년 1월 1일 자정 이후로부터 지난 시간을 멀리 초 단

위로 계산한 값이다. 파일이 존재하지 않는다면 0을 리턴한다.

=======================================소스 코드=======================================

import java.io.File;
import java.util.Date; // Date 클래스를 사용하기 위해 포함시킴

public class TryFile2 {
public static void main(String[] args) {

    // 디렉토리를 참조하는 객체 생성
    File myDir = new File("C:/javaex1");
    System.out.println(myDir.getAbsolutePath()
                       + (myDir.isDirectory() ? " is " : " is not ")
                       + "a directory");
    System.out.println("The parent of " + myDir.getName() + " is "
                       + myDir.getParent());

// 디렉토리 내의 파일 리스트를 얻어옴
File[] contents = myDir.listFiles();

    // 파일 리스트를 출력
    if (contents != null) {
      System.out.println("\nThe " + contents.length
                         + " items in the directory " + myDir.getName()
                         + " are:");
      for (int i = 0; i < contents.length; i++) {
        System.out
          .println(contents[i] + " is a "
                   + (contents[i].isDirectory() ? "directory" : "file")
                   + " last modified "
                   + new Date(contents[i].lastModified()));
      }
    } else {
      System.out.println(myDir.getName() + " is not a directory");
    }

System.exit(0);
}
}

결과 1.

결과 2.

=======================================소스 코드=======================================

4> 파일 리스트 필터링

* list()와 listFiles() 메서드는 파일 리스트를 필터링하는 인자를 받도록 오버로드 되어

있다.

* list() 메서드의 인자는 FilenameFilter 타입의 변수여야 하지만,

* listFiles() 메서드는 FilenameFilter와FileFilter 두 가지를 모두 사용할 수 있다.

4. 파일과 디렉토리를 생성하고 수정하기

File 클래스에는 그 파일을 읽기 전용으로 만들거나 이름을 바꾸는 등 물리적인 파일에 변화

를 줄 수 있는 메서드가 있다. 또한 파일 또는 디렉토리를 생성하거나 삭제할 수 있게 해주는

메서드들도 있다.

renameTo(File path) - 현재 객체가 나타내는 파일의 이름이 메소드의 인자로 전달된

File 객체가 나타내는 경로를 변경될 것이다. 이것은 프로그램에

서 현재의 File 객체를 변경하는 것이 아니라 물리적인 파일을

실제로 바꾸는 것이라는 점을 주의해야 한다. 따라서 현재 File

객체가 나타내던 파일은이 메소드가 수행되고 나면 새로운 이름

을 가지게 되므로 더 이상 존재하지 않을 것이며 다른 디렉토리

에 위치하게 될 수도 있다. 새로운 경로에 있는 파일의 디렉토리

가 원래의 것과 다르다면 파일은 새로운 디렉토리로 옮겨질 것

이다. 만일 새로운 경로가 존재하지 않는 디렉토리이거나 그 곳

에 쓰길을 할 수 없다면 이 메소드는 실패할 것이다. 이 메소드

는 작업이 성공적으로 이루어지면 true를 리턴하고, 그렇지 않으

면 false를 리턴한다.

setReadOnly() - 현재 객체가 나타내는 파일을 읽기 전용으로 설정한다. 성공하면 true

를 리턴한다.

mkdir() - 현재의 File 객체에 의해 지정된 경로로 디렉토리를 생성한다. 이 메소는 생성

하려는 디렉토리의 부모 디렉토리가 미리 존재하지 않으면 실패할 것이다.

이 메소드는 성공하면 true를 리턴하고, 그렇지 않으면 false를 리턴한다.

mkdirs() - 현재 File 객체가 나타내는 디렉토리를 생성하며, 이때 필요한 모든 부모 디

렉토리도 함께 생성한다. 새로운 디렉토리가 성공적으로 생성되었다면 true

를 그렇지 않으면 false를 리턴한다. 메소드가 false를 리턴한 경우에도 부모

경로중 일부가 생성되었을 수도 있다.

createNewFile() - 현재 File 객체로 정의돈 경로에 비어있는 새로운 파일을 생성한다.

파일이 성공적으로 생성되면 true를 리턴한다. 경로에 지정된 디렉

토리가 존재하지 않는다면 IOException 예외가 발생하고, 지정된

파일이 이미 존재한다면 실패한다.

createTempFile(String prefix, String suffix, File directory)

- 이것은 directory 디렉토리에 처음 두 개의 인자를 사용해서 생성된 이름

으로 임시 파일을 생성하는 정적 메소드이고, 생성된 파일에 해당하는

File 객체를 리턴한다. 문자열 prefix는 파일 이름의 앞부분을 나타내며 최

소한 세 글자 이상은 되어야 한다. 문자열 suffix는 파일의 확장자를 나타

낸다. 파일 이름이 prefix와 다섯자 이상은 생성된 문자, 그리고 확장자로

이루어진다. 만약 suffix가 null이라면 확장자는 .tmp 가 될 것이다. prefix

나 suffix가 현재 시스템의 파일 이름으로 쓰기에 너무 길다면 끝 부분을

잘라내고 사용하지만, 세 글자 이하로 잘라내지는 않는다. directory 인자

가 null이라면 시스템의 임시 디렉토리가 사용될 것이다. 만일 팡ㄹ이 생

성될 수 없다면 IOEception이 발생하며 prefix가 세글자 이하라면

IllegalArgument Exception이 발생할 것이다.

createTempFile(String prefix, String suffix)

- createTempFile(String prefix, String suffix, File directory)와 동일하다.

delete() - 현재 File 객체가 나타내고 있는 파일 또는 디렉토리를 삭자하며 성공적으로

삭제되었다면 true를 리턴한다. 이 메소드는 비어있지 않은 디렉토리는 지우

지 않는다. 그러므로 디렉토리를 삭제하려면 디렉토리 내의 모든 파일을 먼

저 지워야 한다.

deleteOnExit() - 현재 File 객체가 나타내는 파일 또는 디렉토리가 프로그램이 끝날 때

에 삭제 되도록 한다. 이 메소드는 값을 리턴하지 않으며, 삭제는

JVM이 정상적으로 종료될 경우에만 시도된다. 일단 File 객체에 대해

서 이 메소드를 호출하면 삭제 작업은 돌이킬 수 없기 때문에 주의해

서 사용해야 한다.

5. 파일 출력 스트림 생성하기

디스크에 존재하는 물리적인 파일에 무언가 쓰고자 할 때 FileOutputStream 객체를 사용할 수

있다.

1>FileOutputStream 객체의 다섯 개의 생성자

FileOutputStream(String filename)

- filename이라는 이름의 파일에 대한 출력 스트림을 생성한다. 파일에 이

미 존재하는 내용을 덮어쓰게 된다. 어떤 이유로든 파일이 열리지 않는다

면 FileNotFoundException이 발생한다.

FileOutputStream(String filename, boolean append)

- filename이라는 이름의 파일에 대한 출려 스트림을 생성하며, 만약

append인자 값이 true이고 파일 내용이 존재한다면 그 내용 뒤에 덧붙여

쓴다. append인자 값이 false라면 이미 존재하는 파일의 내용을 덮어쓰게

된다. 어떤 이유로든 파일이 열리지 않는다면 FileNotFoundException이

발생한다.

FileOutputStream(File file)

- File 객체가 나타내는 파일에 대한 출력스트림을 생성하며, 이미 파일 내

용이 존재하면 그 내용을 덮어쓴다. 어떤 이유로든 파일이 열리지 않는다

면 FileNotFoundException이 발생한다.

FileOutputStream(File file, boolean append)

- File 객체가 나타내는 파일에 대한 출력 스트림을 생성하며, 만약 append

인자 값이 true이고 파일 내용이 이미 존재한다면 그 내용 뒤에 덧붙여 쓴

다. 어떤 이유로든 파일이 열리지 않는다면 FileNotFoundException이 발

생한다.

FileOutputStream(FileDescriptor desc)

- desc와 해당하는 출력 스트림을 생성한다. FileDescriptor 객체는 파일에

대해 이미 존재하고 있는 연결을 참조한다. 그래서 파일이 반드시 존재하

므로 이 생성자는 FileNotFoundException이 발생한다.

6. 파일이 존재하는 것을 보장하기

1> 파일이 존재하면 이 파일에 데이터를 덧붙이고 존재하지 않는 파일이면 생성하고자 할 때

파일 출력 스트림을 생성해야하는데, 여기서 확인해야 할 것들이 있다.

2> File 객체를 사용해서 실제로 디렉토리가 아니라 파일을 나타내고 있는지 확인한다. 만일

파일이 아니라면 더 이상 진행하지 말고 오류 메시지를 출력해 주어야 한다.

3> 그 파일이 존재하는지 확인하기 위해 File 객체를 사용한다. 파일이 존재하지 않는다면

File 객체가 절대경로를 가지고 있는지 확인해야 한다. 이것은 부모 디렉토리를 얻어오고

확인하는 데 사용된다.

4> 부모 디렉토리에 대한 경로를 얻어오고 이것을 사용해서 다른 File 객체를 생성한다. 부모

디렉토리가 존재하는지 확인하기 위해 새로운 File 객체를 사용한다. 만약 존재하지 않는

다면 File 객체의 mkdir() 메서드를 사용해서 새로 생성한다.

=======================================소스 코드=======================================

import java.io.File;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;

public class GuaranteeAFile {
public static void main(String[] args) {
String filename = "C:/Beg Java Stuff/Bonzo/Beanbag/myFile.txt";
File aFile = new File(filename); //File 객체 생성

//경로가 파일인지를 확인
if (aFile.isDirectory()) {

// 오류 메세지 후에 종료함

      // 여기서 키보드로부터 입력을 받아 다시 시도하도록 할 수 있음
      System.out.println("The path " + aFile.getPath()
                         + " does not specify a file. Program aborted.");
      System.exit(1);
    }

    // 파일이 존재하지 않을 경우
    if (!aFile.isFile()) {
      // 부모 디렉토리를 확인
      aFile = aFile.getAbsoluteFile();
      File parentDir = new File(aFile.getParent());
      if (!parentDir.exists()) {   // ... and create it if necessary
        parentDir.mkdirs();
      }
    }

    // 스트림에 대한 참조를 저장할 장소
    FileOutputStream outputFile = null;
    try {

      // 데이터를 추가하는데 사용될 스트림 생성
      outputFile = new FileOutputStream(aFile, true);
    } catch (FileNotFoundException e) {
      e.printStackTrace(System.err);
    }
    System.exit(0);
}
}

=======================================소스 코드=======================================

7. 파일 덮어쓰는 것을 방지하기

* 이미 파일이 존재할 때 그 파일을 덮어쓰고 싶을 않을 때 덮어쓰기를 막을 수 있는 방법이

있다. 저장하려는 원래 이름을 어떠한 방법으로든 바꿔준다면 그것이 덮어쓰기를 막을 수

있는 한 가지 방법이 될 수 있다.

=======================================소스 코드=======================================

import java.io.File;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;

public class AvoidOverwritingFile {
public static void main(String[] args) {
    String filepath = "C:/Beg Java Stuff/myFile.txt";
    File aFile = new File(filepath);
    FileOutputStream outputFile = null;     // 스트림에 대한 참조를 저장할 장소
    if (aFile.isFile()) {
      File newFile = aFile;                 // 원래의 파일을 가지고 시작함

      // 유일한 이름이 될 때까지 파일 이름에 "_old"를 덧붙임
      do {
        String name = newFile.getName();    // 파일의 이름을 얻어옴
        int period =
          name.indexOf('.');         // 확장자의 구분자를 찾음
        newFile = new File(newFile.getParent(),
                           name.substring(0, period) + "_old"
                           + name.substring(period));
      } while (newFile.exists());             // 이름이 바뀔 때까지 반복
      aFile.renameTo(newFile);
    }

// 새로운 파일 생성
try {

      // 데이터를 추가하기 위한 스트림 생성
      outputFile = new FileOutputStream(aFile);
      System.out.println("myFile.txt output stream created");
    } catch (FileNotFoundException e) {
      e.printStackTrace(System.err);
    }
    System.exit(0);
}
}

=======================================소스 코드=======================================

8. FileDescriptor 객체

1> FileDescriptor 객체

* FileOutputStream에는 FileDescriptor 타입의 객체를 리턴해주는 getFD() 메서드가 있

다.

* 여기서 FileDescriptor는 물리적인 파일에 대한 현재의 연결을 나타내는 객체이다.

* 직접 FileDescriptor 객체를 생성할 수는 없고 파일 스트림을 나타내는 객체로부터

getFD() 메서드를 호출해서 FileDescriptor 객체를 얻을 수 있다

* 스트림을 한번 닫고 나면 파일에 대한 연결이 끊어지므로 더 이상 FileDescriptor 객체

를 얻을 수 없다

2> FileDescriptor 객체 사용

* 표준 스트림에 대응되는 바이트나 문자 스트림을 만들고자 할 때 편리하게 사용할 수

있다

<요약>

1> File클래스의 객체는 파일 또는 디렉토리의 경로를 포함한다. File 객체가 가지고 있는 경로는 물리적인 파일이나 디렉토리와 반드시 대응되어야 할 필요는 없다.

2> File 객체가 가지고 있는 경로가 실제의 파일이나 디렉토리를 참조하는지를 확인하기 위해 File객체를 사용할 수 있다. 만약 실제 파일이나 디렉토리를 참조하고 있지 않은 경우 필요한 디렉토리나 파일을 생성할 수 있는 메소드들이 있다.

3> File클래스는 임시 파일을 생성할 수 있는 정적 메소드를 가지고 있다.

4> FileDescriptor 타입의 객체도 물리적인 파일을 나타낼 수 있다.

5> FileOutputStream 객체는 File 객체로부터 생성될 수 있으며, 쓰기 위해 파일이 열린다. 만약 파일이 존재하는 않는다면 가능한 곳에 새로 생성된다.

Window Focus and State in Java

겨울에 — Wed, 6 Jul 2011 13:10:55 +0900

출처 : http://www.developer.com/java/other/article.php/3502181

Java Programming, Notes # 1857

Preface

The focus subsystem

This lesson is part of a series of lessons designed to teach you how to use the focus subsystem. This is also the first part of a two-part lesson to teach you how to use the Window focus and state features.

The first lesson in the series was entitled Focus Traversal Policies in Java Version 1.4. The previous lesson was entitled Capturing Keyboard Strokes in Java.

Previous topics

Previous lessons in this series have taught you how to use several features of the new focus subsystem, including the following:

Defining new focus traversal keys.
How to control focusability at runtime.
The ability to query for the currently focused Component.
The default Focus Traversal Policy.
How to establish a focus traversal policy and modify it at runtime.
How to control the focus programmatically.
Opposite components.
The KeyEventDispatcher.
The KeyEventPostProcessor.

Topics covered in this lesson

This lesson, which is Part 1 of a two-part lesson, will explain Window focus and extended Windowstate.

(Although extended Window state is not a focus topic, it was very convenient to explain and illustrate the topic in this lesson, so I decided to include it here.)

Part 2 of this two-part lesson will present and explain a program that demonstrates various aspects ofWindow focus and extended Window state.

What do we mean by focus?

Among all of the applications showing on the desktop at any point in time, only one will respond to the keyboard.

If that application is a Java application, only one component within that application's graphical user interface (GUI) will respond to the keyboard. That is the component that has the focus at that point in time.

It is also possible for a Java Window, (and its subclasses Frame, JFrame, Dialog, and JDialog) to gain the focus and to respond to the keyboard even if the Window contains no focusable components.

A Java component or Window that has the focus also has the ability to fire KeyEvents when it responds to the keyboard. The fact that a component or Window can fire KeyEvents confirms that it has the focus.

Viewing tip

You may find it useful to open another copy of this lesson in a separate browser window. That will make it easier for you to scroll back and forth among the different figures and listings while you are reading about them.

Supplementary material

I recommend that you also study the other lessons in my extensive collection of online Java tutorials. You will find those lessons published at Gamelan.com. However, as of the date of this writing, Gamelan doesn't maintain a consolidated index of my Java tutorial lessons, and sometimes they are difficult to locate there. You will find a consolidated index at www.DickBaldwin.com.

Background Information

Window focus

An object of the class Window, or its subclasses Frame, JFrame, Dialog, and JDialog can gain the focus and respond to the keyboard. This is true even if the object doesn't contain any focusable components.

Extended Window state

Prior to V1.4, the state information maintained by a Window was limited to:

NORMAL
ICONIFIED

Subsequent to the release of V1.4, a Window can maintain state information that includes:

MAXIMIZED_HORIZ
MAXIMIZED_VERT
MAXIMIZED_BOTH

An object of the class Window and its subclasses Frame and JFrame have the ability to fire events when its state changes. A program can respond to those events and determine both the old state and the new state. The program can also determine the current state at any point in time by invoking thegetExtendedState method on the Window.

(I discovered this new feature while doing research into the Window focus topic. Even though it has little to do with the focus subsystem, it is relatively easy to illustrate and explain along withWindow focus. Therefore, I decided to include it in this lesson.)

Uses of Window focus

A couple of uses for the Window focus capability come immediately to mind. For example, one might like to display an animated creature in the client area of a Window, Frame or JFrame, and to control its movement and behavior using the arrow keys (or any other keys for that matter).

Because the Window can gain the focus, it can also respond to the keyboard and fire KeyEvents. Code could be written into the KeyEvent handlers to control the behavior of the animated creature.

Another possibility might be to display an image, (such as a street map) in the client area of theWindow and to use the arrow keys and other keys to scroll the image or to zoom in and out on the image. Once again, code could be written into KeyEvent handlers to provide the desired behavior.

Uses of Window state

A Window, a Frame, or a JFrame can fire events when the state of the Window changes.

(Throughout this lesson, I will often refer to a Frame, a JFrame, a Dialog, or a JDialog as aWindow, because Window is the superclass of these other classes.)

A Window is in one of the following five states at any point in time:

NORMAL
ICONIFIED
MAXIMIZED_HORIZ
MAXIMIZED_VERT
MAXIMIZED_BOTH

(This feature doesn't apply to Dialog and JDialog objects because they don't provide user controls that allow the user to iconify or to maximize them.)

Maximization

Prior to the release of V1.4, the standard windowIconified and windowDeiconified event types could be used by the program to learn that the user had either iconified or deiconified a Frame or a JFrameobject.

Prior to the release of the extended state feature in V1.4, I was not aware of any mechanism that made it possible for a program to determine that the user had maximized a Frame or a JFrame.

Subsequent to the release of V1.4, that determination is not only possible, it is also easy.

According to Sun,

"In older versions of the JDK a frame state could only be NORMAL or ICONIFIED. Since JDK 1.4 the set of supported frame states is expanded and frame state is represented as a bitwise mask."

Event notification and state maintenance

A program can now request to be notified each time the state of a Window changes, and can easily determine both the old state and the new state when the change occurs.

In addition, the current state is maintained automatically and is available at any time simply by invoking the getExtendedState method on the Window.

(In older versions, the appropriate query method was getState. The Sun documentation for V1.4.2 declares the getState method to be obsolete. - Note that I didn't say deprecated. - The getStatemethod has been replaced by the getExtendedState method in V1.4.)

Required modifications to the API

A fairly large number of modifications were required to add these two features to the API. Here is a partial list:

Definition of a new WindowFocusListener interface. This interface declares two new methods named windowGainedFocus and windowLostFocus. Each method receives an incoming parameter of type WindowEvent.
Definition of a new WindowStateListener interface. This interface declares a single new method named windowStateChanged, which also receives an incoming parameter of typeWindowEvent.
Update the WindowAdapter class to cause it to implement the two new interfaces listed above. It was also necessary to update the class to define default versions of the three new methods declared in those interfaces.
Update the WindowEvent class to add three new constants namedWINDOW_GAINED_FOCUS, WINDOW_LOST_FOCUS, and WINDOW_STATE_CHANGED. New overloaded constructors were also defined that allow for the construction of an object with a specified oldState and a specified newState. New methods named getOldState andgetNewState were also defined.
The Window class was upgraded to add two new methods named processWindowFocusEventand processWindowStateEvent. These two methods are required to support low-level focusand state event handling on the Window in conjunction with the enableEvents method. Four new registration methods named addWindowFocusListener, removeWindowFocusListener,addWindowStateListener, and removeWindowStateListener were added to the Windowclass to support high-level event registration and handling of the new focus and state event types. Finally, several new utility methods such as getWindowFocusListeners,getWindowStateListeners, isFocusableWindow, getFocusableWindowState,setFocusableWindowState, and isFocused were added to the Window class to support the new event types.

Order of event delivery

Sun tells us that when focus moves to a component in a Window that is not currently the activeWindow, the events relative to the newly active Window will be delivered in the following order:

WINDOW_ACTIVATED
WINDOW_GAINED_FOCUS
FOCUS_GAINED on the component gaining the focus

(For the case where the newly active Window doesn't contain any focusable components, only the first two events occur.)

Moving the focus to another Window

Similarly, when the focus moves from that component to a component in another Window, the order of event delivery will be:

FOCUS_LOST on the component losing the focus
WINDOW_LOST_FOCUS on the currently active Window
WINDOW_DEACTIVATED on the currently active Window
WINDOW_ACTIVATED on the new active window
WINDOW_GAINED_FOCUS on the new active window
FOCUS_GAINED on the component that is gaining the focus

Specific order must be maintained

Sun also tells us,

"... each event will be fully handled before the next event is dispatched. This restriction will be enforced even if the Components are in different contexts and are handled on different event dispatching threads.

... each event type will be dispatched in 1-to-1 correspondence with its opposite event type. For example, if a Component receives a FOCUS_GAINED event, under no circumstances can it ever receive another FOCUS_GAINED event without an intervening FOCUS_LOST event."

Preview

In Part 1 of this lesson, I will explain how a Window can gain the focus, and can respond to the keyboard while it has the focus, even if that Window contains no focusable components.

I will describe both low-level and high-level event handlers to respond to Window focus events.

I will explain how to make use of the extended Window state and will explain how a program can respond to Window state events to learn that the user has maximized a Window.

I will provide a program for your review that illustrates the above concepts.

I will explain that program in Part 2 of this lesson.

Description of the Program

The two parts of this lesson present and explain a sample program named FocusWindow02, which illustrates the ability of a Window

To gain and lose the focus
To fire events when the focus is gained or lost

The program also illustrates the capability of a Window object to fire events when the state of theJFrame changes among five different possible states. Significant among these possible states are three states having to with maximization of the Window.

A list of the five possible states was provided earlier in this lesson.

The program GUI

The program causes two JFrame objects to appear on the screen as shown in Figures 1 and 2.


Figure 1 Half of program GUI.

Only one can be active

Both JFrame objects appear on the screen at the same time, but only one can be active (indicated by the bright blue banner) at any given time.

(The fact that they both appear to be active in these images is an artifact of the way that I went about capturing the images.)


Figure 2 The other half of program GUI.

Physical location

The program places the two JFrame objects on the screen, one above the other. The JFrame object on the top (shown in Figure 1) contains two JButton objects, both of which are focusable.

The JFrame object on the bottom (shown in Figure 2) contains a single Canvas object, which is not focusable. Therefore, the JFrame object on the bottom contains no focusable components.

Coordinates of an invisible point

The JFrame object in Figure 2 illustrates the use of focus on a Window that contains no focusable components.

The coordinates of an invisible point are displayed on the Canvas near the location of the invisible point.

(The location of the invisible point is immediately to the left and slightly below the left-most character in the coordinates.)

Behavior of the JFrame object

When this JFrame object has the focus, pressing the arrow keys causes an increase or a decrease in the coordinate values for the invisible point.

(Each press on an arrow key increases or decreases the value of one coordinate by five pixels.)

Thus, pressing the arrow keys modifies and moves the displayed coordinate values.

Demonstrates that the JFrame has the focus

This is accomplished by servicing KeyEvents on the object, thus demonstrating that the JFrame object actually has the focus, even though it contains no focusable components.

Behavior of the other JFrame object

The JFrame object in Figure 1 contains two JButton objects labeled respectively:

Regain focus
Send focus to B

Clicking the button labeled Regain focus:

Causes the JFrame object in Figure 2 to lose the focus (if it has the focus)
Causes the JFrame object in Figure 1 to gain the focus (if it doesn't already have the focus)
Causes the JButton object labeled Regain focus to gain the focus (if it doesn't already have the focus)

(Note that I skipped the part about the frames being deactivated and activated in the above description.)

Clicking the button labeled Send focus to B causes the JFrame object and the button in Figure 1 to momentarily gain the focus. However, the program transfers the focus to the JFrame object in Figure 2 immediately thereafter with a very short time delay. This causes the sequence of events described under Order of event delivery to occur.

Gaining focus in Figure 2

The JFrame object in Figure 2 will gain the focus if the user clicks the button labeled Send focus to Bin Figure 1.

The JFrame object in Figure 2 will also gain the focus if it is clicked with the mouse.

(There are also other ways that the JFrame object in Figure 2 can gain the focus, such as being restored from an iconified state.)

Screen output

As each JFrame object gains and loses focus, and becomes iconified or maximized, information about the gain and loss of focus and the status of the Window is displayed on the screen.

This is accomplished using both high-level event handling and low-level event handling. The event handlers report on events of the following three types:

WINDOW_STATE_CHANGED
WINDOW_GAINED_FOCUS
WINDOW_LOST_FOCUS

High-level event handling

The high-level approach to event handling involves registering objects of the interface typesWindowFocusListener and WindowStateListener on the JFrame object.

Low-level event handling

The low-level approach makes use of the following methods:

enableEvents(AWTEvent.WINDOW_EVENT_MASK)
processWindowEvent(WindowEvent e)
processWindowFocusEvent(WindowEvent e)
processWindowStateEvent(WindowEvent e)

Other WindowEvent types from earlier versions

The program also uses low-level event handling to display information about other WindowEvent types such as the following:

WINDOW_ACTIVATED
WINDOW_CLOSED
WINDOW_CLOSING
WINDOW_DEACTIVATED
WINDOW_DEICONIFIED
WINDOW_ICONIFIED
WINDOW_OPENED

(This list includes event types that have been a standard part of the API since before the release of SDK V1.4.)

Sample screen output

The screen output at startup is shown in Figure 3.

Low:processWindowEvent B
205 WINDOW_ACTIVATED

Low:processWindowFocusEvent B
207 WINDOW_GAINED_FOCUS
High:windowGainedFocus B

Low:processWindowEvent B
200 WINDOW_OPENED

Low:processWindowFocusEvent B
208 WINDOW_LOST_FOCUS
High:windowLostFocus B

Low:processWindowEvent B
206 WINDOW_DEACTIVATED

Low:processWindowEvent A
205 WINDOW_ACTIVATED

Low:processWindowFocusEvent A
207 WINDOW_GAINED_FOCUS
High:windowGainedFocus A
High:focusGained on Regain focus button

Low:processWindowEvent A
200 WINDOW_OPENED

Figure 3

Low-level event handling output

The lines of text that begin with the word Low, and the lines that begin with a number such as 205 were produced by low-level event handlers.

High-level event handling output

The lines that begin with the word High were produced by high-level event handlers.

Combined low and high-level event handling

All of the Window focus events were handled both ways.

(All of the Window state events were also handled both ways, but that is not shown in Figure 3.)

Miscellaneous notes

The low-level event handling always occurs before the high-level event handling for the same event in this program.

(This is something that you have control over, as I will explain in Part 2 of this lesson.)

Only low-level event handling was used for the event types other than Window focus events andWindow state events, (such as the WINDOW_DEACTIVATED event type). These event types have been available for many years, so I saw no need to handle them both ways.

What about a WINDOW_MAXIMIZED event type?

As of this writing, there are ten WindowEvent types:

WINDOW_STATE_CHANGED
WINDOW_GAINED_FOCUS
WINDOW_LOST_FOCUS
WINDOW_ACTIVATED
WINDOW_CLOSED
WINDOW_CLOSING
WINDOW_DEACTIVATED
WINDOW_DEICONIFIED
WINDOW_ICONIFIED
WINDOW_OPENED

A standard WindowEvent, (that is directly descriptive of the event) is fired when a Window is iconified(WINDOW_ICONIFIED) and also when a Window is deiconified (WINDOW_DEICONIFIED).

However, there is no WindowEvent type (that is directly descriptive of the event such as WINDOW_MAXIMIZED) that is fired when a Window is maximized.

A WINDOW_STATE_CHANGED event type

However, a WINDOW_STATE_CHANGED event is fired when a JFrame is maximized (or iconified).

Beginning with V1.4, extended state information regarding the state of the Window is encapsulated in the WindowEvent object when the event is fired. This information can be extracted by invoking the following methods on the WindowEvent object:

getOldState
getNewState

(The state of the Window can also be obtained by invoking the getExtendedState method on theWindow object.)

Was the Window maximized?

The fact that the JFrame has been maximized can be extracted from the state of the Window. The program is no longer deprived of that information.

Allowable states for a Window

As of the date of this writing, the following five states are defined for a Window:

NORMAL
ICONIFIED
MAXIMIZED_HORIZ
MAXIMIZED_VERT
MAXIMIZED_BOTH

(Prior to the release of V1.4, only the first two states were defined for a Window.)

This state information is defined as values of type int, corresponding to descriptive constants matching the above list. These constants are defined in the Frame class, so they are accessible both for aFrame and its subclass JFrame.

What are the values of the constants?

The actual value associated with each constant in the above list (and many other constants as well) can be determined by looking the constant up in the API documentation and selecting the hyperlink namedConstant Field Values.

(Ideally, you don't normally need to know the values of the constants, but that information can sometimes be useful, if only out of curiosity.)

Possible modifications to the program

Although this program uses Swing components and draws the coordinate values on a Canvas object, it is a trivial matter to modify the program to cause it to use only AWT components, and to eliminate theCanvas object. In that case, the coordinate values are drawn directly on the Frame. Since the Framedoesn't contain any components at all in that situation, it is guaranteed that it doesn't contain any focusable components.

It is also easy to convert the program to one that uses JDialog objects in place of JFrame objects. Of course, JDialog objects can't be minimized or maximized, so that portion of the program having to do with the Window State has no meaning with respect to JDialog objects.

The program code

The entire program is provided in Listing 1 near the end of the lesson.

I will break the program down into fragments and discuss it in detail in Part 2 of this two-part lesson.

Run the Program

Although I haven't explained the code in Part 1 of this two-part lesson, I encourage you to copy, compile, and run the program provided in Listing 1 near the end of the lesson.

If you feel comfortable in doing so at this point, experiment with it, making changes and observing the results of your changes.

(If you don't feel comfortable experimenting with the code yet, I will explain the code in detail in Part 2 of this lesson.)

One very useful modification to the program for experimental purposes is to add the following statement in the various event-handler methods:

System.out.println(new Date());

This statement causes the time to be displayed along with the other information related to an event. This makes it easier to interpret the various lines of output on the screen by making it possible to determine which groups of lines were produced in rapid succession.

Also consider modifying the program to use Frame, Dialog, and JDialog objects instead of JFrameobjects. Consider eliminating the requirement for a Canvas object, causing your Window to contain no components at all, focusable or otherwise.

Summary

I explained a Window can gain the focus, and can respond to the keyboard while it has the focus, even if that Window contains no focusable components.

I described both low-level and high-level event handlers to respond to Window focus events.

I explained how to make use of the extended Window state, and explained how the program can respond to Window state events to learn that the user has maximized a Window.

What's Next?

I provided a program that illustrates the above concepts in Listing 1 near the end of this lesson. I will explain that program in Part 2 of this lesson.

Complete Program Listing

A complete listing of the program discussed in this lesson is provided below.

/*File FocusWindow02.java
Copyright 2004 R.G.Baldwin
Rev 07/30/04
This program illustrates the ability of a Window
to gain and lose the focus, and to fire events
when the focus is gained or lost.  This
capability is new to SDK V1.4.

The program also illustrates the ability of a
JFrame to fire events when the state of the
JFrame changes.  This capability is also new to
SDK V1.4.  A list of the possible states is
provided later in this discussion.

The program places two JFrame objects on the
screen, one above the other.  The JFrame object
on the top contains two JButton objects, both
of which are focusable.

The JFrame object on the bottom contains a single
Canvas object, which is not focusable.  Therefore
the JFrame object on the bottom contains no
focusable components.

The JFrame object on the bottom illustrates the
use of focus on a Window that contains no
focusable components.  The coordinates of an
invisible point are displayed on the Canvas near
the location of the invisible point.  When this
object has the focus, pressing the arrow keys
will change the coordinates of the invisible
point, thus modifying and moving the displayed
coordinate values.  This is accomplished by
servicing KeyEvents on the object, thus
demonstrating that the JFrame object actually
has the focus.

The JFrame object on the top contains two
JButton objects labeled respectively:

Regain focus
Send focus to B

Clicking the first of these two buttons will
cause the JFrame object on the top to gain the
focus, will cause the JFrame object on the bottom
to lose the focus, and will also cause the
JButton object to gain the focus.

Clicking the button labeled "Send focus to B"
will momentarily cause the JFrame object and the
button to gain the focus, but will immediately
transfer the focus to the JFrame object on the
bottom.

The JFrame objet on the bottom will also gain the
focus if it is clicked with the mouse.

As each JFrame object gains and loses focus,
information about the gain and loss of focus is
displayed on the screen, using both high-level
event handling and low-level event handling.

The high-level approach makes use of an object
of type FocusListener.

The low-level approach makes use of the following
methods:

enableEvents(AWTEvent.WINDOW_EVENT_MASK)
processWindowEvent(WindowEvent e)
processWindowFocusEvent(WindowEvent e)
processWindowStateEvent(WindowEvent e)

The program also uses low-level event handling to
display information about other WindowEvent types
such as the following.  Note that this list
includes focus and state events, which are new
to SDK V1.4.

WINDOW_ACTIVATED
WINDOW_CLOSED
WINDOW_CLOSING
WINDOW_DEACTIVATED
WINDOW_DEICONIFIED
WINDOW_ICONIFIED
WINDOW_OPENED
WINDOW_STATE_CHANGED
WINDOW_GAINED_FOCUS
WINDOW_LOST_FOCUS

Note that there is no WindowEvent type that is
fired when a JFrame is maximized.  However, a
windowStateChanged event is fired when a JFrame
is maximized.  Information about the state of
the window is encapsulated in the WindowEvent
object and can be extracted using the following
methods:

getOldState
getNewState

The fact that the JFrame has been maximized can
be extracted from the state of the window.  The
following states are defined:

NORMAL
ICONIFIED
MAXIMIZED_HORIZ
MAXIMIZED_VERT
MAXIMIZED_BOTH

This state information is defined as values of
type int, corresponding to the descriptive
constants in the above list.  These constants are
defined in the Frame class.

The actual value associated with each constant in
the above list (and many other constants as well)
can be determined by looking the constant up in
the API documentation and selecting the hyperlink
named Constant Field Values.

Although this program uses Swing components and
draws the coordinate values on a Canvas object,
it is a trivial matter to modify the program
to use only AWT components, and to eliminate the
Canvas object.  In that case, the coordinate
values are drawn directly on the Frame.  Since
the Frame doesn't contain any components at all,
it is absolutely guaranteed that it doesn't
contain any focusable components.

It is also easy to convert the program to one
that uses JDialog objects in place of JFrame
objects.  Of course, JDialog objects can't be
minimized or maximized, so that portion of the
program having to do with the Window State has
no meaning with respect to JDialog objects.

Tested using JDK 1.4 under WinXP
************************************************/

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

public class FocusWindow02 extends JFrame{

  public static void main(String[] args){
    //Instantiate an object of this class, which
    // will, in turn, instantiate an object of
    // the class named GraphicsGUI.
    FocusWindow02 winA = new FocusWindow02();
  }//end main
//---------------------------------------------//
  public FocusWindow02(){//constructor

    //Instantiate a GraphicsGUI object, The
    // GraphicsGUI object will be identified as B
    // in the screen display.
    final GraphicsGUI winB = new GraphicsGUI();

    //Now construct the object of this class,
    // prepare it to handle events, and make it
    // visible.  This object will be identified
    // as A in the screen display.
    // Begin by setting some properties.
    setTitle("A Copyright 2004, R.G.Baldwin");
    getContentPane().setLayout(new FlowLayout());
    setSize(400,100);
    setDefaultCloseOperation(
                           JFrame.EXIT_ON_CLOSE);

    //Instantiate two buttons, prepare them to
    // handle FocusEvents, and add them to the
    // JFrame.
    JButton regainButton = new JButton(
                                 "Regain focus");
    regainButton.addFocusListener(
                               new FocusLstnr());
    getContentPane().add(regainButton);

    JButton sendButton = new JButton(
                              "Send focus to B");
    sendButton.addFocusListener(
                               new FocusLstnr());
    getContentPane().add(sendButton);

    //Prepare one of the buttons to handle
    // ActionEvents using an anonymous inner
    // class.
    sendButton.addActionListener(
      new ActionListener(){
        public void actionPerformed(
                                  ActionEvent e){
          winB.requestFocus();
        }//end actionPerformed
      }//end new ActionListener
    );//end addActionListener

    //Prepare the JFrame to handle events using
    // the low-level process methods.
    enableEvents(AWTEvent.WINDOW_EVENT_MASK);

    //Prepare the JFrame to handle events using
    // the high-level listener methods.
    addWindowFocusListener(new WindowLstnr());
    addWindowStateListener(new WindowLstnr());

    //Make this JFrame visible.  This will steal
    // the focus from the other JFrame.
    setVisible(true);

  }//end constructor
  //-------------------------------------------//

  //The next three methods are low-level event
  // handler methods that are new to V1.4.  These
  // methods are identical to methods having the
  // same names defined for the class named
  // GraphicsGUI, except that the screen output
  // identifies the object as A rather than B.

  //Sample screen output for this method:
  // Low:processWindowEvent A
  // 205 WINDOW_ACTIVATED
  protected void processWindowEvent(
                                  WindowEvent e){
    System.out.println();
    System.out.println(
                     "Low:processWindowEvent A");
    System.out.print(e.getID() + " ");
    System.out.println(getEventType(e.getID()));
    super.processWindowEvent(e);
  }//end processWindowEvent
  //-------------------------------------------//

  //Sample screen output for this method:
  // Low:processWindowFocusEvent A
  // 207 WINDOW_GAINED_FOCUS
  protected void processWindowFocusEvent(
                                  WindowEvent e){
    System.out.println();
    System.out.println(
                "Low:processWindowFocusEvent A");
    System.out.print(e.getID() + " ");
    System.out.println(getEventType(e.getID()));
    super.processWindowFocusEvent(e);
  }//end processWindowFocusEvent
  //-------------------------------------------//

  //Sample screen output for this method:
  // Low:processWindowStateEvent A
  // 209 WINDOW_STATE_CHANGED
  protected void processWindowStateEvent(
                                  WindowEvent e){
    System.out.println();
    System.out.println(
                "Low:processWindowStateEvent A");
    System.out.print(e.getID() + " ");
    System.out.println(getEventType(e.getID()));
    super.processWindowStateEvent(e);
  }//end processWindowStateEvent
  //-------------------------------------------//

  //Method to convert event ID values to text
  // descriptions.
  String getEventType(int ID){
    if(ID == WindowEvent.WINDOW_ACTIVATED){
      return "WINDOW_ACTIVATED";
    }else if(ID == WindowEvent.WINDOW_CLOSED){
      return "WINDOW_CLOSED";
    }else if(ID == WindowEvent.WINDOW_CLOSING){
      return "WINDOW_CLOSING";
    }else if(ID ==
                 WindowEvent.WINDOW_DEACTIVATED){
      return "WINDOW_DEACTIVATED";
    }else if(ID ==
                 WindowEvent.WINDOW_DEICONIFIED){
      return "WINDOW_DEICONIFIED";
    }else if(ID == WindowEvent.WINDOW_ICONIFIED){
      return "WINDOW_ICONIFIED";
    }else if(ID == WindowEvent.WINDOW_OPENED){
      return "WINDOW_OPENED";
    }else if(ID ==
               WindowEvent.WINDOW_STATE_CHANGED){
      return "WINDOW_STATE_CHANGED";
    }else if(ID ==
                WindowEvent.WINDOW_GAINED_FOCUS){
      return "WINDOW_GAINED_FOCUS";
    }else if(ID ==
                  WindowEvent.WINDOW_LOST_FOCUS){
      return "WINDOW_LOST_FOCUS";
    }else{
      return "Unknown event type";
    }//end else
  }//end getEventType

}//end class FocusWindow02
//=============================================//

//Objects of this class are registered on the two
// JButton objects to report high-level
// focusGained and focusLost events.
//Sample outputs from these methods:
// High:focusGained on Regain focus button
// High:focusLost on Regain focus button
// High:focusGained on Send focus to B button
// High:focusLost on Send focus to B button
class FocusLstnr implements FocusListener{

  public void focusGained(FocusEvent e){
    System.out.println("High:focusGained on "
             + ((JButton)e.getSource()).getText()
             + " button");
  }//wns focusGained
  //-------------------------------------------//

  public void focusLost(FocusEvent e){
    System.out.println("High:focusLost on "
             + ((JButton)e.getSource()).getText()
             + " button");
  }//end focusLost
}//end class FocusLstnr

//=============================================//

//Objects of this class are registered on the two
// JFrame objects to report high-level focus and
// state events on the objects.

//Sample outputs from the methods are:
// High:windowGainedFocus A
// High:windowLostFocus A
// High:windowGainedFocus B
// High:windowLostFocus B
// High:windowStateChanged NORMAL to ICONIFIED B
// High:windowStateChanged NORMAL to ICONIFIED A
// High:windowStateChanged ICONIFIED to NORMAL A
// High:windowStateChanged ICONIFIED to NORMAL B

class WindowLstnr implements
         WindowFocusListener,WindowStateListener{
  public void windowGainedFocus(WindowEvent e){
    System.out.print("High:windowGainedFocus ");
    System.out.println(((JFrame)e.getSource()).
                      getTitle().substring(0,1));
  }//end windowGainedFocus

  public void windowLostFocus(WindowEvent e){
    System.out.print("High:windowLostFocus ");
    System.out.println(((JFrame)e.getSource()).
                      getTitle().substring(0,1));
  }//windowLostFocus

  public void windowStateChanged(WindowEvent e){
    System.out.println("High:windowStateChanged "
             + getState(e.getOldState())
             + " to " + getState(e.getNewState())
             + " "
             + ((JFrame)e.getSource()).
                      getTitle().substring(0,1));
  }//windowStateChanged

  //This method converts state values to text
  // descriptions.  See constant values in Frame
  // class for the correlations between state
  // values and descriptive constants.
  String getState(int state){
    if(state == Frame.NORMAL){
      return "NORMAL";
    }else if(state == Frame.ICONIFIED){
      return "ICONIFIED";
    }else if(state == Frame.MAXIMIZED_HORIZ){
      return "MAXIMIZED_HORIZ";
    }else if(state == Frame.MAXIMIZED_VERT){
      return "MAXIMIZED_VERT";
    }else if(state == Frame.MAXIMIZED_BOTH){
      return "MAXIMIZED_BOTH";
    }else{
      return "Unknown state";
    }//end else
  }//end getState
}//end class WindowLstnr
//=============================================//

//An object of this class is instantiated to
// illustrate the use of focus on a Window that
// contains no focusable components.  The
// coordinates of an invisible point are
// displayed on a Canvas in the JFrame near the
// location of the invisible point.  When this
// object has the focus, pressing the arrow keys
// will change the coordinates of the invisible
// point, thus modifying and moving the displayed
// coordinate values.

class GraphicsGUI extends JFrame{

  //These are the coordinates of the invisible
  // point.
  int xCoor = 200;
  int yCoor = 40;

  public GraphicsGUI(){//constructor
    setBounds(0,100,400,100);
    setTitle("B Copyright 2004 R.G.Baldwin");
    Display display = new Display();
    getContentPane().add(display);

    setDefaultCloseOperation(
                           JFrame.EXIT_ON_CLOSE);

    //Prepare this object to handle low-level
    // WindowEvents using the process methods.
    enableEvents(AWTEvent.WINDOW_EVENT_MASK);

    //Prepare this object to handle high-level
    // KeyEvents using a listener.
    this.addKeyListener(new KeyListnr(display));

    //Prepare this object to handle high-level
    // focus and state events using a listener.
    addWindowFocusListener(new WindowLstnr());
    addWindowStateListener(new WindowLstnr());

    setVisible(true);
  }//end constructor
  //-------------------------------------------//

  //The next three methods are low-level event
  // handler methods that are new to V1.4.  These
  // methods are identical to methods having the
  // same names defined for the class named
  // FocusWindow02, except that the screen output
  // identifies the object as B rather than A.

  //Sample screen output for this method:
  // Low:processWindowEvent B
  // 205 WINDOW_ACTIVATED
  protected void processWindowEvent(
                                  WindowEvent e){
    System.out.println();
    System.out.println(
                     "Low:processWindowEvent B");
    System.out.print(e.getID() + " ");
    System.out.println(getEventType(e.getID()));
    super.processWindowEvent(e);
  }//end processWindowEvent
  //-------------------------------------------//

  //Sample screen output for this method:
  // Low:processWindowFocusEvent B
  // 207 WINDOW_GAINED_FOCUS
  protected void processWindowFocusEvent(
                                  WindowEvent e){
    System.out.println();
    System.out.println(
                "Low:processWindowFocusEvent B");
    System.out.print(e.getID() + " ");
    System.out.println(getEventType(e.getID()));
    super.processWindowFocusEvent(e);
  }//end processWindowFocusEvent
  //-------------------------------------------//

  //Sample screen output for this method:
  // Low:processWindowStateEvent B
  // 209 WINDOW_STATE_CHANGED
  protected void processWindowStateEvent(
                                  WindowEvent e){
    System.out.println();
    System.out.println(
                "Low:processWindowStateEvent B");
    System.out.print(e.getID() + " ");
    System.out.println(getEventType(e.getID()));
    super.processWindowStateEvent(e);
  }//end processWindowStateEvent
  //-------------------------------------------//

  //Method to convert event ID values to text
  // descriptions.
  String getEventType(int ID){
    if(ID == WindowEvent.WINDOW_ACTIVATED){
      return "WINDOW_ACTIVATED";
    }else if(ID == WindowEvent.WINDOW_CLOSED){
      return "WINDOW_CLOSED";
    }else if(ID == WindowEvent.WINDOW_CLOSING){
      return "WINDOW_CLOSING";
    }else if(ID ==
                 WindowEvent.WINDOW_DEACTIVATED){
      return "WINDOW_DEACTIVATED";
    }else if(ID ==
                 WindowEvent.WINDOW_DEICONIFIED){
      return "WINDOW_DEICONIFIED";
    }else if(ID == WindowEvent.WINDOW_ICONIFIED){
      return "WINDOW_ICONIFIED";
    }else if(ID == WindowEvent.WINDOW_OPENED){
      return "WINDOW_OPENED";
    }else if(ID ==
               WindowEvent.WINDOW_STATE_CHANGED){
      return "WINDOW_STATE_CHANGED";
    }else if(ID ==
                WindowEvent.WINDOW_GAINED_FOCUS){
      return "WINDOW_GAINED_FOCUS";
    }else if(ID ==
                  WindowEvent.WINDOW_LOST_FOCUS){
      return "WINDOW_LOST_FOCUS";
    }else{
      return "Unknown event type";
    }//end else
  }//end getEventType
//=============================================//

//Begin inner class definitions

class Display extends Canvas{

  Display(){//constructor
    //Set the focusable property to false to
    // guarantee that the JFrame contains no
    // focusable components.
    setFocusable(false);
  }//end constructor

  //Override the paint method to display the
  // coordinates on the screen near the location
  // specified by the coordinates.
  public void paint(Graphics g){
    super.paint(g);
    g.drawString(
        "" + xCoor + ", " + yCoor, xCoor, yCoor);
  }//end paint()
}//end class Display
//=============================================//

//This listener class monitors for key events,
// increments and displays the stored coordinates
// when the arrow keys are pressed.
class KeyListnr extends KeyAdapter{
  Display display;

  KeyListnr(Display display){//constructor
    this.display = display;//save ref to display
  }//end constructor
  //-------------------------------------------//

  //Override the keyPressed method to increment
  // or decrement the coordinates by five pixels
  // when an arrow key is pressed.  Then repaint
  // the canvas to cause the coordinate values to
  // be displayed. Remember y-coordinates are
  // displayed upside down.
  public void keyPressed(KeyEvent e){
    int code = e.getKeyCode();

    if(code == e.VK_UP){
      yCoor -= 5;
    }else if(code == e.VK_LEFT){
      xCoor -= 5;
    }else if(code == e.VK_RIGHT){
      xCoor += 5;
    }else if(code == e.VK_DOWN){
      yCoor += 5;
    }//end else if

    display.repaint();//Display coordinates
  }//end keyPressed()
}//end class KeyListnr
//=============================================//
}//end GraphicsGUI class
//=============================================//

Listing 1

About the author

Richard Baldwin is a college professor (at Austin Community College in Austin, TX) and private consultant whose primary focus is a combination of Java, C#, and XML. In addition to the many platform and/or language independent benefits of Java and C# applications, he believes that a combination of Java, C#, and XML will become the primary driving force in the delivery of structured information on the Web.

Richard has participated in numerous consulting projects, and he frequently provides onsite training at the high-tech companies located in and around Austin, Texas. He is the author of Baldwin's Programming Tutorials, which has gained a worldwide following among experienced and aspiring programmers. He has also published articles in JavaPro magazine.

In addition to his programming expertise, Richard has many years of practical experience in Digital Signal Processing (DSP). His first job after he earned his Bachelor's degree was doing DSP in the Seismic Research Department of Texas Instruments. (TI is still a world leader in DSP.) In the following years, he applied his programming and DSP expertise to other interesting areas including sonar and underwater acoustics.

Richard holds an MSEE degree from Southern Methodist University and has many years of experience in the application of computer technology to real-world problems.

Baldwin@DickBaldwin.com

-end-

java - system 정보 가져오기

겨울에 — Tue, 5 Jul 2011 13:02:13 +0900

출처 : http://blog.naver.com/galoa1123?Redirect=Log&logNo=120118276565
자바로 시스템 정보 가져오기|작성자 스누피

import java.util.Enumeration;

import java.util.Properties;

public class Test {

/**

* @param args

public static void main(String[] args) {

Properties pro = System.getProperties ( ); //시스템 정보를 몽땅 갖고 온다.

Enumeration e = pro.propertyNames();

while(e.hasMoreElements()) {

String obj = ( String )e.nextElement();

System.out.println(obj + ":"+ System.getProperty(obj ));

}

===================================================================================

java.runtime.name:Java(TM) SE Runtime Environment

sun.boot.library.path:C:\usr\local\jdk1.6.0_20\jre\bin

java.vm.version:16.3-b01

java.vm.vendor:Sun Microsystems Inc.

java.vendor.url:http://java.sun.com/

path.separator:;

java.vm.name:Java HotSpot(TM) Client VM

file.encoding.pkg:sun.io

user.country:KR

sun.java.launcher:SUN_STANDARD

sun.os.patch.level:Service Pack 3

java.vm.specification.name:Java Virtual Machine Specification

user.dir:F:\data\home\Test

java.runtime.version:1.6.0_20-b02

java.awt.graphicsenv:sun.awt.Win32GraphicsEnvironment

java.endorsed.dirs:C:\usr\local\jdk1.6.0_20\jre\lib\endorsed

os.arch:x86

java.io.tmpdir:C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\

line.separator:

java.vm.specification.vendor:Sun Microsystems Inc.

user.variant:

os.name:Windows XP

sun.jnu.encoding:MS949

java.library.path:C:\usr\local\jdk1.6.0_20\jre\bin;.;C:\WINDOWS\Sun\Java\bin;C:\WINDOWS\system32;C:\WINDOWS;C:\TmaxSoft\WebtoB4.1\bin;C:\TmaxSoft\WebtoB4.1\lib;C:\TmaxSoft\WebtoB4.1\jeus\bin;C:\TmaxSoft\WebtoB4.1\jeus\lib\system;c:\oracle\product\10.2.0\db_1\bin;C:\TmaxSoft\JEUS5.0\bin;C:\TmaxSoft\JEUS5.0\lib\system;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\Program Files\Common Files\Acronis\SnapAPI\;C:\usr\local\jdk1.6.0_20\bin;C:\Program Files\TortoiseSVN\bin;C:\usr\local\MySQL\bin;C:\jennifer\server\bin\tomcat.bat;C:\TmaxSoft\JEUS5.0\bin;C:\TmaxSoft\JEUS5.0\lib\system;C:\TmaxSoft\JEUS5.0\webserver\bin;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\Program Files\Common Files\Acronis\SnapAPI\;C:\usr\local\jdk1.6.0_20\bin;C:\Program Files\SSH Communications Security\SSH Secure Shell;C:\Program Files\IDM Computer Solutions\UltraEdit\;C:\Program Files\IDM Computer Solutions\UltraCompare\;C:\jennifer\server\bin\tomcat.bat;

java.specification.name:Java Platform API Specification

java.class.version:50.0

sun.management.compiler:HotSpot Client Compiler

os.version:5.1

user.home:C:\Documents and Settings\Administrator

user.timezone:

java.awt.printerjob:sun.awt.windows.WPrinterJob

file.encoding:MS949

java.specification.version:1.6

user.name:Administrator

java.class.path:

java.vm.specification.version:1.0

sun.arch.data.model:32

java.home:C:\usr\local\jdk1.6.0_20\jre

java.specification.vendor:Sun Microsystems Inc.

user.language:ko

awt.toolkit:sun.awt.windows.WToolkit

java.vm.info:mixed mode

java.version:1.6.0_20

java.ext.dirs:C:\usr\local\jdk1.6.0_20\jre\lib\ext;C:\WINDOWS\Sun\Java\lib\ext

sun.boot.class.path:C:\Program Files\MyEclipse 6.5M1\myeclipse\eclipse\plugins\com.genuitec.eclipse.j2eedt.core_6.4.100.zmyeclipse64100200805\data\libraryset\EE_5\javaee.jar;C:\Program Files\MyEclipse 6.5M1\myeclipse\eclipse\plugins\com.genuitec.eclipse.j2eedt.core_6.4.100.zmyeclipse64100200805\data\libraryset\EE_5\jsf-impl.jar;C:\Program Files\MyEclipse 6.5M1\myeclipse\eclipse\plugins\com.genuitec.eclipse.j2eedt.core_6.4.100.zmyeclipse64100200805\data\libraryset\EE_5\jsf-api.jar;C:\Program Files\MyEclipse 6.5M1\myeclipse\eclipse\plugins\com.genuitec.eclipse.j2eedt.core_6.4.100.zmyeclipse64100200805\data\libraryset\EE_5\jstl-1.2.jar;C:\usr\local\jdk1.6.0_20\jre\lib\resources.jar;C:\usr\local\jdk1.6.0_20\jre\lib\rt.jar;C:\usr\local\jdk1.6.0_20\jre\lib\sunrsasign.jar;C:\usr\local\jdk1.6.0_20\jre\lib\jsse.jar;C:\usr\local\jdk1.6.0_20\jre\lib\jce.jar;C:\usr\local\jdk1.6.0_20\jre\lib\charsets.jar;C:\usr\local\jdk1.6.0_20\jre\classes

java.vendor:Sun Microsystems Inc.

file.separator:\

java.vendor.url.bug:http://java.sun.com/cgi-bin/bugreport.cgi

sun.cpu.endian:little

sun.io.unicode.encoding:UnicodeLittle

sun.desktop:windows

sun.cpu.isalist:pentium_pro+mmx pentium_pro pentium+mmx pentium i486 i386 i86

JAVA - 자바로 프로세스 관리

겨울에 — Mon, 4 Jul 2011 15:50:47 +0900

출처 : http://k.daum.net/qna/view.html?qid=00byP [ DAUM 지식 ]

Q.

자바로 윈도우의 프로세스를 관리하고 (실행하거나 실행중인 프로세서를 죽이는등...) 컴퓨터 전원을 끄는 그런 그능이 구현 가능한가요??

A.

가. 프로세스 생성 및 종료

일반적으로 프로그램을 실행시키면, 하나의 프로세스로서 동작하게 됩니다. 다시 말해서, 우리가 실행시키는 하나의 프로그램은 하나의 프로세스로서 나타나게 됩니다. 자바에서의 프로세스는 자바 런타임 환경과 밀접한 관계를 갖고 있습니다. 왜냐하면, 자바 런타임 환경은 프로세스가 실행될 수 있는 기반 환경을 제공해 주기 때문입니다. 프로세스는 다른 프로세스를 생성할 수 있는데, 이 때 생성된 프로세스를 자식 프로세스라하고 기존에 있던 프로세스를 부모 프로세스라 합니다. 이러한 부모/자식 프로세스 개념은 하나의 자바 프로그램에서 다른 프로그램을 실행시키고자 할 때, 주로 사용됩니다. 다시 말해서, 플랫폼 독립적인 자바 프로그램이 플랫폼과 밀접한 관련이 있는 작업을 해야 할 경우, 해당 작업을 수행할 프로그램을 다른 언어로 해당 플랫폼에 맞도록 작성하고, 이 프로그램을 자바 프로그램에서 실행시켜 주는 것입니다.

이를 위해, 플랫폼 종속적인 시스템 함수들을 호출할 수 있도록 해 주는 Runtime 클래스와 실행하고자 하는 응용프로그램을 위한 프로세스를 관리할 수 있도록 해 주는 Process 클래스를 사용할 수 있습니다. 자바에서 프로세스를 생성하기 위하여 다음과 같이 해 줍니다.

- “Runtime runtime = Runtime.getRuntime();”: 런타임 객체를 생성합니다.

- “Process p = runtime.exec(“프로그램경로명”);”: exec 메소드를 이용하여 프로세스를 생성합니다.

위와 같이 프로세스를 생성할 수 있고, 프로세스의 작업을 마치거나 또는 프로세스를 강제고 종료하기 위해서는 다음 중 한 가지 방법으로 할 수 있습니다.

- “p.waitFor();”: 자식 프로세스가 종료될 때까지 기다립니다.

- “p.destroy();”: 부모 프로세스에서 자식 프로세스를 강제로 종료시킵니다.

- “System.exit(0);”: 부모 프로세스만 종료되고 자식 프로세스는 계속 실행됩니다.

Runtime 클래스가 제공해 주는 주요 메소드를 살펴보면 다음과 같습니다.

- public static Runtime getRuntime(): 현재 실행되고 있는 자바 애플리케이션과 관련된 런타임 객체를 리턴해 줍니다.

- public void exit(int status): 현재 자바 가상머신을 종료합니다. status 매개변수는 종료시의 상태값을 나타내며, 일반적으로 0 이외의 값은 비정상적으로 종료되었음을 의미합니다.

- public Process exec(String command) throws IOException: 주어진 명령어를 독립된 프로세스로 실행시켜 줍니다. exec(command, null)와 같이 실행시킨 것과 같습니다.

- public Process exec(String command, String envp[]) throws IOException: 주어진 명령어를 주어진 환경을 갖는 독립된 프로세스로 실행시켜 줍니다. 이 메소드는 명령어 문자열을 토큰으로 나누어 이 토큰들을 포함하고 있는 cmdarray라는 새로운 배열을 생성합니다. 그리고 나서 exec(cmdarray, envp)을 호출합니다.

- public Process exec(String cmdarray[]) throws IOException: 주어진 문자열 배열에 있는 명령어와 매개변수를 이용하여 독립된 프로세스로 실행시켜 줍니다. exec(cmdarray, null)을 호출합니다.

- public Process exec(String cmdarray[], String envp[]) throws IOException: 주어진 문자열 배열에 있는 명령어와 매개변수를 이용하여 주어진 환경을 갖는 독립된 프로세스로 실행시켜 줍니다. 문자열 배열 cmdarray에는 명령어와 명령행 인자들을 나타내고 있습니다.

- public native long freeMemory(): 시스템에 남아있는 메모리의 양을 얻습니다. 이 값은 항상 totalMemory() 메소드에 의해 얻어지는 값보다 작습니다.

- public native long totalMemory(): 자바 가상머신의 최대 메모리 크기를 얻습니다.

Process 클래스가 제공해 주는 주요 메소드를 살펴보면 다음과 같습니다.

- public abstract OutputStream getOutputStream(): 자식 프로세스의 출력 스트림을 얻습니다.

- public abstract InputStream getInputStream(): 자식 프로세스의 입력 스트림을 얻습니다.

- public abstract InputStream getErrorStream(): 자식 프로세스의 에러 스트림을 얻습니다.

- public abstract int waitFor() throws InterruptedException: 자식 프로세스가 종료될 때까지 기다립니다.

- public abstract int exitValue(): 자식 프로세스가 종료할 때의 상태값을 얻습니다.

- public abstract void destroy(): 자식 프로세스를 강제로 종료시킵니다.

다음에 나오는 자바 프로그램은 위의 Runtime 클래스 및 Process 클래스를 이용하여 새로운 프로세스를 생성하고 종료하는 과정을 보여주기 위해 윈도우의 계산기를 실행시키는 간단한 예제입니다.

import java.io.*;

public class ProcessTest {

static public void main(String args[]) {

try {

Process p1 = Runtime.getRuntime().exec("calc.exe");

Process p2 = Runtime.getRuntime().exec("freecell.exe");

Process p3 = Runtime.getRuntime().exec("Notepad.exe");

p1.waitFor();

p2.destroy();

System.out.println("Exit value of p1: "+p1.exitValue());

System.out.println("Exit value of p2: "+p2.exitValue());

} catch(IOException e) {

System.out.println(e.getMessage());

} catch(InterruptedException e) {

System.out.println(e.getMessage());

}

System.exit(0);

}

* Results:

D:AIITJAVA6>java ProcessTest

Exit value of p1: 0

Exit value of p2: 1

D:AIITJAVA6>

<프로그램 1. ProcessTest.java>

나. 상호작용 명령어의 실행

그런데, 위와 같이 프로세스를 이용하여 방식으로 명령어를 실행하다 보면, 명령어에 따라 사용자에게 메시지를 출력하고 이에 대한 적절한 답을 사용자로부터 입력 받기를 원하는 명령어가 있습니다. 이러한 명령어를 상호작용(interactive) 명령어라고 합니다.

D:AIITJAVA6>ping 203.252.134.126

Pinging 203.252.134.126 with 32 bytes of data:

Reply from 203.252.134.126: bytes=32 time<10ms TTL=128

D:AIITJAVA6>

<그림 1. 상호작용 명령어의 실행>

그림에서와 같이 ping 명령어를 실행시키게 되면, ping 명령어는 그 실행 결과를 표준 출력을 이용하여 화면상에 출력해 줍니다. 이렇게 자바에서 실행시킨 프로세스가 출력하는 결과를 자바 프로그램은 알아야 하고, 또한 프로세스가 자바 프로그램으로부터 어떤 대답을 원할 경우가 있는데 이 때 사용자는 이에 대해 적절하게 답을 해 주어야 합니다. 이 때, ping 명령어는 메시지를 자신의 표준 출력에 장치에 출력하게 되는데, 이렇게 프로세스의 표준 출력을 자바 프로그램에서는 p.getInputStream 메소드를 이용하여 얻고, p.getOutputStream 메소드를 이용하여 프로세스의 표준 입력 장치에 쓰게 됩니다. 이 때, 한 가지 주의할 사항은 표준 출력 스트림에 대답을 쓴(write) 후, 꼭 flush 또는 close 메소드를 이용하여 표준 출력 스트림을 비워(flush) 주어야 합니다.

<그림 2. 자바 프로그램과 프로세스 간의 데이터의 전달>

다음에 나오는 자바 프로그램은 도스 상에서 상호작용 명령어를 사용하는 간단한 예제를 보여줍니다.

import java.io.*;

import java.lang.*;

public class InteractiveProcessTest {

public static void main(String[] args) {

try {

Process p = Runtime.getRuntime().exec("ping 203.252.134.126");

byte[] msg = new byte[128];

int len;

while((len=p.getInputStream().read(msg)) > 0) {

System.out.print(new String(msg, 0, len));

}

String rs = "n";

byte[] rb = new byte[] { (byte)'n' } ; //rs.getBytes();

OutputStream os = p.getOutputStream();

os.write(rb);

os.close();

} catch (Exception e) {

e.printStackTrace();

}

* Results:

D:AIITJAVA6>java InteractiveProcessTest

Pinging 203.252.134.126 with 32 bytes of data:

Reply from 203.252.134.126: bytes=32 time<10ms TTL=128

D:AIITJAVA6>

<프로그램 2. InteractiveProcessTest.java>

urlconnection 기능확장으로 편리하게 사용하기

겨울에 — Mon, 27 Jun 2011 17:22:00 +0900

출처 : http://www.okjsp.pe.kr/seq/65126

사용법

String url = "/test/test.jsp";

//일반적으로 text기반

byteResult = WebUtil.callUrlConnect(url,null,false);
out.println("byteResult = "+new String(byteResult));

//binary file

byteResult = WebUtil.callUrlConnect(url,null,true);

기능

- jsp,html 등 웹 text기반 resource 호출가능

- xml 유니코드 호출가능 (한글깨짐방지)

-이미지,플래쉬,동영상등 바이너리 데이타 처리하여 파일로 저장 가능

/**<PRE>
* TODO:
* @param serverUrl : 호출할 URL
* @param hs : 파라미터를 넘길때 사용할 해쉬테이블
* @param bBinary : true-> 바이너리 모드로 호출 false->ascii 모드로 호출
* @return
* @throws java.net.MalformedURLException
* </PRE>
*/
public static byte[] callUrlConnect(String serverUrl,Hashtable hs,boolean bBinary) throws java.net.MalformedURLException
  {

   URL url = null;
   URLConnection connection = null;

   //binary
   OutputStream outStream = null;
   InputStream inStream = null;
   BufferedInputStream bufInStream = null;

   //text
   Writer writer = null;
   java.io.Reader reader = null;
   BufferedReader buf = null;

   String output = null;
   StringBuffer sb = new StringBuffer();

   byte[] bufferResult = null;

   try
   {


    url = new URL(serverUrl);

    connection = url.openConnection();

    connection.setDoOutput(true); //post방식:true
    connection.setDoInput(true); //데이타 첨부되는 경우
    //헤더 셋팅- 웹서버마다 헤더정보가 부족하면 405에러를 반환하기도 한다.
    connection.setRequestProperty("Accept","*/*");
    connection.setRequestProperty("Accept-Charset","euc-kr");
//   connection.setRequestProperty("host",getHostIP());
    connection.setRequestProperty("User-Agent","Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; i-NavFourF; .NET CLR 1.1.4322)");


    outStream = connection.getOutputStream();


    //일반 text 파일 요청시
    //서버로 데이타를 보낼때.. writer를 사용
    writer = new OutputStreamWriter(outStream);
    //DataOutputStream doutput = new DataOutputStream(outStream);

    // form data 를 넣어줄때
    if(hs != null)
    {
     String sKey = null;
     String param = "";
     for (Enumeration e = hs.keys() ; e.hasMoreElements() ;)
     {
      sKey = (String)e.nextElement();
      param += sKey+"="+(String)hs.get(sKey)+"&";
     }


     writer.write(param);
     //doutput.writeBytes(param);

  //   writer.write("&pnum1="+URLEncoder.encode(pnum1));
  //   writer.write("&pnum2="+URLEncoder.encode(pnum2));
    }


    writer.flush();//내부버퍼에 있는 모든 데이타를 전송하도록 한다.
    writer.close();

//   doutput.flush();
//   doutput.close();

    outStream.close();

//   doutput = null;
    writer = null;
    outStream = null;

//   int response_code = connection.getResponseCode();

    //보낸데이타를 받는다.
    inStream = connection.getInputStream();


    //text 읽을때..
    if(bBinary == false)
    {
     //스트링 버퍼로 변환하기 위해서는 아래처럼 한다.
     //euc-kr로 안하면 euc-kr로 인코딩 안된 문서는 utf-8로 읽어들이면서 sun.io.MalformedInputException을 발생

//euc-kr하면 xml등을 호출시 유니코드 한글이 ???로 나온다.
//reader = new InputStreamReader(inStream,"euc-kr");

    //cp949로 하면 euc-kr도 커버하면서 xml 유니코드 한글도 잘 나온다.
     reader = new InputStreamReader(inStream, "cp949");
     buf = new BufferedReader(reader);

  //   log("----- callUrl Result START---------------------\n");
     while((output = buf.readLine()) != null)
     {
  //    log(output+"\n");
      if(!output.equals(""))
      {
       output.trim();
       sb.append(output+"\r\n");
      }
     }

     bufferResult = sb.toString().getBytes();

    }else
    {
     //binary로 읽을 때..(이미지,swf등을 다운로드 할때사용하면 됨)
     bufInStream = new BufferedInputStream(inStream);

     int bufferOffset = 0;
     int nReadSize = 0;
     int bufferCapacity = bufInStream.available()+1;

     System.out.println("--------------------------------------");
     System.out.println("[binary] 초기버퍼사이즈 = "+bufferCapacity);

     bufferResult = new byte[bufferCapacity];

  //   log("----- callUrl Result START---------------------\n");
//    while((i = bufInStream.read(bResult)) != -1);

     //BufferedInputStream가 끝이 아닐때까지 돌면서 버퍼에 채우고 채워진 버퍼를 화면에 출력
     while((nReadSize = bufInStream.read(bufferResult,
              bufferOffset,
              bufferCapacity-bufferOffset)) != -1)
     {
      bufferOffset += nReadSize;

      System.out.println("[binary] nReadSize = "+nReadSize+"/ bufferOffset = "+bufferOffset);

      if(bufferOffset >= bufferCapacity)
      {
       System.out.println("[binary] 버퍼확장 bufferSize = bufferCapacity "+bufferOffset+" = "+bufferCapacity);
       //bufferResult를 확장한다.
       bufferCapacity *= 2;
       byte[] newBuffer = new byte[bufferCapacity];
       System.arraycopy(bufferResult,0,newBuffer,0,bufferOffset);

       //reference를 변경
       bufferResult = newBuffer;
      }
     }
     System.out.println("[binary] 최종 읽은 사이즈 = "+bufferResult.length);
     System.out.println("--------------------------------------");
/*
* binary file 생성 test 소스 - stream으로 기록해야한다.
     File newFile = new File("/home/webroot/download/logo2.gif");

     BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(newFile));

     bout.write(bResult);

     bout.flush();
     bout.close();
*/
    }

   }catch(java.net.ConnectException e)
   {
    sb = null;
    sb = new StringBuffer();
    sb.append(EventLogManager._CONNECT_ERROR_+" | "+e.toString());

   }catch(java.net.SocketException e)
   {
    sb = null;
    sb = new StringBuffer();
    sb.append(e.toString());

   }catch(java.io.IOException e)
   {
    sb = null;
    sb = new StringBuffer();
    sb.append(e.toString());

   }finally
   {

    try
    {

//    System.out.println("통신 스트림 객체 해제중...");

     if(writer != null)
     {
      writer.close();
      writer = null;
     }

     if(outStream != null)
     {
      outStream.close();
      outStream = null;
     }

     if(inStream != null)
     {
      inStream.close();
      inStream = null;
     }

     if(reader != null)
     {
      reader.close();
      reader = null;
     }

     if(buf != null)
     {
      buf.close();
      buf = null;
     }

     if(bufInStream != null)
     {
      bufInStream.close();
      bufInStream = null;
     }

    }catch(java.io.IOException e1)
    {
     e1.printStackTrace();
    }
   }

   return bufferResult;
  }

파싱?.?

겨울에 — Mon, 27 Jun 2011 15:57:53 +0900

출처 : http://blog.daum.net/haha25/5387072

import! java.net.*;
import! java.net.URLEncoder;
import! java.io.*;

public class TestURLConnection {
    public static void main(String[] args) {
        URL url = null;
        URLConnection urlConnection = null;

        // URL 주소
        String sUrl = ("http://student.smu.ac.kr:8080/common/Login.do");

// 파라미터 이름
//String paramName = " ";

        // 파라미터 이름에 대한 값
        //String paramValue = " ";
        //String paramValue2 = " ";

        try {
            // Get방식으로 전송 하기
          url = new URL(sUrl);
            urlConnection = url.openConnection();
            printByInputStream(urlConnection.getInputStream());

            // Post방식으로 전송 하기
            url = new URL(sUrl);
            urlConnection = url.openConnection();
            urlConnection.setDoOutput(true);
            printByOutputStream(urlConnection.getOutputStream(), paramName + "=" + paramValue);

            printByInputStream(urlConnection.getInputStream());
        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    // 웹 서버로 부터 받은 웹 페이지 결과를 콘솔에 출력하는 메소드
    public static void printByInputStream(InputStream is) {
        byte[] buf = new byte[1024];
        int len = -1;

        try {
            while((len = is.read(buf, 0, buf.length)) != -1) {
                System.out.write(buf, 0, len);
            }
        } catch(IOException e) {
            e.printStackTrace();
        }
    }

    // 웹 서버로 파라미터명과 값의 쌍을 전송하는 메소드
    public static void printByOutputStream(OutputStream os, String msg) {
        try {
            byte[] msgBuf = msg.getBytes("UTF-8");
            os.write(msgBuf, 0, msgBuf.length);
            os.flush();
        } catch(IOException e) {
            e.printStackTrace();
        }
    }

}

HttpURLConnection클래스로 웹페이지 POST 요청하기

겨울에 — Mon, 27 Jun 2011 14:11:16 +0900

http://blog.naver.com/musalhk/150082514641
[출처] HttpURLConnectio클래스로 웹페이지 POST 요청하기|작성자 무살해커

// 요청할 파라미터의 정보를 입력한다.

String body = "id=asdf&pass=asdf";

// URL클래스의 생성자로 주소를 넘겨준다.

URL u = new URL( 주소 );

// 해당 주소의 페이지로 접속을 하고, 단일 HTTP 접속을 하기위해 캐스트한다.

HttpURLConnection huc = (HttpURLConnection) u.openConnection();

// POST방식으로 요청한다.( 기본값은 GET )

huc.setRequestMethod("POST");

I// nputStream으로 응답 헤더와 메시지를 읽어들이겠다는 옵션을 정의한다.
huc.setDoInput(true);

// OutputStream으로 POST 데이터를 넘겨주겠다는 옵션을 정의한다.
huc.setDoOutput(true);

// 요청 헤더를 정의한다.( 원래 Content-Length값을 넘겨주어야하는데 넘겨주지 않아도 되는것이 이상하다. )
huc.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

// 새로운 OutputStream에 요청할 OutputStream을 넣는다.
OutputStream os = huc.getOutputStream();

// 그리고 write메소드로 메시지로 작성된 파라미터정보를 바이트단위로 "EUC-KR"로 인코딩해서 요청한다.

// 여기서 중요한 점은 "UTF-8"로 해도 되는데 한글일 경우는 "EUC-KR"로 인코딩해야만 한글이 제대로 전달된다.
os.write( body.getBytes("euc-kr") );

// 그리고 스트림의 버퍼를 비워준다.
os.flush();

// 스트림을 닫는다.

os.close();

// 응답받은 메시지의 길이만큼 버퍼를 생성하여 읽어들이고, "EUC-KR"로 디코딩해서 읽어들인다.

BufferedReader br = new BufferedReader( new OutputStreamReader( huc.getInputStream(), "EUC-KR" ), huc.getContentLength() );

String buf;

// 표준출력으로 한 라인씩 출력

while( ( buf = br.readLine() ) != null ) {

System.out.println( buf );

}

// 스트림을 닫는다.

br.close();

웹사이트의 내용을 긁어오는 Webspider

겨울에 — Mon, 27 Jun 2011 14:06:05 +0900

http://blog.naver.com/nicekkong/100038826513
[출처] 웹사이트의 내용을 긁어오는 Webspider|작성자 nicekkong

import java.net.*;
import java.io.*;

public class WebSpider
{
public static void main(String arg[]) {
  URL url = null;
  try {
   url = new URL(arg[0]);
  } catch (MalformedURLException el) {
   System.out.println(el);
   System.exit(1);
  }

  FileOutputStream fos = null;
  try {
   InputStream in = url.openStream();      // 웹 문서를 openStream() 으로 읽어 온다.
   fos = new FileOutputStream("test.txt");

   byte[] buffer = new byte[512];
   int readcount = 0;

   System.out.println("읽어오기 시작합니다.");
   while((readcount = in.read(buffer)) != -1) {
    fos.write(buffer, 0, readcount);
   }
   System.out.println("finish!");
  } catch (Exception ex) {
   System.out.println(ex);
  } finally {
   try {
    if(fos != null) fos.close();
   } catch(Exception e) {}
  }
}
}

URLConnection 클래스로 웹 페이지 읽기

겨울에 — Mon, 27 Jun 2011 13:57:55 +0900

http://blog.naver.com/nicekkong/100038827474
[출처] URLConnection 클래스로 웹 페이지 읽기|작성자 nicekkong

@ URLConnection 클래스

URLConnection은 URL 주소의 내용을 읽어 오거나, 반대로 URL 주소가 가르키는 웹 어플리케이션(CGI, 서블릿, JSP 등)에게 GET 방식이나 POST 방식으로 추가적인 정보를 전달할수 있다.

그리고 웹 페이지의 내용을 읽어오는 것 외에도 반대로 웹 어플리케이션에 추가적인 정보를 전달해야 할 때가 있는데, 이때 POST 방식을 사용한다.

URLConnection 객체는 URL 클래스의 openConnection() 메서드를 이용해서 얻는다.

import java.net.*;
import java.io.*;

public class WebSpiderWithURLConnection
{
public static void main(String arg[]) {
  URL url = null;
  try {
   url = new URL(arg[0]);
  } catch (MalformedURLException el)   {
   System.out.println("잘못된 URL 형식!!");
   System.out.println(el);
   System.exit(1);
  }

  FileOutputStream fos = null;

  try    {
   URLConnection urlcon = url.openConnection();
   // URL 클래스의 openConnection()을 이용하여 URLConnection 객체를 얻는다.

   String contentType = urlcon.getContentType();

// 웹 문서의 헤드에서 contentType를 읽어 온다.

long dl = urlcon.getDate();
// 읽어 온 시간을 ms로 반환한다.

java.util.Date d = new java.util.Date(dl);

java.text.SimpleDateFormat format =

                  new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss a");
   String sdate = format.format(d);

   System.out.println("Content Type : " + contentType);
   System.out.println("읽어온 시간 : " + sdate);

   InputStream in = urlcon.getInputStream();

// URL 문서의 input stream을 불러온다.

   fos = new FileOutputStream("test.txt");

   byte[] buffer = new byte[512];
   int readcount = 0;

   System.out.println("Reading.....");
   while ((readcount = in.read(buffer)) != -1) {
    fos.write(buffer, 0, readcount);
   }

   System.out.println("text.txt" + "SAVE Finish");
  } catch    (Exception e)    {
   System.out.println(e);
  }   finally {
   try {
    if(fos != null) fos.close();
   }   catch    (Exception e) {}
  }
}
}

Eclipse - Failed to create the Java Virtual Machine.

겨울에 — Tue, 21 Jun 2011 16:50:23 +0900

출처 : http://k-story.tistory.com/165

Failed to create the Java Virtual Machine 에러

1. 이클립스 설치 폴더로 가서 eclipse.ini 파일을 편집기로 연다.

2. 다음 위치에 다음 내용을 추가하고 저장한다.

-vm

자바설치경로\bin\javaw.exe [ 예 - C:\Program Files\Java\jdk1.6.0_26\bin\javaw.exe ]

3. 와 된다 ^.^

전원관리모드. 대기, 절전, 최대절전

겨울에 — Tue, 21 Jun 2011 14:58:14 +0900

출처 : http://www.ntfaq.co.kr/3737 [2007년 3월 26일 ] posted by (주원아빠)

절전, 노트북에 있어서 가장 중요한 부분은 바로 전원관리이다. 데스크탑 PC를 사용하는 사람들은 그리 큰 중요성을 느끼지 못하는 부분이지만, 한정된 전원으로 사용해야 하는 노트북사용자는 전원 관리에 충실하면 그만큼 더 오래 노트북을 사용할 수 있게 된다.

참고로, 전원 관리 모드로는 대기(Standby) 모드, 절전(Suspended) 모드, 최대 절전(Hibernation) 모드 등으로 나눌 수 있다.

윈도우 비스타에서는 powercfg 명령어를 통해 사용가능한 전원 모드를 확인할 수 있다.

C:\>powercfg /a

이 명령시 보여주는 결과를 정리하면 다음과 같다.

S0: 동작 중. 컴퓨터가 정상적으로 동작하는 상태를 의미한다.

S1: Suspend / Sleeping 1: CPU가 동작을 중지하고 나머지 부분은 낮은 전원 관리 상태로 유지한다.

S2: Suspend / Sleeping 2: CPU의 전원이 차단되지만 메모리의 내용은 유지된다.

S3: Suspend / Sleeping 3: S2와 유사하지만 장치들은 다음번 시동시 초기화된다.

S4: Hibernation / suspend-to-disk: 최대 절전 모드 파일(hiberfil.dat) 파일에 모든 사항이 저장되고 시스템의 전원이 꺼진다 (S5와 비슷).

S5: Soft-off: 컴퓨터 끔.

--------------------------------------------------------------------------------------------------------------------

시스템 재시작 shutdown -t 0 -r

시스템 종료 shutdown -t 0 -s

시스템 강제종료 shutdown -f -t 0 -s

시스템 최대 절전 rundll32 powrprof.dll, SetSuspendState

CMD 명령어

겨울에 — Mon, 13 Jun 2011 01:04:28 +0900

출처 : http://ask.nate.com/qna/view.html?n=4813497

[[ CMD(명령 프롬프트 창) 명령어 ]]

ASSOC    파일 확장명 연결을 보여주거나 수정합니다.
AT           명령어와 프로그램의 실행을 스케줄합니다.
ATTRIB    파일 속성을 표시하거나 바꿉니다.
BREAK    확장된 CTRL+C 검사를 설정하거나 지웁니다.
CACLS   파일의 액세스 컨트롤 목록(ACL)을 표시하거나 수정합니다.
CALL       한 일괄 프로그램에서 다른 일괄 프로그램을 호출합니다.
CD           현재 디렉터리 이름을 보여주거나 바꿉니다.
CHCP     활성화된 코드 페이지의 번호를 표시하거나 설정합니다.
CHDIR     현재 디렉터리 이름을 보여주거나 바꿉니다.
CHKDSK   디스크를 검사하고 상태 보고서를 표시합니다.
CHKNTFS 부팅하는 동안 디스크 확인을 화면에 표시하거나 변경합니다.
CLS          화면을 지웁니다.
CMD         Windows 명령 인터프리터의 새 인스턴스를 시작합니다.
COLOR     콘솔의 기본색과 배경색을 설정합니다.
COMP     두 개 또는 여러 개의 파일을 비교합니다.
COMPACT NTFS 분할 영역에 있는 파일의 압축을 표시하거나 변경합니다.
CONVERT FAT 볼륨을 NTFS로 변환합니다. 현재 드라이브는 변환할 수 없습니다.
COPY        하나 이상의 파일을 다른 위치로 복사합니다.
DATE       날짜를 보여주거나 설정합니다.
DEL           하나 이상의 파일을 지웁니다.
DIR            디렉터리에 있는 파일과 하위 디렉터리 목록을 보여줍니다.
DISKCOMP 두 플로피 디스크의 내용을 비교합니다.
DISKCOPY 플로피 디스크의 내용을 다른 플로피 디스크로 복사합니다.
DOSKEY   명령줄을 편집하고, Windows 명령을 다시 호출하고, 매크로를 만듭니다.
ECHO        메시지를 보여주거나, 명령어 반향을 켜거나 끕니다.
ENDLOCAL 일괄 파일에서 환경 변경의 지역화를 끝냅니다.
ERASE       하나 이상의 파일을 지웁니다.
EXIT           CMD.EXE 프로그램(명령 인터프리터)을 마칩니다.
FC              두 파일 또는 파일의 집합을 비교하여 다른 점을 표시합니다.
FIND           파일에서 텍스트 문자열을 찾습니다.
FINDSTR    파일에서 문자열을 찾습니다.
FOR           파일 집합에서 각 파일에 대해 지정된 명령을 실행합니다.
FORMAT Windows에서 사용할 디스크를 포맷합니다.
FTYPE     파일 확장 연결에 사용되는 파일 형식을 표시하거나 수정합니다.
GOTO        Windows 명령 인터프리터가 일괄 프로그램에서 이름표가 붙여진 줄로 가게 합니다.
GRAFTABL Windows가 그래픽 모드에서 확장 문자 세트를 표시할 수 있게 합니다.
HELP       Windows 명령어에 관한 도움말을 제공합니다.
IF             일괄 프로그램에서 조건 처리를 수행합니다.
LABEL      디스크의 볼륨 이름을 만들거나, 바꾸거나, 지웁니다.
MD             디렉터리를 만듭니다.
MKDIR      디렉터리를 만듭니다.
MODE      시스템 장치를 구성합니다.
MORE        출력을 한번에 한 화면씩 표시합니다.
MOVE        하나 이상의 파일을 한 디렉터리에서 다른 디렉터리로 옮깁니다.
PATH        실행 파일의 찾기 경로를 보여주거나 설정합니다.
PAUSE    일괄 파일의 처리를 보류하고 메시지를 보여줍니다.
POPD       PUSHD 명령으로 저장된 디렉터리로 바꿉니다.
PRINT      텍스트 파일을 인쇄합니다.
PROMPT   Windows 명령 프롬프트를 바꿉니다.
PUSHD     현재 디렉터리를 저장한 후 디렉터리를 바꿉니다.
RD            디렉터리를 지웁니다.
RECOVER 불량이거나 결함이 있는 디스크에서 읽을 수 있는 정보를 복구합니다.
REM          일괄 파일 또는 CONFIG.SYS에서 주석을 기록합니다.
REN           파일 이름을 바꿉니다.
RENAME    파일 이름을 바꿉니다.
REPLACE 파일을 대체합니다.
RMDIR       디렉터리를 지웁니다.
SET          Windows 환경 변수를 보여주거나, 설정하거나, 지웁니다.
SETLOCAL 일괄 파일에서 환경 변경의 지역화를 시작합니다.
SHIFT       일괄 파일에서 바꿀 수 있는 매개 변수의 위치를 바꿉니다.
SORT       입력을 정렬합니다.
START      지정된 프로그램이나 명령을 별도의 창에서 시작합니다.
SUBST     경로를 드라이브 문자로 지정합니다.
TIME        시스템 시간을 보여주거나 설정합니다.
TITLE         CMD.EXE 세션에 대한 창의 창 제목을 설정합니다.
TREE         드라이브 또는 경로의 디렉터리 구조를 그래픽으로 화면에 표시합니다.
TYPE         텍스트 파일의 내용을 보여줍니다.
VER           Windows 버전을 보여줍니다.
VERIFY      파일이 디스크에 올바로 쓰였는지 검증할지 여부를 지정합니다.
VOL           디스크 볼륨 이름과 일련 번호를 보여줍니다.
XCOPY     파일과 디렉터리 트리를 복사합니다.

- [링크] The volatile keyword in Java

겨울에 — Sat, 14 May 2011 16:35:51 +0900

출처 : http://cafe.naver.com/litave/419

Volatile 와 Synchronized 의 차이점을 들어서 설명하고 있네요.

http://www.javamex.com/tutorials/synchronization_volatile.shtml

- [Java 기본] JDBC를 이용한 Oracle 연동

겨울에 — Sat, 14 May 2011 16:35:14 +0900

출처 : http://cafe.naver.com/litave/407

//===========================================================================//
Java 기본 마지막 자료군요.

기존 실습때는 MS-Access로 실습 했었는데 그다지 의미가 없어보여,

Oracle에 접속하여 SELECT 및 INSERT 하는 프로그램을 작성하여 올립니다.

역시 말로 장황하게 설명 하기 보다는 이게 편하네요. ㅎㅎ..

작성자 : litwave
//---------------------------------------------------------------------------//

// DBConn.java

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
* JDBC를 이용하여 Database Connection을 얻어오는 클래스
* @author lit
*
*/
public class DBConn {
    private final String driver = "oracle.jdbc.driver.OracleDriver";
    private final String url = "jdbc:oracle:thin:@192.168.1.100:1521:ORA9i";
    private final String id = "scott";
    private final String pw = "tiger";

    public DBConn() {
        loadDriver();
    }

    public void loadDriver() {
        try {
            /** 1.Driver 로딩 */
            Class.forName(this.driver);
            System.out.println("1. Driver loading 성공(Class.forName(this.driver))!!");
        } catch(ClassNotFoundException cnf) {
            System.out.println("1. Driver loading 실패!!");
        }
    }

    /**
     * DriverManager를 통하여 데이터 베이스의 Connection을 얻어온다.
     * @return
     * @throws SQLException
     */
    public Connection getConnection() throws SQLException {
        Connection conn = null;

        conn = DriverManager.getConnection(this.url, this.id, this.pw);
        System.out.println("2. Database Connection 얻기 성공(DriverManager.getConnection(this.url, this.id, this.pw)) !!");
        return conn;
    }

    /**
     * 전달 받은 인자로 데이터를 조회한다.
     * @param hiredate
     * @param sal
     * @param empno
     * @return
     */
    public List selectEmp(String hiredate, int sal, String empno) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        // 수행할 SQL 준비
        StringBuffer query = new StringBuffer();
        query
        .append(" SELECT EMPNO, ENAME, JOB, to_char(HIREDATE, 'RRRR-MM-DD HH24:MI:SS') HIREDATE, SAL \n")
        .append(" FROM EMP \n")
        .append(" WHERE HIREDATE > to_date(?, 'RRRRMMDD') \n")
        .append("   AND SAL >= ? \n")
        .append("   AND EMPNO like ? \n");

        List dataList = new ArrayList();
        try {
            int pstmtCount = 1;
            conn = getConnection();

            System.out.println("3. SQL 수행 준비 및 바인드 변수 설정(conn.prepareStatement(query.toString())) !!");
            pstmt = conn.prepareStatement(query.toString());
            pstmt.setString(pstmtCount++, hiredate.substring(0, 8));
            pstmt.setInt(pstmtCount++, sal);
            pstmt.setString(pstmtCount++, empno + "%");
            System.out.println("4. SQL 실행(pstmt.executeQuery()) !!");
            rs = pstmt.executeQuery();

            EmpInfo info = null;
            System.out.println("5. SQL 실행 결과 패치 및 저장(rs.next()) !!");
            while(rs.next()) {
                info = new EmpInfo(
                    rs.getInt("EMPNO"),
                    rs.getString("ENAME"),
                    rs.getString("JOB"),
                    rs.getString("HIREDATE"),
                    rs.getInt("SAL")
                );

                dataList.add(info);
            }

            rs.close();
            pstmt.close();
            conn.close();

        } catch (SQLException e) {
            e.printStackTrace();

        } finally {
            if(rs    != null) try { rs.close();    } catch (SQLException e) { }
            if(pstmt != null) try { pstmt.close(); } catch (SQLException e) { }
            if(conn  != null) try { conn.close(); } catch (SQLException e) { }
        }
        return dataList;
    }

    /**
     * 전달받은 Emp 정보를 EMP 테이블에 삽입한다.
     * @param info
     * @return
     */
    public int insertEmp(EmpInfo info) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        // 수행할 SQL 준비
        StringBuffer query = new StringBuffer();
        query
        .append(" INSERT INTO EMP(EMPNO, ENAME, JOB, MGR, HIREDATE, SAL, COMM, DEPTNO) \n")
        .append(" VALUES(nvl((SELECT max(EMPNO) FROM EMP), 1) + 1, ?, ?, ?, to_date(?, 'RRRRMMDD'), ?, ?, ?) \n");

        int executeCount = 0;
        try {
            int pstmtCount = 1;
            conn = getConnection();

            // Transaction 을 수동으로 조작
            conn.setAutoCommit(false);

            System.out.println("3. SQL 수행 준비 및 바인드 변수 설정(conn.prepareStatement(query.toString())) !!");
            pstmt = conn.prepareStatement(query.toString());
            pstmt.setString(pstmtCount++, info.getEmpName());
            pstmt.setString(pstmtCount++, info.getJob());
            pstmt.setInt(pstmtCount++, info.getMgr());
            pstmt.setString(pstmtCount++, info.getHiredate().substring(0, 8));
            pstmt.setInt(pstmtCount++, info.getSal());
            pstmt.setInt(pstmtCount++, info.getComm());
            pstmt.setInt(pstmtCount++, info.getDeptno());
            System.out.println("4. SQL 실행(pstmt.executeUpdate()) !!");
            executeCount = pstmt.executeUpdate();

            // Transaction 정상 수행 시 commit 처리
            conn.commit();
            pstmt.close();
            conn.close();

        } catch (SQLException e) {
            // Transaction 오류 발생 시 rollback 처리
            try { conn.rollback(); } catch (SQLException e1) { }
            e.printStackTrace();

        } finally {
            if(pstmt != null) try { pstmt.close(); } catch (SQLException e) { }
            if(conn  != null) try { conn.close(); } catch (SQLException e) { }
        }
        return executeCount;
    }


    /**
     * DB연결 테스트
     * @param args
     */
    public static void main(String [] args) {
        DBConn dbConn = new DBConn();

        // EMP 테이블에서 데이터 조회
        List dataList = dbConn.selectEmp("19810401", 1500, "7");
        System.out.println("\n-----------------------------------------------------------");
        for(int index=0; index < dataList.size(); index++) {
            System.out.println(dataList.get(index));
        }

        // EMP 테이블에 Data Insert 테스트
        EmpInfo info = new EmpInfo("LITWAVE", "PROGRAMER", 7902, "19940711", 1400, 200, 20);
        dbConn.insertEmp(info);
    }
}

/**
* EMP 테이블의 정보를 담을 수 있는 Value Object
*/
class EmpInfo {
    private int empNo;
    private String empName;
    private String job;
    private int mgr;
    private String hiredate;
    private int sal;
    private int comm;
    private int deptno;

    public EmpInfo(int empNo, String empName, String job, String hiredate,
            int sal) {
        this.empNo = empNo;
        this.empName = empName;
        this.job = job;
        this.hiredate = hiredate;
        this.sal = sal;
    }

    public EmpInfo(String empName, String job, int mgr,
            String hiredate, int sal, int comm, int deptno) {
        this.empName = empName;
        this.job = job;
        this.mgr = mgr;
        this.hiredate = hiredate;
        this.sal = sal;
        this.comm = comm;
        this.deptno = deptno;
    }

    public int getEmpNo() {
        return empNo;
    }
    public String getEmpName() {
        return empName;
    }
    public String getJob() {
        return job;
    }
    public String getHiredate() {
        return hiredate;
    }
    public int getSal() {
        return sal;
    }
    public int getMgr() {
        return mgr;
    }
    public int getComm() {
        return comm;
    }
    public int getDeptno() {
        return deptno;
    }

    public String toString() {
        return "EMPNO : " + this.empNo
            + ", EMP_NAME : " + this.empName
            + ", JOB : " + this.hiredate
            + ", HIREDATE : " + this.hiredate
            + ", SAL : " + this.sal;
    }
}

//---------------------------------------------------------------------------//

- [Java 기본] Java Network - MulticastSocket을 이용한 채팅/파일전송 프로그램

겨울에 — Sat, 14 May 2011 16:34:31 +0900

출처 : http://cafe.naver.com/litave/406

/**
* 과거에 MulticastSocket를 이용한 채팅 및 파일 전송 프로그램을 작성했던 내용입니다.
* 작성자 : litwave
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
import java.io.*;
import java.net.*;

class MulticastChatting extends JFrame implements ActionListener, Runnable {

    private Container con;

    private FileInputStream fis = null;
    private FileOutputStream fos = null;

    // 받기위한 패킷, 소켓
    private DatagramPacket receivePacket;
    private MulticastSocket receiveSocket;

    // 보내기 위한 패킷, 소캣
    private DatagramPacket sendPacket;
    private MulticastSocket sendSocket;

    //파일 다이얼 로그
    JFileChooser fd = new JFileChooser("./");

    // 화면 구성 멤버
    private JLabel idLb = new JLabel(" 아이디 ", JLabel.RIGHT);
    private JTextField idTf = new JTextField(15);
    private JTextArea showTa = new JTextArea();
    private JScrollPane showJsp = new JScrollPane(showTa);
    private JLabel sendMsgLb = new JLabel(" 메제지 ", JLabel.RIGHT);
    private JTextField sendMsgTf = new JTextField();
    private JButton sendFileBt = new JButton(" 파일전송 ");
    private JButton exitBt = new JButton(" 종료 ");

    // Border 선언
    private Border btB = BorderFactory.createRaisedBevelBorder();
    private Border tfB = new BevelBorder(BevelBorder.LOWERED);

    //new BevelBorder(BevelBorder.RAISED);
    // 배경색
    private Color bgColor = new Color(255, 242, 242);
    // JLabel 글꼴 지정
    private Font lbFont = new Font("새굴림", Font.BOLD, 16);
    private Color lbTextColor = new Color(172, 89, 255);
    //JButton 모양 설정
    private Font btFont = new Font("HY엽서L", 0, 14);
    private Color btTextColor = new Color(225, 225, 225);
    private Color btBgColor = new Color(0, 0, 160);

    //텍스트 필드 설정
    private Color tfBgColor = new Color(255, 255, 230);
    private Color tfTextColor = new Color(0, 0, 128);
    private Font tfFont = new Font("HY중고딕", 0, 12);

    public void initComponent() {
        idLb.setFont(lbFont);
        sendMsgLb.setFont(lbFont);
        idLb.setForeground(lbTextColor);
        sendMsgLb.setForeground(lbTextColor);

        idTf.setFont(tfFont);
        idTf.setForeground(tfTextColor);
        idTf.setBackground(tfBgColor);
        idTf.setBorder(tfB);
        sendMsgTf.setFont(tfFont);
        sendMsgTf.setForeground(tfTextColor);
        sendMsgTf.setBackground(tfBgColor);
        sendMsgTf.setBorder(tfB);

        showTa.setBackground(new Color(244, 255, 244));
        showTa.setForeground(new Color(0, 0, 128));

        sendFileBt.setFont(btFont);
        sendFileBt.setForeground(btTextColor);
        sendFileBt.setBackground(btBgColor);
        sendFileBt.setBorder(btB);
        exitBt.setFont(btFont);
        exitBt.setForeground(btTextColor);
        exitBt.setBackground(btBgColor); exitBt.setBorder(btB); } public MulticastChatting() {
        super("Multicast Sample Messenger v0.3");
        init();
        start();
        setSize(300, 400);
        Toolkit tk = Toolkit.getDefaultToolkit();
        Dimension d1 = tk.getScreenSize();
        Dimension d2 = this.getSize();
        this.setLocation((int)(d1.getWidth()/2-d2.getWidth()/2),
                    (int)(d1.getHeight()/2-d2.getHeight()/2));
        setVisible(true);
    }

    public void init() {
        con = this.getContentPane();
        con.setLayout(new BorderLayout(5,5));

        JPanel jPn1 = new JPanel(new BorderLayout(5,5));
        jPn1.add("West", idLb);
        jPn1.add("Center", idTf);
        con.add("North", jPn1);

        con.add("Center", showJsp);

        JPanel jPn3 = new JPanel(new BorderLayout(5,5));
        jPn3.add("West", sendMsgLb);
        jPn3.add("Center", sendMsgTf);
            JPanel jPn31 = new JPanel(new GridLayout(1,2));
            jPn31.add(sendFileBt);
            jPn31.add(exitBt);
        jPn3.add("South", jPn31);
        con.add("South", jPn3);

        initComponent();
        con.setBackground(bgColor);
        jPn1.setBackground(bgColor);
        jPn3.setBackground(bgColor);
        jPn31.setBackground(bgColor);

        showTa.setEnabled(false);
        idTf.requestFocus();

        // down 디렉토리 생성
        File f = new File("./down");
        if(!f.exists()) {
            System.out.println("파일 생성 : " + f.mkdir());
        }
    }

    public void start() {
        idTf.addActionListener( this );
        sendMsgTf.addActionListener( this );
        sendFileBt.addActionListener( this );
        exitBt.addActionListener( this );
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    public void run() {
        showTa.setText("##### 대화방에 입장하셨습니다. #####\n");
        try {
            receiveSocket = new MulticastSocket(20000);
            receiveSocket.joinGroup(InetAddress.getByName("239.2.3.4"));
        } catch (IOException ex) { }

        String fileName = null;
        while(true) {
            receivePacket = new DatagramPacket(new byte[1024], 1024);
            try{
                receiveSocket.receive(receivePacket);
            } catch (IOException ex) { }

            byte[] data = receivePacket.getData();
            String protocal = new String(data, 0, 6);

            if(protocal.equals("[MESG]")) {
                showTa.append((new String(data, 6, 1018).trim()) + "\n");
            // 새로운 파일을 열음
            } else if(protocal.equals("[SFNE]")) {
                try {
                    fileName = new String(data, 6, 1018).trim();
                    if(fileName != null)
                        fos = new FileOutputStream(".\\down\\" + fileName);
                } catch(FileNotFoundException ex) {
                    ex.printStackTrace();
                }
            } else if(protocal.equals("[SFIL]")) {
                try{
                    fos.write(data, 8, (int)data[6] * 100 + data[7]);
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
                if((int)data[6] * 100 + data[7] < 1016) {
                    try {
                        if(fos != null) fos.close();
                        showTa.append(fileName + " 파일을 전송 받았습니다.\n");
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                }
            }
            showTa.setCaretPosition(showTa.getText().trim().length());
        }
    }

    public void actionPerformed(ActionEvent ev) {
        if(ev.getSource() == idTf) {
            new Thread(this).start();
            idTf.setEnabled(false);
            sendMsgTf.requestFocus();
        } else if(ev.getSource() == sendMsgTf) {
            String str = sendMsgTf.getText().trim(); // 전송될 메세지
            if(str == null || str.length() == 0) {
                sendMsgTf.setText("");
                sendMsgTf.requestFocus();
                return;
            }

            str = idTf.getText().trim() + " >> " + str;

            // 메세지 전송 프로토콜을 삽입
            str = "[MESG]" + str;

            sendBytes(str.getBytes());

            sendMsgTf.setText("");
            sendMsgTf.requestFocus();

        } else if(ev.getSource() == exitBt) {
            System.exit(0);
        } else if(ev.getSource() == sendFileBt) {
            fd.setDialogTitle("전송할 파일을 선택하세요!!");
            fd.showOpenDialog(this);
            if(fd.getSelectedFile() == null || fd.getSelectedFile().getName().length() == 0) {
                showTa.append("전송할 파일을 선택해야 합니다.!!\n");
                showTa.setCaretPosition(showTa.getText().trim().length());
                return;
            }
            showTa.append(fd.getSelectedFile().getName() + "파일을 전송합니다.\n");
            showTa.setCaretPosition(showTa.getText().trim().length());

            // 파일 이름 전송(with protocal)
            String str = "[SFNE]" + fd.getSelectedFile().getName(); // 전송될 파일이름
            sendBytes(str.getBytes());    // 파일 이름 전송

            byte[] strData = "[SFIL]".getBytes();    // 파일 보내기 Protocal 이름
            byte[] data = new byte[1024];

            for(int i=0; i<6; i++)
                data[i] = strData[i];


            int testInt;
            try {
                fis = new FileInputStream(fd.getSelectedFile());
                while(true) {
                    testInt = fis.read(data, 8, 1024-8);
                    if(testInt == -1) break;

                    // data에 읽어온 데이타의 길이를 data[6], data[7]에 나눠서 넣음
                    data[6] = (byte)(testInt / 100);
                    data[7] = (byte)(testInt % 100);

                    sendBytes(data);
                }
            } catch (FileNotFoundException ex) {

            } catch (IOException ex) {

            } finally {
                try {
                    if(fis != null) fis.close();
                } catch (IOException ex) { }
                showTa.append("파일 전송 완료!!..\n");
            }
            showTa.setCaretPosition(showTa.getText().trim().length());
        }
    }

    // 바이트 배열을 전송 시킨다.
    public void sendBytes(byte[] data) {
        // 데이터 전송
        // 1.데이타그램 패킷 생성
        try {
            sendPacket = new DatagramPacket(data, data.length, InetAddress.getByName("239.2.3.4"), 20000);
        } catch (Exception ex) { }

        //2. 멀티캐스트 소캣 생성
        try {
            sendSocket = new MulticastSocket();
            sendSocket.setTimeToLive((byte)1);
            sendSocket.send(sendPacket);
            sendSocket.close();
        } catch(IOException ex) { }
    }
}

public class MulticastChattingDemo {
    public static void main(String [] ar) {
        new MulticastChatting();
    }
}

- [Java 기본] Java Network

겨울에 — Sat, 14 May 2011 16:33:43 +0900

출처 : http://cafe.naver.com/litave/405

ho0210.zip

ho0212.zip

- Ho0212.zip : 수업시간에 만든 채팅 프로그램

//===========================================================================//

- [Java 기본]Swing

겨울에 — Sat, 14 May 2011 16:32:03 +0900

출처 : http://cafe.naver.com/litave/404

ex0206_01.java

//===========================================================================//
본 내용은 2002년 제가 Java 강의를 수강하며 정리 했던 내용을
    기본으로 하여 정리하였습니다.
  - 마침 java 기초를 전파할 기회가 생겨 핑계김에 정리해 가려 합니다.
작성자 : litwave
//---------------------------------------------------------------------------//

<목차>
1. awt 와 Swing 의 비교
2. 예제 소스
  - 수업시간에 진행했던 소스만 올립니다.

//---------------------------------------------------------------------------//

1. awt 와 Swing 의 비교
                          awt                       swing
    사용시작버젼         1.1미만                   1.2이상
    import               java.awt                  java.awt(Layout Manager 때문에 필요)
                         java.awt.event            java.awt.event
                                                   javax.swing
                                                   javax.swing.border
                                                   javax.swing.event
                                                   javax.swing.tree     //탐색기의 트리형식을 이용할 수 있다
                                                   javax.swing.table    //엑셀같은 형태를 이용할 수 있다

    특징                 platform 종속적           platform 독립적
                         중량 Component            경량 Component      //시스템이 바뀔 경우 이동이 쉽다.
                         단일 Frame                다중 Frame 사용

//---------------------------------------------------------------------------//
2. 예제 소스

// Ex0205_01.java : 파일 선택하기
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class Ex0205_01_Sub extends JFrame {
    //private FileDialog fd = new FileDialog(this, "열기", FileDialog.LOAD);
    private JFileChooser jfc = new JFileChooser("c:");
    public Ex0205_01_Sub() {
        super("Test");
        this.init();
        this.start();
        this.setSize(300, 200);
        this.setVisible(true);
        jfc.showOpenDialog(this);
        System.out.println("선택된 파일 : " + jfc.getSelectedFile());
        //jfc.showSaveDialog(this);
    }
    public void init(){}
    public void start(){}
}
public class Ex0205_01 {
    public static void main(String[] ar) {
        Ex0205_01_Sub es = new Ex0205_01_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0205_02.java : Popup 메시지 출력
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class Ex0205_02_Sub extends JFrame {
    public Ex0205_02_Sub() {
        super("Test");
        this.init();
        this.start();
        this.setSize(300, 200);
        this.setVisible(true);
        /*JOptionPane.showMessageDialog(this,
            "시스템오류\n치명적인 오류입니다.", "경고",
                                        JOptionPane.ERROR_MESSAGE);*/
        JOptionPane.showInputDialog(this, "좋아하는 연예인?");
    }
    public void init() { }
    public void start() { }
}
public class Ex0205_02 {
    public static void main(String[] ar) {
        Ex0205_02_Sub es = new Ex0205_02_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0205_03.java : JButton 테스트
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class Ex0205_03_Sub extends JFrame {
    private JToolBar jtb = new JToolBar();
    private JButton jbt = new JButton(new ImageIcon("image/new.gif"));
    private JButton jbt1 = new JButton(new ImageIcon("aaa1.gif"));
    private JButton jbt2 = new JButton(new ImageIcon("aaa2.gif"));
    private JButton jbt3 = new JButton(new ImageIcon("aaa3.gif"));
    private JRootPane jrp;
    private Container con;
    private JSplitPane jsp = new JSplitPane();
    public Ex0205_03_Sub() {
        super("Test");
        this.init();
        this.start();
        this.setSize(300, 200);
        this.setVisible(true);
    }
    public void init() {
        jrp = this.getRootPane();
        con = jrp.getContentPane();
        con.setLayout(new BorderLayout());
        jtb.add(jbt);
        jtb.add(jbt1);
        jtb.add(jbt2);
        jtb.add(jbt3);
        con.add("North", jtb);
        con.add("Center", jsp);
    }
    public void start() { }
}
public class Ex0205_03 {
    public static void main(String[] ar) {
        Ex0205_03_Sub es = new Ex0205_03_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0205_04.java : Event 테스트
import java.awt.*;
import java.awt.event.*;
class Ex0205_04_Sub extends Frame implements ActionListener {
    private Button bt = new Button("1번");
    private Button bt1 = new Button("2번");
    private Button bt2 = new Button("3번");
    private Panel p = new Panel();
    private Panel p1 = new Panel();
    private Panel p2 = new Panel();
    private Panel pp, pp1;
    private CardLayout cl = new CardLayout();
    public Ex0205_04_Sub() {
        super("Test");
        this.init();
        this.start();
        this.setSize(300, 200);
        this.setVisible(true);
    }
    public void init() {
        this.setLayout(new BorderLayout());
        pp = new Panel(new FlowLayout());
        pp.add(bt);
        pp.add(bt1);
        pp.add(bt2);
        pp1 = new Panel(cl);
        p.setBackground(Color.red);
        p1.setBackground(Color.green);
        p2.setBackground(Color.blue);
        pp1.add(p, "first");
        pp1.add(p1, "second");
        pp1.add(p2, "third");
        this.add("North", pp);
        this.add("Center", pp1);
    }
    public void start() {
        bt.addActionListener(this);
        bt1.addActionListener(this);
        bt2.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e) {
        if(e.getSource() == bt) {
            cl.show(pp1, "first");

        } else if(e.getSource() == bt1) {
            cl.show(pp1, "second");

        } else if(e.getSource() == bt2) {
            cl.show(pp1, "third");
        }
    }
}
public class Ex0205_04 {
    public static void main(String[] ar) {
        Ex0205_04_Sub es = new Ex0205_04_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0205_05.java : JTabbedPane 테스트
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class Ex0205_05_Sub extends JFrame {
    private JRootPane jrp;
    private Container con;
    private JTabbedPane jtp = new JTabbedPane();
    private JPanel jp = new JPanel();
    private JPanel jp1 = new JPanel();
    private JPanel jp2 = new JPanel();
    public Ex0205_05_Sub() {
        super("Test");
        this.init();
        this.start();
        this.setSize(300, 200);
        this.setVisible(true);
    }
    public void init() {
        jrp = this.getRootPane();
        con = jrp.getContentPane();
        con.setLayout(new BorderLayout());
        jp.setBackground(Color.red);
        jp1.setBackground(Color.green);
        jp2.setBackground(Color.blue);
        jtp.addTab("1번", jp);
        jtp.addTab("2번", jp1);
        jtp.addTab("3번", jp2);
        con.add("Center", jtp);
    }
    public void start() { }
}
public class Ex0205_05 {
    public static void main(String[] ar) {
        Ex0205_05_Sub es = new Ex0205_05_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0205_06.java : JTree 테스트
import java.awt.*;
import javax.swing.*;
import javax.swing.tree.*;
class Ex0205_06_Sub extends JFrame{
    private JRootPane jrp;
    private Container con;
    private JLabel jlb = new JLabel("JTree !!", JLabel.CENTER);
    private JButton jbt = new JButton("확인");
    private DefaultMutableTreeNode root = new DefaultMutableTreeNode("전세계");
    private JTree jt = new JTree(root);
    private JScrollPane jsp = new JScrollPane(jt);

    private DefaultMutableTreeNode child1 = new DefaultMutableTreeNode("대한민국");
    private DefaultMutableTreeNode child2 = new DefaultMutableTreeNode("미국");
    private DefaultMutableTreeNode child3 = new DefaultMutableTreeNode("일본");

    public Ex0205_06_Sub() {
        super("Test");
        this.init();
        this.setSize(300, 200);
        this.setVisible(true);
    }
    public void init() {
        jrp = this.getRootPane();
        con = jrp.getContentPane();
        con.setLayout(new BorderLayout());
        jlb.setFont(new Font("휴먼옛체", Font.BOLD, 20));
        con.add("North", jlb);
        con.add("South", jbt);
        root.add(child1);
        root.add(child2);
        root.add(child3);
        con.add("Center", jsp);
    }
}
public class Ex0205_06 {
    public static void main(String[] ar) {
        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } catch(Exception ee) { }
        Ex0205_06_Sub es = new Ex0205_06_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0205_07.java : JTable 테스트
import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.table.*;
class Ex0205_07_Sub extends JFrame {
    private JRootPane jrp;
    private Container con;
    private JLabel jlb = new JLabel("JTable !!", JLabel.CENTER);
    private JButton jbt = new JButton("확인");
    private DefaultTableModel dtm = new DefaultTableModel(3, 10);
    private DefaultTableColumnModel dtcm = new DefaultTableColumnModel();
    private TableColumn[] tc = new TableColumn[3];
    private DefaultTableCellRenderer[] dtcr = new DefaultTableCellRenderer[3];
    private DefaultCellEditor[] dce = new DefaultCellEditor[3];
    private DefaultListSelectionModel dlsm = new DefaultListSelectionModel();
    private JTableHeader jth = new JTableHeader(dtcm);
    private JTable jt = new JTable(dtm, dtcm, dlsm);
    private JScrollPane jsp = new JScrollPane(jt);
    public Ex0205_07_Sub() {
        super("Test");
        this.init();
        this.setSize(300, 200);
        this.setVisible(true);
    }
    public void init() {
        jrp = this.getRootPane();
        con = jrp.getContentPane();
        con.setLayout(new BorderLayout());
        jlb.setFont(new Font("휴먼옛체", Font.BOLD, 20));
        con.add("North", jlb);
        con.add("South", jbt);
        jsp.setBorder(new BevelBorder(BevelBorder.RAISED));

        dtcr[0] = new DefaultTableCellRenderer();
        dce[0] = new DefaultCellEditor(new JCheckBox());
        tc[0] = new TableColumn(0, 75, dtcr[0], dce[0]);
        tc[0].setHeaderValue("순서");
        dtcm.addColumn(tc[0]);
        dtcr[1] = new DefaultTableCellRenderer();
        dce[1] = new DefaultCellEditor(new JComboBox());
        tc[1] = new TableColumn(1, 75, dtcr[1], dce[1]);
        tc[1].setHeaderValue("이름");
        dtcm.addColumn(tc[1]);
        dtcr[2] = new DefaultTableCellRenderer();
        dce[2] = new DefaultCellEditor(new JTextField());
        tc[2] = new TableColumn(2, 75, dtcr[2], dce[2]);
        tc[2].setHeaderValue("주민번호");
        dtcm.addColumn(tc[2]);
        jt.setTableHeader(jth);
        con.add("Center", jsp);
    }
}
public class Ex0205_07 {
    public static void main(String[] ar) {
        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } catch(Exception ee) { }
        Ex0205_07_Sub es = new Ex0205_07_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0205_08.java : JTable 테스트
import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;

class Ex0205_08_Sub extends JFrame {
    private JRootPane jrp;
    private Container con;
    private JLabel jlb = new JLabel("JTable !!", JLabel.CENTER);
    private JButton jbt = new JButton("확인");
    private String[][] str = {{"AAA", "BBB", "CCC"}, {"DDD", "EEE", "FFF"}, {"GGG", "HHH", "III"}};
    private String[] str1 = {"1", "2", "3"};
    private JTable jt = new JTable(str, str1);
    private JScrollPane jsp = new JScrollPane(jt);
    public Ex0205_08_Sub() {
        super("Test");
        this.init();
        this.setSize(300, 200);
        this.setVisible(true);
    }
    public void init() {
        jrp = this.getRootPane();
        con = jrp.getContentPane();
        con.setLayout(new BorderLayout());
        jlb.setFont(new Font("휴먼옛체", Font.BOLD, 20));
        con.add("North", jlb);
        con.add("South", jbt);
        jsp.setBorder(new BevelBorder(BevelBorder.RAISED));
        con.add("Center", jsp);
    }
}
public class Ex0205_08 {
    public static void main(String[] ar) {
        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } catch(Exception ee) { }
        Ex0205_08_Sub es = new Ex0205_08_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ho0205_01.java : JComboBox 테스트
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class Ho0205_01_Sub extends JFrame {
    private JRootPane jrp;
    private Container con;
    private String[] items = {"자전거", "자동차", "오토바이", "스키", "보드", "신발", "지하철", "기차", "맨발", "개발", "닭발"};
    private JComboBox jcb = new JComboBox(items);
    private JScrollPane jp = new JScrollPane(jcb);
    public Ho0205_01_Sub() {
        super("콤보박스에 내용 적기");
        init();
        start();
        setSize(300,50);
        setLocation(300,200);
        setVisible(true);
    }
    public void init() {
        jrp = this.getRootPane();
        con = jrp.getContentPane();
        con.setLayout(new BorderLayout());
        jcb.setEditable(true);
        con.add("Center", jcb);

    }
    public void start() {
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

public class Ho0205_01 {
    public static void main(String [] ar) {
        Ho0205_01_Sub h1s = new Ho0205_01_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ho0205_02.java : JPasswordField 테스트
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;

class Ho0205_02_Sub extends JFrame {
    private JRootPane jrp;
    private Container con;
    private JPasswordField jpf = new JPasswordField();

    public Ho0205_02_Sub() {
        super("JPasswordField 연습");
        init();
        start();
        setSize(300,70);
        setLocation(300,300);
        setVisible(true);
    }
    public void init() {
        jrp = this.getRootPane();
        con = jrp.getContentPane();
        con.setLayout(new BorderLayout());
        jpf.setEchoChar('●');
        jpf.setBorder(new TitledBorder("암호"));
        con.add("Center", jpf);
    }
    public void start() {
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}
public class Ho0205_02 {
    public static void main(String [] ar) {
        Ho0205_02_Sub h2s = new Ho0205_02_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ho0205_03.java : JProgressBar 테스트
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;

class WorkPanel extends JPanel {
    private int nValue;
    private int x, y, w, h;
    public void paint(Graphics g) {
        for(int i=0; i < nValue; i++) {
            x = (int)(getSize().width * i / 200.0f);
            w = getSize().width - 2 * x;
            y = (int)(getSize().height * i / 200.0f);
            h = getSize().height - 2 * y;
            g.setColor(new Color(0, 0, i*2 + 50));
            g.fillRect(x, y, w, h);
        }
        g.setColor(Color.black);
        g.drawRect(x, y, w, h);
    }
    public void setNValue(int i) {
        nValue = i;
    }
    public int getNValue() {
        return nValue;
    }
}

class Ho0205_03_Sub extends JFrame implements Runnable {
    private JProgressBar jpb = new JProgressBar(0, 100);
    private JRootPane jrp;
    private Container con;
    private WorkPanel wp = new WorkPanel();
//    private Ho0205_03_Sub h3s = new Ho0205_03_Sub();
    public Ho0205_03_Sub() {
        super("JProgressBar Test");
        init();
        start();
        setSize(300,200);
        setLocation(300,300);
        setVisible(true);
    }
    public void init() {
        jrp = this.getRootPane();
        con = jrp.getContentPane();
        con.setLayout(new BorderLayout());
        JPanel jp1 = new JPanel(new BorderLayout());
        jp1.setBorder(new TitledBorder("진행상태"));
        jpb.setStringPainted(true);
        jpb.setIndeterminate(true);
        jp1.add("Center", jpb);
        con.add("South", jp1);
        con.add("Center", wp);
    }
    public void start() {
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public void run() {
        for(int i=1; i <= 100; i++) {
            wp.setNValue(i);
            wp.repaint();
            try {
                Thread.sleep(100);
            } catch(Exception ee) { }
            jpb.setValue(i);
            jpb.setString("현재 : " + (int)(jpb.getPercentComplete() * 100) + "%");
        }
    }
}

public class Ho0205_03 {
    public static void main(String [] ar) {
        Ho0205_03_Sub h3s = new Ho0205_03_Sub();
        Thread thd = new Thread(h3s);
        try {
            thd.start();
        } catch (Exception ee) { }
    }
}

//---------------------------------------------------------------------------//
// Ho0205_05.java : 색상 선택하기 프로그램
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class Ho0205_05_Sub extends JFrame implements ActionListener{
    //west
    private JLabel jlb1 = new JLabel("Red", JLabel.RIGHT);
    private JLabel jlb2 = new JLabel("Green", JLabel.RIGHT);
    private JLabel jlb3 = new JLabel("Blue", JLabel.RIGHT);
    //cen   //선택 색상 초기값으로 버튼에 표시
    private JTextField redjtf1 = new JTextField("140", 5);
    private JTextField greenjtf2 = new JTextField("84");
    private JTextField bluejtf3 = new JTextField("44");
    //ease //색상 선택 버튼
    private JButton jbt1 = new JButton("색상 선택");
    //south //Button 선택값 보여주기
    //sou-west
    private JLabel jlb4 = new JLabel("선택 색상 - ");
    //Sou-Cen
    private JTextField jtf4 = new JTextField();

    private JRootPane jrp;
    private Container con;

    private JColorChooser jcc;

    public Ho0205_05_Sub() {
        super("색상 얻어오기");
        init();
        start();
        this.pack();
        Toolkit tk = Toolkit.getDefaultToolkit();
        Dimension di1 = tk.getScreenSize();
        Dimension di2 = this.getSize();
        setLocation((int)(di1.getWidth()/2 - di2.getWidth()/2),
                    (int)(di1.getHeight()/2 - di2.getHeight()/2));
        setVisible(true);
    }
    public void init() {
        jrp = this.getRootPane();
        con = jrp.getContentPane();
        con.setLayout(new BorderLayout());
        //wst
        JPanel jp1 = new JPanel(new GridLayout(3,1));
        jp1.add(jlb1);
        jp1.add(jlb2);
        jp1.add(jlb3);
        con.add("West", jp1);
        //cen
        JPanel jp2 = new JPanel(new GridLayout(3,1));
        jp2.add(redjtf1);
        jp2.add(greenjtf2);
        jp2.add(bluejtf3);
        con.add("Center", jp2);
        con.add("East", jbt1);
        //sou
//        JPanel jp3 = new JPanel(new BorderLayout());
//        jp3.add("West", jlb4);
//        jp3.add("Center", jtf4);
        con.add("South", jlb4);
    }
    public void start() {
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jbt1.addActionListener( this );
    }
    public void actionPerformed(ActionEvent e) {
        int red, green, blue;
        red = green = blue = 0;
        if(e.getSource() == jbt1) {
            if(redjtf1.getText().length() == 0 || greenjtf2.getText().length() == 0 || bluejtf3.getText().length() == 0) {
                return;
            }
            red = Integer.parseInt(redjtf1.getText().trim()) % 256;
            green = Integer.parseInt(greenjtf2.getText().trim()) % 256;
            blue = Integer.parseInt(bluejtf3.getText().trim()) % 256;
            Color cc = new Color(red, green, blue);
            jbt1.setBackground(cc);
            jcc = new JColorChooser();
            try {
                cc = jcc.showDialog(this, "색상선택", cc);
                jbt1.setBackground(cc);
                jlb4.setText("선택색상 - R: " + cc.getRed() + ", G: " + cc.getGreen() + ", B: " + cc.getBlue());
            } catch (NullPointerException ee) {
                cc = new Color(red, green, blue);
                jbt1.setBackground(cc);
                jlb4.setText("선택색상 - R: " + cc.getRed() + ", G: " + cc.getGreen() + ", B: " + cc.getBlue());
            }
        }
    }
}

public class Ho0205_05 {
    public static void main(String [] ar) {
        Ho0205_05_Sub h5s = new Ho0205_05_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ho0205_09.java : JTree를 이용한 디렉토리 구조 보여주기
import java.awt.*;
import javax.swing.*;
import javax.swing.tree.*;
import java.io.*;

class Ho0205_09_Sub extends JFrame {
    private JRootPane jrp;
    private Container con;
    private File f = new File("c:\\Documents and Settings\\All Users\\");        //여기에 절대 경로 표시
    private DefaultMutableTreeNode root = new DefaultMutableTreeNode(f.getAbsolutePath());
    private JTree jt = new JTree(root);
    private JScrollPane jsp = new JScrollPane(jt);

    public Ho0205_09_Sub() {
        super("경로보여주기");
        setSize(300,200);
        Toolkit tk = Toolkit.getDefaultToolkit();
        Dimension di1 = tk.getScreenSize();
        Dimension di2 = this.getSize();
        setLocation((int)(di1.getWidth()/2 - di2.getWidth()/2),
                    (int)(di1.getHeight()/2 - di2.getHeight()/2));
        init();
        start();
        setVisible(true);
    }
    public void init() {
        jrp = this.getRootPane();
        con = jrp.getContentPane();
        con.setLayout(new BorderLayout());
        creatPath(f);
        con.add("Center", jsp);
    }
    public void start() {
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public void creatPath(File f) {        //시작시만 실행(root에 f를 add 시킴)
        String fpath = f.getAbsolutePath();
//      System.out.println(fpath);   //현재 파일 절대 경로 포함 표시

        if(f.isDirectory()) {
            String[] str = f.list();
            for(int i=0; i < f.list().length; i++) {
                File nf = new File(fpath + "\\" + str[i]);
                creatPath(nf, root);
            }
        }
    }

    public void creatPath(File f, DefaultMutableTreeNode dmtn) {        //dmtn에 f를 add 시킴
        String fpath = f.getAbsolutePath();
        DefaultMutableTreeNode indmtn = new DefaultMutableTreeNode(f.getName());
        dmtn.add(indmtn);
//      System.out.println(fpath);   //현재 파일 절대 경로 포함 표시

        if(f.isDirectory()) {
            String[] str = f.list();
            for(int i=0; i < f.list().length; i++) {
                File nf = new File(fpath + "\\" + str[i]);
                creatPath(nf, indmtn);
            }
        }
    }
}

public class Ho0205_09 {
    public static void main(String [] ar) {
        Ho0205_09_Sub h9s = new Ho0205_09_Sub();
    }
}

//===========================================================================//

- [Java 기본] JAVA File I/O

겨울에 — Sat, 14 May 2011 16:31:05 +0900

출처 : http://cafe.naver.com/litave/403

1. Java I/O
  - 컴퓨터는 복잡하고 많은 데이타의 저장 및 읽기가 쉽게 사용할 수 있도록 하기 위해서 나오게 되었다.
  - Java I/O  -> Byte형식 -> Stream
    o Java는 모든 형식을 바이트 단위로 처리하게 되어 있고, 이런 형식을 Stream이라고 이야기 한다.

  - Stream은 두가지 형식의 작용을한다.
    1) 사이펀 작용 : 파일 읽기, 네트웍에서 데이타를 가져오기, 키보드 로 입력 받기(무한)
       - 물을 계속 적으로 끓어오는 작업
    2) 호스 작용 : 파일에 데이타를 쓰기, 네트웍으로 데이타 전송하기, Console로 출력하기

2. I/O 관련 클래스
  1) File
  2) OutputStream
  3) InputStream
  4) Writer
  5) Reader
  6) ObjectOutputStream
  7) ObjectInputStream
  8) RandomAccessFile

3. 자료형
  3.1 정수형
    1) byte : 기본적인 입.출력을 담당하는 자료형(-128~127 : 전송되는 타입은 0~255 의 범위로 입력을 받을 수 있다.)
    2) short : 다른 언어와 호환하기 위해서 나온 자료형이다.(C언어에서는 기본 데이터 처리 단위가 2바이트 이기 때문)
        - 거의 사용 안함
    3) int : Java의 기본적인 타입의 자료형이다.
    4) long

  3.2 문자형
    1) char :(0~65535)
        - char 형은 (byte * 256 + byte) 로 자동 형변환이 이루어진다.

    2) 문자형
      a) ASSCII - 7bit(0~127)
        - 0~31, 32, 127 : white Character (화면에 표시되지 않는 제어 문자들) 라고 한다.

      b) ISO Latin-I : 8bit (0~255를 가지는 문자)
        - 컴퓨터에서 사용하는 대부분의 타입
          0~127 : ASCII와 동일하다.
          128~255 : 대부분의 서구 유럽어들을 표시할수 있다.

      c) Unicode - 16bit(0~65535)
          0~255 : ISO Latin-I 과 동일
          256~65535 : (한국어, 일본어, 그리스어 등을 표시하기 위해 만듬)
        - 숫자 및 문자로 표시할 수 있다.
        - 매칭되는 데이타 타입을 표시할 수 없을 경우에는 '\u????' 로 표시 가능하다.

      d) UTF-8 : 24bit(3byte)           //우리가 자주사용해야 하는 타입
        - 유니코드타입에서의 메모리 낭비 단점을 보안하기 위해서 나옴
          0~255 : ISO Latin-I(1byte)
          256~2175 : Unicode(2Byte) 타입
          2176~? : 3byte
        - 자바 파일을 컴파일 하면 .class 파일은 자동으로 UTF-8 타입으로 바뀌게 된다.

4. I/O 관련 클래스 상세
  4.1 File
    1) Constructor Summary
      new File(File, String)    // File:경로, String:파일명(경로와 동시에 파일명을 적어도 됨)
      new File(String)          //경로와 파일명을 동시에 적고, 경로를 적지 않으면 현재 디렉토리를 의미 한다.
      new File(String, String)
      new File(URL)             // 웹상에 특정 문서를 연결 시켜 줄 수 있는 생성자

    2) Method Summary
      - Ex0202_01.java 파일 참조

      - canRead() : 파일의 읽기를 할수 있는지 확인 하는 것.
      - canWrite() : 파일을 쓸수 있는지 확인 하는 것..

      File file = new File("MyFile.txt")
      - file.createNewFile()    : 특정 파일을 생성
      - file.delete()           : 특정 파일을 삭제

      - file.getName()          : 해당 파일의 이름을 가져옴
      - file 만 쓰면 뒤에 toString() 가 생략된 형태

      - file.list()             : 특정 디렉토리에 있는 모든 파일을 리턴
                                : 디렉토리에 있는 파일들을 String객체로 얻어 온다.
      - mkdir()                 : 디렉토리 형태로 파일 만들기.(마지막 하나의 디렉토리만 생성, 앞의 경로가 정확히 일치해야 한다.)
      - mkdirs()                : 경로명과 디렉토리를 모두 만들고 싶을때 사용

  4.2 OutputStream : 대상체에 출력을 한다.
    - 파일을 출력하는 최상위 클래스 이다.
    - OutputStream : 추상 클래스로 바로 객체 생성이 불가능 하다.
    1) Method Summary
      - write(int i)         //버퍼로 추력하는 것
      - write(byte[])
      - write(byte[], int start , int end)
      - flush()              // 버퍼가 차지 않아도 버퍼의 내용을 모두 보낸다. => Ex0202_02.java
      - close()

    2) OutputStream 의 상속관계
       OutputStream - FileOutputStream(파일과 연계해서 사용할 때 사용 가능)
                    - ByteArrayOutputStream(데이타를 바이트 단위로 쪼개어서 보낼때 사용.(데이타 전송시 사용))
                    - PipedOutputStream(쓰레드간의 통신을 위해서 나온 클래스)
                    - FilterOutputStream(필터기능 포함)  - BufferedOutputStream(버퍼를 사용하도록 해둠)
                                                         - PrintStream(System.out과 연계해서만 사용됨)
                                                         - DataOutputStream(데이타에 우선을 두어 전송을 하도록 사용)
       - 과제 ) OutputStream, InputStream, Writer, Reader // 의 상속관계 위와 같이 그려 오기(과제1)

    3) 임의의 OutputStream 을 생성해여 redirection 시키는 방법 => Ex0202_03 : 화면 상에 아무것도 출력되지 않게 됨.
        - System.out.println => 화면 이외의 곳으로 출력하는 방법
          System.setOut(ps);
          System.setErr(ps);    // 임의의 곳으로 접근 권한을 옮김.
                                // println은 무조건 write를 이용하도록 되어 있다.

    4) FileOutputStream
      - 매개변수로 파일 객체를 받을 수 있다.
      - 해당 파일의 접근 권한을 갖게 된다.
        사용예-> Ex0202_04
      - 파일을 열면 닫아야 한다.

    5) BufferedOutputStream
      - 버퍼에 한꺼번에 담았다가 스트림 단위로 내보낸다.
      - 파일을 버퍼에 한꺼번에 담았다가 출력하는 것이 빠르기 때문이다..

    6) DataOutputStream
      - 특정 데이터를 포맷된 데이터로 전송할 수 있다

    7) 파일에서 -1은 파일의 끝을 의미 한다.

  4.3 InputStream
    1) InputStream 의 상속관계
        InputStream - FileInputStream    : 파일과 연계하여 파일을 읽어 온다.
                    - ByteArrayInputStream
                    - PipedInputStream
                    - FilterInputStream  - BufferedInputStream
                                         - DataInputStream
                    - SequenceInputStream : 파일을 연결 시켜서 여러개 연결 시킬때 사용한다.

       - System.in은 BufferedInputStream 과 연결 되어 있다.
       - 리다이렉션 시켜서 다른 파일에서 입력을 받을 수 있다.

    2) Method Summary
      - int <- read()   : int로 리턴 된다. 사용범위는 0~255이다. ctrl+z는 -1(End Of File:ctrl+z/ctrl+d, \n)이 리턴된다. 리턴된다.
      - read(byte[])    : byte단위로 입력됨.
      - read(byte[], int(시작위치), int(개수));
      - close();
      - mark(?)    //특정한 파일에서 몇번 연속해서 읽기 위해서 mark(n) : n번째위치에 마킹표시
      - reset();   //특정위치에서 mark된 위치로 돌아감.

  4.4 Writer
      - Writer 와 Reader 는 2바이트 단위의 흐름을 가진다.
    1) Writer 관련 클래스
      Writer - FileWriter
             - OutputStreamWriter
             - BufferedWriter
             - PrintWriter

    2) 클래스 사용
      2.1) FileWriter fw = FileWriter(---); //파일의 접근 권한을 연다.
                                             //파일에 대한 정상적 접근을 위해서 만듬
      2.2) OutputStreamWriter osw = OutputStreamWriter(System.out 혹은 네트웍 Output);
          // console과 network에 대한 정상적 접근을 위해서 만들어 놓았다.
      2.3) BufferedWriter bw = new BufferedWriter(osw);
          // osw나 fw를 담아서 이용하면 버퍼를 이용하겠다는 것을 의미 한다.
      2.4) PrintWriter pw = new PrintWriter(bw);
          // pw.println("하하하"); 처럼 처리할 수 있다.
          -> 파일, 네트웍, 화면으로의 출력을 섞어 가며 출력하고 싶다면.. -> Ex0204_01.java
          - 하나의 코딩으로 매개 변수만 바꿔 가며, 여러개의 형식에 맞추어 출력 할수 있다.

  4.5 Reader
    1) Reader 상속 관계
      Reader - FileReader
             - InputStreamReader
             - BufferedReader

    2) 사용예
      FileReader fr = new FileReader(---);       //파일로 부터 2바이트 단위로 데이타를 읽어 온다.
      InputStreamReader isr = new InputStreamReader(System.in 혹은 네트웍 입력);    //키보드로 부터의 입력 또는 네트웍 입력
      BufferedReader br = new BufferedReader(fr 혹은 isr)

5. Serializable
    - Object I/O 는 Stream 입출력 이다.
    - 객체단위로 입출력이 될 수 있는 단위는 직렬화가 되어 있어야 한다.
    - 데이타를 주고 받는데 아무 문제가 없는 형태를 직렬화라고 한다. (예:Serializable)

  1) 직렬화 되지 않은 클래스
    - 데이타를 한번에 읽을수 없는 형태는 직렬화가 아니다.
    - 그래서.. 이것을 컴퓨터가 입력 받을 수 있는 형태로 만들어 주어야 한다. 그것을 직렬화라고 한다.
    class A {
      int x;
      float y;
      double z;
   }

  2) 직렬화 된 클래스
    class A implements Serializable {
      int x;
      float y;
      double z;
    }

  3) Serializable 은 인터페이스이고, 메소드를 하나도 안 가지고 있다.
     그래서 implements Serializable 만하면 직렬화가 된다.

6. Object I/O
  1) Object 출력
    File f = new File(---);
    FileOutputStream fos = new FileOutputStream(f);
    ObjectOutputStream oos = new ObjectOutputStream(fos);   //버퍼를 이용해도 상관 없다.
      - oos 를 객체 단위로 담을 수 있다.

    A ap = new A();
    oos.writeObject(ap);   //객체가 하나 전송되어 저장되었다. f라는 파일속에 객체하나를 저장 했다.
                           //vector 도 vector만 적으면 저장할 수 있다.
    oos.close();
    fos.close();

  2) Object 입력
    File f = new File(---);
    FileInputStream fis = new FileInputStream(f);
    ObjectInputStream ois = new ObjectInputStream(fis);     // 오브젝트 타입으로 객체를 입력 받을 수 있다.
                                                            // 클래스 캐스팅 Exception이 발생 할 수도 있다.
                                                            // 해당 클래스가 없을 수 있기 때문에 ClassNotFoundException 처리도 해 주어야 한다.
    A bp = (A)ois.readObject(); // Object 타입으로 불려짐으로 캐스팅 해주어야 한다.
    cis.close();
    fis.close();

7. FileDialog
  - 예 :  -> Ex0204_03
    String dir =  fd.getDirectory();
    String file = fd.getFile();
        을 통해서 파일을 읽어 올 수 있다.
    -> 취소를 누르면.. null이 넘어 온다.
    -> 확인을 하면 디렉토리(fd.getDirectory())와 파일명(fd.getFile())이 넘어 온다.
        - Ex0202_10.java 그림그리기 파일에 열기 저장 기능 추가

8. RandomAccessFile
    - 하나의 클래스로부터 입력과 출력을 동시에 처리 할 수 있는 클래스 이다.

    1) 생성
        RandomAccessFile raf = new RandomAccessFile("파일명", "mode:속성");

    2) mode 속성
      r    - 읽기 전용으로 열겠다..
      rw   - 읽기와 쓰기 동시에 가능 하도록 연다.
      rwd  - 데이타가 변형되었을때 자동으로 강제적으로 데이타를 집어 넣는 방식.. // file만 변한 경우
      rws  - 데이타가 변형되었을때 자동으로 강제적으로 데이타를 집어 넣는 방식.. // file + metadata(파일의 주변 데이타) 동시에 변한경우
        - write 및 read 관련 모든 Method를 사용이 가능 하다.
        - 파일의 전체 길이를 구한 후 seek 메소드를 통해서 해당 위치부터 추가 시킬 수 있다.
           -> 예) seek(3) 으로 처리 할 수 있다.

    3) 예 : Ex0204_04.java

//---------------------------------------------------------------------------//
// 수업중 소스
// Ex0202_01.java : File 클래스 테스트
import java.io.*;

public class Ex0202_01 {
    public static void main(String [] ar) {
/* 파일 읽기 쓰기 확인
        File f = new File("test.txt");
        if(f.canRead() && f.canWrite()) {
          System.out.println(f + "는 읽기 + 쓰기");
        }
        else if(!f.canRead() && f.canWrite()) {
          System.out.println(f + "는 쓰기 전용");
        }
        else if(f.canRead() && !f.canWrite()) {
          System.out.println(f + "는 읽기 전용");
        }
*/
/*
        File f = new File("MyFile.txt");   //새로운 파일 만들기
        try {
            f.createNewFile();
        } catch(IOException ee) { }
*/
/* 파일이 있는 것을 확인 후 특정 파일 삭제 하기
        File f = new File("test2.txt");
        if(f.exists()) {
            if(f.delete()) {
                System.out.println(f + "를 지웠다.");
            } else {
                System.out.println(f + "를 못 지웠다.");
            }
        } else {
          System.out.println("해당하는 파일 " + f + " 가 없습니다.");
        }
*/
// 0121 폴더내의 파일 정보 알아 오기
        File f = new File("D:\\G03_academy_data\\FreshCamp\\030202\\강사코딩");
        if(f.exists() && f.isDirectory()) {
            String[] str = f.list();
            for(int i=0; i < str.length; i++) {
                System.out.println(i + "번째 파일 : " + str[i]
                            + ", 길이 : " + (new File(f, str[i])).length() + "byte");      //크기 값 알아오기
            }
        } else {
          System.out.println("디렉토리가 아니거나 해당하는 파일이 없습니다.");
        }

/*
    File f = new File("c:\\A\\B\\C\\D\\E");
        f.mkdir(); //에러 발생
        f.mkdirs();   // 실행가능
*/

    }
}

//---------------------------------------------------------------------------//
// Ex0202_02.java : byte 데이터로 출력하기
public class Ex0202_02 {
  public static void main(String [] ar) {
        System.out.write(65);
        System.out.flush();
        byte[] bb = {'A', 'B', 'C'};
        System.out.println();
        try {
            System.out.write(bb);
        } catch(java.io.IOException ee) {}
        System.out.println();
        byte[] bbb = "Hello Java!".getBytes();   //byte 배열로 바꿔줌.
        System.out.write(bbb, 3, 6);
      System.out.println();
    }
}

//---------------------------------------------------------------------------//
// Ex0202_04.java : System.out.println 출력 Stream 파일로 변경 하기
import java.io.*;

public class Ex0202_04 {
  public static void main(String [] ar) {
        File f = new File("./abc.txt");
        if(!f.exists()) {
            try {
                f.createNewFile();
            } catch (Exception ee) { }
        }
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(f);
        } catch (Exception ee) { }
        if(f.canRead() && !f.canWrite()) {
            System.out.println("해당 파일은 읽기전용입니다.");
            return;
        }
        PrintStream ps = new PrintStream(fos);
        System.setOut(ps);
        System.setErr(ps);
        System.out.println(65);
        System.out.println("Hello Java !");
        System.out.close();
    }
}

//---------------------------------------------------------------------------//
// Ex0203_05.java : 키보드 입력 파일로 출력하기
import java.io.*;
public class Ex0203_05 {
    public static void main(String[] ar) {
        if(ar.length == 0){
            System.out.println("Usage : java Ex0203_05 파일명.확장자");
            return;
        }
        File f = new File(ar[0]);
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;
        try {
            fos = new FileOutputStream(f);
            bos = new BufferedOutputStream(fos);
            System.out.print("데이터를 입력하세요 : ");
            while(true) {
                int xx = System.in.read();
                if(xx == 10) {
                    break;
                }
                bos.write(xx);
            }
            bos.close();
            fos.close();
        } catch(IOException ee) { }

    }
}

//---------------------------------------------------------------------------//
// Ex0203_06.java : DataOutputStream 을 이용한 파일 저장
// Ex0203_07.java : DataInputStream 을 이용한 파일 읽기
import java.io.*;
public class Ex0203_06 {
    public static void main(String[] ar) throws IOException {
        File f = new File("myfile.imsi");
        if(!f.exists()) {
            f.createNewFile();
        }
        FileOutputStream fos = new FileOutputStream(f);
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        DataOutputStream dos = new DataOutputStream(bos);
        int x = 10;
        float ff = 20.3f;
        double d = 40.5;
        char c = 'A';
        dos.writeInt(x);
        dos.writeFloat(ff);
        dos.writeDouble(d);
        dos.writeChar(c);
        dos.close();
        bos.close();
        fos.close();
    }
}

import java.io.*;
public class Ex0203_07 {
    public static void main(String[] ar) throws IOException{
        File f = new File("myfile.imsi");
        FileInputStream fis = new FileInputStream(f);
        BufferedInputStream bis = new BufferedInputStream(fis);
        DataInputStream dis = new DataInputStream(bis);
        System.out.println("int = " + dis.readInt());
        System.out.println("float = " + dis.readFloat());
        System.out.println("double = " + dis.readDouble());
        System.out.println("char = " + dis.readChar());
        dis.close();
        bis.close();
        fis.close();
    }
}

//---------------------------------------------------------------------------//
// Ex0204_01.java : PrintWriter을 이용하여 Console로 데이터 보내기
import java.io.*;
public class Ex0204_01 {
    public static void main(String [] ar) {
        OutputStreamWriter osw = new OutputStreamWriter(System.out);
        BufferedWriter bw = new BufferedWriter(osw);
        PrintWriter pw = new PrintWriter(bw);
        pw.println("안녕하세요!");
        pw.println("홍혁기 입니다.");
        pw.println("반갑습니다.");
        pw.flush();
    }
}

//---------------------------------------------------------------------------//
// Ex0204_02.java : 파일을 읽어서 화면에 출력하기
import java.io.*;

public class Ex0204_02 {
    public static void main(String [] ar) throws IOException {
        if(ar.length == 0) {
            System.out.println("Usage : java Ex0204_02 파일명");
            System.exit(0);
        }

        File f = new File(ar[0]);
        FileReader fr = new FileReader(f);         //2byte 로 접근 권한을 열어 놓음
        BufferedReader br = new BufferedReader(fr);
        while(true) {
            String imsi = br.readLine();
            if(imsi == null) {
                break;
            }
            System.out.println(imsi);
        }
        br.close();
        fr.close();
    }
}

//---------------------------------------------------------------------------//
// Ex0204_10.java : 그림판에 그린 그림 Object 형태로 파일로 저장/읽기 기능 구현
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.io.*;

class Ex0204_10_Sub1 implements Serializable {
    private int x, y, x1, y1, dist;
    private Color color = new Color(0, 0, 0);
    private boolean fillok = false;
    Ex0204_10_Sub1(int x, int y, int x1, int y1, int dist, Color color, boolean fillok) {
        this.x = x;  this.x1 = x1;
        this.y = y;  this.y1 = y1;
        this.dist = dist;   this.color = color;
        this.fillok = fillok;
    }
    public int getX() {
      return x;
    }
    public int getY() {
      return y;
    }
    public int getX1() {
      return x1;
    }
    public int getY1() {
      return y1;
    }
    public int getDist() {
      return dist;
    }
    public Color getColor() {
      return color;
    }
    public boolean getFillOk() {
      return fillok;
    }
}

class Ex0204_10_Sub extends Frame implements MouseListener, MouseMotionListener, ActionListener, ItemListener {
    private Vector vc = new Vector();

    //Fram initialization용 Field
    private CheckboxGroup cgb1 = new CheckboxGroup();
    private Checkbox cb1 = new Checkbox("연필", true, cgb1);
    private Checkbox cb2 = new Checkbox("직선", false, cgb1);
    private Checkbox cb3 = new Checkbox("사각형", false, cgb1);
    private Checkbox cb4 = new Checkbox("원", false, cgb1);

    //Menu용 Field
    private MenuBar mb = new MenuBar();
    private Menu file = new Menu("파일");
    private   MenuItem fnew = new MenuItem("New");
    private   MenuItem fopen = new MenuItem("Open");
    private   MenuItem fsave = new MenuItem("Save");
    private   MenuItem fexit = new MenuItem("Exit");
    private Menu tool = new Menu("도구");
    private Menu option = new Menu("옵션");
    private   MenuItem osetcolor = new MenuItem("색상");
    private   CheckboxMenuItem ofill = new CheckboxMenuItem("채우기", false);
    private   CheckboxMenuItem ounfill = new CheckboxMenuItem("비우기", true);

    //색상 설정 다이얼 로그 박스 만들기
    private Dialog dlg = new Dialog(this, "Color", true);
    private Label dlglb = new Label("red = ", Label.RIGHT);
    private Label dlglb1 = new Label("green = ", Label.RIGHT);
    private Label dlglb2 = new Label("blue = ", Label.RIGHT);
    private TextField dlgtf = new TextField("0");
    private TextField dlgtf1 = new TextField("0");
    private TextField dlgtf2 = new TextField("0");
    private Button dlgbt = new Button("preview");
    private Button dlgbt1 = new Button("set");
    private Button dlgbt2 = new Button("cancel");

    //화면 크기 생성용
    private Toolkit tk = Toolkit.getDefaultToolkit();
    private Dimension di = tk.getScreenSize();

    private int x, y, x1, y1;
    private Color color = new Color(0,0,0);
    //x = y = x1 = y1 = 0;

    private Ex0204_10_Sub_Can hsc = new Ex0204_10_Sub_Can(this);

    Ex0204_10_Sub(String str) {
        super(str);
        this.setLayout(new BorderLayout());
        setSize(500, 400);      //Frame 크기 설정
        //Frame를 화면 정 중앙에 배치
        Dimension di1 = this.getSize();
        setLocation((int)(di.getWidth()/2-di1.getWidth()/2),
                    (int)(di.getHeight()/2-di1.getHeight()/2));
        init();
        start();

        setVisible(true);
    }
    //Frame의 초기화
    public void init() {
        this.setLayout(new BorderLayout(5,5));
        initMenu();        //메뉴 초기화
        initDlg();
        this.add("Center", hsc);
        Panel p1 = new Panel(new GridLayout(1,5));
        p1.setBackground(Color.green);
        p1.add(new Label());
        p1.add(cb1);
        p1.add(cb2);
        p1.add(cb3);
        p1.add(cb4);
        this.add("South", p1);
    }
    private void initDlg(){
        dlg.setLayout(new BorderLayout());
        dlg.setLocation(400,300);
        Panel p = new Panel(new GridLayout(3, 1));
        p.add(dlglb);
        p.add(dlglb1);
        p.add(dlglb2);
        dlg.add("West", p);
        Panel p1 = new Panel(new GridLayout(3, 1));
        p1.add(dlgtf);
        p1.add(dlgtf1);
        p1.add(dlgtf2);
        dlg.add("Center", p1);
        dlg.add("East", dlgbt);
        Panel p2 = new Panel(new FlowLayout(FlowLayout.RIGHT));
        p2.add(dlgbt1);
        p2.add(dlgbt2);
        dlg.add("South", p2);
        dlg.setSize(200, 150);
    }
    //Menu의 초기화 Method
    public void initMenu () {
        this.setMenuBar(mb);
        mb.add(file);
            file.add(fnew);
            file.addSeparator();
            file.add(fopen);
            file.add(fsave);
            file.addSeparator();
            file.add(fexit);
        mb.add(option);
            option.add(osetcolor);
            option.addSeparator();
            option.add(ofill);
            option.add(ounfill);
    }

    public void start() {
    //창 닫기 버튼 누르면 실행
        this.addWindowListener( new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
              System.exit(1);
            }
        });

        hsc.addMouseListener( this );
        hsc.addMouseMotionListener( this );

        //ActionListener 관련 이벤트 발생시
        fnew.addActionListener( this );
        fopen.addActionListener( this );
        fsave.addActionListener( this );
        fexit.addActionListener( this );
        osetcolor.addActionListener( this );
        dlgbt.addActionListener( this );
        dlgbt1.addActionListener( this );
        dlgbt2.addActionListener( this );

        //ItemListener 관련 이벤트 발생시
        ofill.addItemListener( this );
        ounfill.addItemListener( this );
    }

    public void mouseClicked(MouseEvent e) { }
    public void mouseEntered(MouseEvent e) { }
    public void mouseExited(MouseEvent e) { }
    public void mousePressed(MouseEvent e) {
    this.x = e.getX();
        this.y = e.getY();
    }
    public void mouseReleased(MouseEvent e) {
        this.x1 = e.getX();
        this.y1 = e.getY();
        int dist = 0;
        if(cb2.getState()) dist = 1;
        else if(cb3.getState()) dist = 2;
        else if(cb4.getState()) dist = 3;
        Ex0204_10_Sub1 hss = new Ex0204_10_Sub1(x, y, x1, y1, dist, color, ofill.getState());
        vc.add(hss);
        hsc.repaint();
    }
    public void mouseMoved(MouseEvent e) { }
    public void mouseDragged(MouseEvent e) {
        if(cb1.getState()) {
            x1 = e.getX();
            y1 = e.getY();
            Ex0204_10_Sub1 hss = new Ex0204_10_Sub1(x, y, x1, y1, 1, color, false);
            vc.add(hss);
            hsc.repaint();
            x = x1;
            y = y1;
        } else {
            x1 = e.getX();
            y1 = e.getY();
            hsc.repaint();
        }
}

    public void actionPerformed(ActionEvent e) {
      if(e.getSource() == fnew) {
            vc.clear();
            x = y = x1 = y1 = 0;
            hsc.repaint();

        } else if(e.getSource() == fopen) {
            FileDialog fd = new FileDialog(this, "열기", FileDialog.LOAD);
            fd.setVisible(true);
            String dir = fd.getDirectory();
            String file = fd.getFile();
            if(dir == null || file == null) {
                return;
            }
            File f = new File(dir, file);
            FileInputStream fis = null;
            ObjectInputStream ois = null;
            try {
                fis = new FileInputStream(f);
            } catch(FileNotFoundException ee) { }

            try {
                ois = new ObjectInputStream(fis);
                vc = (Vector)ois.readObject();
                ois.close();
                fis.close();
            } catch (Exception ee) { }
            hsc.repaint();

        } else if(e.getSource() == fsave) {
            FileDialog fd = new FileDialog(this, "저장", FileDialog.SAVE);
            fd.setVisible(true);
            String dir = fd.getDirectory();
            String file = fd.getFile();
            if(dir == null || file == null) {
                return;
            }
            File f = new File(dir, file);
            FileOutputStream fos = null;
            ObjectOutputStream oos = null;
            try {
                fos = new FileOutputStream(f);
            } catch(FileNotFoundException ee) { }
            try {
                oos = new ObjectOutputStream(fos);
                oos.writeObject(vc);
                oos.close();
                fos.close();
            } catch (Exception ee) { }

        } else if(e.getSource() == fexit) {
          System.exit(1);

        } else if(e.getSource() == osetcolor) {
          dlg.setVisible(true);

        } else if(e.getSource() == dlgbt) {
            int r = Integer.parseInt(dlgtf.getText().trim());
            int g = Integer.parseInt(dlgtf1.getText().trim());
            int b = Integer.parseInt(dlgtf2.getText().trim());
            Color cc = new Color(r, g, b);
            dlgbt.setBackground(cc);

        } else if(e.getSource() == dlgbt1) {
            int r = Integer.parseInt(dlgtf.getText().trim());
            int g = Integer.parseInt(dlgtf1.getText().trim());
            int b = Integer.parseInt(dlgtf2.getText().trim());
            Color cc = new Color(r, g, b);
            color = cc;
            dlg.setVisible(false);

        } else if(e.getSource() == dlgbt2) {
            dlg.setVisible(false);
        }
    }

    //채우기나 비우기 둘 중 하나가 선택 되면 다른 하나의 채크된 것을 채크되지 않은 상태로
    public void itemStateChanged(ItemEvent e) {
        if(e.getSource() == ofill) {
            ofill.setState(true);
            ounfill.setState(false);
        } else if(e.getSource() == ounfill) {
            ofill.setState(false);
            ounfill.setState(true);
        }
    }
    public Color getColor() {
        return color;
    }
    public Vector getVc() {
        return vc;
    }
    public Checkbox getCb2() {
        return cb2;
    }
    public Checkbox getCb3() {
        return cb3;
    }
    public Checkbox getCb4() {
        return cb4;
    }
    public CheckboxMenuItem getOfill() {
        return ofill;
    }
    public int getX() {
        return x;
    }
    public int getX1() {
        return x1;
    }
    public int getY() {
        return y;
    }
    public int getY1() {
        return y1;
    }
}

class Ex0204_10_Sub_Can extends Canvas {
    Ex0204_10_Sub h1s = null;
    private int x, x1, y, y1;
    Ex0204_10_Sub_Can(Ex0204_10_Sub h1s) {
        this.h1s = h1s;
    }
    public void paint(Graphics g) {
        g.setColor(h1s.getColor());
        x = h1s.getX(); x1 = h1s.getX1();  y = h1s.getY(); y1 = h1s.getY1();
        if(h1s.getCb2().getState()) g.drawLine(x, y, x1, y1);     //잔상 남기기..

        else if(h1s.getOfill().getState()) {
            if (h1s.getCb3().getState()) g.fillRect(x, y, x1-x, y1-y);
            else if(h1s.getCb4().getState()) g.fillOval(x, y, x1-x, y1-y);

        } else {
            if (h1s.getCb3().getState()) g.drawRect(x, y, x1-x, y1-y);
            else if (h1s.getCb4().getState()) g.drawOval(x, y, x1-x, y1-y);
        }

        for(int i=0; i < h1s.getVc().size(); i++) {
            Ex0204_10_Sub1 imsi = (Ex0204_10_Sub1)h1s.getVc().elementAt(i);
            g.setColor(imsi.getColor());
            switch(imsi.getDist()) {
                case 1:
                  g.drawLine(imsi.getX(), imsi.getY(), imsi.getX1(), imsi.getY1());
                  break;
                case 2:
                  if(imsi.getFillOk()) g.fillRect(imsi.getX(), imsi.getY(), imsi.getX1()-imsi.getX(), imsi.getY1()-imsi.getY());
                    else g.drawRect(imsi.getX(), imsi.getY(), imsi.getX1()-imsi.getX(), imsi.getY1()-imsi.getY());
                    break;
                case 3:
                if(imsi.getFillOk()) g.fillOval(imsi.getX(), imsi.getY(), imsi.getX1()-imsi.getX(), imsi.getY1()-imsi.getY());
                else g.drawOval(imsi.getX(), imsi.getY(), imsi.getX1()-imsi.getX(), imsi.getY1()-imsi.getY());
                    break;
            }
        }
    }
}

//Main 객체 정의
public class Ex0204_10 {
    public static void main(String [] ar) {
        Ex0204_10_Sub h1s = new Ex0204_10_Sub("그림판");
    }
}

//---------------------------------------------------------------------------//
// Ho0202_01 : File을 이용한 게시판 만들기
import java.awt.*;
import java.awt.event.*;
import java.io.*;

class FreeBoard implements Serializable {
    private int data;
  private String title;
  private String author;
  private int hit;
  private String story;
  public int getData() {
    return data;
}
  public String getTitle() {
    return title;
}
  public String getAuthor() {
    return author;
}
  public int getHit() {
    return hit;
}
  public String getStory() {
    return story;
}
  public void setData(int i) {
    data = i;
}
  public void setTitle(String str) {
    title = str;
}
  public void setAuthor(String str) {
    author = str;
}
  public void setHit(int i) {
    hit = i;
}
  public void setStory(String str) {
    story = str;
}
}

class Ho0202_01_Sub extends Frame implements ActionListener {
    //Nor
  private Label lb1 = new Label("게 시 판", Label.CENTER);
  //Cen-Nor
  //Cen-Nor-Grid(1,4)
  private Label lb2 = new Label("Data", Label.CENTER);
  private Label lb3 = new Label("제 목", Label.CENTER);
  private Label lb4 = new Label("작성자", Label.CENTER);
  private Label lb5 = new Label("hit", Label.CENTER);
  //Cen-Cen
  private List lt1 = new List(10);
  //Sou-Flow
  private Button write = new Button("쓰기");
  private Button show = new Button("보기");

  //쓰기용 Dialog box
  private Dialog wdlg = new Dialog(this, "쓰기", true);
  //Nor
  //Nor-Nor
  private Label wdlglb1 = new Label("글쓰기");
  //Nor-Wst
  //Nor-Wst-Grid(2,1)
  private Label wdlglb2 = new Label("제 목 : ",Label.RIGHT);
  private Label wdlglb3 = new Label("작성자 : ",Label.RIGHT);
  //Nor-Cen-Grid(2,1)
  private TextField wdlgtf1 = new TextField();
  private TextField wdlgtf2 = new TextField();
  //Cen
  private TextArea wdlglt1 = new TextArea();
  //Sou
  //Sou-Flow
  private Button wdlgbt1 = new Button("확인");
  private Button wdlgbt2 = new Button("취소");

  //보기용 Dialog box
  private Dialog sdlg = new Dialog(this, "보기", true);
  //Nor
  //Nor-Nor
  private Label sdlglb1 = new Label("Title", Label.CENTER);
  //Nor-Cen
  //Nor-Cen-Flow
  private Label sdlglb2 = new Label("작성자 : ");
  private Label sdlglb3 = new Label("name");
  //Cen
  private TextArea sdlglt1 = new TextArea();
  //Sou-Flow
  private Button sdlgbt1 = new Button("확인");


  public Ho0202_01_Sub(String str) {
      super(str);
    setSize(400, 500);
    Toolkit tk = Toolkit.getDefaultToolkit();
    Dimension di = tk.getScreenSize();
    Dimension di1 = this.getSize();
    setLocation((int)(di.getWidth()/2 - di1.getWidth()/2),
                (int)(di.getHeight()/2 - di1.getHeight()/2));
    setLayout(new BorderLayout());
    init();
    start();
    setVisible(true);
}

  public void init() {
      this.add("North", lb1);
    Panel p1 = new Panel(new BorderLayout());
    Panel p2 = new Panel(new GridLayout(1,4));
    p2.add(lb2);
    p2.add(lb3);
    p2.add(lb4);
    p2.add(lb5);
    p1.add("North", p2);
    p1.add("Center", lt1);
    this.add("Center", p1);
    Panel p3 = new Panel(new FlowLayout(FlowLayout.RIGHT));
    p3.add(write);
    p3.add(show);
    this.add("South", p3);
    initDlg();
    initBoard();
}
  public void initDlg() {
      //쓰기 Dialog 설정
    wdlg.setSize(200, 300);
    wdlg.setLocation(300,300);
    wdlg.setLayout(new BorderLayout());
    Panel p4 = new Panel(new BorderLayout());
    p4.add("North", wdlglb1);
    Panel p5 = new Panel(new GridLayout(2,1));
    p5.add(wdlglb2);
    p5.add(wdlglb3);
    p4.add("West", p5);
    Panel p6 = new Panel(new GridLayout(2,1));
    p6.add(wdlgtf1);
    p6.add(wdlgtf2);
    p4.add("Center", p6);
    wdlg.add("North", p4);
    wdlg.add("Center", wdlglt1);
    Panel p7 = new Panel(new FlowLayout(FlowLayout.RIGHT));
    p7.add(wdlgbt1);
    p7.add(wdlgbt2);
    wdlg.add("South", p7);

    //보기 Dialog 설정
    sdlg.setSize(200, 300);
    sdlg.setLocation(300,300);
    sdlg.setLayout(new BorderLayout());
    Panel p8 = new Panel(new BorderLayout());
    p8.add("North", sdlglb1);
    Panel p9 = new Panel(new FlowLayout(FlowLayout.RIGHT));
    p9.add(sdlglb2);
    p9.add(sdlglb3);
    p8.add("Center", p9);
    sdlg.add("North", p8);
    sdlg.add("Center", sdlglt1);
    Panel p10 = new Panel(new FlowLayout(FlowLayout.RIGHT));
    p10.add(sdlgbt1);
    sdlg.add("South", p10);
}
    public void initBoard() {
        File f = new File(".\\db");
    int i = f.list().length + 1;
    for(int j=1; j < i; j++) {
        if(j < 10) {
          f = new File(".\\db", "fname0" + j + ".dat");
      } else {
          f = new File(".\\db", "fname" + j + ".dat");
      }
      FreeBoard fb = new FreeBoard();
      FileInputStream fis = null;
      ObjectInputStream ois = null;
      try {
          fis = new FileInputStream(f);
      } catch(FileNotFoundException ee) { }
      try {
          ois = new ObjectInputStream(fis);
        fb = (FreeBoard)ois.readObject();
        ois.close();
        fis.close();
      } catch(Exception ee) { }
        lt1.add("               " + String.valueOf(fb.getData())
                  + "                 " + fb.getTitle()
            + "                 " + fb.getAuthor()
            + "                 " + String.valueOf(fb.getHit()));
    }
}

  public void start() {
      this.addWindowListener(new WindowAdapter() {
        public void windowClosing(WindowEvent e) {
          System.exit(0);
      }
    });
    write.addActionListener(this);
    show.addActionListener(this);
    wdlgbt1.addActionListener(this);
    wdlgbt2.addActionListener(this);
    sdlgbt1.addActionListener(this);
}
  public void actionPerformed(ActionEvent e) {
      if(e.getSource() == write) {
        wdlg.setVisible(true);
    }
    else if(e.getSource() == show) {
        if(lt1.getSelectedItem() != null) {
          int i = lt1.getSelectedIndex() + 1;
        File f = null;
        if(i < 10) {
            f = new File(".\\db", "fname0" + i + ".dat");
        } else {
            f = new File(".\\db", "fname" + i + ".dat");
        }
        FreeBoard fb = new FreeBoard();
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            fis = new FileInputStream(f);
        } catch(FileNotFoundException ee) { }
        try {
            ois = new ObjectInputStream(fis);
          fb = (FreeBoard)ois.readObject();
          ois.close();
          fis.close();
        } catch(Exception ee) { }
        sdlglb1.setText(fb.getTitle());
        sdlglb3.setText(fb.getAuthor());
        sdlglt1.setText(fb.getStory());
        fb.setHit(fb.getHit()+1);

              lt1.replaceItem("               " + String.valueOf(fb.getData())
                            + "                 " + fb.getTitle()
                      + "                 " + fb.getAuthor()
                      + "                 " + String.valueOf(fb.getHit()), i-1);

        FileOutputStream fos = null;
            ObjectOutputStream oos = null;
            try {
                fos = new FileOutputStream(f);
            } catch (FileNotFoundException ee) { }
          try {
              oos = new ObjectOutputStream(fos);
            oos.writeObject(fb);
            oos.close();
            fos.close();
          } catch (Exception ee) { }

        sdlg.setVisible(true);
      }
    }
    else if(e.getSource() == wdlgbt1) {
            File f = new File(".\\db");
      int i = f.list().length + 1;
      if(i < 10) {
          f = new File(".\\db", "fname0" + i + ".dat");
      } else {
          f = new File(".\\db", "fname" + i + ".dat");
      }
      FreeBoard fb = new FreeBoard();
      fb.setData(i);
      fb.setTitle(wdlgtf1.getText().trim());     wdlgtf1.setText("");
      fb.setAuthor(wdlgtf2.getText().trim());    wdlgtf2.setText("");
      fb.setStory(wdlglt1.getText().trim());     wdlglt1.setText("");
      fb.setHit(0);
      FileOutputStream fos = null;
      ObjectOutputStream oos = null;
      try {
          fos = new FileOutputStream(f);
      } catch (FileNotFoundException ee) { }
      try {
          oos = new ObjectOutputStream(fos);
        oos.writeObject(fb);
        oos.close();
        fos.close();
      } catch (Exception ee) { }
        wdlg.setVisible(false);
        lt1.add("               " + String.valueOf(fb.getData())
                  + "                 " + fb.getTitle()
            + "                 " + fb.getAuthor()
            + "                 " + String.valueOf(fb.getHit()));
    }
    else if(e.getSource() == wdlgbt2) {
        wdlg.setVisible(false);
    }
    else if(e.getSource() == sdlgbt1) {
        sdlg.setVisible(false);
    }
}
}

public class Ho0202_01 {
  public static void main(String [] ar) {
      Ho0202_01_Sub h1s = new Ho0202_01_Sub("게시판");
}
}

//===========================================================================//

>>>>> 답글

File 출력 시 깨지는 문제 아래와 같은 옵션으로 해결할 수도 있네요. ^^
java -Dfile.encoding=KSC5601

- [Java 기본]Thread, synchronized, 압축 및 배포

겨울에 — Sat, 14 May 2011 16:29:03 +0900

출처 :

<html>

<head>
        <title> 시간보기 </title>
    </head>
    <body bgcolor=000000 text=ffffff>
        <center>
            <h2> 이것은 애플릿 </h2><p>
            <applet code="Ex0129_03.class" width=500 height=300>
            
            </applet>
        </center>
        <hr>
        <a href="Ex0129_03.java"> 소스보기 </a>
    </body>
</html>

// Ex0129_03.java
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
public class Ex0129_03 extends Applet
                implements Runnable, ActionListener{
    private Button bt = new Button("Yahoo!");
    private Button bt1 = new Button("Empas!");
    private Button bt2 = new Button("Naver!");
    private Runtime rt;
    public void init(){
        rt = Runtime.getRuntime();
        this.setLayout(new BorderLayout());
        Panel p = new Panel(new FlowLayout());
        p.add(bt);
        p.add(bt1);
        p.add(bt2);
        this.add("South", p);
    }
    public void start(){
        Thread tt = new Thread(this);
        tt.start();
        bt.addActionListener(this);
        bt1.addActionListener(this);
        bt2.addActionListener(this);
    }
    public void run(){
        while(true){
            try{
                Thread.sleep(1000);
            }catch(InterruptedException ee){}
            this.repaint();
        }
    }
    public void actionPerformed(ActionEvent e){
        if(e.getSource() == bt){
            try{
                rt.exec("explorer.exe http://www.yahoo.co.kr");
            }catch(Exception ee){}
        }
        else if(e.getSource() == bt1){
            try{
                rt.exec("explorer.exe http://www.empas.com");
            }catch(Exception ee){}
        }
        else if(e.getSource() == bt2){
            try{
                rt.exec("explorer.exe http://www.naver.com");
            }catch(Exception ee){}
        }
    }
    public void paint(Graphics g){
        Calendar ca = Calendar.getInstance();
        String str = ca.get(Calendar.YEAR) + "년 " +
                (ca.get(Calendar.MONTH) + 1) + "월 " +
                ca.get(Calendar.DAY_OF_MONTH) + "일 " +
                ca.get(Calendar.HOUR_OF_DAY) + "시 " +
                ca.get(Calendar.MINUTE) + "분 " +
                ca.get(Calendar.SECOND) + "초";
        g.setFont(new Font("TimesRoman", Font.BOLD, 20));
        g.drawString("Time : " + str, 50, 100);
    }
    public static void main(String[] ar){
        Ex0129_03 es = new Ex0129_03();
        es.init();
        es.start();
        Frame f = new Frame();
        f.setLayout(new BorderLayout());
        f.add("Center", es);
        f.setSize(500, 300);
        f.setVisible(true);
    }
}

//===========================================================================//

--------------------------------------------------------------------------------------------------

>>>>> 답글

위의 것 쓰레드부분은 정말 맛배기만인데, 정확히는 스테이트 프로세스 아키텍쳐
(스테이트 머신)에 대한 개념을 깔고서 각 메소드들의 역할이 상태를 전이하는 역할을 하는
것이다라는 식으로 설명해주는게 더 좋을 듯 한데..

그러면 초급 수준을 뛰어넘게 되니 힘드려낭 -_-;;

아무튼 가장 개념적인 이해와 설명이 많이 요구되는 부분이 아닐까;;
동기화문제에 따른 트랜잭션이란 개념도 있궁.. ㅋ

지금 생각해보면 상당히 날림으로 넘어간 부분중 하나이긴 하는.. ㅎㅎ

예제도 단순히 쓰레드를 통해서 멀티로 프로세스가 진행 될 수 있다 정도만 보여줄뿐
쓰레드의 생명주기라던지 등등은 잘 파악하기 힘든 예제라.. 많이 아쉽삼.. ㅋㅋ

-------------------------------------------------------------------------------------------

Thread 동기화 관련된거는 다음 강의 내용에 있더라구.. 일단 거기서 약간 언급될꺼 같고..
나도 기본적인 것만 사용하고 따로 공부를 해본건 아니라.. 깊이 있는 내용은 못다루겠네.. ㅋㅋ...
그럼 관심 가져줘서 고마우이~~ ㅎㅎ..
괜찮은 자료 있음 좀 답글로 좀 올려도 좋을듯.. 나도 참고좀 하게..

>>>>>> synchronized, Thread 샘플 예제

//===========================================================================//
본 내용은 2002년 제가 Java 강의를 수강하며 정리 했던 내용을
    기본으로 하여 정리하였습니다.
- 마침 java 기초를 전파할 기회가 생겨 핑계김에 정리해 가려 합니다.
작성자 : litwave
//---------------------------------------------------------------------------//

<목차>
1. Synchronize(동기화) 개념
2. synchronized
3. Thread 실습

//---------------------------------------------------------------------------//

1. Synchronize(동기화) 개념
- 하나의 Thread 에서 무한적으로 수행되는 두개의 Method 를 포함하고 있다고 가정하자.

class A extends Thread {
  static int x;
  run() {
    aaa();
    bbb();
}
aaa() {
      // x에 어떤 값을 계속 더하고 출력하는 프로그램
}
bbb() {
      // x에 또 다른 값을 더하고 출력하는 프로그램
}
}

- 특정한 경우에 aaa()가 모두 처리되고 bbb()를 순차적으로 처리하면 값 x에 동시에 접근하는 문제를 막을 수 있다.
- 그러므로 하나의 프로그램이 실행이 끝날때 까지 다른 프로그램의 접근을 막는 방법을 생각해 놨다.

- synchronized 는        // 특정 Method 혹은 변수에 lock 를 거는 것이다.
- 다중 Thread 를 사용할 경우 dead lock이 발생할 수 있으므로, 이러한 상태가 발생하지 않도록 미연에 막아 주어야 한다.
- dead lock : 서로의 프로그램 간에 상대가 끝나기를 기다리면서 대기 상태로 빠지는 것이다.

2. synchronized
1) 형식
    접근자 synchronized 지정어 void aaa(---) { }
     - 특정 Method 에 대해서 접근을 막아줌

2) 특정 구간에만 lock을 걸 때 사용.(특정 구역의 작업을 할 때는 다른 것의 방해를 받지 않도록 하는 것)

3) x 라는 변수에만 lock을 걸기 : x라는 변수에 대해서는 어느 누구도 그 구간에서는 아무도 접근 할 수 없게 해준다

    void aaa() {
       .
       .
      synchronized(x) {
        x += ?;

      }
       .
       .
    }

3. Thread 실습
- 말달리기 프로그램 만들기

3.1 말 한마리 셋팅하기..
    1) Canvas 상속을 받는 클래스 하나를 만든다.(말이 그려진 판)
    2) 중앙에 가로선을 하나 그린다.
    3) 말을 원으로 그린다.

3.2 말을 쓰레드로 움직이게 만든다.
    1) run() 메소드 정의하기
    2) 말이 움직이는 x좌표를 바꾸고 repaint시킨다.
    3) 출발이라는 버튼을 눌렀을 때 run이 실행 될 수 있도록 고친다.

3.3 말의 수를 입력 받고 필요 없는 것을 지워 준다.
    1) num과 set 버튼에 ActionListener 를 추가한다.
    2) 말의 수만 큼.. Center을 분할 시킨다.(Penel을 통해서)
      this.remove(dist);    // 구성된 화면 지우기..
      this.validate(); // 화면을 재 구성해주는 메소드..

3.4 말이 셋팅 된 상태에서 출발 버튼을 누르면 말들이 달려가게 만들기
    1) start 이벤트에 추가
    2) Thread 배열 형태로 말의 수만큼 만든다.
    3) 각 Thread 에 난수로 우선순위를 주어 출발 시킨다.

3.5 List창에 도착 순서 뿌리기
    1) 1번말 부터 말의 이름을 지정해 준다.

//---------------------------------------------------------------------------//
// Ex0130_01.html
<html>
    <head><title>말달리기</title></head>
    <body bgcolor='fcfcfc'>
      <center>
        <applet code="Ex0130_01.class" width='700' height='600'></applet>
        <hr>
        <font size=10>
          <a href="Ex0130_01.java"> 소스보기 </a>
        </font>
        </center>
    </body>
</html>

// Ex0130_01.java
import java.awt.*;
import java.awt.event.*;
import java.applet.*;

class Ex0130_01_Sub extends Canvas implements Runnable {
    private int xx;
    private static int rank = 1;
    private int hnum;
    private Ex0130_01 es;
    public Ex0130_01_Sub(int hnum, Ex0130_01 es) {
        this.hnum = hnum;
        this.es = es;
    }
    public static void setRank(int i) {
        rank = i;
    }
    public void run() {
        for(xx=0; xx <= (int)(this.getSize().getWidth() - 10); xx += (int)(Math.random() * 6) + 1) {
            repaint();
            try {
              Thread.sleep(100);
            } catch(InterruptedException ee) { }
        }
        xx = (int)(this.getSize().getWidth()) - 10;
        repaint();
        es.getRankList().add(hnum + "번째 말이 " + rank++ + "등으로 도착 했습니다...");
    }
    public void paint(Graphics g) {
        g.setColor(Color.black);
        g.drawLine(0,
            (int)(this.getSize().getHeight()/2),
            (int)(this.getSize().getWidth()),
            (int)(this.getSize().getHeight()/2));
        g.setColor(Color.red);
        g.fillOval(xx, 0, 10, (int)(this.getSize().getHeight()));
    }
}

//
public class Ex0130_01 extends Applet implements ActionListener{
    //Nor
    //Nor-Flow
    private Label lb1 = new Label("말의 수 : ");
    private TextField num = new TextField("",4);
    private Button set = new Button("Set");
    private Button clear = new Button("Clear");
    //Center

    //South
    //Sou-Nor
    private Label lb2 = new Label("등 수 판");
    //Sou-Cen
    private List ranklist = new List(7);
    //Sou-Sou-Flow
    private Button start = new Button("출발");
    private Button end = new Button("종료");
    private boolean frame = false;

    private Ex0130_01_Sub ess[];
    public Panel dist = null;

    public Ex0130_01() { }
    public Ex0130_01(boolean bb) {
        frame = bb;
    }
    public List getRankList() {
        return ranklist;
    }

    public void init() {
        this.setLayout(new BorderLayout());
        lb1.setForeground(Color.white);
        lb1.setFont(new Font("둗움", Font.BOLD, 12));
        Panel p1 = new Panel(new FlowLayout(FlowLayout.CENTER));
        p1.add(lb1); p1.add(num); p1.add(set); p1.add(clear);
        this.add("North", p1);
        //this.add("Center", ess);
        Panel p2 = new Panel(new BorderLayout());
        lb2.setForeground(Color.white);
        lb2.setBackground(new Color(192,129,255));
        lb2.setFont(new Font("둗움", Font.BOLD, 12));
        p2.add("North", lb2);
        p2.add("Center", ranklist);
        Panel p3 = new Panel(new FlowLayout(FlowLayout.RIGHT));
        p3.add(start);
        if(frame) {
            p3.add(end);
        }
        p2.add("South", p3);
        this.add("South", p2);
        p1.setBackground(new Color(192,129,255));
        p3.setBackground(new Color(192,129,255));
    }
    public void start() {
        end.addActionListener(this);
        start.addActionListener(this);
        num.addActionListener(this);
        set.addActionListener(this);
        clear.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e) {
        if(e.getSource() == end) {
            System.exit(1);

        } else if(e.getSource() == start) {
            Thread[] tt = new Thread[ess.length];
            for(int i=0; i < tt.length; i++) {
                tt[i] = new Thread(ess[i]);
            }
            for(int i=0; i < tt.length; i++) {
                tt[i].setPriority((int)(Math.random() * 10) + 1);
            }
            for(int i=0; i < tt.length; i++) {
                tt[i].start();
            }
        } else if(e.getSource() == num || e.getSource() == set) {
            int imsi = Integer.parseInt(num.getText().trim());
            dist = new Panel();
            dist.setLayout(new GridLayout(imsi, 1, 5, 5));
            ess = new Ex0130_01_Sub[imsi];
            for(int i=0; i < ess.length; i++) {
                ess[i] = new Ex0130_01_Sub(i+1, this);
                dist.add(ess[i]);
            }
            this.add("Center", dist);
            this.validate();
            num.setEnabled(false);
            set.setEnabled(false);
            clear.setEnabled(true);

        } else if(e.getSource() == clear) {
            this.remove(dist);
            this.validate();
            num.setText("");
            num.setEnabled(true);
            set.setEnabled(true);
            clear.setEnabled(false);
            num.requestFocus();
            Ex0130_01_Sub.setRank(1);
        }
    }

    public void paint(Graphics g) {}

    public static void main(String [] ar) {
        Ex0130_01 h1 = new Ex0130_01(true);
        h1.init();
        h1.start();
        Frame f = new Frame("말달리기");
        f.setLayout(new BorderLayout());
        f.add("Center", h1);
        f.setSize(700,600);
        f.setLocation(200,100);
        f.setVisible(true);
        f.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(1);
            }
        });
    }
}

//===========================================================================//

- [Java 기본] Applet

겨울에 — Sat, 14 May 2011 16:27:53 +0900

출처 : http://cafe.naver.com/litave/393

수업중소스모음.zip

- [Java 기본] Graphics

겨울에 — Sat, 14 May 2011 16:18:35 +0900

출처 : http://cafe.naver.com/litave/387

ho0123_02.java

ho0123_01.java

//---------------------------------------------------------------------------//

*Graphics
  - java.awt.*;          //에 포함된 클래스 이다.

1. 생성자() -> update(Graphics g) -> paint(Graphics g)
  - paint 는 setVisible 실행 시 화면이 뜨면서 처음으로 실행되는 부분
class A extands Frame {
  public void update(Graphics g) {        // 이부분은 Frame에 정의 되어 있다.
                                          // 일반적으로 제정의 하지 않는다.

    paint(g);    //디폴트로 <- 를 실행한다.
}
  public void paint(Graphics g) {       //이부분도 Frame에 포함된 메소드 이므로 제정의 해서 사용할 수 있다.

}
}

A ap = new A();          // ap에서 A라는 객체의 메소드를 호출하면..
                         // public void update(Graphics g) { }       이 자동으로 호출 된다.
                         //   -> 여기에는 현재의 프레임을 Default로 설정 하라고 되어 있다.

2. Method     // Graphics에서 자주 사용하는 메소드(paint { } 에서 사용할 수 있는 것들.)
  1) draw
    a) drawLine(x, y, x1, y1);           //전부 pixel의 값이다.
    b) draw(fill)Rect(x, y, w, h);       //draw속성과 fill속성을 둘다 가지고 있다.      //사각형을 그리겠다.
    c) draw(fill)Oval(x, y, w, h);       //draw는 선을 그리고 fill은 -> 사용하면 안에 색이 칠해 진다. //원을 그리겠다.
      - 여기서 그리는 원은 사각형에 내접하는 원이 그려 진다.
    d) draw(fill)RoundRect(x, y, w, h, rx, ry);
      - 모서리가 둥근 사각형이 그려진다.
    e) draw(fill)Polygon(x[], y[], 개수);
      - 다각형을 그릴 수 있다.
      - x[], y[]는 꼭지점의 좌표들을 담고 있다.
        -> 꼭지점의 순서대로 배열에 넣어 주면 된다.
  2) String             // 글자들은 특정 구역에 상관 없이 적어 줄 수 있다.
    - drawString(string, x, y);
    예) drawString("ggg", 100, 100);   //여기서 좌표는.. 글자의 중간 쯤이다..

  3) Image
    객체발생 :
      Image im = Toolkit.getDefaultToolkit().getImage("파일");  // 특정 파일로 부터 자바의 프로그램으로 불러 올 수 있다.
                  //Toolkit 객체 생성(외부와의 연동시 절대 경로명을 적어 주어야 한다. 리눅스: / , 윈도우: \\(역슬레시 두개를 사용해 주어야 한다.)

    - drawImage(im, x, y, 표시화면)        //특정 시작 점에서 부터 이미지의 크기대로 그려진다.
    - drawImage(im, x, y, w, h, 표시화면)

  4) 도형의 색 지정
    - g.setColor(?)를 이용해서 특정 색상을 글자나 도형에 표시 할 수 있다.
    - g.setColor(?)를 도형을 그리기 직전에 지정하면 그림은 그 바로 이전에 지정한 색상으로 그려진다.

3. paint가 실행되는 시기.
  1) 생성자 실행시
  2) resize 되는 순간에 update -> paint(--) 순으로 수행됨 (아이콘화 하는 것도 포함)
  3) repaint() Method를 호출 하는 순간에.. update->paint(--) 실행 된다.

4. 여기서 문제 점은 컴퍼넌트와 결합해서 사용 할때 그래픽과 컴퍼넌트 사이의 충돌이 일어나게 된다.
  -> 이미지를 컴퍼넌트화 시키면 된다.

  Graphics --> Component로 만들기
               ^(Canvas 클래스를 상속 받거나) 혹은 Conponent 혹은 Container 을 상속 받아서 사용해야 한다.
                    ^awp만 됨                        ^ 여기는 전부 됨

//---------------------------------------------------------------------------//
// 수업중 소스
// Ex0123_01.java : Graphics 클래스 내 메소드 실습
// - aaa.gif는 아무 이미지나 사용하면 됨
import java.awt.*;
import java.awt.event.*;
class Ex0123_01_Sub1 extends Canvas{
    private Image im;
    public Ex0123_01_Sub1() {
        im = Toolkit.getDefaultToolkit().getImage("aaa.gif");
    }
    //public void update(Graphics g){
    //    ........
    //    paint(g);
    //}
    public void paint(Graphics g) {
        g.drawLine(100, 100, 150, 150);
        g.setColor(Color.red);
        g.drawRect(50, 50, 100, 100);
        g.setColor(Color.blue);
        g.drawOval(50, 50, 100, 100);
        g.setColor(Color.green);
        int[] x, y;
        g.drawPolygon(x = new int[]{70, 120, 50}, y = new int[]{30, 100, 120}, 3);
        g.drawImage(im, 150, 50, 100, 100, this);
    }
    public Image getIm() {
        return im;
    }
}

class Ex0123_01_Sub extends Frame {
    private Ex0123_01_Sub1 ess = new Ex0123_01_Sub1();
    public Ex0123_01_Sub() {
        super("Test");
        this.init();
        this.start();
        //this.setIconImage(ess.getIm());
        this.setSize(300, 200);
        this.setVisible(true);
    }
    public void init() {
        this.setLayout(new BorderLayout());
        this.add("North", new Button("확인"));
        this.add("Center", ess);
    }
    public void start() {

    }
}
public class Ex0123_01 {
    public static void main(String[] ar) {
        Ex0123_01_Sub es = new Ex0123_01_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0123_02.java : Image 확대 축소 실습
// - aaa.gif는 아무 이미지나 사용하면 됨
import java.awt.*;
import java.awt.event.*;
class Ex0123_02_Sub1 extends Canvas {
    private Image im;
    private int x = 100, y = 100;
    public Ex0123_02_Sub1() {
        im = Toolkit.getDefaultToolkit().getImage("aaa.gif");
    }
    public void paint(Graphics g) {
        g.drawImage(im, 50, 50, x, y, this);
    }
    public void setXY(int x, int y) {
        this.x = x;
        this.y = y;
        this.repaint();
    }
}

class Ex0123_02_Sub extends Frame implements ActionListener {
    private Button bt = new Button("확대");
    private Button bt1 = new Button("축소");
    private Ex0123_02_Sub1 ess = new Ex0123_02_Sub1();

    public Ex0123_02_Sub() {
        super("Test");
        this.init();
        this.start();
        this.setSize(400, 400);
        this.setVisible(true);
    }
    public void init() {
        this.setLayout(new BorderLayout());
        Panel p = new Panel(new FlowLayout(FlowLayout.RIGHT));
        p.add(bt);
        p.add(bt1);
        this.add("North", p);
        this.add("Center", ess);
        bt1.setEnabled(false);//취소버튼 사용 못함..
        bt.requestFocus();
    }
    public void start() {
        bt.addActionListener(this);
        bt1.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e) {
        if(e.getSource() == bt){//확대..
            bt.setEnabled(false);
            bt1.setEnabled(true);
            bt1.requestFocus();
            ess.setXY(200, 200);
        } else if(e.getSource() == bt1) {//축소...
            bt1.setEnabled(false);
            bt.setEnabled(true);
            bt.requestFocus();
            ess.setXY(100, 100);
        }
    }
}
public class Ex0123_02 {
    public static void main(String[] ar) {
        Ex0123_02_Sub es = new Ex0123_02_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0123_03.java : 사각형 및 원 그리기 실습
import java.awt.*;
import java.awt.event.*;
class Ex0123_03_Sub1 extends Canvas {
    private int x, y, w, h;
    public void setXYWH(int x, int y, int w, int h) {
        this.x = x; this.y = y;
        this.w = w; this.h = h;
        this.repaint();
    }
    public void paint(Graphics g) {
        g.drawRect(x, y, w, h);
        g.drawOval(x, y, w, h);
    }
}

class Ex0123_03_Sub extends Frame implements ActionListener {
    private Ex0123_03_Sub1 ess = new Ex0123_03_Sub1();
    private Button bt = new Button("사각형 + 원 그리기");
    private Dialog dlg = new Dialog(this, "그리기", true);
    private Label dlglb = new Label("x = ", Label.RIGHT);
    private Label dlglb1 = new Label("y = ", Label.RIGHT);
    private Label dlglb2 = new Label("w = ", Label.RIGHT);
    private Label dlglb3 = new Label("h = ", Label.RIGHT);
    private TextField dlgtf = new TextField();
    private TextField dlgtf1 = new TextField();
    private TextField dlgtf2 = new TextField();
    private TextField dlgtf3 = new TextField();
    private Button dlgbt = new Button("그리기");
    private Button dlgbt1 = new Button("취소");
    public Ex0123_03_Sub() {
        super("Test");
        this.init();
        this.start();
        this.setSize(300, 200);
        this.setVisible(true);
    }
    public void init() {
        this.initDlg();
        this.setLayout(new BorderLayout());
        Panel p = new Panel(new FlowLayout(FlowLayout.RIGHT));
        p.add(bt);
        this.add("South", p);
        this.add("Center", ess);
    }
    public void initDlg() {
        dlg.setLayout(new BorderLayout());
        Panel p = new Panel(new GridLayout(4, 1));
        Panel p1 = new Panel(new GridLayout(4, 1));
        Panel p2 = new Panel(new FlowLayout(FlowLayout.RIGHT));
        p.add(dlglb); p.add(dlglb1);
        p.add(dlglb2); p.add(dlglb3);
        p1.add(dlgtf); p1.add(dlgtf1);
        p1.add(dlgtf2); p1.add(dlgtf3);
        p2.add(dlgbt); p2.add(dlgbt1);
        dlg.add("West", p);
        dlg.add("Center", p1);
        dlg.add("South", p2);
        dlg.setSize(200, 140);
    }
    public void start() {
        bt.addActionListener(this);
        dlgbt.addActionListener(this);
        dlgbt1.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e) {
        if(e.getSource() == bt) {
            //다이얼 로그...띄우기...
            dlg.setVisible(true);
        } else if(e.getSource() == dlgbt) {
            int x = Integer.parseInt(dlgtf.getText().trim());
            int y = Integer.parseInt(dlgtf1.getText().trim());
            int w = Integer.parseInt(dlgtf2.getText().trim());
            int h = Integer.parseInt(dlgtf3.getText().trim());
            ess.setXYWH(x, y, w, h);
            dlg.setVisible(false);
        } else if(e.getSource() == dlgbt1) {
            dlg.setVisible(false);
        }
    }
}
public class Ex0123_03 {
    public static void main(String[] ar) {
        Ex0123_03_Sub es = new Ex0123_03_Sub();
    }
}

//===========================================================================//

>>>>> Graphics - 그림판 예제

/****************************************

Title : 수업 내용 Canvas로 구성하기
Author : litwave
Date : 2003. 01. 27
****************************************/
import java.awt.*;
import java.awt.event.*;
import java.util.*;

class Ho0127_01_Sub1 {
    private int x, y, x1, y1, dist;
    private Color color = new Color(0, 0, 0);
    private boolean fillok = false;
    Ho0127_01_Sub1(int x, int y, int x1, int y1, int dist, Color color, boolean fillok) {
        this.x = x;  this.x1 = x1;
        this.y = y;  this.y1 = y1;
        this.dist = dist;   this.color = color;
        this.fillok = fillok;
    }
    public int getX() {
      return x;
    }
    public int getY() {
      return y;
    }
    public int getX1() {
      return x1;
    }
    public int getY1() {
      return y1;
    }
    public int getDist() {
      return dist;
    }
    public Color getColor() {
      return color;
    }
    public boolean getFillOk() {
      return fillok;
    }
}

class Ho0127_01_Sub extends Frame implements MouseListener, MouseMotionListener, ActionListener, ItemListener {
    private Vector vc = new Vector();

    //Fram initialization용 Field
    private CheckboxGroup cgb1 = new CheckboxGroup();
    private Checkbox cb1 = new Checkbox("연필", true, cgb1);
    private Checkbox cb2 = new Checkbox("직선", false, cgb1);
    private Checkbox cb3 = new Checkbox("사각형", false, cgb1);
    private Checkbox cb4 = new Checkbox("원", false, cgb1);

    //Menu용 Field
    private MenuBar mb = new MenuBar();
    private Menu file = new Menu("파일");
    private   MenuItem fnew = new MenuItem("New");
    private   MenuItem fopen = new MenuItem("Open");
    private   MenuItem fsave = new MenuItem("Save");
    private   MenuItem fexit = new MenuItem("Exit");
    private Menu tool = new Menu("도구");
    private Menu option = new Menu("옵션");
    private   MenuItem osetcolor = new MenuItem("색상");
    private   CheckboxMenuItem ofill = new CheckboxMenuItem("채우기", false);
    private   CheckboxMenuItem ounfill = new CheckboxMenuItem("비우기", true);

    //색상 설정 다이얼 로그 박스 만들기
    private Dialog dlg = new Dialog(this, "Color", true);
    private Label dlglb = new Label("red = ", Label.RIGHT);
    private Label dlglb1 = new Label("green = ", Label.RIGHT);
    private Label dlglb2 = new Label("blue = ", Label.RIGHT);
    private TextField dlgtf = new TextField("0");
    private TextField dlgtf1 = new TextField("0");
    private TextField dlgtf2 = new TextField("0");
    private Button dlgbt = new Button("preview");
    private Button dlgbt1 = new Button("set");
    private Button dlgbt2 = new Button("cancel");

    //화면 크기 생성용
    private Toolkit tk = Toolkit.getDefaultToolkit();
    private Dimension di = tk.getScreenSize();

    private int x, y, x1, y1;
    private Color color = new Color(0,0,0);
    //x = y = x1 = y1 = 0;

    private Ho0127_01_Sub_Can hsc = new Ho0127_01_Sub_Can(this);

    Ho0127_01_Sub(String str) {
        super(str);
        this.setLayout(new BorderLayout());
        setSize(500, 400);      //Frame 크기 설정
        //Frame를 화면 정 중앙에 배치
        Dimension di1 = this.getSize();
        setLocation((int)(di.getWidth()/2-di1.getWidth()/2),
                    (int)(di.getHeight()/2-di1.getHeight()/2));
        init();
        start();

        setVisible(true);
    }
    //Frame의 초기화
    public void init() {
      this.setLayout(new BorderLayout(5,5));
        initMenu();        //메뉴 초기화
        initDlg();
        this.add("Center", hsc);
        Panel p1 = new Panel(new GridLayout(1,5));
        p1.setBackground(Color.green);
        p1.add(new Label());
        p1.add(cb1);
        p1.add(cb2);
        p1.add(cb3);
        p1.add(cb4);
        this.add("South", p1);
    }
    private void initDlg() {
        dlg.setLayout(new BorderLayout());
        dlg.setLocation(400,300);
        Panel p = new Panel(new GridLayout(3, 1));
        p.add(dlglb);
        p.add(dlglb1);
        p.add(dlglb2);
        dlg.add("West", p);
        Panel p1 = new Panel(new GridLayout(3, 1));
        p1.add(dlgtf);
        p1.add(dlgtf1);
        p1.add(dlgtf2);
        dlg.add("Center", p1);
        dlg.add("East", dlgbt);
        Panel p2 = new Panel(new FlowLayout(FlowLayout.RIGHT));
        p2.add(dlgbt1);
        p2.add(dlgbt2);
        dlg.add("South", p2);
        dlg.setSize(200, 150);
    }
    //Menu의 초기화 Method
    public void initMenu () {
        this.setMenuBar(mb);
        mb.add(file);
        file.add(fnew);
        file.addSeparator();
        file.add(fopen);
        file.add(fsave);
        file.addSeparator();
        file.add(fexit);
        mb.add(option);
        option.add(osetcolor);
        option.addSeparator();
        option.add(ofill);
        option.add(ounfill);
    }

    public void start() {
        //창 닫기 버튼 누르면 실행
        this.addWindowListener( new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(1);
            }
        });

        hsc.addMouseListener( this );
        hsc.addMouseMotionListener( this );

        //ActionListener 관련 이벤트 발생시
        fnew.addActionListener( this );
        fopen.addActionListener( this );
        fsave.addActionListener( this );
        fexit.addActionListener( this );
        osetcolor.addActionListener( this );
        dlgbt.addActionListener( this );
        dlgbt1.addActionListener( this );
        dlgbt2.addActionListener( this );

        //ItemListener 관련 이벤트 발생시
        ofill.addItemListener( this );
        ounfill.addItemListener( this );
    }
/*
    public void paint(Graphics g) {
        g.setColor(color);

        if(cb2.getState()) g.drawLine(x, y, x1, y1);     //잔상 남기기..
        else if(ofill.getState()) {
            if (cb3.getState()) g.fillRect(x, y, x1-x, y1-y);
            else if (cb4.getState()) g.fillOval(x, y, x1-x, y1-y);
        } else {
            if (cb3.getState()) g.drawRect(x, y, x1-x, y1-y);
            else if (cb4.getState()) g.drawOval(x, y, x1-x, y1-y);
        }

        for(int i=0; i < vc.size(); i++) {
            Ho0127_01_Sub1 imsi = (Ho0127_01_Sub1)vc.elementAt(i);
            g.setColor(imsi.getColor());
            switch(imsi.getDist()) {
                case 1:
                    g.drawLine(imsi.getX(), imsi.getY(), imsi.getX1(), imsi.getY1());
                    break;
                case 2:
                    if(imsi.getFillOk()) g.fillRect(imsi.getX(), imsi.getY(), imsi.getX1()-imsi.getX(), imsi.getY1()-imsi.getY());
                    else g.drawRect(imsi.getX(), imsi.getY(), imsi.getX1()-imsi.getX(), imsi.getY1()-imsi.getY());
                    break;
                case 3:
                    if(imsi.getFillOk()) g.fillOval(imsi.getX(), imsi.getY(), imsi.getX1()-imsi.getX(), imsi.getY1()-imsi.getY());
                    else g.drawOval(imsi.getX(), imsi.getY(), imsi.getX1()-imsi.getX(), imsi.getY1()-imsi.getY());
                    break;
            }
        }
    }
    */
    public void mouseClicked(MouseEvent e) { }
    public void mouseEntered(MouseEvent e) { }
    public void mouseExited(MouseEvent e) { }
    public void mousePressed(MouseEvent e) {
    this.x = e.getX();
        this.y = e.getY();
    }
    public void mouseReleased(MouseEvent e) {
        this.x1 = e.getX();
        this.y1 = e.getY();
        int dist = 0;
        if(cb2.getState()) dist = 1;
        else if(cb3.getState()) dist = 2;
        else if(cb4.getState()) dist = 3;
        Ho0127_01_Sub1 hss = new Ho0127_01_Sub1(x, y, x1, y1, dist, color, ofill.getState());
        vc.add(hss);
        hsc.repaint();
    }
    public void mouseMoved(MouseEvent e) { }
    public void mouseDragged(MouseEvent e) {
        if(cb1.getState()) {
            x1 = e.getX();
            y1 = e.getY();
            Ho0127_01_Sub1 hss = new Ho0127_01_Sub1(x, y, x1, y1, 1, color, false);
            vc.add(hss);
            hsc.repaint();
            x = x1;
            y = y1;
        } else {
            x1 = e.getX();
            y1 = e.getY();
            hsc.repaint();
        }
    }

    public void actionPerformed(ActionEvent e) {
        if(e.getSource() == fnew) {
            vc.clear();
            x = y = x1 = y1 = 0;
            hsc.repaint();

        } else if(e.getSource() == fopen) {
          FileDialog fd = new FileDialog(this, "열기", FileDialog.LOAD);
            fd.setVisible(true);

        } else if(e.getSource() == fsave) {
          FileDialog fd = new FileDialog(this, "저장", FileDialog.SAVE);
            fd.setVisible(true);

        } else if(e.getSource() == fexit) {
          System.exit(1);

        } else if(e.getSource() == osetcolor) {
          dlg.setVisible(true);

        } else if(e.getSource() == dlgbt) {
            int r = Integer.parseInt(dlgtf.getText().trim());
            int g = Integer.parseInt(dlgtf1.getText().trim());
            int b = Integer.parseInt(dlgtf2.getText().trim());
            Color cc = new Color(r, g, b);
            dlgbt.setBackground(cc);

        } else if(e.getSource() == dlgbt1) {
            int r = Integer.parseInt(dlgtf.getText().trim());
            int g = Integer.parseInt(dlgtf1.getText().trim());
            int b = Integer.parseInt(dlgtf2.getText().trim());
            Color cc = new Color(r, g, b);
            color = cc;
            dlg.setVisible(false);
        }
        else if(e.getSource() == dlgbt2) {
            dlg.setVisible(false);
        }
    }

    //채우기나 비우기 둘 중 하나가 선택 되면 다른 하나의 채크된 것을 채크되지 않은 상태로
    public void itemStateChanged(ItemEvent e) {
      if(e.getSource() == ofill) {
            ofill.setState(true);
            ounfill.setState(false);

        } else if(e.getSource() == ounfill) {
            ofill.setState(false);
            ounfill.setState(true);
        }
    }

    public Color getColor() {
        return color;
    }
    public Vector getVc() {
        return vc;
    }
    public Checkbox getCb2() {
        return cb2;
    }
    public Checkbox getCb3() {
        return cb3;
    }
    public Checkbox getCb4() {
        return cb4;
    }
    public CheckboxMenuItem getOfill() {
        return ofill;
    }
    public int getX() {
        return x;
    }
    public int getX1() {
        return x1;
    }
    public int getY() {
        return y;
    }
    public int getY1() {
        return y1;
    }
}

class Ho0127_01_Sub_Can extends Canvas {
    Ho0127_01_Sub h1s = null;
    private int x, x1, y, y1;
    Ho0127_01_Sub_Can(Ho0127_01_Sub h1s) {
        this.h1s = h1s;
    }
    public void paint(Graphics g) {
        g.setColor(h1s.getColor());
        x = h1s.getX(); x1 = h1s.getX1();  y = h1s.getY(); y1 = h1s.getY1();
        if(h1s.getCb2().getState())
            g.drawLine(x, y, x1, y1);     //잔상 남기기..
        else if(h1s.getOfill().getState()) {
            if (h1s.getCb3().getState()) g.fillRect(x, y, x1-x, y1-y);
            else if(h1s.getCb4().getState()) g.fillOval(x, y, x1-x, y1-y);
        } else {
            if (h1s.getCb3().getState()) g.drawRect(x, y, x1-x, y1-y);
            else if (h1s.getCb4().getState()) g.drawOval(x, y, x1-x, y1-y);
        }

      for(int i=0; i < h1s.getVc().size(); i++) {
            Ho0127_01_Sub1 imsi = (Ho0127_01_Sub1)h1s.getVc().elementAt(i);
            g.setColor(imsi.getColor());
            switch(imsi.getDist()) {
                case 1:
                    g.drawLine(imsi.getX(), imsi.getY(), imsi.getX1(), imsi.getY1());
                    break;
                case 2:
                    if(imsi.getFillOk()) g.fillRect(imsi.getX(), imsi.getY(), imsi.getX1()-imsi.getX(), imsi.getY1()-imsi.getY());
                    else g.drawRect(imsi.getX(), imsi.getY(), imsi.getX1()-imsi.getX(), imsi.getY1()-imsi.getY());
                    break;
                case 3:
                    if(imsi.getFillOk()) g.fillOval(imsi.getX(), imsi.getY(), imsi.getX1()-imsi.getX(), imsi.getY1()-imsi.getY());
                    else g.drawOval(imsi.getX(), imsi.getY(), imsi.getX1()-imsi.getX(), imsi.getY1()-imsi.getY());
                    break;
            }
        }
    }
}

//Main 객체 정의
public class Ho0127_01 {
    public static void main(String [] ar) {
        Ho0127_01_Sub h1s = new Ho0127_01_Sub("그림판");
    }
}

- [Java 기본]AWT, Listener, Event

겨울에 — Sat, 14 May 2011 16:14:51 +0900

출처 : http://cafe.naver.com/litave/383

ho0121_01.java

import java.awt.*;
import java.awt.event.*;
class Ex0121_01_Sub extends Frame implements MouseListener, WindowListener {
    private List li = new List(5, false);
    public Ex0121_01_Sub() {
        super("Ex0121_01");
        this.init();
        this.start();
        this.setSize(300, 200);
        this.setVisible(true);
    }
    public void init() {
        this.setLayout(new FlowLayout());
        for(char ch = 'A'; ch <= 'Z'; ch++) {
            li.add("" + ch + ch + ch);
        }
        this.add(li);
    }
    public void start() {
        this.addWindowListener( this );
        li.addMouseListener( this );
    }
    public void mouseClicked(MouseEvent e) {
        int x = e.getClickCount();
        if(x == 1) {
            String str = (String)li.getSelectedItem();
            System.out.println("선택된 내용 = " + str);
        }
    }
    public void mousePressed(MouseEvent e) {}
    public void mouseReleased(MouseEvent e) {}
    public void mouseEntered(MouseEvent e) {}
    public void mouseExited(MouseEvent e) {}
    public void windowClosing(WindowEvent e) {
        System.exit(0);
    }
    public void windowClosed(WindowEvent e) {}
    public void windowOpened(WindowEvent e) {}
    public void windowIconified(WindowEvent e) {}
    public void windowDeiconified(WindowEvent e) {}
    public void windowActivated(WindowEvent e) {}
    public void windowDeactivated(WindowEvent e) {}
}
public class Ex0121_01 {
    public static void main(String[] ar) {
        Ex0121_01_Sub es = new Ex0121_01_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0121_02.java : 익명 Inner 클래스를 이용한 Event 실습

import java.awt.*;
import java.awt.event.*;
import java.util.*;
class Ex0121_02_Sub extends Frame {
                                                //implements ActionListener{
    private Label lb = new Label("생년월일 : ", Label.RIGHT);
    private Choice year = new Choice();
    private Choice month = new Choice();
    private Choice day = new Choice();
    private Label lb1 = new Label("년");
    private Label lb2 = new Label("월");
    private Label lb3 = new Label("일");
    private Button bt = new Button("확인");
    public Ex0121_02_Sub() {
        super("Ex0121_02");
        this.init();
        this.start();
        this.setSize(300, 200);
        this.setVisible(true);
    }

    public void init() {
        this.setLayout(new FlowLayout());
        this.add(lb);
        Calendar ca = Calendar.getInstance();
        int y = ca.get(Calendar.YEAR);
        for(int i = y; i >= 1900; i--) {
            year.add(String.valueOf(i));
        }
        this.add(year);
        this.add(lb1);
        for(int i = 1; i <= 12; i++) {
            month.add(String.valueOf(i));
        }
        this.add(month);
        this.add(lb2);
        for(int i = 1; i <= 31; i++) {
            day.add(String.valueOf(i));
        }
        this.add(day);
        this.add(lb3);
        this.add(bt);
    }

    public void start() {
        this.addWindowListener( new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        bt.addActionListener( new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                String y = (String)year.getSelectedItem();
                String m = (String)month.getSelectedItem();
                String d = (String)day.getSelectedItem();
                System.out.println("생년월일 : " + y + "년 " + m + "월 " + d + "일");
            }
        });
    }
}
public class Ex0121_02 {
    public static void main(String[] ar) {
        Ex0121_02_Sub es = new Ex0121_02_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0121_03.java : Action Event 실습

import java.awt.*;
import java.awt.event.*;
class Ex0121_03_Sub extends Frame
                implements ActionListener {
    private Button bt = new Button("확인");
    private Button bt1 = new Button("취소");
    public Ex0121_03_Sub() {
        super("Ex0121_03");
        this.init();
        this.start();
        this.setSize(300, 200);
        this.setVisible(true);
    }
    public void init() {
        this.setLayout(new FlowLayout());
        this.add(bt);
        this.add(bt1);
    }
    public void start() {
        bt.addActionListener(this);
        bt1.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e) {
        Button imsi = (Button)e.getSource();
        System.out.println(imsi.getLabel() + "을 누르셨습니다.");
        //if(imsi.getLabel().equals("확인")){
        //    System.out.println("확인을 눌렀다.");
        //}
        //else if(imsi.getLabel().equals("취소")){
        //    System.out.println("취소를 눌렀다.");
        //}
        /*
        if(e.getSource() == bt){
            System.out.println("확인을 눌렀다.");
        }
        else if(e.getSource() == bt1){
            System.out.println("취소를 눌렀다.");
        }
        */
    }
}
public class Ex0121_03 {
    public static void main(String[] ar) {
        Ex0121_03_Sub es = new Ex0121_03_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0121_04.java : MouseEvent 실습

import java.awt.*;
import java.awt.event.*;
class Ex0121_04_Sub extends Frame
            implements MouseMotionListener{
    private Label lb = new Label("x = 000, y = 000");
    public Ex0121_04_Sub(){
        super("Ex0121_04");
        this.init();
        this.start();
        this.setSize(500, 400);
        this.setVisible(true);
    }
    public void init() {
        this.setLayout(new FlowLayout());
        lb.setFont(new Font("휴먼옛체", Font.BOLD, 20));
        this.add(lb);
    }
    public void start() {
        this.addMouseMotionListener(this);
    }
    public void mouseMoved(MouseEvent e) {
        if(e.getSource() == this){
            int x = e.getX();
            int y = e.getY();
            lb.setText("x = " + x + ", y = " + y);
        }
    }
    public void mouseDragged(MouseEvent e) {
        if(e.getSource() == this){
            int x = e.getX();
            int y = e.getY();
            lb.setText("x = " + x + ", y = " + y);
        }
    }
}
public class Ex0121_04 {
    public static void main(String[] ar) {
        Ex0121_04_Sub es = new Ex0121_04_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0121_05.java : 계산기 실습

import java.awt.*;
import java.awt.event.*;
class Ex0121_05_Sub extends Frame
                    implements ActionListener {
    private Label lb = new Label("Su1 = ", Label.RIGHT);
    private Label lb1 = new Label("Su2 = ", Label.RIGHT);
    private Label lb2 = new Label("RES = ", Label.RIGHT);
    private TextField su1 = new TextField();
    private TextField su2 = new TextField();
    private TextField result = new TextField();
    private Button add1 = new Button("+");
    private Button min1 = new Button("-");
    private Button mul1 = new Button("*");
    private Button div1 = new Button("/");
    private Button per1 = new Button("%");
    private Button end = new Button("종료");
    public Ex0121_05_Sub() {
        super("정수 계산기");
        this.init();
        this.start();
        this.setSize(250, 150);
        this.setVisible(true);
    }
    public void init() {
        this.setLayout(new GridLayout(5, 1));
        Panel p = new Panel(new BorderLayout());
        p.add("West", lb);
        p.add("Center", su1);
        this.add(p);
        Panel p1 = new Panel(new BorderLayout());
        p1.add("West", lb1);
        p1.add("Center", su2);
        this.add(p1);
        Panel p2 = new Panel(new GridLayout(1, 5));
        p2.add(add1);
        p2.add(min1);
        p2.add(mul1);
        p2.add(div1);
        p2.add(per1);
        this.add(p2);
        Panel p3 = new Panel(new BorderLayout());
        p3.add("West", lb2);
        p3.add("Center", result);
        this.add(p3);
        Panel p4 = new Panel(new FlowLayout(FlowLayout.RIGHT));
        p4.add(end);
        this.add(p4);
    }
    public void start() {
        add1.addActionListener(this);
        min1.addActionListener(this);
        mul1.addActionListener(this);
        div1.addActionListener(this);
        per1.addActionListener(this);
        add1.setActionCommand("yonsan");
        min1.setActionCommand("yonsan");
        mul1.setActionCommand("yonsan");
        div1.setActionCommand("yonsan");
        per1.setActionCommand("yonsan");
        end.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e) {
        if(e.getSource() == end){
            System.exit(0);
        } else if(e.getActionCommand().equals("yonsan")) {
            int x = 0;
            try {
                x = Integer.parseInt(su1.getText().trim());
            } catch(NumberFormatException ee) {
                su1.setText("");
                su1.requestFocus();
                return;
            }
            int y = 0;
            try {
                y = Integer.parseInt(su2.getText().trim());
            } catch(NumberFormatException ee) {
                su2.setText("");
                su2.requestFocus();
                return;
            }
            char yon = ((Button)e.getSource()).getLabel().charAt(0);
            int tot = 0;
            switch(yon) {
            case '+': tot = x + y; break;
            case '-': tot = x - y; break;
            case '*': tot = x * y; break;
            case '/':
                try {
                    tot = x / y;
                } catch(ArithmeticException ee) {
                    su2.setText("");
                    su2.requestFocus();
                    return;
                }
                break;
                case '%':
                try {
                    tot = x % y;
                } catch(ArithmeticException ee) {
                    su2.setText("");
                    su2.requestFocus();
                    return;
                }
                break;
            }
            result.setText(String.valueOf(tot));
        }
    }
}
public class Ex0121_05 {
    public static void main(String[] ar) {
        Ex0121_05_Sub es = new Ex0121_05_Sub();
    }
}

//---------------------------------------------------------------------------//
// 과제 : 아래와 같이 Window의 계산기와 동일한 모양을 AWT를 이용하여 구현하세요

// 기능은 다음 수업에서 진행

//===========================================================================//

/*
* 전일 과제를 통하여 구현한 화면을 기준으로
* 수업 시간에 계산기 기능을 구현한 것입니다.
*/

import java.awt.*;
import java.awt.event.*;

class Ho0122_01_Sub extends Frame implements ActionListener {
    //메뉴바 정의
    private MenuBar mb = new MenuBar();
    private Menu medit = new Menu("편집(E)");
    private Menu mview = new Menu("보기(V)");
    private Menu mhelp = new Menu("도움말(H)");
    private MenuItem mcopy = new MenuItem("복사(C) Ctrl+C");
    private MenuItem mpaste = new MenuItem("붙여넣기(P) Ctrl+V");
    private CheckboxMenuItem mmt = new CheckboxMenuItem("일반용(T)");
    private CheckboxMenuItem mms = new CheckboxMenuItem("공학용(S)");
    private CheckboxMenuItem mmi = new CheckboxMenuItem("자릿수 구분 단위(I)");
    private MenuItem mhlist = new MenuItem("도움말 항목");
    private MenuItem minfo = new MenuItem("계산기 정보");

    //Frame Component 정의
    //Nor
    private Label view = new Label("0.", Label.RIGHT);
    //Wst
    //Wst-Nor
    private Label mv = new Label("",Label.CENTER);
    //Wst-Cen
    //Wst-Cen-Grid(4,1)
    private Button mc = new Button("MC");
    private Button mr = new Button("MR");
    private Button ms = new Button("MS");
    private Button mp = new Button("M+");
    //Cen
    //Cen-Nor
    //Cen-Nor-Grid(1,3)
    private Button bs = new Button("Backspace");
    private Button ce = new Button("CE");
    private Button c = new Button("C");
    //Cen-Cen
    //Cen-Cen-Grid(4,5);
                            //숫자와 연산자는 배열로 처리
    private Button [] su = new Button[10];
    private String [] yonchar = new String[] {"/", "*", "-", "+", "="};
    private Button [] yon = new Button[5];

    private Button sqrt = new Button("sqrt");
    private Button na = new Button("%");
    private Button per = new Button("1/x");
    private Button sign = new Button("+/-");
    private Button jum = new Button(".");

    private boolean first = true;    // true : 처음 실행
    // false : 이미 한번 실행됨
    private double tot = 0.0;
    private char yonsan = '+';
    private boolean press = false;

    public double memory = 0.0;

    Ho0122_01_Sub(String str) {
        super(str);
        this.setSize(301, 233);
        this.setBackground(new Color(191, 191, 191));
        Toolkit tk = Toolkit.getDefaultToolkit();
        Dimension di = tk.getScreenSize();
        Dimension di1 = this.getSize();
        setLocation((int)(di.getWidth()/2-di1.getWidth()/2), (int)(di.getHeight()/2-di1.getHeight()/2));
        setLayout(new BorderLayout(10,5));
        init();
        start();
        this.setResizable(false);
        this.setVisible(true);
    }
    public void init() {
        initMenu();
        initData();
        view.setBackground(new Color(255,255,255));
        view.setFont(new Font("휴먼옛체", Font.BOLD, 20));
        this.add("North", view);
        Panel p1 = new Panel(new BorderLayout(5,5));
        p1.setForeground(new Color(255, 0, 0));
        p1.setFont(new Font("굴림", 0, 14));
        p1.add("North", mv);
        Panel p2 = new Panel(new GridLayout(4,1,5,5));
        p2.add(mc);
        p2.add(mr);
        p2.add(ms);
        p2.add(mp);
        p1.add("Center", p2);
        this.add("West", p1);
        Panel p3 = new Panel(new BorderLayout(5,5));
        Panel p4 = new Panel(new GridLayout(1,3,5,5));
        p4.setFont(new Font("굴림", 0, 13));
        p4.setForeground(new Color(255, 0, 0));
        p4.add(bs);
        p4.add(ce);
        p4.add(c);
        p3.add("North", p4);
        Panel p5 = new Panel(new GridLayout(4,5,5,5));
        p5.setFont(new Font("굴림", 0, 12));
        p5.setForeground(new Color(0,0,255));

        for(int i=0; i < yon.length; i++) {
            yon[i].setForeground(new Color(255, 0, 0));
        }

        mv.setForeground(new Color(0,0,0));
        mv.setBackground(new Color(210,210,210));
        p5.add(su[7]);
        p5.add(su[8]);
        p5.add(su[9]);
        p5.add(yon[0]);
        p5.add(sqrt);
        p5.add(su[4]);
        p5.add(su[5]);
        p5.add(su[6]);
        p5.add(yon[1]);
        p5.add(na);
        p5.add(su[1]);
        p5.add(su[2]);
        p5.add(su[3]);
        p5.add(yon[2]);
        p5.add(per);
        p5.add(su[0]);
        p5.add(sign);
        p5.add(jum);
        p5.add(yon[3]);
        p5.add(yon[4]);
        p3.add("Center", p5);
        this.add("Center", p3);
    }

    public void initMenu() {
        this.setMenuBar(mb);
        mb.add(medit);
        medit.add(mcopy);
        medit.add(mpaste);
        mb.add(mview);
        mview.add(mmt);
        mview.add(mms);
        mview.addSeparator();
        mview.add(mmi);
        mb.add(mhelp);
        mhelp.add(mhlist);
        mhelp.addSeparator();
        mhelp.add(minfo);
    }

    //데이타 초기화 Method
    public void initData() {
        for(int i=0; i < su.length; i++) {
            su[i] = new Button(String.valueOf(i));
        }
        for(int i=0; i < yon.length; i++) {
            yon[i] = new Button(yonchar[i]);
        }
    }

    public void start() {
        this.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

        for(int i = 0; i < su.length; i++) {
            su[i].addActionListener( this );
            su[i].setActionCommand("su");
            if(i < yon.length) {
                yon[i].addActionListener( this );
                yon[i].setActionCommand("yon");
            }
        }

        sign.addActionListener(this);
        jum.addActionListener(this);

        ce.addActionListener(this);
        c.addActionListener(this);

        bs.addActionListener(this);

        mc.addActionListener(this);
        mr.addActionListener(this);
        ms.addActionListener(this);
        mp.addActionListener(this);

        sqrt.addActionListener(this);
        per.addActionListener(this);
        na.addActionListener(this);
    }

    public void actionPerformed(ActionEvent e) {
        if(e.getActionCommand().equals("su")) {
            String imsi = ((Button)e.getSource()).getLabel().trim();        //e.getSource() 리턴값이 Object 타입이다.
            if(first == true) {
                //if(imsi != "0") first = false;
                view.setText(imsi + ".");
                if(imsi.equals("0")) {
                  return;
                }
                first = false;
            } else {
                if(press == true) {
                    String str = view.getText().trim();
                    str += imsi;
                    view.setText(str);
                } else {
                  String str = view.getText().trim();
                    str = str.substring(0, str.indexOf("."));
                    view.setText(str + imsi + ".");
                }
            }
        }
        else if(e.getActionCommand().equals("yon")) {
            double x = Double.parseDouble(view.getText());
            switch (yonsan) {
            case '+': tot += x; break;
            case '-': tot -= x; break;
            case '*':
                        double imsi = tot;
                        int i = 1;
                        while(imsi-(int)imsi != 0) {
                            i *= 10;
                            imsi *= 10;
                        }
                        tot = (imsi * x) / i;
                        break;
            case '/': tot /= x; break;
            }
            yonsan = ((Button)e.getSource()).getLabel().trim().charAt(0);
            first = true;
            press = false;
            double imsi = tot - (int)tot;
            if(imsi == 0.0) {
                view.setText((int)tot + ".");
            }
            else {
                view.setText(String.valueOf(tot));
                press = true;                         //과제.. 나눗셈 연산 후 Double 값이면, jum버튼 클릭한 것처럼 처리
            }
            if(yonsan == '=') {
                tot = 0.0;
                yonsan = '+';
            }
        }
        else if(e.getSource() == sign) {
            String str = view.getText().trim();
            if(str.equals("0.")) {
                return;
            }
            char imsi = str.charAt(0);
            if(imsi == '-') {
                str = str.substring(1);
            } else {
                str = "-" + str;
            }
            view.setText(str);
        }
        else if(e.getSource() == jum) {
            if(first == true) {
                view.setText("0.");
            }
            press = true;
            first = false;
        }
        else if(e.getSource() == ce) {
            first = true;
            press = false;
            view.setText("0.");
        }
        else if(e.getSource() == c) {
            first = true;
            press = false;
            view.setText("0.");
            tot = 0.0;
            yonsan = '+';
        }
        else if(e.getSource() == bs) {
            String str = view.getText().trim();
            if(str.length() == 3 && str.charAt(0) == '-') {
                view.setText("0.");
                first = true;
                press = false;
                return;
            }
            if(str.length() == 2) {
                view.setText("0.");
                first = true;
                press = false;
                return;
            }
            if(press) {
                if(str.charAt(str.length()-1) == '.') {
                    press = false;
                    return;
                }
                str = str.substring(0, str.length() - 1);
            } else {
                str = str.substring(0, str.length() - 2);
                str += ".";
            }
            view.setText(str);
        }
        else if(e.getSource() == mr) {
            double imsi = memory - (int)memory;
            if(imsi == 0.0) {
                view.setText((int)memory + ".");
                first = true;                    //memory에 0값이 있을 때 mr을 누른 후 숫자 입력시.. 0이 시작부분에 출력되는 것 막음
            } else {
                view.setText(String.valueOf(memory));
            }
        }
        else if(e.getSource() == mc) {
            memory = 0.0;
            mv.setText("");
        }
        else if(e.getSource() == ms) {
            String str = view.getText().trim();
            memory = Double.parseDouble(str);
            mv.setText("M");
        }
        else if(e.getSource() == mp) {
            String str = view.getText().trim();
            memory = Double.parseDouble(str);
            mv.setText("M");
        }
        else if(e.getSource() == sqrt) {
            double x = Double.parseDouble(view.getText());
            tot = Math.sqrt(x);
            double imsi = tot - (int)tot;
            if(imsi == 0.0) {
                view.setText((int)tot + ".");
                press = false;
                first = true;
                tot = 0.0;
            }
            else {
                view.setText(String.valueOf(tot));
                press = true;
                tot = 0.0;
            }
        }
        else if(e.getSource() == per) {
            double x = Double.parseDouble(view.getText());
            tot = 1 / x;
            double imsi = tot - (int)tot;
            if(imsi == 0.0) {
                view.setText((int)tot + ".");
                press = false;
                first = true;
                tot = 0.0;
            }
            else {
                view.setText(String.valueOf(tot));
                press = true;
                tot = 0.0;
            }
        }
        else if(e.getSource() == na) {
            double x = Double.parseDouble(view.getText());
            x = x / tot;
            double imsi = x - (int)x;
            if(imsi == 0.0) {
                view.setText((int)x + ".");
                press = false;
                first = true;
            }
            else {
                view.setText(String.valueOf(x));
                press = true;
            }
        }
    }
}

public class Ho0122_01 {
    public static void main(String [] ar) {
        Ho0122_01_Sub h1s = new Ho0122_01_Sub("계산기");
    }

}

--------------------------------------------------------------------------------------------------

>>>>>

Q. 2.0 - 1.1 하면 이상한 값이 나옵니당..

A.
나누샘을 2진 부동 소수점 연산을 사용하는 double을 사용하기 때문에 오는 근본적인 문제임.. ㅋㅋ..
그래서 세밀한 연산에 대해서는 long 타입으로 변환 후 계산하고 결과를 돌려주던지... BigDecimal 클래스를 이용하라고 권고 되어 있는듯.. ㅋㅋ...
관련 링크 : http://blog.naver.com/redshoe?Redirect=Log&logNo=30021284413

- [Java 기본]Menu, Frame 정렬, FileDialog, Dialog, Event

겨울에 — Sat, 14 May 2011 16:09:20 +0900

출처 : http://cafe.naver.com/litave/379

ho0120.zip

//===========================================================================//
본 내용은 2002년 제가 Java 강의를 수강하며 정리 했던 내용을
    기본으로 하여 정리하였습니다.
  - 마침 java 기초를 전파할 기회가 생겨 핑계김에 정리해 가려 합니다.
작성자 : litwave
//---------------------------------------------------------------------------//

<목차>
1. ScrollPane
2. Menu
3. Frame 배치
4. FileDialog
5. Dialog
6. Event

//---------------------------------------------------------------------------//
일반적으로 java를 배우는 순서
설치->자료형->연산자->기본I/O->제어문->Java Method->Java 배열->기본클래스->String
-> static->Info class->무한 Data->Package->예외처리->상속성->다형성->abstract->Inner클래스
-> Awt->Event->Graphics->applet->Thread->I/O->Swing->network->JDBC

1. ScrollPane 사용 방법
    Panel p = new Panel(new BorderLayout());

    this.add("North", ~);
    this.add("Center", ~);
    this.add("South",~);        //this -> sp로 바꿈

    ScrollPane sp = new ScrollPane();
    sp.add(p);
    this.add("Center", sp);

2. Menu관련 된 것
  2.1 사용 방법
    MenuBar mb = new MenuBar();        //메뉴바 객체를 만든다.(회색메뉴공간)
    Menu file   = new Menu("파일");     //메뉴를 생성 시킨다.
    Menu option = new Menu("옵션");
    Menu help   = new Menu("도움말");
    //메뉴바에 올라갈 수 있는 메뉴는 메뉴들만 올라갈 수 있다.
    //이러한 메뉴를 메뉴바에 올린다.
    MenuItem fnew = new MenuItem("New");
    MenuItem fexit = new MenuItem("Exit");

    file.add(fnew);         //파일 메뉴 항목 메뉴에 넣기
    file.addSeparator();    //분할 선 삽입
    file.add(fexit);        //종료 메뉴에 넣기

    mb.add(file);           //메뉴바에 파일 메뉴 넣기
    mb.add(option);
    mb.add(help);
    this.setMenuBar(mb);              //메뉴바를 현재의 프레임에 추가 시킨다.

    //메뉴 하단부에 올수 있는 것은 메뉴, 메뉴아이템, 체크박스 메뉴아이템
    Menu : 하위 메뉴를 가지는 것
    MenuItem : 단독적으로 객체로 작용 되는 것
    CheckboxMenuItem : 채크가 가능한 MenuItem

3. 화면에 뜨는 화면을 프레임 정중앙에 뛰우는 방법
  -> Toolkit 을 사용하면 화면, 프린터, 경고음 등의 정보를 나타낼 수 있다.
  -> 화면의 정중앙은 x축과 y축이 만나는 점(정중앙)을 찾고 프레임 크기의 절반 만큼
     좌측과 상단으로 이동 시키면 된다.

    Toolkit tk = Toolkit.getDefaultToolkit();      //화면의 정중앙에 배치 시키기
    Dimension di = tk.getScreenSize();  // 폭과 높이를 얻어 온다.
    Dimension di1 = this.getSize();    //프레임의 높이를 얻어 온다
    int xx = (int)(di.getWidth() / 2 - di1.getWidth() / 2);    //화면의 전체폭 나누기 2
    int yy = (int)(di.getHeight() / 2 - di1.getHeight() / 2);
    this.setLocation(xx, yy);

4. FileDialog  //어딘가에 종속되어 나타나야 한다.
  1) 생성자 :
    // (다이얼로그가 포함될 프레임-특정 컴포넌트, "Title", FileDialog.SAVE-FileDialg.LOAD)
    FileDialog fd = new FileDialog(this, "내꺼열기", FileDialog.SAVE);

5. Dialog //객체에 의한 방법을 많이 쓴다.
  -> 누군가에게 종속되어서 만들어져야 한다는 것만 제외하고는 Frame과 거의 똑같다.
  -> 배경색이 회색으로 되어 있고, X 버튼만 있다.(창 최소, 최대는 없음)
  -> Frame의 객체 만드는 것과 동일하게 하면 된다.

  1) 생성자 :
        Dialog dlg = new Dialog(this, "title", true/false);
        // Modal 상태지정(true: Dialog가 죽어야 다음 실행을 한다. false: Dalog상태와 상관 없이 실행 된다.)
        dlg.setLayout(new BorderLayout());
        dlg.set.add("North", new Label("Test"));
        .
        .
        .
        dlg.setSize(200, 150);
        dlg.setLocation(--------);
        dlg.setVisible(true);          // 이것은 항상 마지막 라인에 적어 주어야 한다.

6. Event
    - 상당히 중요한 부분임
    - 이벤트 중심의 프로그램 : 내가 어떠한 행동을 했을 때 그 결과가 바로 나타나는 프로그램
                               내가 어떠한 행동을 했을 때 그 응답이 즉시 나타나는 프로그램
    - 우리는 7가지 이벤트만 배울 것이다. 나머지는 이것을 토대로 공부를 해야함.

  6.1  Event type           -> 자주 이용하는 Component
    1) Window               -> Frame, Dialog
    2) Action               -> Button, List, TextField, MenuItem
    3) Mouse - Mouse        -> Botton, 대부분의 Component, Frame, Dialog
             - MouseMotion  -> Frame, Dialog
    4) Focus                -> TextField, 대부분의 component, Frame, Dialog
    5) Item                 -> List, Checkbox, Choice, CheckboxMenuItem
    6) Key                  -> TextField, TextArea

  6.2 Event 추가 / 삭제
    1) 추가 : 대상객체, add(Event type)Listener(실행객체);
    2) 삭제 : 대상객체, remove(Event type)Listener(실행객체);

  6.3 실행 객체 정의 법
    1) Adapter 상속     -> Ex0120_04.java 참조
    2) Listener 구현    -> Interface 상속이므로, 모든 abstract method를 모두 재정의 해주어야 한다.
                        -> 그러나 다중 상속이 가능하므로, 여러가지 이벤트를 정의해서 사용 할 수 있다.
                        -> 클래스의 수를 줄일 수 있다.
    3) Frame 클래스에 Listener 구현
    4) 익명 Inner 클래스 사용.

  6.4 Awt 실행객체 종류
    1) Method 가 1개 존재하면 Listener만 존재
    2) 나머지는 Listener와 Adapter type 존재

  6.5 접근자 및 결과형 리턴값 : public void

  6.6 매개변수 : type Event
    -> 예외) Mouse          --> MouseEvent
             MouseMotion    --> MouseEvent

7. Event 정리
  7.1 실재로 이벤트는 무수히 많다.
    - java.awt.event.*;        // * 는 폴더는 불러 오지 못하므로 따로 import시켜야 한다.
    - java.awt.event.*; 여기에 무수한 이벤트를 포함하고 있다.

  7.2 어떤 컴포넌트에 어떤 이벤트를 사용할 수 있는지 알아보는 방법.
      - Window 이벤트를 가지고 할수 있는 일  7가지
      - java doc -> java.awt.event -> interface -> Window Listener -> Method Summary 에 나와 있음.
    1) Closing  -> x 버튼을 눌렀을 때 이벤트 처리 할수 있다.
    2) Open 할때
    3) Close
    4) Iconified     -> 아이콘화 시킬 때
    5) Deiconified
    6) Activated     -> 창을 활성화 시킬 때
    7) Deactivated   -> 창을 비활성화 시킬 때

      - 다른 이벤트들도 위와 같이 찾아서 사용할 수 잇다.
      - 여기서 다루는 메소드는 알아 두는 것이 좋다.
        접근자 및 결과형 리턴값은 public void 이고, 매개변수 typeEvent : 해당 타입의 이름이 소문자로 적혀 있다.

  7.2 Event를 처리하는 클래스는 두가지 종류가 있다.
    - Listener와 Adapter 는 거의 똑같다.
    - 차이점이 있다면   Adapter : 클래스(단일 상속) 이고,
    - Listener : Interface 이다.(다중 상속이 가능하다.)

//---------------------------------------------------------------------------//
// 수업중 소스
// Ex0120_01.java : FileDialog 예제
import java.awt.*;

class Ex0120_01_Sub extends Frame{
  private MenuBar mb = new MenuBar();
    private Menu file = new Menu("파일");
    private Menu option = new Menu("욥션");
    private MenuItem mnew = new MenuItem("New");
    private MenuItem mopen = new MenuItem("Open");
    private MenuItem msave = new MenuItem("Save");
    private MenuItem mexit = new MenuItem("Exit");
    private Menu msize = new Menu("크기");
    private Menu mcolor = new Menu("색상");
    private CheckboxMenuItem tw = new CheckboxMenuItem("12", true);
    private CheckboxMenuItem tf = new CheckboxMenuItem("24");
    private CheckboxMenuItem ts = new CheckboxMenuItem("34");
    private CheckboxMenuItem mred = new CheckboxMenuItem("Red");
    private CheckboxMenuItem mgreen = new CheckboxMenuItem("Green", true);
    private CheckboxMenuItem mblue = new CheckboxMenuItem("Blue");
    private FileDialog fd = new FileDialog(this, "내꺼열기", FileDialog.SAVE);

    Ex0120_01_Sub(String str) {
      super(str);
      this.setMenuBar(mb);
      init();
      this.setSize(300,200);

      Toolkit tk = Toolkit.getDefaultToolkit();      //화면의 정중앙에 배치 시키기
      Dimension di = tk.getScreenSize();  // 폭과 높이를 얻어 온다.
      Dimension di1 = this.getSize();    //프레임의 높이를 얻어 온다
      int xx = (int)(di.getWidth() / 2 - di1.getWidth() / 2);    //화면의 전체폭 나누기 2
      int yy = (int)(di.getHeight() / 2 - di1.getHeight() / 2);
      this.setLocation(xx, yy);

        this.setVisible(true);
        fd.setVisible(true);

    }

    public void init() {
        mb.add(file);
        mb.add(option);
        file.add(mnew);
        file.addSeparator();
        file.add(mopen);
        file.add(msave);
        file.addSeparator();
        file.add(mexit);

        option.add(msize);
        option.addSeparator();
        option.add(mcolor);
        msize.add(tw);
        msize.add(tf);
        msize.add(ts);
        mcolor.add(mred);
        mcolor.add(mgreen);
        mcolor.add(mblue);
    }
}

public class Ex0120_01 {
    public static void main(String [] ar) {
      Ex0120_01_Sub e1s = new Ex0120_01_Sub("메뉴바");
    }
}

//---------------------------------------------------------------------------//
// Ex0120_02.java : Dialog 예제
import java.awt.*;
class Ex0120_02_Sub extends Frame {
    private Dialog dlg = new Dialog(this, "경고", false);
    private Label dlglb = new Label("경고가 발생했습니다.", Label.CENTER);
    private Button dlgbt = new Button("확인");
    public Ex0120_02_Sub() {
        super("Test");
        this.init();
        this.setSize(300, 200);
        dlg.setVisible(true);
        Toolkit.getDefaultToolkit().beep();
        this.setVisible(true);
    }
    public void init() {
        this.initMenu();
        this.initDlg();
    }
    public void initMenu() {

    }
    public void initDlg() {
        dlg.setLayout(new BorderLayout());
        dlg.add("Center", dlglb);
        Panel p = new Panel(new FlowLayout());
        p.add(dlgbt);
        dlg.add("South", p);
        dlg.setSize(200, 120);
    }
}

public class Ex0120_02 {
    public static void main(String[] ar) {
        Ex0120_02_Sub es = new Ex0120_02_Sub();
    }
}

//---------------------------------------------------------------------------//
// Ex0120_03.java : Adapter를 이용한 Event 처리
import java.awt.*;
import java.awt.event.*;

class Ex0120_03_Sub extends Frame{
    Button bt = new Button("확인");
    Ex0120_03_Sub(String str) {
        super();
        setLayout(new FlowLayout(FlowLayout.CENTER));
        setSize(200,150);
        init();
        start();
        setVisible(true);
    }
    public void init() {
        this.add(bt);
    }
    public void start() {
        A ap = new A();
        bt.addMouseListener(ap);
    }
}

public class Ex0120_03 {
    public static void main(String [] ar) {
        Ex0120_03_Sub e3s = new Ex0120_03_Sub("Text");
    }
}

class A extends MouseAdapter {
    public void mousePressed(MouseEvent e) {
      System.exit(0);
    }
}

//---------------------------------------------------------------------------//
// Ex0120_03.java : WindowAdapter를 이용한 Event 처리
import java.awt.*;
import java.awt.event.*;
class Ex0120_03_Sub extends Frame {
    public Ex0120_03_Sub() {
        super("Test");
        this.init();
        this.start();
        this.setSize(300, 200);
        this.setVisible(true);
    }
    public void init() {

    }
    public void start() {
        A ap = new A();
        this.addWindowListener( ap );
    }
}
public class Ex0120_03 {
    public static void main(String[] ar) {
        Ex0120_03_Sub es = new Ex0120_03_Sub();
    }
}

class A extends WindowAdapter {
    public void windowOpened(WindowEvent e) {
        System.out.println("Window 열림!!");
    }
    public void windowIconified(WindowEvent e) {
        System.out.println("Window 아이콘화!!");
    }
}

//---------------------------------------------------------------------------//
// Ex0120_04.java : WindowAdapter를 이용한 Event 처리
import java.awt.*;
import java.awt.event.*;
class Ex0120_04_Sub extends Frame{
    private Button bt = new Button("확인");
    public Ex0120_04_Sub(){
        super("Test");
        this.init();
        this.start();
        this.setSize(300, 200);
        this.setVisible(true);
    }
    public void init(){
        this.setLayout(new FlowLayout());
        this.add(bt);
    }
    public void start(){
        A ap = new A();
        bt.addMouseListener( ap );
        this.addWindowListener( ap);
    }
}
public class Ex0120_04 {
    public static void main(String[] ar){
        Ex0120_04_Sub es = new Ex0120_04_Sub();
    }
}

class A implements MouseListener, WindowListener{
    public void mouseEntered(MouseEvent e){
        System.exit(0);
    }
    public void mouseClicked(MouseEvent e){}
    public void mouseReleased(MouseEvent e){}
    public void mousePressed(MouseEvent e){}
    public void mouseExited(MouseEvent e){}
    public void windowClosing(WindowEvent e){
        System.exit(0);
    }
    public void windowOpened(WindowEvent e) { }
    public void windowIconified(WindowEvent e) { }
    public void windowDeiconified(WindowEvent e) { }
    public void windowDeactivated(WindowEvent e) { }
    public void windowClosed(WindowEvent e) { }
    public void windowActivated(WindowEvent e) { }
}

//---------------------------------------------------------------------------//

과제 1. 입력한 글을 System.out.println으로 출력하세요.

과제 2. 주민등록번호 6자리를 입력하면 자동으로 뒤의 TextField로 넘어가도록 프로그램하세요.

과제 3. 셀렉트 박스를 변경시 변경된 값을 System.out.println으로 출력하세요.

과제 4. 리스트 박스 선택 시 선택된 값을 화면에 출력하세요.

과제 5. 생년월일을 입력 후 확인 버튼을 클릭하면 해당 일자를 화면에 출력하세요.

과제 6. 확인 버튼과 취소버튼을 클릭시 해당 정보를 화면에 출력하세요.

과제 7. 마우스가 "나잡아봐라" 위로 이동시 해당 텍스트가 도망다니도록 프로그램하세요

- [Java 기본] AWT - Panel, Label, Button, Checkbox, Choice, List, TextField, TextArea

겨울에 — Sat, 14 May 2011 16:04:54 +0900

출처 : http://cafe.naver.com/litave/377

ho0116.zip

- [Java 기본]AWT, FlowLayout, GridLayout, BorderLayout

겨울에 — Sat, 14 May 2011 16:01:43 +0900

출처 : http://cafe.naver.com/litave/376

ho0115.zip

//===========================================================================//
본 내용은 2002년 제가 Java 강의를 수강하며 정리 했던 내용을
    기본으로 하여 정리하였습니다.
  - 마침 java 기초를 전파할 기회가 생겨 핑계김에 정리해 가려 합니다.
작성자 : litwave
//---------------------------------------------------------------------------//

<목차>
1. AWT
2. 기본 Window 생성
3. Component
4. FlowLayout, GridLayout, BorderLayout

<<참고>> 설명보다는 예제를 실행해 보세요.

//---------------------------------------------------------------------------//

1. Awt(Abstract Window Toolkit)
  1.1 Component(공통적인 부분들을 가지고 있다.)
      - 전부 사각형으로 되어 자신만의 영역을 가지고 있다.
         -> 오늘 과제 1: Component 메소드들 한번 훌터 보기
    a) Frame
        - 사각형 테두리로서 X버튼과 화면 크게 하기 줄이기 버튼이 있는 것.
        - 일반 창
    b) Label
    c) Button
    d) Checkbox
    e) CheckboxGroup
    f) Choice
    g) List
    h) TextField
    i) TextArea
    j) MenuBar
    k) Menu
    l) MenuItem
    m) CheckboxMenuItem
    n) Dialog
    o) FileDialog

  1.2 Layout Manager   // 화면의 분할을 담당하는 Layout이다.
    a) FlowLayout
    b) GridLayout
    c) BorderLayout
    d) CardLayout
    e) GridBagLayout    // 가장 중요하고 많이 사용하는 것.

  1.3 Util
    a) Color    // 256*256*256 만큼의 색상 표현 가능
    b) Cursor
    c) Dimension     // 크기(폭,높이)를 관리하는 클래스
    d) Toolkit       // 시스템과 관련된 정보를 얻어낼 수 있는 abstract 클래스
    e) Image
    f) Font
    g) Panel   // 매우 중요
    h) ScrollPane

  1) 위의 모든 클래스는 java.awt package 에 속해 있는 클래스들 이다.
  2) 상속 : 위 클래스 들의 상속 관계
    Object -> Conponent -> Container -> Window -> Frame
                   |
                    -> 모든 Components
  3) 위의 클래스는 java 1.2 이전의 버젼에서 나왔던 클래스들 이고, 그 이후에 나온 것은 javax.swing 이다.
     Frame 위의 모든 클래스 내용을 담을 수 있고, 사용할 수 있다.

  4) Java언어는 GUI를 처리하기 위해 만들었다가 Console부분은 나중에 추가 시켰다.
     그래서 Java언어는 GUI에 강한 언어이다.
     자바는 클라이언트 측면의 프로그램과 서버전용의 프로그램으로 구분 할 수 있다.
     우리는 클라이언트 측면의 프로그램을 배울 것이다.

2. GUI를 만드는 방법
  1) 객체를 이용한 Frame 을 만드는 방법
    a) import java.awt.*;   //import를 시켜야 한다.
    b) 객체를 발생 시켜야 한다.
      Frame f = new Frame();       //빈 Frame를 만든 것과 똑같다.
    c) 화면에 보여 주십시오 하는 메소드를 찾는다.
      setVisible(), view()
      f.setVisible(true); 화면에 보여 준다.


    d) Ex0115_01.java 참조

  2) Frame 상속에 의한 방법
    a) import java.awt.*;   //import를 시켜야 한다.
    b) sub클래스를 만든다.
      class Ex0115_02_Sub extends Frame {

      }  // 내용이 아무 것도 없으면.. Frame와 Ex0115_02_Sub 클래스는 똑같다. // 그대로 상속 받았으므로

      public class Ex0115_02 {
        public static void main(String [] args) {
          Ex0115_2_Sub es = new Ex0115_02_Sub();  // 위의 Frame f = new Frame();와 동일 하다.
        }    // 한줄만 만들고, 나머지 내용은 Sub 클래스에 넣어서 하나의 모듈을 만들겠다는 의미이다.
      }

    c) Ex0115_02.java 참조.

3. Component
  3.1 Frame
    - 다른 컨퍼넌트를 얹어서 사용할 수 있는 장소이다.

      * Component 추가/삭제
      1) 추가 : 프레임객체.add(추가될 객체);
                프레임객체.add(위치, 추가될 객체);
                프레임객체.add(추가될객체, 위치);
      2) 삭제 : 프레임객체.remove(삭제될객체);
                    ^this   ^행동
  3.2 Label
      - 생성자 : Label lb = new Label();    //default 생성자 조그만 사각형
                 Label lb1 = new Label("Test");      // 디폴트로 왼쪽 치우침이 되어 있다.
                 Label lb2 = new Label("Test", Label.LEFT);       //자신만의 영역에 위치 지정 가능 RIGHT, LEFT, CENTER

//---------------------------------------------------------------------------//

4. 레이아웃 메니져를 이용한 화면 구성
  - 하나의 프레임이나 하나의 영역에는 하나의 레이아웃만 적용이 가능하다.
  - Ex0115_03.java 참조

  4.1 FlowLayout 메니져
    1) 생성자
      FlowLayout flow = new FlowLayout();
      FlowLayout flow = new FlowLayout(FlowLay.(RIGHT,CENTER,LEFT));    // default로 FlowLay.CENTER로 되어 있다.

     특징) 콤포넌트들의 크기를 default의 형태로 나타내 줄 수 있는 Layout이다.
           컴포넌트들의 위치가 지정되어 있지 않다. 정렬의 위치를 바꿀 수 있다.


     설정) this.setLayout(flow);        //플로우로 현재 프레임을 지정

  4.2 GridLayout
    1) 생성자
      GridLayout gl = new GridLayout();
                    = new GridLayout(int, int);   //행과 열을 지정 가능
                    = new GridLayout(int, int, int, int); // (행, 열, x축의 방향의 사이간격, y축 방향의 삽입 간격)

      주의사항 : 한영역에는 하나의 컴포넌트만 삽입이 가능하다.
                 행열을 (3,2)로 지정하면 현재 프레임의 높이 를 삼등분하고, 너비는 2등분하고,
                 똑같이 된다. 그리고 6개의 컴포넌트를 집어 넣을 수 있다.
                 그리고 들어가는 순서는 가로를 먼저 채우고 순서가 정해 진다.
                 그리고 들어간 컴포넌트는 들어간 위치 전체를 전부 자신의 영역으로 차지하게 된다.

  4.3 Border Layout
    1) 생성자
      BorderLayout border = new BorderLayout();
      BorderLayout border = new BorderLayout(int, int);  //(x축 사이의 간격, y축 사이의 간격)

    2) 방향 표시의 형태로 분할이 되어있다.
              North

   West       Center         East

              South
    3) add만 시키면.. Center에만 추가 시키도록 되어 있다.
      a) 위치를 지정해서 위치를 지정해서 삽입하는 방법을 사용한다.
         this.add("North",lb);
         this.add("West",lb2);
         this.add("South",lb1);
         -> 대소문자 주의해야 한다.
      b) this.add(lb, Border.NORTH); // 과 형태로 지정하는 방법도 있다.

//---------------------------------------------------------------------------//
// Ex0115_01.java
import java.awt.*;

public class Ex0115_01 {
    public static void main(String [] ar) {
      Frame f = new Frame();

        f.setSize(300,200); //300 * 200 size로 프래임의 크기를 지정해서 뛰운다.
        f.setVisible(true);
    }
}

//---------------------------------------------------------------------------//
// Ex0115_02.java : null Layout
import java.awt.*;

class Ex0115_02_Sub extends Frame {
    private Label lb = new Label();
    private Label lb1 = new Label("Text1");
    private Label lb2 = new Label("Test2", Label.CENTER);
    private Color cc = new Color(0,0,128); // Color cc = new Color(red, green, blue); 로 재정의 해서 사용할 수 있다.
    private Font f    = new Font("Sans-Serif", Font.BOLD, 15);     //Font("글자체",글자style(Font.BOLD, Font.ITALIC, Font.PLAIN), 글짜크기);

    public Ex0115_02_Sub(String str) {
        super(str);           // new Frame("Title"); 하면 자동으로 this.setTitle("Title"); 로 전달 된다.

        // this는 현재 프레임을 의미 한다.
        this.setLayout(null);    // default Layout 는 Board Layout이다. 이것을 null Layout로 셋팅을 하겠다.
        this.setBackground(cc);  // 배경색을 지정하겠다.(Color 클래스의 객체가 들어가야 한다.
        this.init();   //폼구성 Method
        this.setLocation(300, 250); // 좌표를 고정시키고 싶다.
        this.setResizable(false);// Size(크기)를 변환 못시키게 하겠다.
        //this.setTitle("Test"); // 타이틀을 변경하고 싶다.
        this.setSize(300,200);  //300 * 200 size로 프래임의 크기를 지정해서 뛰운다.
        this.setVisible(true);  //종료시키려면 DOS는 Ctrl+c 이고..
                                //setVisible은 항상 마지막에 와야 한다.
    }
    public void init() {  // 폼구성 메쏘드
                          //컴포넌트를 프레임에 올려 놓는 작업은 여기서 실행
        lb.setBounds(50, 50, 50, 50);
        lb1.setBounds(50, 120, 50, 50);    // setBounds(위치, 위치, 폭, 높이);
        lb2.setBounds(120, 50, 50, 50);
        lb.setBackground(Color.gray);      //버튼 배경색.. 지정
        lb1.setBackground(Color.green);
        lb2.setBackground(new Color(255,255,255));
        lb1.setForeground(Color.yellow);   //글자색 지정

        lb2.setFont(f);    //폰트지정
        lb1.setFont(f);

        this.add(lb);
        this.add(lb1);
        this.add(lb2);
    }
}

public class Ex0115_02 {
  public static void main(String [] ar) {
      Ex0115_02_Sub es = new Ex0115_02_Sub("Title");
    }
}

//---------------------------------------------------------------------------//
// Ex0115_03.java : BorderLayout 연습
import java.awt.*;

class Ex0115_03_Sub extends Frame {
  private Label lb = new Label();
    private Label lb1 = new Label("Text1");
    private Label lb2 = new Label("Test2", Label.CENTER);
    private Color cc = new Color(0,0,128); // Color cc = new Color(red, green, blue); 로 재정의 해서 사용할 수 있다.
    private Font f    = new Font("Sans-Serif", Font.BOLD, 15);     //Font("글자체",글자style(Font.BOLD, Font.ITALIC, Font.PLAIN), 글짜크기);
//    private FlowLayout flow = new FlowLayout();            //FlowLayout로 레이아웃 바꾸기
//    private GridLayout grid = new GridLayout(3, 1, 5, 5); //GridLayout 레이아웃으로 바꾸기
    private BorderLayout border = new BorderLayout(5,5);

    public Ex0115_03_Sub(String str) {
        super(str);

        //this.setLayout(flow);      //FlowLayout 레이아웃 적용
        //this.setLayout(grid);        //GridLayout로 레이아웃 적용
        this.setLayout(border);

        this.setBackground(cc);  //배경색을 지정하겠다.(Color 클래스의 객체가 들어가야 한다.
        this.init();   //폼구성 Method
        this.setLocation(300, 250); // 좌표를 고정시키고 싶다.
        this.setResizable(true);// Size(크기)를 변환 못시키게 하겠다.
        //this.setTitle("Test"); // 타이틀을 변경하고 싶다.
        this.setSize(300,200);  //300 * 200 size로 프래임의 크기를 지정해서 뛰운다.
        this.setVisible(true);  //종료시키려면.. DOS는 Ctrl+c 이고..
                                //setVisible은 항상 마지막에 와야 한다.
    }

    public void init() {  // 폼구성 메쏘드
                          //컴포넌트를 프레임에 올려 놓는 작업은 여기서 실행
        lb.setBackground(Color.gray);      //버튼 배경색.. 지정
        lb1.setBackground(Color.green);
        lb2.setBackground(new Color(255,255,255));
        lb1.setForeground(Color.yellow);   //글자색 지정

        lb2.setFont(f);    //폰트지정
        lb1.setFont(f);

//    this.add("North", lb);     // BorderLayout 에서 위치 지정해서 레이아웃 하기...
//    this.add("South", lb1);
//    this.add("West", lb2);

        this.add(lb, BorderLayout.NORTH);     // BorderLayout 에서 위치 지정해서 레이아웃 하기...
        this.add(lb1, BorderLayout.SOUTH);
        this.add(lb2, BorderLayout.WEST);
    }

}

public class Ex0115_03 {
    public static void main(String [] ar) {
      Ex0115_03_Sub es = new Ex0115_03_Sub("Title");
    }
}

//---------------------------------------------------------------------------//
// Ex0115_04.java : Grid Layout 연습
import java.awt.*;

class Ex0115_04_Sub extends Frame {
    private Color cc = new Color(0,0,128); // Color cc = new Color(red, green, blue); 로 재정의 해서 사용할 수 있다.
    private GridLayout grid = new GridLayout(4, 3, 5, 5);  //GridLayout 레이아웃으로 바꾸기
    private Button[] bt = new Button[12];
    private String[] btname = new String[]{"*", "0", "#"};

    public Ex0115_04_Sub(String str) {
        super(str);

        this.setLayout(grid);
        this.setBackground(cc);  //배경색을 지정하겠다.(Color 클래스의 객체가 들어가야 한다.
        this.init();   //폼구성 Method
        this.setLocation(300, 250); // 좌표를 고정시키고 싶다.
        this.setResizable(true);// Size(크기)를 변환 못시키게 하겠다.
        //this.setTitle("Test"); // 타이틀을 변경하고 싶다.
        this.setSize(300,200);  //300 * 200 size로 프래임의 크기를 지정해서 뛰운다.
        this.setVisible(true);  //종료시키려면.. DOS는 Ctrl+c 이고..
                                //setVisible은 항상 마지막에 와야 한다.
    }
    public void init() {  // 폼구성 메쏘드
                          //컴포넌트를 프레임에 올려 놓는 작업은 여기서 실행
        for(int i=0; i < bt.length; i++) {
            if(i < 9) {
              bt[i] = new Button(String.valueOf(i+1));
            } else {
              bt[i] = new Button(String.valueOf(btname[i-9]));
            }
        }

        for(int i=0; i<bt.length; i++) {
            this.add(bt[i]);
        }
    }
}

public class Ex0115_04 {
    public static void main(String [] ar) {
        Ex0115_04_Sub es = new Ex0115_04_Sub("전화기");
    }
}

//===========================================================================//
// 과제 아래의 그림과 같이 만드세요.

- [Java 기본]프로세스와 쓰레드

겨울에 — Sat, 14 May 2011 15:58:31 +0900

출처 : http://cafe.naver.com/litave/375

process_&_thread.doc

- [Java 기본]다형성, Abstract, Interface, Inner Class

겨울에 — Sat, 14 May 2011 15:56:56 +0900

출처 : http://cafe.naver.com/litave/373

ex0920.zip

//===========================================================================//
본 내용은 2002년 제가 Java 강의를 수강하며 정리 했던 내용을
    기본으로 하여 정리하였습니다.
  - 마침 java 기초를 전파할 기회가 생겨 핑계김에 정리해 가려 합니다.
작성자 : litwave
//---------------------------------------------------------------------------//

<목차>
1. 다형성
2. Abstract(상속)
3. Interface
4. Inner Class

//---------------------------------------------------------------------------//

1. 다형성 : 부모의 이름으로 자식을 컨트롤 하겠다.

  1.1 Overridng(재정의)
    1) 부모의 이름으로 자식의 메소드를 컨트롤 할 수 있지만, 멤버 Field는 컨트롤 할수 없다.
    2) 그중에서도 overriding 된 메소드만 컨트롤 할 수 있다.

    3) Sample Program
        class A {
          int x = 100;
          void view() {
            System.out.println(x);
          }
        }

        class B extends A {
          int x = 200;
          void view() {
            System.out.println(x);
          }
        }

        public class Sample
            {
            public static void main(String[] args) {
                A bp = new B();
                System.out.println(bp.x);   // 부모 A의 값을 출력하므로 100 출력
                bp.view();                  // 자식 B의 메소드가 호출되어 200 출력
            }
        }

  1.2 다형성의 개념
      - 다형성 : 형태가 많이 존재한다.

    1) 자식의 값을 부모에게 대입 시켜서 자식의 부분을 부모의 이름으로 사용하자는 개념
      a) 메소드가 overriding이 되어 있으면 자식 것을 먼저 실행 한다.
      b) 변수는 절대 자식의 것을 컨트롤 할 수 없다.
      c) overriding되지 않은 메소드는 컨트롤 할 수 없다.
      d) overriding된 메소드는 부모의 메소트 처럼 사용하면 된다.
        -> 모두 부모의 메소드처럼 처리하고, overriding 된 메소드만 자식의 메소드를 사용할 수 있다고 생각하면 쉽다.

      특징) 객체를 부모이름으로 만들고, 자식의 이름을 대입해서 사용하는 것.

    2) 우리가 상속 관계의 클래스를 만들었다고 가정하자.

                       Company 클래스
                       멤버   : String name
                                int age
                                void view() { }
        상속 받음
               전산부       자재부       인사부         총무부
            String          int year        .             .
            String work        .            .             .
            void view() {

            }

        정보를 출력하는 view메소드를 각 부서마다 모두 만들고,

        각 부서의 정보를 보고자 한다면
        전산부 a = new 전산부();
         a.view();
        자재부 b = new 자재부();
         b.view();
        .
        .
        .
        와 같이 부서가 늘어날 수록 코딩이 복잡해 진다.

        이것을 해결하기 위한 방안으로 나온 것이 다형성의 overriding이다.
        Comp[] cp = new Comp[4];
        cp[0] = new 전산부();
        cp[1] = new 자재부();
        cp[2] = new 인사부();
        cp[3] = new 총부부();
        for(int i=0; i<cp.length; i++) {
          cp[i].view();
        }

//---------------------------------------------------------------------------//

2. Abstract(추상 = virtual(순수에 가까운)과 유사하다.)
    - 메소드와 클래스 지정어로 사용할 수 있다.

  2.1 Method -> abstract
    1) 형식) 접근자 abstract [다른지정어] 결과형 리턴값 Method명(매개들) 예외전가;
                   -> ;(세미콜론)으로 끝난다는 특징이 있다.
      -> 정의부(메소드 내용)를 가지지 않는 Method 이다.

    2) 사용용도(목적) : 디자인된 메소드를 만들때 사용한다.
      abstract 를 생략해도 끝에 ;를 찍으면 자바 컴파일러가 자동으로 abstract 라고 인식한다.
      -> 다형성에서 사용한 개념에서 view() {}를 부모 노드에 정의하여 overriding

  2.2 Abstract 클래스 특징
    1) 클래스 -> 단일 상속만 가능하다.
    2) 객체를 발생 시킬 수 없는 객체이다.
      ex) abstract class A { }
        A ap = new A();    // new A()부분 에러 발생

      ex2) abstract Method 를 포함하는 클래스도 자동으로 abstract 클래스로 인식 된다.
        class A {
            abstract void aaa();
        }

        A ap = new A();    // 사용 시 new A() 부분 에러 발생

   3) 포함멤버 : Constructor, Method, Field, abstract Method

   4) 사용형태 : 하위로 상속 시킨 다음 만약 abstract Method 가 존재하면 overriding 해야함
     ex) abstract class A { }
         class B extends A{ }
            A ap = new A();     // 안된다.
            A ap = new B();     // 잘 된다.
            B bp = new B();     // 잘 된다.

     ex) abstract class A { abstract void aaa(); }    // 형태로 되어 있다면
         class B extends A{ void aaa() { }}   // 와 같이 재정의를 해서 사용해야 한다.

   5) 디자인 + 효율성

//---------------------------------------------------------------------------//

3. Interface
  3.1 Interface의 특징
    1) 클래스 -> 다중 상속
    2) 객체를 발생 할 수 없는 클래스 이다.
        ex) interfatc A{ }
            A ap = new A();   // new A()에서 에러 발생

    3) 포함 멤버 : 단 두가지 밖에 없다.
      a) Field : public static final 자료형 변수명 = 값    // 무조건 이 종류만 포함 할 수 있다.
        ex)
            interface A {
                int x = 10;     //public static final가 생략되어 있는 형태이다.
            }
        A.x 와 같이 클래스명으로의 접근이 가능하다.(static이 생략된 형태이므로)

      b) Method : public abstract 결과형리턴값 Method명(매개변수) 예외전가;  //abstract Method만 포함을 시킬 수 있다.
        interface A {
            int x = 80;      //public static final 생략된 형태
            void aaa();      //public abstract가 생략된 형태
        }

    4) 하위클래스로 상속 시킨다음 존재하는 MEthod 모두를 overriding 해야함
        ex)
            interface A { }    A ap = new A() // 사용 안됨

            interface B extends A { }    B bp = new B() // 사용 안됨
            class C implements B { }
            A ap = new C();    //사용 가능
            B bp = new C();    //사용 가능
            C cp = new C();    //사용 가능

            // 상위에 메소드가 존재하면 overriding이 있어야 한다.

            5) 순수 디자인 목적으로 사용

//---------------------------------------------------------------------------//
질문
   ex) Abstract
    abstract class A {
        int x = 10;
        A(int x) {
            this.x = x;
        }
        abstract void view();
    }

    class B extends A {
        int x = 20;
        B(int x, int x1) {
            super(x);
            this.x = x;
        }
        void view() {      // view1()이나 int view(), view(int x)라고 하면 overriding 되어있지 않으으므로 A bp = new B(); 에서 에러가 발생한다. abstract 정의를 필요로 한다는 에러 메세지 출력됨.
            System.......(super.x);
            System.......(this.x);
        }
    }

    A ap = new A();     // 안됨 -> abstract 클래스이므로...
    A bp = new B();     // 실행 가능
    System.out.println(bp.x);      // 10출력

    abstract 메소드를 재정의 하지 않으면.. 에러메세지를 발생한다.

ex) interface
    interface A {
        int x = 100;
        void view();
    }
    class B implements A {
        int x = 200;
        //B(int x, int x1) {
        // super(x); //인터페이스는 생성자를 가질 수 없으므로 에러가 발생한다. super가 올수가 없다.
        B(int x) {
            this.x = x;
        }
        public void view() {      // void view() 로 사용하면 에러 발생 -> 클래스 A의 view()는 .. public abstract 가 생략되어 있기 때문이다.
            System.out.println(super.x);
            System.out.println(this.x);
        }
    }

    A ap = new A(); // 사용 안됨
    System.out.println(A.x);    // 100출력
    A.view();
    A ap = new B();
    B bp = new B();
    System.out.println(B.x);    // 200출력
    ap.view();                  // 두개 모두.. B의 view가 실행 된다.
    bp.view();

다이아 몬드 상속.. Ex0114_01로 만들 것임.

//---------------------------------------------------------------------------//
4. Inner 클래스
  4.1 중첩 클래스
    1) 사용 목적
      a) 접근상에 제약을 두기 위해서
      b) 클래스 이름의 충돌 방지
      c) static을 사용할 수 없다.

    2) 형식 : 일반 클래스가 가질 수 있는 것은 모두 가질 수 있고, 클래스 자체를 덩어리 통체로 포함 시킬 수 있다.
       밖의 클래스를 Outer클래스라 하고, 안쪽에 있는 것을 Inner라고 한다.

    class A {
        int ..
        A () { };
        class B {

        }
    }

      - 2개의 .class 파일이 생성 된다.
        -> 파일명 : A.class 와 A$B.class 두개의 파일이 생겨 난다.
      // 내부로 들어갈 수록 $표시가 붙는다.
      // 이름 끼리의 충돌을 방지 시킬 수 있다.

    class A {
        int x = 10;
        class B {
            int y = 20;
        }
    }

    -> y값을 출력 하기 위해서의 접근 방법
       A ap = new A();
       A.B bp = ap.new B();     // ap.B bp = ap.new B();로는 에러가 발생한다.
       System.out.println(bp.y);

    -> static을 사용하기위해서는 정적 중복 클래스로 만들면 된다.
    class A {
        int x = 10;
        static class B {
            int y = 20;
        }
    }
    A.B bp = new A.B();  // 정적 중첩 클래스는 객체의 이름으로 바로 만들어 사용할 수 있다.

    -> 다음과 같은 파일이 있을때..
    public class A {
        public static class B {
            public static void main(String [] ar) {
                System.out.println();
            }
        }
    }

    다음의 파일명은 -> A.java
    컴파일시 두개의 파일이 생김 A.class, A$B.class 파일이 생긴다.
    실행을 시킬 때는 java A$B 로 실행을 해야 실행이 된다.

  2. 정적 중첩 클래스

  3. 지역 중첩 클래스
    -> 현재는 거의 사용하지 않는 클래스

  4. 익명 중첩 클래스
    -> 지역 중첩클래스의 확장..
    -> 내일 배울 것이다.. awk event part에서 배우게 될 것이다.

과제.. 상속성과 다형성 공부해 올것..

//---------------------------------------------------------------------------//
// 수업중 소스
// Ex0114_1.java
class A {
  public String toString() {
      return "AAA";
    }
}

class B {
  public String toString() {
      return "BBB";
    }
}

class C {
  public String toString() {
      return "CCC";
    }
}

public class Ex0114_1 {
    public static void main(String [] ar) {
        A ap = new A();
        System.out.println(ap);
        B bp = new B();
        System.out.println(bp);
        C cp = new C();
        System.out.println(cp);

        Object[] ob = new Object[3];
        ob[0] = new A();
        ob[1] = new B();
        ob[2] = new C();

        for(int i=0; i < ob.length; i++)
            System.out.println(ob[i]);
    }

}

//---------------------------------------------------------------------------//
// FirstInter.java
public interface FirstInter {
    int red = 1;
    int green = 2;
    int blue = 3;
}

// FirstClass.java
public abstract class FirstClass implements FirstInter{
    private String str;
    public FirstClass(String str) {
        this.str = str;
    }
    public String getText(){
        return str;
    }
    public abstract void viewText();
}

// FirstInter.java
public interface SecondInter extends FirstInter{
    void viewColor();
}

// SecondClass.java
public class SecondClass extends FirstClass implements SecondInter {
    public SecondClass(String str) {
        super(str);
    }
    public void viewColor() {
        System.out.println("Red = " + red);
        System.out.println("Green = " + green);
        System.out.println("Bluew = " + blue);
    }
    public void viewText() {
        System.out.println("문자열 = " + getText());
    }
}

public class Ex0114_02 {
    public static void main(String[] ar){
        SecondClass sc = new SecondClass("Test");
        System.out.println(sc.red);
        System.out.println(sc.blue);
        System.out.println(sc.green);
        System.out.println(SecondClass.red);
        System.out.println(sc.getText());
        sc.viewColor();
        sc.viewText();


        /*
        FirstClass fc = new SecondClass("Test");
        System.out.println(fc.red);//FirstClass.red
        System.out.println(fc.green);//FirstClass.green
        System.out.println(fc.blue);//FirstClass.blue
        System.out.println(fc.getText());
        //fc.viewColor();
        fc.viewText();
        */


        /*SecondInter si = new SecondClass("Test");
        System.out.println(si.red);//SecondInter.red
        System.out.println(si.green);//SecondInter.green
        System.out.println(si.blue);//SecondInter.blue
        //System.out.println(si.getText());
        si.viewColor();
        //si.viewText();
        */


        /*FirstInter fi = new SecondClass("Test");
        System.out.println(fi.red);//FirstInter.red
        System.out.println(fi.blue);//FirstInter.blue
        System.out.println(fi.green);//FirstInter.green
        //System.out.println(fi.getText());
        //fi.viewColor();
        //fi.viewText();
        */
    }
}

//===========================================================================//

>>>>> 답글들

예전에 강사님께 말로 설명 들을때의 뉘앙스랑 노트의 뉘앙스가 사뭇 많이 달라서
오역할 수도 있을 것 같은데, 가능하면 샘플 위주로 해서 이론적인 것은 좋은 책의
좀 지루하더라도 체계적인 설명들을 볼 것을 추천합니다.

다형성의 활용적인 면에서 보자라면 클래스의 구성요소 중에서 메소드보다는 멤버
즉 데이터라는 면에서 많이 활용합니다.

파라미터를 넘기거나 받을 때에 메소드를 오버라이드 하거나 오버로딩 하기도 하지만
다형성을 이용하게되면 instanceOf 연산자 등을 통한 동적인 파라미터에 대한
동적인 비즈니스 처리를 할 수 있으니까요.

물론, 요즘은 XML 이나 기타 여러가지 방법들이 많이 등장해서 개발자들이 직접적으로
다형성을 쓰기보다는 기반이 되는 라이브러리나 API 등에서 보통 이런 기법들을 많이
활용해서 쓰고 있죠.

예를들어 sql 문장에 대한 쿼리 처리를 할때에 String 변수를 쓰는 사람도 있고,
StringBuffer 를 쓰는 사람도 있고, StringBuilder 를 쓰는 사람도 있습니다.

이런 케이스를 다 만족하는 처리를 하고자 할때에 메소드의 파라미터를
CharSequence 로 해주게 되면 구별없이 동일한 처리를 할 수도 있죠 ^^;

-------------------------------------------------------------------------------------------

글쎄.. 나도 다형성은 필요한 경우만 사용을해서리.. 개념적으로도 대충 잡고 있는 형태이고...
일반적으로 설계 단계에서 공통적인 부분을 인터페이스나 추상클래스로 정의 후에 구체적인 기능들을 구현하곤 하지요.
혹은 기존에 존재하는 라이브러리에 필요한 부분을 약간 첨가해서 제것에 맞게 사용할때도 간혹 사용하곤 합니다.
상속을 이용하는 가장 큰 이유는 모듈간의 약속을 정의할 수가 있다는것이 아닐까 생각합니다.
글자만을 이용해서 예를 들기가 만만치 않군요. A라는 클래스는 abc(B b)라는 메소드가 있고 B가 Interface라면, 그리고 abc 메소드에서 하는 역할이 b.makeEvent(event) 이렇게 메소드를 호출하는 역할을 한다면.. 저는 B를 상속받은 클래스를 만들고, 그것에 makeEvent 메소드를 구현하면 되겠지요.. abc 메소드에서 전달해 주는 event를 받아서 파일로 저장하건 DB로 저장하건, 화면으로 출력하건 이런건 저의 몫이구요.. 저는 그냥 A클래스에 abc메소드를 호출하며 제가 구현한 B 클래스를 던져주기만 함녀 되겠죠..

- [Java 기본]예외처리, 클래스 상속

겨울에 — Sat, 14 May 2011 15:54:39 +0900

출처 : http://cafe.naver.com/litave/366

ho0113.zip

//===========================================================================//
본 내용은 2002년 제가 Java 강의를 수강하며 정리 했던 내용을
    기본으로 하여 정리하였습니다.
  - 마침 java 기초를 전파할 기회가 생겨 핑계김에 정리해 가려 합니다.
작성자 : litwave
//---------------------------------------------------------------------------//

<목차>
1. 예외처리
2. 상속성

//---------------------------------------------------------------------------//

* 예외처리

o 예외처리를 배우는 목적
  1) 예외 발생 시 정상적인 종료를 위하여
  2) 예외 발생 시 대안적인 결과를 주기위하여
  3) 예외 발생 시 무시하고 계속 실행 시키기 위하여

o 예약어
  1) throw
  2) throws
  3) try ~ catch ~ finally

1. 예외의 개념 잡기
  1) 예외 처리기
    예제 -> Ex0113_01
    Su1과 Su2를 입력 받는다.
    a) 숫자를 받아야할 자리에 문자를 입력하면 NumberFormatException 이 발생한다.
        -> 사용자가 런타임시 발생할 수 있는 에러이다.
  *참고) 자바는 컴파일 에러와 런타임 Exception 으로 구분한다.

    b) 정수를 0으로 나눈 경우 ArithmeticException
     -> 실행 중에 발생한 것 사용자가 실행을 해 보아야 알 수 있는 것이다..
     -> 일단 실행을 해보아야 알수있는 에러들을 예외라고 한다.
     -> 에러 발생시 자바 프로그램은 비정상 종료를 하게 된다. 이런 것을 방지 하기 위하여 Exception을 처리 한다.

2. 예외 처리시 만나는 예약어
  1) throw : 예외 발생
    -> Client 에게 프로그램을 잘못 되었다는 것을 알려 줄때.
   사용 예)
     if(Su1 < 0) {    //특정 조건시 임의의 에러 출력 가능
       NumberFormatException nfe = new NumberFormatException("음수 입력하면 안된다.");
       throw nfe;
            //에러가 발생 한 사항을.. 던저 줄수도 있다.
     }

  2) throws : 예외 전가
   -> 예외를 전달 전달 시킨다.
   -> 하나의 Method에서 throws IOException 을 사용하면 그 Method를 사용하는 부분에서도 예외 전가를 시키기 위해서(throwsIOException) 혹은 try catch 를 사용해야 한다.

  3) try ~ catch ~ finally
          ^예외 처리기(catch:다섯가지 예약어 중에서 유일한 예외 처리기 이다.)

예외 처리
    a) try : 예외가 발생되리라 예상되는 지역을 블럭으로 묶어서 관리 하는 예약어
        -> 프로그래며는 사용자의 입장을 고려하여 예외 발생 예상 지역을 알아야 한다.
        사용예:
        try {
            예외 발생 예상 지역
        } catch(NumberFormatException nfe) {
            이부분에.. 예외 상황 발생시 처리할 프로그램 구문을 적어주면 된다.
        } catch(ArrayIndexOutOfBoundsException afe) {

        }

       -> 문제점 : 어떤한 경우에도 에러가 발생하지 않는 부분을 묶으면 프로그램 자체에서 에러가 발생한다.(적어도 한라인은 에러 발생 유발 지점이 포함되어 있어야 한다.)

       * 참고) 블럭안에서 선언된 변수는 블럭을 빠져 나가면 사라진다.(공통 사항)

    b) catch
        -> NumberFormatException 이 발생하면 이것을 잡아서(catch) 예외 발생시 담아 둘수 있는 공간이 필요하다.
        -> 그리고 그 다음 블럭에 다음 처리할 명령어를 적어 준다.
        -> 아무것도 적지 않으면 무시하고 그냥 넘어 간다.
        -> catch 는 여러번 적을 수도 있다.(발생할 수 있는 예상 에러 수 만큼) if ~ else 를 연상 하면 된다.

    c) finally 적지 않아도 되는 선택 사항이다.
        -> 에러가 발생하던 발생하지 않던 간에 무조건 실행하고 싶은 구문을 여기다 적어 준다.
        -> 무조건적으로 실행하는 구문 이다. break;나 return;문을 중간에 만나더라도 이것은 무조건 실행 한다.
           (단, System.exit(0); 는 프로세서가 아예 죽는 상황 이므로 이부분에서만 실행 되지 않는다.)

//---------------------------------------------------------------------------//

* 상속성

o 누군가가 임의의 클래스 A를 만들었다고 하자.
    class A {
        String name;
        int age;

        A() {
            name = null;
            age = 0;
        }

        A(String name, int age) {
            this.name = name;
            this.age = age;
        }

        void disp() {
            System.out.println(name);
            System.out.println(age);
        }

    }

    - 위의 클래스에서 전화번호 까지 관리하는 클래스를 만들고 싶다는 생각이 들었다..
    - 또 누군가는 주소까지 관리하는 클래스를 만들고 싶다는 생각을 하게 되었다.
    - 이렇게 동일한 기능을 가지는 클래스가 있는데도 계속해서 만들면 다른 사람이 만든 클래스는 의미가 없어 진다.
      그래서 이것을 간단히 사용하고 싶은 생각이 들었다.
      그래서 나온 것이 포함 오브젝트라는 개념이 나왔다.

    class B {
        A ap = new A();
        String tel;
        .
        .
    }

    class C {
      B bp = new B();
      String addr();
    }

    1) 포함 오브젝트를 사용하더라도
    2) 상위 클래스로 접근을 하기 위해서는 cp.addr, cp.bp.tel, cp.bp.ap.name 등으로 사용하게 되면,
     사용자가 너무 복잡 하게 되어서 나온 개념이 상속 성이다.
    3) 상속성은 상위 부모 클래스의 것을 그대로 받아서 사용해야 한다.

//---------------------------------------------------------------------------//

1. 상속성
  1) 형식
      접근자 지정어 class 클래스명 extends 상위클래스 {     }
    a) 일반 클래스와 동일 하지만 extends 를 사용해서 상위 클래스를 지정할 수 있다.
    b) Object 를 최상위 클래스로서 가진다.
    c) 자바의 클래스 상속은 Object 를 제외하고는 단일 상속만 가능하다.
    d) 상위 멤버를 지칭 할 때는 예약어로서 super 를 사용하고 하위 멤버를 지칭 할 때는 예약어로서 this 를 사용한다.
      * 참고) 상위의 상위 클래스를 나타 낼 때는 super.super 을 하면 된다.

    e) 생성자는 상속이 되지 않는다. -> 상위 클래스의 생성자는 super() 메소드를 사용할 수 있고.
                                    -> 하위 클래스의 생성자는 this() 메소드를 사용할 수 있다.

    f) private, public, package, protected 는 상속이 무조건 된다.(메모리 할당이 된다.)
       -> 디폴트 값을 가진다.
       -> 그러나 private 은 상속은 되지만 사용을 할 수 없다.
       -> 접근자의 역할은 멤버 Field 의 사용을 할 수 있는가? 없는가?를 나타내는 것이다.

  2) 기본적으로 모든 것을 상속한다는 개념으로 클래스를 만들어 보자
      class A {             // 하나의 점을 관리 할 수 있는 클래스
        protected int x;    //상속 관계에서는 사용할 수 있게 하기위해 protected를 사용 하였다.
        protected int y;
        public A() {
          x = y = 0;
        }
        public A(int i, int y) {
          this.x = x;
          this.y = y;
        }
        public void view() {
          System.out.println("x = " + this.x);
          System.out.println("y = " + this.y);
        }
      }

      class B extends A { //x, y, view
        private int x;
        private int y;
        public B() {
          x = y = 0;
        }
        public B(int x, int y, int x1, int y2) {
          super.x = x;      super.y = y;
          this.x = x1;      this.y = y1;
        }
        public void view() {
          System.out.println(super.x);
          System.out.println(super.y);
          System.out.println(this.x);
          System.out.println(this.y);
        }
      }

    // 하지만 대부분의 사람은 private를 사용한다.
      class A {             //하나의 점을 관리 할 수 있는 클래스
        private int x;
        private int y;
        public A() {
          x = y = 0;
        }
        public A(int i, int y) {
          this.x = x;
          this.y = y;
        }
        public void view() {
          System.out.println("x = " + this.x);
          System.out.println("y = " + this.y);
        }
      }


    // 누군가 이 클래스를 이용하여 사각형을 그리고 싶다.

      class B extends A { //x, y, view
        private int x;
        private int y;
        public B() {       //자바에서는 { (블럭의 시작)의 다음에 super(); 가 있다고 가정 하고 디폴트로 이것이 생성된다.
          x = y = 0;
        }
        //super메소드나 this메소드 모두 블럭의 시작 다음에 위치해야 하기 때문에 일반적으로 this메소드를 사용하지 않는다.
        //위의 특징으로 둘중 하나만 사용을 해야 한다.
        public B(int x, int y, int x1, int y2) {
          super(x, y);   //super.x = x;      super.y = y;
                         //이렇게 사용한다.
          this.x = x1;
          this.y = y1;
        }

        //같은 이름을 가지고 있을때는 super를 사용해야 한다.
        //super를 적지 않는 것은 기본적으로 this가 붙는다.
        public void view() {
          super.view();        // System.out.println(super.x);
                               // System.out.println(super.y);
          System.out.println(this.x);
          System.out.println(this.y);
        }
      }

// 상속 관계에서
// 메소드 이름이 같고 매개 변수가 다르면(갯수, 타입) -> overloading 이라고 하고

// 메소드 이름이 같고, 매개변수의 타입과 개수가 같은면 -> overriding(메소드 재정의)라고 한다.
// 이것은 this와 super를 사용해서 구분 해 주어야 한다.
// 상단부에 예외 전가가 있으면 무조건 예외 전가를 시켜 주어야 한다.

중요 채크 사항)
  a) 상단부의 접근자가 protected이면, 하단부의 재정의 접근자는 protected이거나, public일 수 있다.
  b) 상단부의 접근자가 package이면, 하단부의 재정의 접근자는 package이거나, public일 수 있다.
c) 상단부의 접근자가 public이면, 하단부는 public일 수 밖에 없다.

다이아몬드 그램..
1. 인터페이스는 클래스에 상속을 줄 수 있지만 클래스는 인터페이스에 상속을 줄 수 없다.
2. 클래스는 단일 상속만 가능하고, 인터페이스는 다중 상속을 할 수 있다.

//---------------------------------------------------------------------------//

오늘의 과제 :
** 그림 그리기 **
1. 원 그리기
2. 사각형 그리기
3. 그림 전체 보기
4. 종료
--->  1                  //무한적으로 돌면서 실행 되어야 한다.
x = 12
y = 12
r = 5
원이하나 저장되었습니다.

---> 2
x = 30
y = 20
w = 7
h = 10
사각형이 저장 되었습니다.

---> 3                        // 만들지 않아도 된다.
원 : 점좌표 x = 12, y = 12
     반지름 r = 5
사각형 : 점좌표 x = 30, y = 20
         폭 = 7, 높이 = 10

---> 4
종료

//---------------------------------------------------------------------------//
// 수업중 소스 : Ex0113_01.java
import java.io.*;
public class Ex0113_01 {
    public static void main(String[] ar) throws IOException{
        BufferedReader br = new BufferedReader(
                                new InputStreamReader(System.in));
        int su1, su2, tot;
        su1 = su2 = tot = 0;
        boolean err = false;

        do{
            System.out.print("Su1 = ");
            try {
                su1 = Integer.parseInt(br.readLine());
                err = false;
            } catch(NumberFormatException nfe) {
                System.out.println("ErrorMessage = " + nfe);
                System.out.println("숫자를 입력하셔야 합니다.");
                err = true;
            }
        } while(err);


        do{
            System.out.print("Su2 = ");
            try {
                su2 = Integer.parseInt(br.readLine());
                tot = su1 / su2;
                err = false;
            } catch(NumberFormatException nfe) {
                System.out.println("ErrorMessage = " + nfe);
                System.out.println("숫자를 입력하셔야 합니다.");
                err = true;
            } catch(ArithmeticException ae) {
                System.out.println("ErrorMessage = " + ae);
                System.out.println("정수연산에서 0으로 나누시면 안됩니다.");
                err = true;
            }
        } while(err);


        System.out.println("su1 / su2 = " + tot);

    }
}

//---------------------------------------------------------------------------//
// 수업중 소스 : Point1.java
import java.io.*;
public class Point1 {
    private int x;
    private int y;

    public Point1() throws IOException {
      System.out.print("x = ");
        x = System.in.read();
        if(System.in.read() == '\r') System.in.read();
      System.out.print("y = ");
        y = System.in.read();
        if(System.in.read() == '\r') System.in.read();
    }

    public Point1(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public void view() {
        System.out.println("x = " + this.x);
        System.out.println("y = " + this.y);
    }
}

// 수업중 소스 : Rect1.java
public class Rect1 extends Point1 {
    private int w;
    private int h;

    public Rect1() throws IOException {
//    super();
        System.out.print("w = ");
        w = System.in.read();
        if(System.in.read() == '\r') System.in.read();
        System.out.print("h = ");
        h = System.in.read();
        if(System.in.read() == '\r') System.in.read();
    }

    public Rect1(int x, int y, int w, int h) throws IOException {
        super.view();
        this.w = w;
        this.h = h;
    }

    public void view() {
        super.view();
        System.out.println("w = " + this.w);
        System.out.println("h = " + this.h);
    }
}

// 수업중 소스 : Circle1.java
import java.io.*;

class Circle1 extends Point1 {
    private int r;

    public Circle1() throws IOException {
      super();
        System.out.print("r = ");
        r = System.in.read();
        if(System.in.read() == '\r') System.in.read();
    }

    public Circle1(int x, int y, int r) throws IOException {
      super();
        this.r = r;
    }

    public void view() {
        super.view();
        System.out.println("r = " + this.r);
    }
}

//===========================================================================//

>>> 답글들

예외처리에 대해서 약간 첨언하자면...
Java Checked Exception은 java.lang.Exception을 상속한 Exception으로 컴파일 시점에 이 Exception을 try~catch 구문으로 처리하지 않는 경우 에러가 발생한다. 예를 들어 java.io.IOException이 대표적인 Checked Exception 이다.
Unchecked Exception은 java.lang.RuntimeException을 상속한 Exception으로 컴파일 시점에 try ~ catch 구문으로 처리하지 않아도 컴파일 에러가 발생하지 않는다. 예를 들어 java.lang.NullPointerException이 대표적인 Unchecked Exception이다.
참고자료) Spring 프레임워크 워크북 : 한빛미디어 87 페이지

-------------------------------------------------------------------------------------------------------

상속(inheritance)과 구성(composition)에 대해서
일반적으로 사용이 편한 상속을 주로 사용하지만, 패턴관련 책들을 읽다보면 구성을 활용하는 것이 더 나은 방향이라고들 합니다.
몇몇 이유가 있겠지만 생각나는 것은 상속을 사용할 경우 상위 클래스와의 종속 관계가 너무 강해지고, 하위 클래스에서 상위 클래스의 변경 여부를 체크해야 하지만,
구성을 이용할 경우 해당 클래스를 선언 후 사용하는 형태이므로, 자신이 사용하는 메소드에 대한 안정성만 보장 받으면되기 때문 이었던 것으로 기억납니다. ㅎㅎ..

-------------------------------------------------------------------------------------------------------

OOP관점에서 보면 link 에는 association 과 inheritance 가 있죠...

저도 첨에는 inheritance 를 이용하는 extends 나 implements 를 많이 사용했었는데,
inheritance 는 강한 결합입니다.

하지만, 프로그램의 유지보수, 분업을 위한 모듈화 등을 보면 약한 결합을 많이 강조하죠.

그리고, 최근에 관심가지는 퍼포먼스나 튜닝면에서도 컴파일러관점에서 override 체킹이라는 것이
악영향을 미치는 것 중에 하나라고 알게되면서 부터...

association 형태의 약한 결합들을 많이 씁니다

-------------------------------------------------------------------------------------------------------

아무래도 자바도 SmallTalk를 기원으로 하는 언어다보니 "모든 것은 객체다." 라는 철학에 너무 심취하면
상속이 멋있어보이고 그를 이용한 구현도 많이 하게 됩니다만...

시스템이란게 하다보면 하나의 객체에서 그를 확장해 나가는 형태는 매우 특수하거나 혹은 소규모이거나 혹은 작은 부분일때이고 대게는 매우 다양한 객체의 조합들과 관계로 이뤄지게 되죠.

겉보기에는 상속인거 같으면서도 실제론 관계로 풀어나가는 경우도 많구요 ^^..

최근에는 언어의 철학이란 것도 좀 생각해보면서 Ruby 란 것에도 많이 관심이 갑니다. ㅋㅋ

-------------------------------------------------------------------------------------------------------

Hello, World ♡.♡

윈도우 핸들이란 무엇인지 알아봅시다

프로세스 이름으로 검색 & 종료

HTML 색 이름(color name)

색상명을 클릭하면, 클릭한 색상을 배경으로 다른 색과의 조화를 볼수 있습니다. [출처] HTML 색 이름(color name)|작성자 뱃놀이

LPSTR, LPCSTR, LPTSTR, LPCTSTR, LPWSTR, LPCWSTR

[EnumWindows()]

현재 실행중인 프로세스를 종료하는 C언어, C++

FindWindow, FindWindowEx, WindowFromPoint

윈도우 핸들 가져오기

실행된 프로그램의 특정 버튼을 누르게

C 에서 Dos 명령어 실행하기

Windows에 GCC 컴파일러 설치하기

개인서버에서 메일설정과 SSL설정 FTP설정 XE core버전업방법 텍스트큐브 openid오류

My sql encode, decode, password로 암호화 하긔

Oracle NVL, DECODE 함수

[JAVA] File과 Directory 접근

Window Focus and State in Java

java - system 정보 가져오기

JAVA - 자바로 프로세스 관리

가. 프로세스 생성 및 종료

나. 상호작용 명령어의 실행

urlconnection 기능확장으로 편리하게 사용하기

파싱?.?

HttpURLConnection클래스로 웹페이지 POST 요청하기

웹사이트의 내용을 긁어오는 Webspider

URLConnection 클래스로 웹 페이지 읽기

Eclipse - Failed to create the Java Virtual Machine.

전원관리모드. 대기, 절전, 최대절전

CMD 명령어

- [링크] The volatile keyword in Java

- [Java 기본] JDBC를 이용한 Oracle 연동

- [Java 기본] Java Network - MulticastSocket을 이용한 채팅/파일전송 프로그램

- [Java 기본] Java Network

- [Java 기본]Swing

- [Java 기본] JAVA File I/O

- [Java 기본]Thread, synchronized, 압축 및 배포

- [Java 기본] Applet

- [Java 기본] Graphics

- [Java 기본]AWT, Listener, Event

- [Java 기본]Menu, Frame 정렬, FileDialog, Dialog, Event

- [Java 기본] AWT - Panel, Label, Button, Checkbox, Choice, List, TextField, TextArea

- [Java 기본]AWT, FlowLayout, GridLayout, BorderLayout

- [Java 기본]프로세스와 쓰레드

- [Java 기본]다형성, Abstract, Interface, Inner Class

- [Java 기본]예외처리, 클래스 상속

색상명을 클릭하면, 클릭한 색상을 배경으로 다른 색과의 조화를 볼수 있습니다.

[출처] HTML 색 이름(color name)|작성자 뱃놀이