|
|
[자바의 정의]
자바를 한마디로 표현하기란 매우 어렸다. 그러나 다음과 같은 특징들을 통해 자바가 어떤 언어이며 자바에 대한
이해를 얻을 수 있을 것이다.
sample, object-oriented, distributed, interpreted, robust, secure, architecture, natrural, protable,
high-performance, multithreaded, and dunamic language.
1. 다른 언어에 비해 코딩이 간단하다.
즉, 똑같은 기능을 하는 프로그램을 기존의 프로그래밍인 C나 C++의 코드로 작성한 것과 자바로 작성한 것을
비교해 보았을 때 자바로 작성한 것이 코드의 길이가 훨씬 간단하면서도 같은 기능을 수행한다. 그리고 자바언어
는 기존의 C언어에서 많은 부분들을 계승해 왔지만 자바 언어의 특성에 맞게 계승되어졌기 때문에 기존의 C에서
의 불필요한 코드 부분들 많이 삭제하였다.
2. 행동과 상태를 지닌 객체 지향적이다.
자바는 숫자(int,float)나 논리값(true,false)을 제외한 거의 모든 것이 객체로 구성되어 있습니다. 실제로 자바는
Object클래스에서 모든 클래스를 파생한다. C++와 비교할 때 자바는 단일 클래스 상속만 지원하여 다중 클래스 상
속시 발생할 수 있는 개념의 혼란을 막았다. 또 자바는 연산자 오버로딩과 객체간의 함축적 유형 변환을 지원한다.
3. 네트웍 분산 환경을 지원하다.
자바에는 TCP/IP 라이브러리가 기본적으로 포함되어 있습니다. 또한 http와 ftp프로토콜을 기본적으로 사용할
수 있도록 자바의 기본 패키지에서 지원을 해주고 있어 분산 환경에서 자바 프로그램을 수행할 수 있습니다.
4. 실행에 있어서 인터프리터 언어이다.
자바 언어는 작성한 프로그램을 컴파일을 한 후 컴파일된 코드를 가지고 실행을 하는 컴파일 언어이면서 컴파
일 과정을 기존의 basic과 같은 한 라인 단위씩 컴파일 처리하는 인터프리터 방식을 사용하는 언어입니다. 자바의
컴파일 방식은 텍스트 소스를 컴파일 하여 2진 파일로 만든 다음 자바 런타임이 클래스 파일을 인터프리트하면서
실행한다. 먼저 시스템에 무관한 2진 파일을 만듦으로써 자바는 컴파일 언어에 가까운 속도와 시스템 독립성을 동
시에 얻을 수 있게 되었습니다.
5. 언어 자체가 강하다.
이것은 자바가 C++와 마찬가지로 컴파일 때에 유형검사를 하여 에러를 막을 뿐 아니라 도구들까지 명확한 유
형 선언을 하도록 합니다. 자바는 포인터 연산을 지원하지 않습니다. 이는 잘못된 주소를 가리킬 가능성을 사전에
없앤 것이다. 자바는 포인터를 표현하기 위해 실제 배열을 사용하여 메모리 경계를 범할 가능성을 없애고 메모리
검사를 가능하게 하였다. 자바는 모든 메모리 접근을 자바 시스템이 계산하고 제한하며 도한 예외 핸들링을 하여
시스템이 붕괴의 우려가 없습니다.
6. 보안에 있어서 안전하다.
자바는 포인터 개념이 없고 유형 정의가 간단하여서 실행 전에 클래스 파일을 이용한 프로그램의 검사가 가능
하다 실제로 웹 브라우저가 애플릿을 실행하기 전에 보안 검사를 한다.
7. 플랫폼 중립적이다.
웹의 클라이언트서버 환경에서 이 기종 클라이언트 서버의 지원은 매우 중요한 문제이다. 자바는 웹을 기본 환
경으로 하고 있기 때문에 처음부터 이 문제를 염두해 두고 만들어졌다. 자바의 실행 파일은 기계 중립적인 이진
코드파일이다. 이 클래스 파일을 기계 종속적인 자바 런타임이 인터프리트하여 실행시키는 것이다. 따라서 자바 런
타임이 설치된 시스템에서는 어디서나 자바 프로그램을 실행할 수 있다.
8. 이식성이 높다.
자바는 유형 정의를 시스템에 무관하게 정의하고 있다. 따라서 C++에서처럼 시스템에 따라 동일한 유형이 다르
게 사용되는 경우가 없다. 또한 기계 중립적인 자바의 특성은 곧바로 자바의 높은 이식성을 제공한다..
9. 높은 수행능력을 제공한다.
자바는 기계 중립적인 이진코드로 미리 컴파일된 것을 실행할 기계어 코드로 번역하여 수행하는 방식을 채택하
고 있고 또 이진 코드는 기계어로 번역될 것을 감안하여 설계되었으므로 그 수행능력이 C나 C++ 컴파일러에 의한
기계어 코드에 견줄 만 하다. 현재 자바 이진코드의 수행속도는 C컴파일러의 약 10분의 1이라고 한다.
10. 멀티스레딩을 지원한다.
원도우 NT, 윈도우 95나 솔라리스는 쓰레드를 지원하는 운영체계이다. 윈도우 3.1은 멀티쓰레드를 지원하지 않
으므로 자바 런타임을 구현할 수 없다. 쓰레드는 하나의 프로세스 인스턴스(인스턴스는 객체의 실제 변수로 생각하
면 된다.)가 실행되는 경로로 정의되는데 멀티 쓰레드를 지원할 경우 하나의 프로그램 단위가 동일한 쓰레드를 동
시에 수행할 수가 있다. 보통 사용자 인터페이스 쓰레드와 장시간 계산이 필요한 쓰레드가 동시에 필요할 때 멀티
쓰레드가 효과적이다. 특히 자바는 멀티 프로세스 하드웨어를 지원하도록 설계되었으므로 멀티 CPU 시스템에서
높은 효율을 낼 수 있다.
11. 동적이다.
자바 인터페이스를 이용하면 하나의 모듈을 갱신할 때 다른 모듈을 모두 갱신 할 필요가 없다. 이것은 인터페
이스가 모든 인스턴스 변수와 도구의 실행문을 배제한 채 객체간의 상호 작용을 정의하기 때문이다. 인터페이스
대해서는 뒤에서 다시 설명한다.
이젠 자바가 대충 어떤 특징을 지녔고 어떻게 동작이 되는지 또한 다른 언어에 비해 어떻게 다른지 짐작이 가질
것입니다. 그러나 위의 글만으로 자바를 이해했다고 하기에는 다소 이른 감이 있습니다. 지금 막 첫 단추를 끼워
넣었으니 앞으로 자바를 좀 더 쉽고 자세히 알려드리도록 하겠습니다.
[자바 개발 도구] JDK의 의미와 구성요소
--------------------------------------------------------------------------------
[자바 개발 도구]
저번 시간에는 자바의 정의에 대해 알아봤으니 그 다음으로 알아야 할 것이 뭐니뭐니 해도 자바 프로그래밍을 작
성하기 위해 필요한 도구에 대해 알려 드리도록 하겠습니다.
[JDK의 의미]
자바 개발 도구(이하 JDK하고 함)는 Java Developement Kit의 약자로서, 그대로 해석을 하면 자바를 개발할 수
있는 툴이라는 뜻입니다. 실제로도 그런 의미이고요.
자바 언어를 처음 대하시는 초보분들은 JDK가 어떻게 구성되어 있는지 매우 궁금해하실 것입니다. JDK는 자바
프로그램 유틸리티, 문서, 샘플 코드 그리고 자바 클래스 패키지로 이루어져 있습니다.
[JDK의 구성요소들]
첫 번째 자바 프로그램 유틸리티는 java, javac, appletviewer등 자바 언어를 컴파일하고 실행할 수 있도록 도와
주는 시스템 명령어들의 모임으로 이루어져 있습니다.
두 번째 자바 문서는 자바에 대한 기본적인 사용법 등을 JDK를 만든 선사에서 JDK를 배포할 때 JDK안에 함께
포함시켜 배포하여 그 문서를 봄으로서 자바 언어를 쉽게 이해하고 사용하도록 하였습니다. JDK1.02버전까지는 문
서가 포함되어 있었지만 JDK1.1로 버전이 올라가면서 JDK1.1기능이 방대해진 만큼 문서의 크기도 같이 늘어나게
되어 JDK에 포함되어 나오지 않고 이제는 JDK1.1.x버전과 JDK 문서를 따로 나누어 배포하고 있습니다.
세 번째 구성요소인 샘플 코드는 자바언어를 쉽게 이해할 수 있도록 자바를 만든 선에서 JDK의 버전에 따른 코
드를 가지고 작성한 예제를 실어 놓은 것입니다. 이 예제 코드들을 실행해 봄으로서 새로운 버전의 JDK에선 어떤
기능들이 추가되었고 또한 어떻게 코드를 구현하였는지 JDK를 이용한 프로그래머들을 쉽게 알 수 있게 되었습니
다.
[JDK의 필수 구성요소]
네 번째로 자바 클래스 패키지는 자바로 프로그래밍을 하고자 한다면 이것이 꼭 필요합니다. 이것에 더욱 많은
이해가 필요하므로 차후 자세히 설명하도록 하겠습니다.
자바 프로그래밍을 실제로 작성하고 실행하는데 필요한 것은 위의 4가지의 구성 요소 중 첫 번째와 네 번째 요소
가 필수적으로 필요합니다. 나머지는 필요에 의해 설치를 하셔도 되고 인하셔도 됩니다.
[JDK의 최신버전]
그럼 JDK의 최신 버전은 어디까지 왔고, 어디서 구하는지 알려드리도록 하죠
아직도 JDK1.02버전을 가지고 자바 프로그래밍을 하시는 분들이 많은데, 현재 JDK의 최신 버전은 JDK1.1.4입니
다. JDK1.02의 프로그래밍 방식과 JDK1.1.x버전의 프로그래밍 방식에 있어서 많은 변화가 있었기 때문에 처음 자
바언어를 시작하시려는 초보분들에게는 JDK1.1.x버전 이왕이면 최신 버전인 JDK1.1.4로 자바 프로그래밍을 시작하
기를 군하고 싶습니다. 그래야 최근의 자바 프로그래밍의 동향과 기법 관습 등을 익힐 수 있으므로 자바 프로그래
밍 코딩에 있어 상당한 도움이 될 수 있을 것입니다.
[JDK의 미래]
차기 버전인 JDK1.2의 스펙이 자바 소프트에 공개되었습니다. 내년쯤에 JDK1.2가 나온다고
하는군요.
[자바 개발 도구] JDK1.1.4 구하기
--------------------------------------------------------------------------------
[JDK1.1.4 구하기]
JDK의 최신 버전까지 알아보았으니 이젠 JDK 의 최신 버전인 JDK1.1.4를 구하고 설치하는 방법에 대해 알려 드
리도록 하겠습니다.
JDK1.1.4를 구하기 위해서는 자바 언어를 만든 회사의 인터넷 사이트를 방문하셔야 합니다. 프로그래밍에 조금이
라도 관심이 있으신 분이라면 자바 하면 미국에 있는 선(SUN)이라는 회사가 생각나실 것입니다. 바로 선(SUN)에
서 자바언어를 처음 탄생시킨 곳이지요. 지금도 주도적으로 자바 언어를 발전시키고 있습니다.
그럼 선(SUN)의 사이트로 가면 받을 수 있겠지 하고 생각할 수 있으나, 선(SUN)에서는 자바 언어 부분을 전담
하도록 자바소프트라는 자회사를 두었습니다. 그렇게 하여 자바 언어에 관련된 모든 것을 자바 소프트에서 담당하
도록 하였고 대다수의 자바 패키지나 소프트웨어를 자바 소프트를 통해 공개하고 있습니다.
그러므로 선(SUN)의 자회사인 자바 소프트에 가야 JDK를 받을 수 있습니다. 인터넷 브라우저를 통해
"http://www.javasoft.com"에 들어가시면 자바소프트에 들어가실 수 있습니다. 이곳에 들어가면 좌측에 다양한 메
뉴가 있는데, 이중 "Prodect"라는 메뉴가 있을 것입니다. 이곳을 선택하세요. 그러면 다음에 나오는 화면에 List박
스로 자바에 관한 여러 가지를 선택할 수 있도록 하는 선택메뉴가 나옵니다. 그 중에서 Java Developement Kit를
선택하신 후 옆에 있는 go버튼을 눌러주세요. 그러면 JDK1.1.4버전에 대한 설명 글들이 좀 나온 후에 JDK1.1.4를
다운 받을 수 있도록 자신에게 맞는 운영체제를 선택하라는 List박스가 나옵니다. 솔라리스와 윈도우95&NT용이
있을 것입니다. 대부분의 사용자가 윈도우95이므로 윈도우95를 선택하시고 Download버튼을 눌러주세요. 만약 자신
의 시스템 운영체제가 윈도우95가 아닌 솔라리스를 사용한다면 그것을 선택하세요. 솔라리스도 아닌 타 그 밖의
운영체제라면 JDK포팅된 것을 구하셔야 합니다. 그러면 JDK사용에 대한 라이선스 동의를 물어보는 글이 나온 후
동의와 비동의 버튼이 나옵니다. 동의하시면 동의 버튼을 누르시면 JDK1.1.4를 다운 받을 수 있도록 HTML문장이
나타납니다. JDK1.1.4의 다운 링크를 누르신 후 하드에 저장하시면 됩니다.
[요약]
2. 좌측 메뉴 중 Product메뉴 선택
3. List박스에서 Java Developement Kit를 선택
* 주의 * [JDK1.02도 있는데 이것이 안입니다. 반드시 Java Developement Kit
4. 자신의 운영체제를 선택, Windows95
5. 라이선스 동의
6. 다운 링크를 눌러 다운 받음
[자바 개발 도구] JDK1.1.4 설치하기
--------------------------------------------------------------------------------
자바 프로그래밍을 하기 위해 JDK1.1.4를 구하는 방법은 저번에 알아보았지요. 다들 JDK1.1.4를 구하셨는지요. 인
터넷의 느린 속도로 인해 아직도 못 구하신 분이 계시다면 국내의 많은 통신 서비스의 자료실에서도 JDK1.1.4가
대부분 올려져 있으므로 국내의 통신망을 이용해 빠르게 다운 받아 보세요.
유니텔의 자료실 플라자의 자바 자료실에도 자바에 대한 많은 자료가 있으니 그곳도 방문해 보세요.
JDK1.1.4를 구하셨다면 이젠 자바 프로그래밍을 위해 자신의 하드에 JDK1.1.4를 설치해야 겠지요. 그럼 JDK1.1.4
의 설치 방법을 알려드리도록 하겠습니다.
JDK1.1.4를 받으면 약 9메가 정도의 exe확정자인 실행파일로 되어 있을 것입니다. 확인해 보시고요. 맞다면 실행
을 시켜 주세요. 아참 JDK는 윈도우3.1에서는 작동하지 않습니다. 반드시 윈도우95에서 실행시켜야 합니다.
JDK1.1.4가 실행이 되면 나타나는 메시지에 따라 계속 진행을 하다보면 JDK안에 포함된 구성 요소 중 설치할 것
을 선택하는 곳이 있습니다.
Program File, library&header, Demo Applet, Source이렇게 4가지가 있는데 이중에 Program File, library&header
는 꼭 선택해 주세요. 그리고 나머지 Demo Applet과 Source는 자신에게 필요하다고 생각되시면 설치해 주세요.
Source는 필요한 경우가 많으니 설치해 두시면 좋습니다. Demo Applet의 경우는 초보님들이 자바를 처음 감상하
실 수 있는 기회입니다. 애플릿이므로 브라우저를 통해 감상하실 수 있지요.
선택을 다했다면 이젠 디렉토리를 설정하는 곳이 있는데 이곳은 기본으로 주어진 디렉토리인 c:jdk1.1.4가 하셔
도 좋고 자신이 편리한 디렉토리를 적어 주셔도 됩니다. 디렉토리까지 설정을 했으면 다음 버튼을 눌러 설치에 들
어갑니다.
자동으로 알아서 지정된 디렉토리에 설치를 해줍니다. 설치가 끝나기를 기다립니다.
[자바 개발 도구] JDK1.1.4 환경설정
--------------------------------------------------------------------------------
이전 시간에 JDK1.1.4를 구하고 설치하는 방법까지 알려 보았지요. 이번 시간에는 JDK를 자바 프로그래밍에 사
용하기 위한 환경설정을 알려 드리도록 하겠습니다.
자바 언어를 프로그래밍할 수 있는 JDK는 윈도우95의 경우 AUTOEXEC.BAT파일에 다음과 같은 JDK에 대한
정보를 기입해 메모리에 기억시켜 주어야 합니다. 그래야 JDK의 정보를 기억하고 있다가 필요시 메모리에서 정보
를 넣어 필요한 것들을 불러들어 사용합니다.
그럼 AUTOEXEC.BAT의 안의 들어다 봅시다.
[AUTOEXEC.BAT]
...
...
SET PATH=C:JDK1.1.4BIN
SET CLASSPATH=C:JDK1.1.4LIBCLASSES.ZIP
기존의 AUTOEXEC.BAT안에 위에서 보는 것과 같이 2줄의 첨가시켜 주시면 됩니다.
그럼 위의 2줄이 어떤 기능을 하는지 알아보도록 할까요.
우선 첫 번째 라인은 JDK1.1.4BIN안에 있는 JDK의 Program file들을 path설정을 해줌으로서 c:jdk1.14bin디렉
토리로 이동하지 않고 어떤 디렉토리에서든지 c:jdk1.1.4bin안에 포함되어 있는 자바 시스템 명령어들 사용할 수
있도록 해 줍니다.
다음으로 두 번째 라인은 JDK의 구성요소를 살펴보았을 때 네 번째 구성요소인 패키지를 클래스 패스로 설정해
주는 것입니다. c:jdk1.1.4libclasses.zip안에는 자바 클래스 패키지들을 묶어 ZIP으로 압축을 해 놓은 것입니다.
패키지에 대해서는 다음에 자세히 알려드리겠지만 패키지는 자바 프로그래밍에 있어서 꼭 필요한 요소입니다. 이
런 패키지는 CLASSPATH로 설정하여 패키지 안의 클래스들을 자바 프로그래밍에 불러들어 사용할 수 있습니다.
만약 클래스 패스가 설정이 잘못되었을 경우에는 자바 컴파일 시에 제일 먼저 쓰레드(Thread)클래스를 찾을 수
없다는 에러가 발생합니다. 그리고 위같이 설정을 했어도 AUTOEXEC.BAT나 CONFIG.SYS안의 다른 여러 설정
값들이 메모리에 올려지는 순서에 따라 클래스 패스가 설정되지 않을 경우도 있습니다. AUTOEXEC.BAT나
CONFIG.SYS안의 명령어 실행 순서를 잘 조절해 주시면 설정이 될 것입니다.
JDK살펴보기(1) / JDK도구의 기능과 역할
--------------------------------------------------------------------------------
자바 JDK를 설치하고 나면 c:jdk1.1.4bin디렉토리 아래 자바의 여러 가지 실행 프로그램들이 있는 것을 볼 수
있을 것입니다. 이것이 바로 JDK의 도구인 것입니다. 이 JDK도구를 가지고 자바 언어로 컴파일도 할 수 있고 실
행도 시킬 수 있고 애플릿뷰어(appletviewer)로 애플릿으로 작동시킬 수도 있는 등 자바 코드로 작성된 text형식의
파일을 원하는 실행코드로 만들 수 있는 도움을 주는 도구들입니다.
이 코너가 초보자들을 위한 코너인 만큼 JDK도구의 어려운 개념의 도구와 그다지 사용하지 않는 JDK도구에 대
해서는 이곳에서 다루지 않고 그런 것들은 문법코너들 통해 알려 드리도록 하겠습니다.
그럼 JDK의 도구들의 기능과 역할에 대해 간단히 알아보고 이중 중요한 몇 가지 도구들은 다음 글에서 더 자세
히 알아 드리도록 하겠습니다.
javac, java, javadoc, appletviewer, jdb, jar, javah
1. javac : java 의 컴파일러. java 로 작성된 프로그램(*.java)을 컴파일하여 바이트 코드(*.class)를 생성
[사용법] javac myjava.java
2. java : java 인터프리터, 바이트 코드를 JAVA 가상 머신 상에서 해석하고 수행 javac를 이용해 생성된 바이트
코드인 class파일을 java도구가 자바 가상 머신의 환경을 만들어 그 안에서 실행을 시킴
[사용법] java myjava
3. javadoc : java 프로그램으로부터, 하이퍼텍스트 형태로 API 문서 생성.
자바 소스 파일을 분석하여 HTML파일을 생성하여 준다.
[사용법] javadoc myjava
4. appletviewer : 웹 브라우저를 이용하지 않고 명령어로 애플릿 실행
[사용법] appletviewer myjava
5. jdb : java 프로그램 디버거
자바 코드에 이상이 있을 경우 jdb를 이용하여 한 단계씩 코드를 추적해 에러가 난 곳이나 막힌 곳을 알아
낼 수 있다.
[주의] jdb실행에 프로세서의 자원 점유율과 시간이 많이 들어감으로 cpu의 속도에 따라 jdb의 실행을
검토바람. javac에서 옵션으로 -g옵션을 주어진 class만이 jdb를 이용할 수 있다.
[사용법] jdb myjava
6. jar : java의 빠른 실행을 위해 실행 관련 클래스(class), 이미지(image), 사운드(au sound), 텍스트(text)파일 등
실행에 필요한 모든 파일을 하나의 jar압축 파일로 묶어 이곳에서 불러들어 사용 jar형식으로 된 애플릿
을 인터넷을 통해 실행할 경우 특히 많은 속도의 향상을 얻을 수 있다. 주로 자바빈즈 프로그래밍에
사용됨
[사용법] jar my.jar myjava.class image.gif sound.au
7. javah : 헤더 파일(*.h) 과 소스 파일(*.c) 생성
자바 헤더와 Stub파일 생성기로서 C언어 안에서 자바 메소드를 이식하기 위한 C헤더와 소스 파일을 생
성하는데 사용됩니다. 생성된 파일들은 C코드로부터 객체의 멤버 변수로 접근하도록 사용될 수 있습니
다.
[사용법] javah myjava .
JDK살펴보기(2) / 자바 런타임 인터프리터
--------------------------------------------------------------------------------
java(자바 런타임 인터프리터)
자바 런타임 인터프리터(java)는 핫자바 브라우저 안에 내장된 자바 인터프리터의 단독 실행(stand-alone) 버전입
니다. 런타임 인터프리터는 컴파일 되어 바이트 코드로 포맷으로 구성된 자바 클래스(class)프로그램을 실행시켜
줍니다. 런타임 인터프리터는 텍스트 모드 자바 프로그램을 실행하기 위한 커맨드 라인 툴로서 작동됩니다.
런타임 인터프리터(java)를 사용하기 위한 문법을 다음과 같습니다.
java Options Classname Arguments
- Option : 런타임 인터프리터가 자바 프로그램을 어떻게 수행할 지에 관계된 옵션을 지정하는 곳입니다. Option이
므로 생략 가능합니다.
아래는 일반적으로 런타임 인터프리터에서 사용되는 옵션들입니다.
- debug : jdb(자바 디버거)를 사용할 수 있도록 함
- checksource, -cs : 소스와 기존 클래스의 수정날짜 비교
- classpath Path : 실행에 필요한 클래스 패스를 직접 지정
- verbose, -v : 자바 클래스 로드시 메세지를 출력
- verbosegc : 가버지 콜렉션을 수행할 때마다 메시지 출력
- verify : 모든 코드에서 검증자를 실행하도록 함
- verifyremote : remote의 코드에서 //
- noverity : 모든 코드에서 검증자 사용하지 않음
- DPropertyName=NewValue : 자바의 시스템 속성값을 새로 지정
- Classname : 실행하고자 하는 클래스(class)의 이름을 지정
- Arguments : 자바 실행 프로그램 내에서 필요한 값을 외부에서 받아 들어 사용하기를 원할 경우 인자를 주어
프로그램 내부와 연결할 수 있다. 자바 프로그램에서 인자(Arguments)를 필요로 하지 않는 경우에는 넣
을 필요가 없다.
JDK살펴보기(3) / 자바 컴파일러
--------------------------------------------------------------------------------
자바 컴파일러(javac)
자바 컴파일러는 자바 소스코드 파일을 실행 가능한 자바 바이트 코드인 클래스 파일로 컴파일 하는데 사용합니
다. 자바 언어에서는 소스코드의 확장자를 ".java"로 정의하고 있습니다. 이런 java확장자의 파일을 ".class"확장자
를 갖는 실행 가능한 클래스 파일로 컴파일 하는데 자바 컴파일러가 이용됩니다.
자바 컴파일러는 소스파일에서 정의된 각각의 클래스를 하나의 클래스 파일로 만듭니다. 이것은 하나의 자바 소
스코드 파일에서 여러 개의 실행 가능한 클래스 파일이 컴파일 될 수 있음을 뜻합니다. 즉 하나의 소스 파일이 여
러 개의 클래스 정의를 가질 수 있습니다. 첫걸음 코너에서는 다루지 않겠지만 이런 개념으로 JDK1.1.x에서 내부
클래스라는 개념이 등장하고 있습니다. 주로 이벤트 처리 등이 이런 내부 클래스로서 사용되고 있지요. BEANS메
뉴나 GUI메뉴에 가지면 내부 클래스의 사용예제들을 보실 수 있을 것입니다.
자바 컴파일러 역시 자바 런타임 인터프리터와 비슷하게 작동하는 커맨드 라인 도구입니다.
자바 컴파일러를 사용하기 위한 문법은 다음과 같습니다.
javac Options Filename
- Option : 자바 컴파일러가 어떻게 실행 가능한 자바 클래스를 생성할 것인지에 관련된 옵션을 지정하도록 되어
있습니다.
아래는 일반적으로 자바 컴파일러에서 사용되는 옵션들입니다.
- classpath Path : 소스 코드 컴파일에 필요한 클래스 패스를 직접 지정
- d Dir : 클래스(class)를 생성할 디렉토리를 지정
- g : 자바 디버거 사용을 위한 class를 생성함
- nowarn : 컴파일 시에 경고를 나타나지 않도록 함
- verbose : 컴파일시 소스 파일을 구분하기 위함
- o : 컴파일러가 컴파일된 코드를 최적화 하도록 한다.
-Filename : 컴파일할 소스코드 파일의 이름을 지정합니다.
[주의] 자바 컴파일러로 컴파일 할 시에는 "javac filename.java"와 같이 파일 이름 뒤에 ".java"확장자까지 파일
이름 전체를 기입해야 하나, 자바 인터프리터로 클래스 파일을 실행시킬 경우에는 "java filenams"와 같
이 ".class"라는 확장자는 필요가 없습니다. 파일 이름만 지정해야 합니다. 초보자분들 주의하시기 바랍
니다.
JDK살펴보기(4) / 애플릿 뷰어
--------------------------------------------------------------------------------
애플릿 뷰어(appletviewer)
우선 애플릿이 무엇인가 궁금하시겠죠. 애플릿(Applet)이란 웹상(브라우저)에서 자바 코드(class)를 다운 받아 실
행할 수 있는 작은 프로그램을 말합니다.
애플릿 프로그램을 작성할 때에는 자바 애플리케이션 프로그램의 작성법과 다른 기본적으로 들어가야 할 메소드
(Method)들이나 Applet클래스를 상속해야 하는 등 약간의 차이점이 있습니다. 이 차이점에 대해서는 차후 다시 자
세히 설명하기로 하고 애플릿이 인터넷을 통해 다운 받아 브라우저 안에서 실행할 수 있는 것이라는 정도만 알고
있기 바랍니다.
애플릿 뷰어는 이런 자바 애플릿 프로그램으로 작성한 코드를 컴파일하여 생성된 클래스(class)파일을 테스트해
볼 수 있게 지원해주는 도구입니다.
보통 애플릿은 브라우저를 통하여 테스트하는데, 애플릿 프로그램을 작성하고 테스트 할 때마다 브라우저로 테스
트한다면 시간적으로나 시스템 자원의 낭비가 심해 애플릿 프로그램의 작성 속도가 느려질 수 있습니다.
그렇기 때문에 애플릿 프로그램을 테스트하는 작업에서는 애플릿 뷰어를 많이 이용하지요.
그럼 애플릿 뷰어로 어떻게 자바 애플릿 프로그램을 실행시키는지 알아볼까요.
저번 시간에 자바 런타임 인터프리터(java)에 대해 알아볼 때 "java myjava" 이런 식으로 컴파일된 자바 코드를
실행시킨다고 알려드린바 있습니다.
이같은 방식이 바로 자바 애플리케이션(application) 프로그램을 실행시키는 방법입니다.
애플릿 프로그램의 경우는 javac컴파일러를 이용하여 컴파일하는 과정까지는 자바 애플리케이션 프로그램을 작성
할 때와 똑같습니다. 그 다음 생성된 바이트 코드인 클래스(class) 파일을 실행시키는 방법이 애플리케이션 프로그
램과 다르지요.
어떻게 다른지 알려드리도록 하겠습니다. 이것이 애플릿뷰어의 실행방법이지요.
위에서 애플릿은 브라우저를 통해 실행한다면 말한바 있습니다. 그렇기 때문에 브라우저가 인식할 수 있는 문장
인 HTML문장 안에서 애플릿 프로그램을 불러서 실행시켜야 합니다. 이런 기능을 하는 HTML 태그(TAG)로서
<APPLET>이라는 태그가 있습니다.
<APPLET>태그로 애플릿 프로그램을 실행하는 방법에 대해서만 알아보고
<APPLET>태그의 자세한 사용법은 차후 자세히 알려드리도록 하겠습니다.
HTML문장 안에서 <APPLET>태그를 이용하여 애플릿 프로그램을 브라우저 또는 애플릿 뷰어에서 실행시키기
위해서는 다음과 같이 작성하셔야 합니다.
[AppletTest.html]
------------------------------------------------
<applet code="myApplet.class" width=300 height=300>
</applet>
------------------------------------------------
이렇게 2줄의 코드를 작성한 후 확장자를 html를 지닌 파일로 저장합니다.
저장을 했으면 이젠 애플릿뷰어를 통해 애플릿 프로그램을 실행해 볼 수 있습니다.
위에서 작성한 AppletTest.html을 애플릿 뷰어로 실행하는 방법은 다음과 같다.
"appletviewer AppletTest.html"
위 문장을 클래스 파일과 HTML문장이 함께 있는 디렉토리에서 실행시키면 myApplet애플릿 코드를 실행할 수
있습니다.
도스 프롬프트에서 위 명령으로 실행시키면 윈도우상태로 넘어와 애플릿 윈도우가 되면서 실행이 됩니다.
[주의] appletviewer가 path지정이 돼 있지 않으신 분은 JDK1.1.4 환경설정에 대한 글을 보시고 path설정을 미리
해주시기 바랍니다.
JDK살펴보기(5) / 자바 디버거
--------------------------------------------------------------------------------
자바 디버거(jdb)는 자바 애플리케이션을 디버그(debug)할 수 있는 자바 도구입니다.
디버거라는 말은 기존의 프로그램들에서도 많이 사용되어 왔기 때문에 이미 많은 분들이 아시겠지만 코드의 실행
은 컴맨드-라인방식으로 한 라인씩 추측해(실행해) 가면서 소스코드의 잘못된 곳이나 특정 상황에서 어떻게 작동
을 하는지 알아 볼 수 있는 프로그램을 뜻합니다.
자바 언어에서 디버거는 "jdb"라는 도구가 담당하고 있습니다.
그럼 자바 디버그인 jdb의사용법을 알려드리겠습니다.
jdb를 사용하기 위해서는 자바 코드를 자바 컴파일러인 javac로 컴파일할때 디버거 옵션인 "-g"를 첨가하여 주어
클래스 파일에 디버깅에 대한 정보를 포함하도록 해 주어야 합니다. 다음과 같이 말이죠.
[디버거를 위해 디버깅 옵션 지정을 한 컴파일 방식]
javac -g myjava.java
이렇게 컴파일을 하여 생성된 자바 클래스 파일(바이트 코드)에는 디버깅(jdb)에 필요한 여러 가지 정보들이 포함
되어 있습니다.
이렇게 생성된 디버깅 정보를 포함한 클래스 파일을 디버거 하고자 한다면 다음과 같이 하시면 됩니다.
jdb myjava
위 문장을 치시면 좀 오랜 시간동안 jdb의 초기화를 위해 시스템 내부에서 많은 작업이 진해되므로 시스템의 성
능이 많이 저하됩니다. jdb초기화에도 쾌 시간이 걸리고요. 얼마정도의 시간이 흐른 후 다음과 같은 문장이 나타납
니다.
initailizing jdc...
0x13a41b8:class(myjava)
>
위 문장들이 jdb프로그램 안으로 들어왔음을 알리는 문장이며 마지막 줄의 ">"가 바로 jdb의 프롬프트 상태입니
다. 도스 프롬프트와 마찬가지로 이곳에 jdb에서 사용 가능한 명령어를 쳐주면 그에 맞는 처리가 수행됩니다.
그럼 jdb의 간단한 수행법을 알려드리겠습니다.
자바 디버거는 특정 부분까지 수행을 하고 나서야만이 한 단계씩 추척하는 것이 가능하므로 특정 위치에 정지점
(breakpoint)를 설정하는 방법을 먼저 알려 드리겠습니다.
[참고] 정지점(breakpoint) : 디버거를 사용할 경우 사용자가 지정한 특정 부분에서 프로그램의 실행을 멈추게 하
는 위치를 말함
정지점(breakpoint)를 설정하는 방법은 2가지가 있습니다.
1. 첫번째 방법은 "stop in 클래스이름.메소드이름"
2. 두번째 방법은 "stop at 클래스이름.행번호"
전자의 방법은 특정 메쏘드로 들어가는 시점에서 실행을 멈추는 것이고
후자의 방법은 코드 파일의 행번호에 해당하는 부분에서 실행을 정지시킴니다.
다음 두문장은 정지점(breakpoint)를 설정하는 2가지 예제입니다.
> stop in myjava.main
> stop at myjava.8
위 문장을 jdb의 프롬프트 상태에서 실해시키면 다음과 같이 정지점 설정 메세지가 나타납니다.
Breakpoint set in myjava.main
Breakpoint set in myjava.8
정지점(breakpoint)까지 설정을 끝마쳤으면 이젠 정지점까지 jdb를 수행시켜야겠지요. "run"이라는 명령어가 정지
점까지 수행하는 기능을 합니다.
> run
"run"명령어를 실해하면 다음과 같은 문장이 나옵니다.
run myjava
Breakpoint hit: running...
myjava.main(myjava:8)
main[1]
위에서 main은 현재 수행중인 쓰레드의 이름이며, []안의 숫자는 현재의 스택 프레임(stack frame)를 뜻합니다.
쓰레드에 대해서는 문법메뉴에 올려놓은 글이 있으니 참고하세요.
"threads"를 jdb프롬프트에서 치면 현재 수행중인 쓰레드의 목록이 나오며, 추척하고 싶은 쓰레드를 선택하려면
"thread 쓰레드 번호"를 입력하시면 됩니다. 그리고 현재 추척중인 원시 코드를 보고 싶다면 "list"명령을 입력하시
면 됩니다.
또한 변수의 내용을 보고 싶다면 "print"를, 한 단계씩 추적해가고 싶다면 "step"이나 "next"등의 명령을 사용하면
되고, 정지된 곳에서 계속 수행하고 싶을 경우에는 "cont"명령어를 사용하면 됩니다. 그 외에 jdb에 대한 명령어들
은 "help"를 치면 jdb명령어에 대한 설명이 짤막하게 나오는 그것을 참고하세요.
JDK살펴보기(6) / 클래스 파일 역어셈블러
--------------------------------------------------------------------------------
자바 클래스 파일 역어셈블러(javap)는 클래스 파일을 역어셈블하는데 사용합니다. javap의 기본 출력물로서
public데이터와 메소드로 구성됩니다. 클래스 파일 역어셈블러는 클래스의 소스코드를 얻을수는 없지만, 클래스 파
일이 어떻게 작동을 하는지 알수 있는 정보를 제공합니다.
자바 클래스 파일 역어셈블러를 사용하기 위한 문법은 다음과 같습니다.
javap Option Classname[s]
- Option : 자바 클래스 역어셈블에 옵션을 적용합니다.
-c : javap 역어셈블러가 각각의 메소드에 대한 실제 바이트 코드를 출력하도록 함
-p : javap역어셈블러가 자신의 출력 사항에 provate변수와 메쏘드를 포함하도록 함
-n : C헤더 파일에서 사용될 수 있는 정보를 생성하도록 함
이 옵션을 사용할 경우 소스코드가 없는 자바 클래스로 C코드와 인터페이스할 때 유용합니다.
-classpath Path : 클래스 파일의 코드에서 import하여 사용한 클래스를 지정된 경로의 위치에서 찾도록
합니다.
- verify : javap역어셈블러가 자신의 버전을 출력하도록 함
- Classname : 역어셈블하고자 하는 클래스 파일을 하나나 그 이상 여러개의 클래스 이름을
기입합니다.
JDK살펴보기(7) / 자바 문서 생성기
--------------------------------------------------------------------------------
자바 문서 생성기(javadoc)
javadoc 프로그램은 .java 소스 파일에 포함되어 있는 클래스와 변수, 그리고 메소드의 이름은 물론 프로그래머가
소스 파일에 붙여놓은 주석을 포함하는 HTML 파일을 자동으로 생성해 줌으로서 자바 코드에 대한 이해를 쉽게
해주고 관련 문서의 생성을 도와줍니다.
자바 소프트에서 자바 문서로서 배포하고 있는 곳에 클래스 API에 관한 HTML문서도 javadoc(자바 문서 생성
기)를 이용하여 만들어진 것입니다.
javadoc으로 생성한 문서가 어떤 형태인지 미리 보고 싶으신 분들은 http://www.javasoft.com에 가셔서 api에 대
한 부분을 보시면 대충 내용을 알수 있을 것입니다.
자바 문서 생성기는 프로그래머가 /** **/를 이용하여 붙여 놓은 주석을 자동으로 포함하여 문서를 생성합니다.
자바 문서 생성기를 사용하기 위한 문법은 다음과 같습니다.
javadoc Option javasourcename
-Option : 자바 문서 생성기의 작동을 변경합니다.
- classpath path : .java 파일이 있는 경로명을 지정해줄 때 사용한다.
- d directory : 만들어질 HTML 파일을 저장할 경로를 지정해 준다.
- encoding : encoding 소스 파일의 문자 인코딩을 지정한다.
- docencoding : doc-ument_encoding 만들어질 HTML 문서의 문자 인코딩을 지정한다.
-javasourcename : 자바 소스 코드의 확장자를 제외한 이름을 적습니다.
작성될 도큐먼트용 HTML 파일이 포함하고 있는 내용을 서로 링크해주기 위해서 다음과 같은 태그를 이용할 수
있다.
@see classname "See also"라는 항목을 만들어 해당 클래스와 연결해 준다.
@see classname#methodname "See also"란 항목을 만들어 특정 메소드와 연결해 준다.
@version text HTML 파일의 버전을 표시하는 항목을 만들어 준다.
@author text HTML 파일의 저자를 표시하는 항목을 만들어 준다.
@param name description 특정 메소드가 취하는 인자를 기술할 때 사용한다.
@return description 특정 메소드의 리턴값을 기술할 때 사용한다.
@exception classname 특정 메소드가 발생시킬 수 있는 예외를 기술할 때 사용한다.
자바 문서 생성기(javadoc)에 대한 자세한 것은 아래 사이트에서 참고하세요.
Javadoc(http://java.sun.com/products/jdk/javadoc/writingdoccomments.html)
자바기초(1) / Hello,World!프로그램 작성
--------------------------------------------------------------------------------
저번 시간까지 JDK살펴보기를 통하여 JDK도구들에 대해 간략하게 나마 알려드렸습니다. 이런 도구들의 사용법
을 어느정도 알고있어야 앞으로 여러분들에게 알려드릴 내용에 대해 실행을 할 수 있을 것입니다.
그러니 자바 컴파일러(javac)와 자바 런타임 인터프리터(java)의 사용법 정도는 꼭 알고 이제부터 올라오는 글을
읽어 주시면 한결 이해가 빠른 것입니다.
그럼 초보자분들께서 그토록 기다리던 첫번째 프로그램을 작성해 보도록 하죠.
대부분의 컴퓨터 언어에서 첫번째 프로그램으로 "Hello, World!"프로그램을 작성합니다. 이곳에서도 마찬가지로
"Hello, World!"프로그램을 작성해 보도록 하겠습니다.
[참고] "Hello, World!"프로그램은 단순히 콘솔(Consol:화면의 모니터)상에 "Hello, World!"라는 문자열을 출력할
뿐이지만 초보자들이 자바 프로그램이 어떻게 동작을 하는지를 쉽게 알 수 있는 간단한 프로그램입니다.
그럼 "Hello, World!" 자바 코드를 작성해 우선 한눈에 보도록 하고 다음 한줄 한줄에 대해 설명을 해드리도록 하
겠습니다.
[HelloWorld 클래스] 작성
--------------------------------------------------------------
class HelloWorld{
public static void main(String args[])[
System.out.println("Hello World!, 환영 자바 이야기");
}
}
--------------------------------------------------------------
자바기초(2) / Hello,World!프로그램 분석
--------------------------------------------------------------------------------
[HelloWorld 클래스 코드]
--------------------------------------------------------------
class HelloWorld{
public static void main(String args[])[
System.out.println("Hello World!, 환영 자바 이야기");
}
}
--------------------------------------------------------------
[HelloWorld 클래스 분석]
위의 소스 코드와 같이 HelloWorld는 매우 작은 자바 프로그램이지만, 비록 그렇다고 하여도, 이 몇 줄 안되는 코
드 안에는 많은 일이 일어나고 있습니다. 무슨 일이 일어나고 있는지 한줄한줄 알려드리도록 하겠습니다.
class HelloWorld
----------------------------------------------------------------
자바 언어는 객체지향 프로그래밍 언어이기 때문에 프로그램의 실행을 클래스 단위로 실행 처리하도록 되어 있습
니다. 그렇기 때문에 자바 언어로 작성되는 모든 프로그램은 class라는 키워드 다음에 그 프로그램의 이름을 기입
하게 되어 있습니다.
첫번째 문장에서 "class HelloWrold"라는 문장이 나왔는데 이것이 바로 이 자바 코드의 이름을 "HelloWrold"로 하
겠다고 명시한 것입니다. 나중에 또 알려드리겠지만 이 "HelloWorld"라는 이름이 바로 이 코드가 저장될 이름과
똑같습니다. 즉, "HelloWorld.java"라는 이름으로 위의 코드를 저장하여야만 됩니다.
----------------------------------------------------------------
public static void main(String args[]){
----------------------------------------------------------------
두번째 문장이다. HelloWorld클래스에 존재하는 유일한 메소드인 main이다. 처음 문자열부터 하나씩 알아보자
public : 클래스의 안이든 바깥이든 어디에서나 이 main메소드가 호출될 수 있음을 뜻한다. 접근 제한자에 대한 자
세한 것은 문법 메뉴를 참고하시면 많은 정보를 얻을 수 있다.
static : mian()메소드가 메모리에 인스턴스되는 공간의 주소가 모두 똑같음을 나타냅니다. 프로그래밍을 처음 시작
하시는 분들이라면 이 static이라는 키워드의 기능에 대해 이해하기가 좀 어려울 것입니다. 지금부터 제가
설명하는 것을 자세히 읽어 보시면 왠만큼 이해는 될 것입니다. static키워드는 매번 자바 언어에서 객체들
이 생성되고 이용되는 과정에서 메모리의 기억 장소를 이용합니다. 매번 객체들이 생기고 저장되고 참조하
는 과정들이 무진장 일어나죠. 그래서 메모리를 많이 잡아 먹게 됩니다. 이런 메모리 점유를 조금이나마 줄
이고 수행 속도의 증가를 위해 static키워드를 지정함으로서 static으로 지정된 객체나 메소드에 대해서는 메
모리의 똑 같은 자리(주소)를 계속해서 사용하므로 메모리의 낭비를 막을 수 있습니다. 그러나 주의하실 점
은 이런 객체나 메소드는 정적으로 이용되므로 같은 static객체나 메소드에 의해 호출이 되며, 클래스의 초
기 화시 맨 처음으로 메모리에 적재됩니다.
void : C언어나 C++언어를 해보신 분들이라면 지겹도록 많이 보았을 키워드지요. 자바에서 void의 기능은 이 메소
드 여기에서는 main()메소드의 안에서 작업을 처리하고 main을 호출한 호출자에게 반환한(리턴값) 결과값이
아무 것도 없다는 것을 의미합니다.
main(String args[]) : main()메소드는 모든 자바 애플리케이션 프로그램에 꼭 들어가야 하는 문장이며, 캄파일하여
실행시킬 경우 자바 런타임 인터프리터가 제일 먼저 이 main()메소드를 찾아 실행을 하는 곳입니다. main()
메소드는 "String args[]"라는 한 개의 파라미터값을 갖도록 정의되어 있습니다. args는 실행시의 클래스에
전달되는 커맨드 라인 인자로서 String의 배열형으로 정의함으로서 여러개의 문자열을 받아들일 수 있습니
다.
쉽게 말해, 자바 애플리케이션 프로그램을 자바 인터프리터(java)로 실행할 경우 실행 명령뒤에 문자
열을 인자로 줄 수 있는데 이것을 받아들이는 String형 배열입니다.
위의 HelloWrold프로그램에서는 커맨드 라인 인자를 필요로 하지 않기 때문에 args인자를 주어지기 않
아도 되며, args는 무시됩니다.
---------------------------------------------------------------------
System.out.println("Hello World!, 환영 자바 이야기");
--------------------------------------------------------------------
System클래스 out객체의 println()메소드는 단순히 매개변수(인자)로 주어진 문자열(메세지)를 화면(Consol)에 출
력하는 메소드입니다. System클래스는 자바 프로그램이 실행될 경우 기본적으로 수입되는 java.lang.*패키지에 포
함되어 있으므로, 수입문장(import)을 사용하여 프로그램에 포함시킬 필요는 없습니다.
println()메소드는 문자열의 끝에 자동적으로 newline(n)을 추가합니다.
C언어의 printf메소드와 비슷한 기능을 하는 셈이죠.
out객체는 표준 출력 스트림을 의미하는 System객체의 멤버 변수이고, System객체는 시스템의 기능을 캡슐화하
는 전역 객체입니다.
"Hello World!, 환영 자바 이야기"는 매개변수(인자)로서 사용되는 문자열이므로 반드시 " "안에 기입하셔야 합니
다.
---------------------------------------------------------------------
간단한 자바 프로그램이면서 가장 기본적인 자바 프로그램인 Hello, World!출력 프로그램을 작성해 보았습니다.
이 프로그램에 대한 이해를 기반으로 이제부터 자바 프로그래밍의 세계의 많은 정보를 알려드리도록
하겠습니다.
자바기초(3) / Hello,World!프로그램컴파일
--------------------------------------------------------------------------------
HelloWorld 자바 코드도 작성하고 분석도 해보았으니 이젠 컴파일을 하여 실행을 해보는 일만 남았군요. 자바 코
드를 컴파일하는 방법과 실행하는 방법에 대해서는 이미 자바 개발 도구에서 자세히 다루었으므로 자바 컴파일러
(javac)나 런타임 인터프리터(java)에 대한 자세한 것은 생략하고 실질적인 실행법만을 알려드리도록 하겠습니다.
자 그럼 첫번째 자바 프로그램인 Hello, World!프로그램의 실행 방법을 알아볼까요.
우선 아래와 같이 HelloWorld라는 클래스 이름으로 자바 애플리케이션 프로그램을 작성하였으면 반드시 클래스
이름과 동일한 이름을 지니고 확장자가 ".java"로된 이름 "HelloWorld.java"라는 이름으로 반드시 저장하셔야 합니
다.
[POINT] 자바 코드안의 클래스 이름이 바로 코드 저장 파일명이 된다는 점
클래스 이름 => "클래스 이름.java"로 저장
[HelloWorld 클래스 코드]
--------------------------------------------------------------
class HelloWorld{
=========
public static void main(String args[])[
System.out.println("Hello World!, 환영 자바 이야기");
}
}
--------------------------------------------------------------
자바 코드를 "HelloWorld.java"로 저장하셨다면 이젠 자바 컴파일러(javac)를 이용해 자바 가상머신에서 실행할
수 있도록 바이트 코드인 클래스 파일을 만들어 주는 작업을 해야 합니다. 그 작업을 자바 컴파일러(javac)가 해주
며 다음과 같이 하면 됩니다.
[HelloWorld 컴파일]
--------------------------------------------------------------
javac HelloWorld.java
--------------------------------------------------------------
HelloWorld.java가 저장되어 있는 디렉토리로 이동을 한 후 위의 명령어를 실행시키면, 자바 컴파일러(javac)는
HelloWorld.java안의 문장들의 문법 검사를 우선적으로 하며, 만약 자바 문법에 어긋나는 문장이나 키워드등이 있
을 경우 이것을 화면 출력을 통해 프로그래머에게 알려줍니다. 이런 에러가 난 곳이 있다면 코드의 틀린 부분을
자바 문법에 맞게 재작성하여 다시 컴파일을 해야 합니다.
문법검사에서 아무런 에러가 나지 않았다면 자바 컴파일러(javac)는 자바 코드(HelloWorld)를 자바 가상 머신에서
작동할 수 있는 바이트 코드인 자바 클래스 파일을 같은 디렉토리내에 생성해 줍니다. 위 문장이 정상적으로 실행
이 되었다면 HelloWorld.java가 있는 디렉토리에서 파일 리스트를 보시면 HelloWorld.class라는 자바 클래스 파일
이 생성되어 있음을 알 수 있습니다. 확인해 보세요.
자바기초(4) / Hello,World!프로그램 실행
--------------------------------------------------------------------------------
자 그럼 이제 드디어 첫번재로 작성한 자바 애플리케이션 프로그램인 HelloWorld를 자바 가상 머신을 통해 실행
시켜 볼까요.
자바 가상 머신에서 자바 바이트 클래스를 실행시키기 위해서는 이미 알려드린바 있는 자바 런타임 인터프리터가
이용됩니다.
다음과 같이 HelloWorld의 코드 파일을 자바 컴파일러로 컴파일하여 생성된 클래스 파일인 HelloWrold.class파일
이 이용됩니다. 아래 문장이 HelloWorld클래스의 실행법입니다.
[HelloWorld의 실행]
--------------------------------------------------------------
java HelloWorld
--------------------------------------------------------------
[주의점] 자바 컴파일러(javac)를 이용해 자바 코드를 컴파일할 때 사용한 문장에서는 "javac HelloWorld.java"
와 같이 파일 이름뒤의 확장자까지 기입해 주었습니다. 그러나 자바 인터프리터로 자바 클래스 파일을 실행시
킬 경우에는 위 문장에서 보듯이 ".class"라는 확장자를 기입하지 않았습니다. 자바 인터프리터에서 자바 클래
스 파일을 실행시킬 경우 확장자인 ".class"를 기입하지 말아야 하며 자바 인터프리터는 ".class"를 기입하지 않
아도 스스로 알아서 실행을 시켜 줍니다.
이렇게 자바 인터프리터(java)로 HelloWorld클래스를 실행시켰을 경우 어떤 결과가 나올지 무척 기대가 되시죠.
결과는 아래 보는 것과 같이 화면에 단순히 주어진 문자열인 "Hello World!, 환영 자바 이야기" 를 출력할 뿐입니
다.
[HelloWorld의 결과]
--------------------------------------------------------------
Hello World!, 환영 자바 이야기
--------------------------------------------------------------
[HelloWorld 프로그램의 의미]
위와 같이 자바 클래스 파일을 자바 가상 머신에서 실행 시키는 방법에 대해 알아보았습니다.
비록 결과를 작은 것일지라도 이 작은 결과가 나오기 까지의 자바 프로그램의 코드 작성이나 컴파일과정, 그리고
실행과정, 또한 자바 프로그램의 작성 흐름과 수행 과정등 자바 언어 프로그래밍의 전반적인 이해가 되었을 것입
니다.
더 좋은 자바 프로그램을 작성하기 위해 자바의 기초 개념들에 대해 다음부터 알려드리도록 하겠습니다.
♣♣ [HTML] 쉬운 JDK1.1.4설치 ♣♣
--------------------------------------------------------------------------------
[문서에 대해]
실제 JDK1.1.4의 설치 과정을 글과 그림을 통해 설명한 HTML문서입니다.
[문서가 있는곳]
자바 이야기 자료실에 있습니다.
[문서 사용법]
적당한 디렉토리에 Winzip을 이용하여 압축을 푸신후 인터넷 브라우저를 통해 jdk.htm파일을 Open하시면
됩니다.
♣♣ [HTML] HelloWorld 작성/실행 ♣♣
--------------------------------------------------------------------------------
[문서에 대해]
자바 초보님들을 위해 자바 첫걸음 메뉴의 HelloWorld를 쉽게 실행 할 수 있도록, HelloWorld의 실제 실행 과정을
그림과 글을 통해 설명한 문서입니다. 자바 이야기 자료실에 있습니다.
[문서의 사용]
Winzip으로 압축을 푸신 후 HelloWorld.htm파일을 Open
애플릿(1) / 애플릿 정의
--------------------------------------------------------------------------------
[애플릿의 정의]
애플릿(applet)이란 무엇인가? 자바 하면 애플릿을 떠올릴 만큼 많은 인터넷 사용자들에게 화려함(정적인 웹 페이
지를 동적으로 만들 수 있는)으로 나타나 많은 인기를 얻고 있다. 애플릿은 인터넷등을(네트웍) 통하여 원격의 자
원에 접근하여 프로그램을 실행시켜 결과를 얻을 수 있는 프로그램을 뜻한다.
자바 애플리케이션 프로그램이 단독으로 실행이 되는데에 비해, 애플릿 프로그램은 브라우저등을 통하여 해석과
실행이 되므로 브라우저의 해석할 수 있는 여부와 보안에 대한 허용여부등에 따라 실행할 수 있는 기능에 있어 제
한 사항이 많기 때문에 자바 애플리케이션 보다 작은 범위의 자바 프로그램이다.
자바 애플리케이션 프로그램이 하나의 완벽한 프로그램을 작성한다면, 애플릿 프로그램의 경우에는 하나의 작은
일부분에 초점을 맞춰 간결하고 효율적으로 프로그래밍 하는 방식이다.
애플릿은 애플릿 뷰어(appletviewer)이나, 자바 지원 브라우저를 통해 실행 가능한 컴파일된 자바 프로그램이다.
애플릿으로 구현할 수 있는 것은 프로그래머의 능력에 달렸지만 대개 애니메이션이나 사운드, 웹을 통한 동적인
데이터 처리등을 위해 작성 작성되어 사용되고 있습니다.
애플릿은 java.awt.Panel의 서브클래스이기 때문에, 애플릿은 추상 윈도우 툴킷(Abstract Window Toolkit)과 자바
언어 패키지로부터 나오는 여러 가지의 특징들을 포함하고 있으며, 선(자바 언어를 만든회사)에서는 애플릿 프로그
램의 적성을 돕기 위해 자바 애플릿 패키지를 JDK의 CLASS 패키지로서 제공하고 있습니다.
애플릿(2) / 애플릿 인터넷 브라우저
--------------------------------------------------------------------------------
애플릿 프로그램은 작기 때문에 인터넷을 통해 빠르게 다운로드하여 실행할 수 있다는 점과 용량을 많이 차지하
는 프로그램을 설치할 필요없이 필요할 때마다 원격의 호스트로부터 필요한 파일만을 다운 받아 실행하여 시스템
의 용량을 많이 절약할 수 있다는 점등 애플릿은 인터넷의 변화에 많은 영향을 끼치기 시작했습니다.
많은 웹페이지들이 다양한 용도로 자바 애플릿 프로그램을 이용하고 있으며 다음은 애플릿 프로그램이 웹에서 주
로 사용되는 용도입니다.
1. 에니메이션
2. 사운드
3. 이미지
4. 텍스트 효과
5. 그래픽 효과
6. 게임
7. 대화
자바 애플릿은 웹브라우저 내부에 있던 기존 특성을 활용함으로서, 프로그래머로 하여금 최소한의 코드로 충분한
특성을 표현할 수 있게 해줍니다. 예를 들어 자바 애플릿에 GIF나 JPEG의 이미지 파일을 포함시키려고 할때, 이
이미지 화일 처리를 위한 어떤 다른 해석기법을 쓸 필요가 없이 브라우저에 내장된 해석 기법을 이용하면 됩니다.
만약 새로운 이미지 형태가 대중화되고, 그것이 브라우저에 반입되면, 자바 애플릿은 자동적으로 그 이미지 형태를
처리할 수 있을것입니다.
애플릿은 인터넷에 가장 잘 어울리는 것인데, 왜냐하면 그 크기를 줄이고, 다운로드 속도를 높이며, 애플릿 프로
그래밍을 단순화하기 위해 브라우저의 특성을 지렛대로 삼기 때문이다.
위 글만 보면 애플릿 프로그램이 간결하고 빠르게 다운받아 실행할 수 있다는 점과 브라우저의 특성을 이용할 수
있다는 점등이 좋은 점이지만, 애플릿 프로그램이 브라우저안에서 실행되는 만큼 브라우저가 애플릿을 해석하고
실행시키기 때문에 브라우저의 특성이 자바 애플릿의 기능을 많이 제한한다는 점을 명심하기 바랍니다.
자바 지원 브라우저를 통해 실행되는 애플릿의 제한사항에 대해서는 다음 글에서 알려드리도록 하겠습니다.
애플릿(3) / 애플릿 애플리케이션의 차이
--------------------------------------------------------------------------------
저번의 글에서도 애플릿은 애플리케이션 프로그램에 비해 많은 기능에 있어 제한이 따른다고 알려드린바 있습니
다. 이런 제한에 대해서는 다음 글에서 자세히 알려드리도록 하겠고, 이번에는 애플릿과 애플리케이션 프로그램의
차이점에 대해서 알려드리도록 하겠습니다.
[자바 애플릿 & 애플리케이션 차이점]
-------------------------------
1. 브라우저의 기능을 사용
2. 파일접근에서의 한계를 지님
3. 네트워크 접근에 한계를 지님
-------------------------------
첫째, 자바 단독 실행 프로그램인 애플리케이션 프로그램은 자바 개발 도구에 포함되어 있는 자바 클래스 패키지
만을 상속하여 모든 기능을 구현하지만 애플릿 프로그램은 네트웍을 통해 자바 지원 브라우저의 안에서 실행
되기 때문에 브라우저의 기능을 사용할 수 있음
둘째, 애플릿 프로그램이 네트웍을 통해 실행이 되는 프로그램이므로 보안상의 이유로 인해 파일 접근에 있어서
많은 제약을 지닌다. 그러나 애플리케이션 프로그램의 경우는 파일 접근(읽고/쓰기)에 있어 제약을 받지 않음.
특히, 애플릿의 경우 파일 쓰기에 있어 많은 제약이 따른다.
셋째, 역시 보안상의 이유로 애플릿은 어떤 원격의 호스트로부터 다운받아 자신의 시스템에서 실행시켰을 경우 다
운받아 실행되는 애플릿 프로그램에서는 자신의 원격 호스트(다운 받기전 애플릿 클래스 파일이 있던 곳) 이
외의 다른 호스트에 접근할 수 없다.
애플릿(4) / 애플릿 한계(1) / 기능상 제한
--------------------------------------------------------------------------------
아래 글들에서 애플릿이 한계에 대해 간략하게 몇 가지 알려드린바 있으나 이번 글을 통해 애플릿의 제약사항에
대해 자세히 알려 드리도록 하겠습니다.
애플릿 프로그램은 웹을 통해 다운되어 자신의 컴퓨터 내에서 실행이 된다. 그렇기 때문에 애플릿 프로그램에 많
은 제한을 둔 것이다.
쉽게 말하면 다음과 같이 표현할 수 잇다. 애플릿 프로그램을 누군가가 바이러스를 넣거나 정보를 빼내기 위한
해킹 프로그램을 포함시켜 교묘히 위장했을 경우 이것을 모르고 사용자가 위장된 애플릿 프로그램을 웹을 통해 다
운받아 실행시켰을 경우 시스템에 치명적인 에러를 유발할 수 있으며, 중요한 정보를 자신도 모르는 사이 에 외부
로 유출될 수도 있다.
웹을 통해 다운받아 자신이 로컬 시스템에서 실행이 되는 애플릿 프로그램은, 이런 위에서 예를 들어 설명한 문
제들 말고도 많은 문제가 야기될 수 있다. 그렇기 때문에 애플릿 프로그램의 기능 제한이나 브라우저를 통한 기능
제한 등을 통해 이런 문제를 해결하고자 다음과 같은 제한을 두게 되었음을 알아두세요.
[애플릿 자체(기능상)의 제한]
1. 이름에 의한 호출(call by name)
애플릿의 기능상의 제한으로서 첫번째 이름에 의한 호출(call by name)방식이 애플릿 메소드 변수의 검증 방식이
있다. 초보자들에게는 좀 어려운 개념으로 다음과 같이 설명할 수 있다. 자바 애플릿 코드에서 선언된 변수나 메소
드는 자바 컴파일러에 의해 해석되고 메모리에 선언된 변수이름으로 참조할 수 있는 메모리 공간을 할당하게 된
다. 이런 참조이름에 의해 애플릿 프로그램이 실행시 메모리의 정보를 얻어 오도록 하는 방법이다. 왜 이런 방법을
사용하는지 궁금하겠죠. 다음과 같은 이유에서 입니다. 만약 애플릿 프로그램도 실행을 하고 다른 여러가지의 프로
그램을 동시에 수행하고 있다고 생각해 보세요. 메모리에는 온통 여러가지의 프로그램들에 대한 정보가 저장되어
있을 것이며 이러한 정보들의 자신의 프로그램에만 정보를 전달하여야지 다른 프로그램에 의해 접근되어 정보를
유출될 수 있으므로 자바 언어에서는 Call by name방식의 호출만을 애플릿 프로그램의 실행에 허용하여 이러한
문제점을 막았습니다. 기존의 C/C++언어의 경우 포인터를 이용하여 메모리의 특정 주소의 정보를 마음대로 얻어
올 수 있는 등 정보의 보안에 많은 허점을 드러내고 있습니다.
[참고] 자바 언어는 C/C++의 포인터 방식을 사용하지 않기 때문에 안정성이나 보안성 등에서 우수합니다. 그러나
직접 메모리를 컨트롤하는 포인터에 비해 속도면에서 많이 뒤쳐지는 것이 사실입니다.
2. 파일 시스템 접근 제한
두번째 제한사항으로는 애플릿 프로그램은 개인 컴퓨터의 파일 시스템에 접근에 많은 제한을 지닙니다. 개인 파
일 시스템에 접근하게 된다면 파일 정보의 유출이나 변경등 심각한 문제가 발생할 수 있으므로 파일의 읽기나 쓰
기 등에 대해, 특히 파일 쓰기에 대해 거의 접근이 되지 않습니다.
한 예로 애플릿 프로그램을 통해 다운받아 실행중인 애플릿 프로그램에서 파일 일기가 된다면 애플릿을 실행하고
있는 개인 파일 시스템의 정보가 유출될 수 있으며, 쓰기 접근이 된다면 정보를 제가하거나 변경할 수 있는 문제
가 발생하게 됩니다.
3. 라이브러리 로딩 제한
세번째 제한으로는 다른 프로그래밍 언어로부터 동적 또는 공유 라이브러리를 로딩하는 데 제한이 있다는 것입니
다. 자바 언어는 C/C++와 같은 다른 언어의 라이브러리를 자바 가상 머신이 이용할 수 있게 해주는 native와 같은
메소드를 정의할 수 있습니다. 그러나 이 라이브러리들은 입증될 수 없고 파일에 대한 접근을 필요로 하기 때문에
애플릿 프로그램에서는 이런 동적 라이브러리의 사용에 제한을 두었습니다. 이런 동적 라이브러리를 아예 자바로
구현하여 다른 언어와의 연결의 필요성을 제거하고 보안성을 강화하였습니다. 아마 이것이 JDK를 설치할 때 두번
째 구성요소인 라이브러이와 헤더파일들이 아닐까 생각됩니다.
애플릿(5) / 애플릿 한계(2) /브라우저제한
--------------------------------------------------------------------------------
저번 글에서는 애플릿 자체의 기능상 제한에 대해 알려드렸죠. 이번 글에서는 브라우저에 의한 제한사항을 알려
드리겠습니다.
브라우저에서 애플릿의 기능을 왜 제한하는지 우선 알아야겠죠. 여러분들이 여러가지의 프로그램들을 가져다 자
신의 시스템에 설치하여 그 프로그램을 실행시켜 다양한 작업을 처리하고 결과를 얻습니다. 이런 과정에서 여러분
들은 어떤 작업을 위해 특정한 프로그램을 설치해야 하는데 이것이 자신의 시스템에 어떤 영향을 미칠지 생각해
보셨는지요. 인터넷 브라우저와 같은 프로그램은 웹은 검색할 수 있게 해주며, 이 브라우저 프로그램을 실행시켜도
이 프로그램은 이미 여러차례의 인증을 마쳤고 또한 자신의 운영체제등에 아무런 영향을 주지 않는 신뢰할 수 있
는 프로그램인 반면, 애플릿의 경우는 대개 웹을 통해 다운받아 실행해야 하므로 애플릿 프로그램 안에 어떠한 내
용이 포함되어 있는지 실행이 되기 전에 알 수 없습니다. 애플릿을 받아오는 브라우저에서 애플릿을 받아올때 아
무런 검사도 하지 않고 그대로 실행을 시킨다면 이 애플릿 프로그램이 시스템이나 운영체제에 치명적인 문제를 발
생시킬 수 있습니다. 그렇기 때문에 브라우저에서 애플릿의 실행의 검증은 물론 여러가지의 제한을 두고 있습니다.
그럼 브라우저에서 애플릿에 어떠한 제한을 두는지 알아볼까요.
브라우저의 제한으로는 네트워크 접속의 제한이 있습니다.
네트워크 접속의 제한이란 애플릿이 다운로드되는 웹 서버와는 접속을 할 수 있지만 그외의 다른 호스트 컴퓨터
에 대해서는 접속을 하지 못하도록 브라우저에서 제한을 하고 있습니다. 왜냐하면 만약 애플릿이 자신이 다운로드
되는 웹 서버 이외의 다른 인터넷의 많은 호스트 컴퓨터와 연결이 된다면 자바의 강력한 기능을 이용하여 그 호스
트 컴퓨터에 충분히 문제를 일으킬 수 있기 때문이죠
브라우저에서 애플릿 프로그램의 네트워크 접속을 제한하는 것은 애플릿 사용에 많은 제약을 주지만, 그것은 시
스템의 보안이라는 이점을 주기도 합니다. 앞으로 더욱 훌륭한 보안 방법이 개발되고 네트워크 접속의 제약이 점
차 사라진다면 애플릿은 더욱 많은 기능을 갖게 될 것입니다.
애플릿(6) / 애플릿 계층구조
--------------------------------------------------------------------------------
자바 클래스의 계층 구조의 상속에 따라 애플릿은 추상 윈도우 툴킷(AWT) 내의 Panel객체를 확장하며, 아래의
그림처럼 Container클래스의 서브 클래스 입니다.
[애플릿 클래스의 상속구조]
java.lang.Object
|
java.awt.Component
|
java.awt.Container
|
java.awr.Panel
|
java.applet.Applet
Container클래스는 버튼이나, 메뉴, 스크롤바등의 컴포넌트를 포함할 수 있는데, 자바 언어 계층구조에 따른 상속
의 특성에 따라 애플릿은 상위 클래스들의 이러한 여러가지 성질들을 상속받음
애플릿은 init(), start(), stop(), destory()메소드를 이용하여 애플릿의 초기화, 시작, 중지, 파괴등의 단계의 작업을
수행할 수 있도록 해줍니다.
이 네가지의 메소드에 대해서는 다음글에서 자세히 알려드리도록 하겠습니다.
애플릿(7) / 애플릿 4가지 필수 메소드
--------------------------------------------------------------------------------
애플릿이 웹 브라우저 상에서 실행되는 데는 init, start, stop, destory메쏘드 이렇게 4가지의 메소드가 필요하지
만, 사용자가 만드는 애플릿에서 4가지의 메소드중 어느 것을 구현하지 않으면 부모 클래스인 애플릿 클래스에 구
현되어 있는 아무 일도 하지 않는 빈 메소드를 호출합니다.
[참고] 사용자 애플릿이란 java.applet.Applet클래스를 확장하여 사용자가 필요한 어떤 작업을 처리하기 위해 작성
한 애플릿을 말한다.
이러한 4가지의 메소드는 애플릿뷰어나 브라우저가 애플릿의 실행에 있어 필수적으로 호출하기 때문에 이것을 오
버라이드(재정의)하여 필요한 작업을 넣어주면 됩니다.
[애플릿의 필수 메소드 4가지]
아래 사용자 애플릿 코드는 일반적인 애플릿의 4가지 메소드의 사용예제이다.
import java.applet.Applet;
public class javaStoryApplet extends Applet{
public void init(){ 애플릿 초기화 }
public void start(){ 쓰레드 시작 }
public void stop(){ 쓰레드 종료 }
public void destory(){ 애플릿 파괴 }
public void paint(Graphics g){ 그래픽 작업 }
}
[애플릿 필수 메소드 설명]
init()
- 애플릿의 초기화를 위해 브라우저나 애플릿 뷰어에서 제일 먼저 호출되는 메소드이다.
- 애플릿이 브라우저에 로드될때 단 한번만 호출된다.
- 애플릿이 실행되는 기간동안 사용할 자원을 할당받거나 초기화를 위해 오버라이드(재정의)하여 사용한다.
[참고] 오버라이드(재정의) : 부모 클래스에서 이미 정의된 메소드를 서브 클래스에서 여러가지 기능을 추가한
메소드로 다시 재정의하여 사용하는 것을 의미합니다.
- 사용자 애플릿에서는 애플릿의 초기화(변수 선언이나 이미지 로드등)을 위해 사용하나 초기화할 것이 없다면 재
정의하지 않아도 되며, 그럴경우에는 사용자 클래스의 부모 클래스인 java.applet.Applet클래스의 init()메소드가
호출되어 사용된다.
start()
- init()메소드의 모든 과정이 완료되어 애플릿을 실행할 준비가 되면 애플릿 뷰어나 브라우저가 이 메소드를 호출
하게 된다.
- start()메소드는 주로 init()메소드에서 선언된 Thread등을 실행시킬 때 주로 사용된다. (예) 사운드 연주, 지속적
인 에니메이션
[참고] 쓰레드(Thread) : 지속적이고 연속적인 작업을 처리하는데 사용. 자세한 것은 문법메뉴에 있는 글을 참
고하기 바람, 차후 다시 쓰레드에 대해 알려드리도록 하겠습니다.
- init()메소드와는 달리 애플릿 실행중에 여러번 호출될 수 있으며, 애플릿이 처음 실행되거나 브라우저에서 애플
릿이 있는 HTML의 페이지를 떠났다가 다시 되돌왔을 때 브라우저가 이 메소드를 호출하여 재실행을 시킵니다.
- start()메소드를 구현했으면 다음에 나올 stop()메소드를 구현해 주어야 함
stop()
- 애플릿을 벗어나거나 브라우저 상의 애플릿이 포함된 HTML문서를 벗어날을 경우 브라우저에 의해 stop()메소
드가 호출되어 위의 start()메소드 안에서 계속 실행되고 있는 쓰레드(Thread) 작업을 종료하는 기능을 합니다.
- stop()메소드도 start()메소드와 마찬가지로 브라우저에 의해 여러번 호출되어 질 수 있습니다.
- start()메소드와 stop()메소드는 쌍으로 함께 사용하셔야 합니다.
destory()
- destory()메소드는 애플릿을 종료거나 브라우저가 종료될 경우 자동으로 이 destory()메소드를 호출하여, 애플릿
에 할당한 자원이나 애플릿 자체를 완전히 제거하기 위해 브라우저 또는 애플릿 뷰어가 이 메소드를 호출하여 그
러한 작업을 처리합니다.
- destory()메소드는 애플릿 객체가 파괴될때 단 한번만 호출되어 집니다.
이미지 파일과 버튼, 레이블과 같은 컴포넌트는 모두 리소스에 해당하므로 당연히 init()메소드에서 초기화되고 로
딩해야 한다. 클래스에서 선언된 대부분의 인스턴스 변수는 변수 선언 규칙에 의해 적당한 초기값을 갖게 되지만
리소스는 할당되기 전까지 null값을 갖고 있기 때문에 리소스 객체는 new연산자를 통해 객체를 생성한 후 할당해
야 한다. 이렇게 생성한 객체는 애플릿이 종료될때, 즉, destory()메소드가 호출될 때 메모리에서 제거되며 애플릿
도 파괴된다.
애플릿(8) / 애플릿 클래스 확장
--------------------------------------------------------------------------------
애플릿은 AWT내의 Panel객체의 속성들과 java.applet.Applet클래스로부터 애플릿 클래스 속성들을 상속받습니다.
모든 사용자가 만드는 애플릿의 구성되는 방법에 있어 동일합니다.
사용자 애플릿을 작성하기 위해 기본 java.applet.Applet클래스를 사용자 애플릿 프로그램의 코드에서 다음과 같이
작성해야 합니다.
[사용자 애플릿 초기화]
-------------------------------------
import java.applet.Applet;
public class appletName extends Applet{
또는
public class appletName extends java.applet.Applet{
-------------------------------------
1. 프로그래머가 자신의 애플릿을 만들려면 위에서 보는 것과 같이 우선 기본 애플릿 클래스인 java.applet.Applet
클래스를 import(수입문장)을 통해 작성하고자 하는 애플릿 프로그램에 java.applet.Applet클래스 안에 정의된 여러
기능들을 사용할 것을 자바 컴파일러에게 알려주어야 만이 두번째 문장에서 보듯이 수입된 클래스인 Applet을 사
용할 수 있습니다.
2. 두번째로 애플릿 프로그램은 모두 위의 문장에서 수입한 Applet클래스를 확장하여 사용하게 되어 있으므로
extends키워드를 사용해 앞에는 사용자의 애플릿 이름을 뒤에는 확장하고자 하는 기본 Applet클래스를 기입해 주
시면 됩니다.
3. 세번째 문장에서 처럼 확장하고자 하는 클래스 이름의 패키지명을 전부 써준다면 수입문장을 사용해 import할
필요가 없습니다.
4. [참고] 두번째 문장에 보면 맨앞에 public으로 접근 제한자를 설정하고 있는것이 보이는데, 애플릿의 경우 인터
넷등 네트워크 상에서 다운 받아 실행해야 하므로 클래스에 대한 접근이 public으로 설정이 되어야만이 애플릿이
실행이 됩니다.
애플릿(9) / 애플릿 HTML관계및 사용
--------------------------------------------------------------------------------
애플릿 코드가 자바 컴파일러에 의해 컴파일되어 생성된 바이트 코드인 클래스 파일은 JDK에서 지원하는 애플릿
뷰어나 자바 지원 브라우저를 통해 수행시킬 수 있습니다. 그러나 애플릿 프로그램을 자바 애플리케이션 처럼 자
바 런타임 인터프리터로는 실행시킬 수 없고 브라우저나 애플릿 뷰어가 HTML 문장에서 애플릿 프로그램을 호출
하여 실행할 수 있게 해주는 <applet>이라는 HTML태그를 지원합니다.
자바 애플릿 프로그램의 실행은 다음과 같은 내용으로 됩니다.
자바 지원 브라우저니 애플릿 뷰어에서는 HTML문장을 해석하여 브라우저에 표현할 수 있는데, 브라우저가 이런
HTML문장내에 자바 애플릿 프로그램의 실행을 의미 하는 <applet>태그를 발견했을 경우 <applet>태그 안에 기
입해준 애플릿 클래스를 브라우저를 통해 앞에서 알려드린 바 있는 애플릿의 4가지 필수 메소드를 단계적으로 호
출 함으로서 애플릿 프로그램을 브라우저를 통해 실행시킬 수 있습니다.
위 글을 보시면 브라우저나 애플릿 뷰어를 통해 애플릿을 실행시키기 위해 어떠한 것들이 필요한지 대충할 수 있
을 것입니다. 정리를 하자면
1. 자바 지원 브라우저 또는 JDK의 애플릿 뷰어
2. 컴파일된 바이크 코드인 클래스 파일
3. 기본적인애플릿 정보와 매개변수들을 포함하는 HTML파일
자 그럼 이젠, 브라우저나 애플릿 뷰어를 통해 애플릿 프로그램을 실행시키기 위한 기본적인 HTML파일을 적성
에 대해 알려드리겠습니다.
[애플릿 실행 HTML]
--------------------------------------------------------
<html>
<applet code="appletClassName.class" width=300 height=300>
</applet>
</html>
--------------------------------------------------------
[HTML 설명]
브라우저나 애플릿 뷰어가 HTML문장을 만나서 해석을 하는중 <applet>태그가 있다면 다음과 같이 <applet>태
그를 인식하며 실행을 시킵니다.
1. <applet>도 HTML문법과 같이 시작과 끝을 다음과 같이 표현합니다.
<applet></applet>
2. <applet>태그 안에 code="appletClassName.class"부분은 브라우저나 애플릿 뷰어를 통해 실행시키고자 하는 애
플릿 클래스 파일의 이름을 적어주시면 됩니다. 위 문장은 appletClassName.class애플릿 프로그램을 브라우저를 통
해 실행시키킬 것을 알리는 문장입니다.
3. 클래스 이름뒤에 나오는 width나 height는 브라우저나 애플릿 뷰어의 화면에 얼마만큼의 영역을 애플릿 프로그
램의 실행을 위해 할당해 줄 것인지를 기입하시면 됩니다.
애플릿 실행을 위해 HTML문장 안에서 사용되는 <applet>태그에는 애플릿 실행에 대한 여러가지 정보를 다루기
위한 여러 <param>태그와 매개변수들을 지원하는데 간략히 살펴 보도록 하겠습니다.
[<param>태그의 사용]
--------------------------------------------------------
<html>
<applet code="appletClassName.class" width=300 height=300>
<param name="parameter" value="value">
</applet>
</html>
--------------------------------------------------------
<param>태그
- <param>태그는 매개변수의 이름과 그 값을 애플릿 프로그램 실행시 지정할 수 있게 해줌
- HTML차원(HTML문서)에서 <param>태그를 이용해 자바 애플릿에 변하는 변수의 값을 지정하므로서 자바 코
드를 재컴파일을 할 필요가 없다.
- 위의 예제처럼 <param 다음에 name이라는 매개변수의 이름을 정의하고 value다음에 값을 넣어주면 된다.
- 이 <param>태그를 이용해 HTML에서 값을 받아 사용할려면 애플릿 프로그램에 다음과 같은 코드를 첨가해야
한다.
String htmlInputValue=getParameter("parameter");
if(htmlInputValue==null){
htmlInputValue="입력되지 않을 때 기본값";
}
- 위 parameter라는 이름으로 문자열 htmlInputValue의 값을 애플릿 실행을 위한 HTML문서의 <applet>태그 안
의 <param> 태그 사용에 값을 외부에서 받아들여 사용하는 것입니다.
- if처리문은 HTML문서상에서 <param>태그로 htmlInputValue의 값을 입력 받게 되어있는제 이것이 입력되지
않았을 경우 기본값으로 사용할 문자열값을 지정하는 것입니다.
다음은 <applet>태그의 사용에 대해 브라우저에게 애플릿에 대한 정보를 제공할 수 있는 매개변수들입니다. 자세
한 사용법은 차후 실제 애플릿 프로그램의 사용시 알아보도록 하고 우선 매개변수들의 기능에 대해 알려드리도록
하겠습니다.
[<applet>태그의 일반적인 형태]
---------------------------------------------------------------
<applet codebase="codebaseURL"
code="appletFile"
alt="alternateText"
name="appletInstanceName"
width=pixelValue
height=pixelValue
align=alignment>
<param name="parameter1" value="value1">
<param name="parameter2" value="value2">
...
</applet>
---------------------------------------------------------------
[<applet>태그의 매개변수들]
---------------------------------------------------------------
codebase : 자바 클래스 파일이 위치한 곳을 기본 URL로 지정합니다.
이 URL를 기준으로 브라우저를 통해 실행할 애플릿 클래스인 code매개변수 뒤에 지정한 애플릿 클래스
를 찾습니다.
code : <applet>태그속에 꼭 필요한 요소로서 브라우저를 통해 실행할 애플릿 클래스의 실제 위치를 기입해 줍니
다.
width : 브라우저에 애플릿 프로그램의 실행을 위해 얼마만큼의 넓이(가로)를 할당해 줄 것인지를 지어해 줍니다.
height : 브라우저에 애플릿 프로그램의 실행을 위해 얼마만큼의 폭(세로)를 할당해 줄 것인지를 지어해 줍니다.
alt : HTML문서의 <alt>태그와 같이 자바가 지원되지 않는 브라우저에서 애플릿을 실행시킬경우 실행이 되지않
을때 대신 나타나는 문자열를 기입해 주시면 됩니다.
name : 실행될 애플릿에 대해 특정한 이름을 지정하여, 이 이름으로 같은 HTML 페이지내에서 실행중인 다른 애
플릿과 통신을 하기 위함이다.
vspace : <align>태그를 가지고 애플릿을 오른쪽 또는 왼쪽으로 정렬할 때 애플릿 주위의 수직의 여백을 지정
hspace : <align>태그를 가지고 애플릿을 오른쪽 또는 왼쪽으로 정렬할 때 애플릿 주위의 수평의 여백을 지정
align : left, right, top, texttop, middle, absmiddle, baseline, buttom, absbotton등의 지정할 수 있다.
<img>태그에서의 의미와 같다.
---------------------------------------------------------------
이제까지 살펴본 애플릿에 대한 개념적인 것들을 바탕으로 다음 글에서는 직접 애플릿의 작성과 컴파일및 실행
과정에 대해 알려드리도록 하겠습니다.
애플릿(10) / Hello 애플릿 작성
--------------------------------------------------------------------------------
지금까지 살펴본 애플릿에 대한 내용들을 바탕으로 초보자들을 위한 HTML문장을 통해 이름을 받아들여 인사하
고, 각 애플릿의 단계를 콘솔에 출력하는 간단한 애플릿을 작성해 보고 분석을 한후 실행 방법까지 알려드리도록
하겠습니다.
그럼 우선 helloApplet애플릿을 작성해 보겠습니다.
[helloApplet 작성]
----------------------------------------------------------
import java.applet.Applet;
import java.awt.*;
public class helloApplet extends Applet{
String yourName;
public void init(){
System.out.println("helloApplet 애플릿의 init() 시작 부분입니다.");
yourName=getParameter("name");
if(yourName==null){
yourName="자바 이야기";
}
System.out.println("helloApplet 애플릿의 init() 끝 부분입니다.");
}
public void start(){
System.out.println("helloApplet 애플릿의 start()상태입니다.");
}
public void stop(){
System.out.println("helloApplet 애플릿의 stop()상태입니다.");
}
public void destory(){
System.out.println("helloApplet 애플릿의 destory()상태입니다.");
}
public void paint(Graphics g){
System.out.println("helloApplet 애플릿의 paint()상태입니다.");
g.drawString("Hello! "+yourName, 40,100);
}
}
----------------------------------------------------------
애플릿(11) / Hello 애플릿 분석
--------------------------------------------------------------------------------
저번 글에서 작성한 helloApplet 애플릿에 대해 분석을 해보도록 하겠습니다.
[helloApplet 애플릿 분석]
1. import java.applet.Applet;
------------------------
첫번째 수입문장입니다. 위 문장을 통해 기본 Applet클래스를 지금 작성하고자 하는 helloApplet에 불러들입니다.
애플릿 프로그램에서는 반드시 첨가해 주셔야 합니다.
2. import java.awt.*;
-----------------
아래 paint()메소드에서 사용한 Graphics가 속한 패키지입니다.
helloApplet 애플릿에서 paint()메소드의 Graphics객체를 이용하여 애플릿 화면에 무언가를 그리기 위해 수입합니
다.
Graphics객체가 화면객체를 뜻합니다. 아래에서 g.drawString()메소드가 보이는데 쉽게 말해 g(화면)에 문자를 그
려달라는 명령입니다.
4. public class helloApplet extends Applet{
--------------------------------------
이 문장이 바로 사용자가 작성한 helloApplet프로그램이 애플릿 프로그램임을 뜻하는 문장입니다.
기본적인 기능만 갖춘 java.applet.Applet클래스를 확장한 사용자 애플릿인 helloApplet이라는 애플릿 클래스 만들
겠다는 의미입니다.
public접근 제한자는 애플릿의 경우 대개 인터넷을 통해 다운받아 실행이 되므로 모든 사용자가 접근할 수 있어
야 하므로 public으로 접근 제한을 선언하여 모든 사용자로부터 helloApplet클래스 실행을 할 수 있게 하였습니다.
[참고] 자세한 것은 문법메뉴의 접근 제한자에 대한 글을 참고하세요.
5. String yourName;
-----------------------
HTML의 매개변수로서 이름을 입력받아 저장해둘 기억공간입니다.
문자열 타입의 yourName을 전역 변수로서 선언하였습니다.
helloApplet에 있는 모든 메소드인 init(), start(), stop(), destory(), paint() 각각의 블록 범위를 모두 포함하는
Applet{ }블록 범위내에 선언되었기 때문에 상위 블록 범위내에서 선언된 문자열 타입인 yourName은 모든
init(),start(), stop(), destory(), paint()안에서 사용할 수 있습니다.
7. public void init(){
-----------------
애플릿의 필수 메소드중 첫번째 메소드인 init()부분입니다.
helloApplet애플릿에서 사용할 변수들의 값을 초기화하는데 사용합니다.
애플릿 실행시 단 한번만 실행이 됩니다.
8. System.out.println("helloApplet 애플릿의 init() 시작 부분입니다.");
----------------------------------------------------------
이 문장은 단순히 현재의 helloApplet애플릿이 어떤 상태에 있는지를 콘솔(화면)에 문자열로 표시해 주기 위해 사
용한 문장입니다.
helloApplet애플릿 클래스의 init()메소드의 실행에 처음 들어갈때 출력이 됩니다.
9. yourName=getParameter("name");
--------------------------------
getParameter()메소드를 이용해 HTML로부터 yourName에 들어갈 이름을 받아옵니다. 인자로서 주어진 "name"
은 HTML의 <param>태그안에 name의 값이 됩니다.
HTML에서 name이라는 값을 지정하는 예입니다.
----------------------------------
<param name="name" value="전덕찬">
----------------------------------
10. if(yourName==null){
--------------------
이 부분은 위의 8번째 문장에서 HTML문장의 <param>태그를 통해 yourName의 값을 받아들이게 되있는데 만약
HTML문장에서 yourName의 값을 주지 않거나 <param>태그의 잘못된 사용으로 값을 받아들이지 못할 경우
yourName에는 아무런 값도 없는 상태인 null상태가 계속 유지됩니다. 그럴 경우 if조건문을 사용하여 판단하여
null인 경우에는 아래 11번 문장을 실행하고, HTML에서 값을 받아들였을 경우 10번 문장을 실행하지 않도록 하는
것입니다..
11. yourName="자바 이야기";
-------------------------
10번 문장에서 HTML를 통해 yourName의 값이 입력되지 않았을 경우, yourName에 기본값으로 "자바 이야기"라
는 값을 넣도록 한 것입니다.
11. }
----
if구문 블록 범위의 종료
12. System.out.println("helloApplet 애플릿의 init() 끝 부분입니다.");
---------------------------------------------------------
helloApplet애플릿 클래스의 init()메소드 안의 모든 문장을 실행하고 init() 부분을 빠져나가기 전에 끝으로 콘솔
(화면)에 위 문장을 출력하여 현재의 진행 상태를 표시합니다.
13. }
----
init()블록 범위의 종료
15. public void start(){
--------------------
애플릿의 필수 메소드중 두번째 메소드인 start()메소드입니다.
init()메소드의 실행을 마친후 start()메소드가 호출되어 실행됩니다.
쓰레드의 초기화및 생성을 주로하는 곳입니다.
차후 쓰레드의 사용에 대한 글에서 알려드리도록 하겠습니다.
stop상태에서 다시 start()상태로 여러번 실행될 수 있습니다.
16. System.out.println("helloApplet 애플릿의 start()상태입니다.");
--------------------------------------------------------
helloApplet애플릿 클래스의 start()메소드 안을 실행하고 있을때 이 문장이 실행이 되어 현재의 상태를 표시해 줍
니다.
17. }
----
start()블록 범위의 종료
19. public void stop(){
--------------------
helloApplet애플릿 클래스의 stop()메소드 부분입니다.
주로 start()메소드등에서 선언된 쓰레드등을 종료시킬 때 이용됩니다. 브라우저의 페이지에서 애플릿 실행을 종료
하거나 중지시켰을 경우 실행됩니다.
start()와 stop()메소드는 쌍으로 사용됩니다.
start()와 stop()과정은 여러번 호출되어 사용될 수 있습니다.
14. System.out.println("helloApplet 애플릿의 stop()상태입니다.");
--------------------------------------------------------
helloApplet애플릿 클래스의 stop()메소드가 실해되고 있을때 콘솔에 현재 상태를 표시해
줍니다.
15. }
----
stop()블록 범위의 종료
17. public void destory(){
----------------------
브라우저 완전히 종료되어 메모리로부터 helloApplet을 적재하고 있을 필요가 없을 경우 브라우저는 destory()메
소드를 호출하여 메모리로부터 완전히 helloApplet에 대한 정보를 제가(파괴)합니다.
자바 언어는 자동 가베지 콜렉션(쓰레기 수집기)방식으로 블록의 범위를 벗어난 변수나 필요없는 객체등을 자동
으로 수집해 제가하여 줍니다.
18. System.out.println("helloApplet 애플릿의 destory()상태입니다.");
----------------------------------------------------------
destory()메소드의 실행시 콘솔에 현재 destory()실행 상태임을 알려줌
19. }
----
destory()블록 범위의 종료
21. public void paint(Graphics g){
------------------------------
모든 애플릿에 무엇가를 그리기 위해서는 paint()메소드를 재정의 하여야 합니다. 인자로서 주어지는 Graphics객
체인 g는 그래픽 객체를 뜻하는 것으로 보통 현재의 애플릿 화면(Canvas : 무언가를 그릴수 있는 컨테이너)을 뜻
합니다.
Graphics객체는 java.awt.*패키지 안에 포함되어 있으므로 수입문장인 import를 사용하여 수입시켜야 합니다.
22. System.out.println("helloApplet 애플릿의 paint()상태입니다.");
--------------------------------------------------------
현재 helloApplet이 paint()메소드 안을 실행하고 있음을 콘솔에 표시합니다.
23. g.drawString("Hello! "+yourName, 40,100);
----------------------------------------
그래픽 객체인 g에 "Hello!" 와 HTML에서 받아들인 문자열을 합쳐 x,y좌표 40,100에 문자열을 그립니다.
drawString()메소드는 문자열을 그려주는 메소드로서 첫번째 인자를 그릴 문자열, 두번째 세번째 인자를 문자열이
그려질 x,y좌표를 취합니다.
24. }
----
paint()블록 범위의 종료
25. }
----
helloApplet블록 범위의 종료
다음 글에서는 helloApplet애플릿을 컴파일하고 실행하는 방법에 대해 알려드리도록 하겠습니다.
[helloApplet 애플릿 소스 코드]
----------------------------------------------------------
import java.applet.Applet;
import java.awt.*;
public class helloApplet extends Applet{
String yourName;
public void init(){
System.out.println("helloApplet 애플릿의 init() 시작 부분입니다.");
yourName=getParameter("name");
if(yourName==null){
yourName="자바 이야기";
}
System.out.println("helloApplet 애플릿의 init() 끝 부분입니다.");
}
public void start(){
System.out.println("helloApplet 애플릿의 start()상태입니다.");
}
public void stop(){
System.out.println("helloApplet 애플릿의 stop()상태입니다.");
}
public void destory(){
System.out.println("helloApplet 애플릿의 destory()상태입니다.");
}
public void paint(Graphics g){
System.out.println("helloApplet 애플릿의 paint()상태입니다.");
g.drawString("Hello! "+yourName, 40,100);
}
}
----------------------------------------------------------
애플릿(12) / Hello 애플릿 컴파일
--------------------------------------------------------------------------------
helloApplet의 컴파일및 실행 밥법에 대해 알려드리도록 하겠습니다.
자바 애플릿 프로그램이나 애플리케이션 프로그램은 모두 컴파일 과정은 똑같습니다. 클래스 이름으로 저장을
한 후 자바 컴파일러인 "javac.exe"로 컴파일을 해주는 것이지요.
우선 텍스트 편집기나 자바 툴을 이용하여 helloApplet애플릿을 모두 작성하였다면, 애플릿 클래스 이름이
helloApplet이므로 "helloApplet.java"라는 이름으로 적당한 디렉토리에 저장을 합니다.
도스 프롬프트(창) 상태로 실행하여 "helloApplet.java"저장한 디렉토리로 이동한 후 "helloApplet.java"라는 파일
이 있는지 dir로 확인을 합니다.
"helloApplet.java"라는 파일이 있으면 이젠 "helloApplet.java"애플릿 프로그램의 컴파일을 다음과 같이 합니다.
[helloApplet애플릿 프로그램 컴파일]
-------------------------------
javac helloApplet.java
-------------------------------
[주의]
자바 소스를 컴파일할때는 반드시 클래스이름과 함께 확장자까지 모두 적어주셔야 합니다.
위와 같이 "helloApplet.java" 자바 애플릿 소스 코드 파일을 컴파일 하면 helloApplet.class라는 자바 바이트 코드
인 클래스 파일이 같은 디렉토리에 생성됩니다. 생성되었는지 "dir"명령을 쳐서 확인해 보세요.
helloApplet.java
helloApplet.class
위 파일 2개가 디렉토리에 있을 것입니다.
만약 컴파일시에 에러가 나온다면 helloApplet의 소스 코드를 다시 보시고 틀린 곳을 수정해 주신 후
helloApplet.java인 같은 이름으로 저장하신 후 다시 컴파일 하시면 됩니다.
자바 애플릿 프로그램은 애플리케이션과는 다른 HTML의 <applet>태그를 통해 실행시킨다고 알려드린 바 있습
니다. 다음 글에서는 애플릿의 실행에 대해 알려드리도록 하겠습니다.
애플릿(13) / Hello 애플릿 실행
--------------------------------------------------------------------------------
helloApplet애플릿 프로그램을 컴파일 과정까지 마쳤다면 이젠 HTML을 통해 브라우저에서 실행을 시켜 보아야
겠지요.
여러 차례 말했지만 애플릿 프로그램은 자바를 지원하는 브라우저나 자바 개발도구(JDK)안에 포함되어 있는 애
플릿 뷰어를 통해 실행시킬 수 있습니다.
애플릿 프로그램은 HTML의 <applet>태그를 사용하여 실행이 되므로 25번글에서 알려드린 대로 <applet>태그를
통해 애플릿 프로그램을 실행시키려 됩니다. 자 그럼 hello.html이라는 helloApplet애플릿 프로그램 실행 HTML파
일을 작성해 보겠습니다.
[hello.html작성]
-------------------------------------------------
<html>
<body>
<applet code="helloApplet.class" width=300 height=300>
<param name="name" value="전덕찬">
</applet>
-------------------------------------------------
[hello.html실행]
-------------------------------------------------
1. 자바 지원 브라우저를 통한 실행
자바 지원 브라우저를 통해 실행시킬 경우에는 helloApplet자바 소스코드를 컴파일하여 생성된 바이트 코드인
helloApplet.class클래스 파일과 위의 hello.html파일이 같은 디렉토리에 있어야 하며, 브라우저를 통해 hello.html파
일을 open시켜 주시면 됩니다.
그러면 브라우저는 hello.html파일의 태그들을 해석하며 <applet>태그를 만나 helloApplet의 필수 메소드등을
차례대로 호출하고 해석하여 브라우저의 페이지내에 helloApplet의 결과를 출력합니다.
2. 애플릿 뷰어를 통한 실행
애플릿 뷰어도 브라우저와 마찬가지로 helloApplet.class파일과 hello.html 파일이 같은 디렉토리에 존재해야 하
며, 애플릿 뷰어는 다음과 같이 실행을 시킵니다.
appletviewer hello.html
도스 프롬프트 상태로 잠시나와 helloApplet.class와 hello.html파일이 있는 곳에서 위 문장을 실행시키면 잠시
후 윈도우95의 화면으로 이동을 하여 애플릿 뷰어가 hello.html안의 태그를 해석하여 helloApplet클래스 파일을 실
행시킵니다.
[helloApplet애플릿 프로그램의 결과]
--------------------------------
이제까지의 helloApplet의 모든 실행과정을 마쳤다면 다음과 같은 결과가 브라우저나 애플릿 뷰어의 x좌표 40과
y좌표 100 이 되는곳에
Hello! 전덕찬
이라는 문자열이 그려질 것입니다.
그리고 화면(콘솔)에는 다음과 같이 현재 상태를 문자열로 표시가 됩니다. 참고로 애플릿 뷰어는 도스 프롬프트에
아래 메세지가 나타나고, 브라우저는 Communicator메뉴의 자바 콘솔창을 열면 그곳에 나타납니다. 브라우저의 경
우는 한글 지원에 문제가 있는지 한글이 깨져가 나오는 군요.
[helloApplet실행시]
helloApplet애플릿의 init() 시작 부분입니다.
helloApplet애플릿의 init() 끝 부분입니다.
helloApplet애플릿의 start() 상태입니다.
helloApplet애플릿의 paint() 상태입니다.
[helloApplet종료시]
helloApplet애플릿의 stop() 상태부분입니다.
-------------------------------------------------------------
destory()메소드의 상태 표시가 나타나지 않는데 이 메소드의 경우 브라우저의 종료나 애플릿뷰어의 종료시 즉 완
전히 프로그램이 종료될 때 나타나기 때문에 프로그램의 실행 상태에서 벗어나 메세지를 출력하지 않습니다.
이것으로 helloApplet에 대한 글을 마치도록 하겠습니다. HTML문서를 작성과 실행 과정을 쉽게 다시 설명하도록
하겠습니다.
자바개념(1) / 객체지향(1) / 객체
--------------------------------------------------------------------------------
대다수의 프로그래밍 언어에서 객체지향이라는 단어를 사용하였고, 자바 언어 또한 객체, 클래스, 패키지, 인터페
이스등을 내세워 객체지향 프로그래밍을 구현하고 있다. 그럼 자바 언어에서 객체지향 프로그램밍을 위해 사용하
는 객체, 클래스, 패키지, 인터페이스등과 객체지향 프로그램과 관련된 많은 개념들을 이번 시간부터 알려드리도록
하겠습니다.
왜 객체지향의 기술을 사용하려 하는가를 궁금해 하시는 분들도 있겠지만, 객체지향의 기술을 사용하면 프로그램
의 디자인(설계)에 있는 많은 장점들을 제공합니다. 객체지향 기술의 장점에 대해서는 앞으로의 글들을 통해 알려
드릴 것입니다. 이러한 객체지향 기술의 장점을 이용하려면 객체지향 기술에 대한 완벽한 이해가 필요한데 프로그
래밍 경험이 없는 초보자분들에게는 좀 이해하기 어려운 내용이 될 것입니다. 그러나 이 객체지향에 대한 내용을
계속적인 학습으로 어느 정도 이해를 한다면 차후 자바 프로그래밍 과정에서 많은 도움이 될 것이며, 또한 객체지
향적인 우수한 프로그램을 작성할 수 있을 것입니다.
객체지향 기술의 의미부터 알아보자
객체지향이란 기술의 의미는 프로그래머로 하여금 실제 세계가 존재하는 것과 비슷하게 프로그램을 디자인(설계)
할 수 있게 한다것을 의미합니다.
위 객체지향을 한마디로 표현한 문장인데, 잘 이해가 안갈것이다. 그럼 이제부터 자바 언어에서의 객체지향을 위
한 개념들을 하나하나 알려드리도록 하겠습니다.
[객체]
-----------------------------------------------------------------
객체지향이라 하면 제일 먼저 알아야 하는것이 뭐니해도 객체입니다.
- 객체는 객체지향 기술의 핵심이다.
- 우리들이 살아가는 실제세계에도 수많은 객체들이 있습니다. 움직이건 움직이지 않든 간에 모든 물체는 객체이
며, 모든 물체 하나하나는 자신만의 특별한 상태와 동작을 할 수 있습니다.
가령 예를 들어보면 사자의 상태는 색깔, 무게, 사자가 피곤한지 혹은 배가 고픈지 등을 포함한 많은 사자의 상
태가 있으며, 으르렁거림, 잠자기, 사냥하기, 달리기 등의 여러 가지의 동작을 가지고 있습니다. 자동차의 경우에는
현재 속도, 변속기의 종류, 2륜구동인지 4륜구동인지, 전조등이 켜있는지, 현재 기어의 상태 등 많은 상태를 지니고
가지고 있으며, 자동차의 동작에는 방향전환, 멈춤, 가속 등의 동작을 가질 수 있습니다.
위의 예처럼 실제 세계의 모든 물체(객체)들은 두가지 일반적인 특징인 상태와 동작을 가지고 있습니다. 소프트
웨어의 세계에서도 실세계처럼 어떤 프로그램이건 간에 어떤 상태를 지닐 수 있으며, 또한 실세계의 동작에 해당
하는 어떠한 특정 작업(일)을 처리할 수 있습니다.
이런 소프트웨어 객체의 상태와 동작은, 자바 언어에서는 데이터와 메소드에 의해 표현되거나 결정되며 바뀔수
있습니다.
이런 실세계의 객체와 소프트웨어 객체간에 연결을 생성함으로써, 객체가 어떻게 실제 세계와 컴퓨터 안의 소
프트웨어 세계와의 차이점을 연결시킬 수 있는지를 알 수 있다.
- 소프트웨어세계의 객체들은 대부분이 실제 세계의 객체를 모방하여 만들어집니다. 그러므로 실제 세계의 객체를
더 쉽게 표현할 수 있습니다. 가령 예를 들어 동물원이라는 소프트웨어 프로그램을 만든다면 실제 세계에 존재하
고 있는 모든 동물들의 객체를 이용하여 동물들의 상태나 동작들을 가지고 프로그램의 데이터나 메소드 등을 사용
하여 쉽게 프로그램 객체로 표현할 수 있으며, 프로그램 객체를 이용하여 동물원 프로그램을 만들 수 있을 것입니
다.
- 그러나 모든 소프트웨어 객체가 실세계의 객체를 모방하여 모델링한 것은 아닙니다. 소프트웨어 객체는 실세계
에 없는 가상의 객체를 만들어 낼 수 있으며, 이런 것들을 추상적인 객체로 모델링 됩니다.
[소프트웨어 객체의 요소및 흐름도]
---------------------------------
메세지
[message]
|
----------------------------
| 메소드 --------데이터[data]|
|[method] |
----------------------------
|
응답
[Reponse]
---------------------------------
실세계의 객체인 사자 객체가 먹이를 발견하면 먹이를 쫓아가는 일을 하고, 자동차는 출발시키면 달리듯이, 소프
트웨어 세계에서도 실세계의 객체들처럼 객체는 어떤 메세지를 받아 메소드에서 일을 처리하는데 현재의 상태인
데이터를 참조하여 일을 처리하도록 되어 있습니다. 가령 자동차 게임에서 자동차 객체에를 출발시키라는 명령을
내리면 자동차 객체의 출발 메소드는 현재의 자동차의 휘발유 상태나 기어상태 또는 전조등을 켜야하는지 꺼야하
는지등 모든 자동차의 상태를 저장하고 있는 데이터를 참조한 후 자동차가 출발할 수 있는 상태이면 출발을 시킬
것입니다.
실세계에 존재하는 자동차를 소프트웨어 객체로 만들 경우 다음과 같이 데이터와 메소드로 표현해 자동차 객체화
할 수 있을 것입니다.
[소프트웨어 자동차 객체의 구성]
------------------------------
--메소드(method)-
| 브레이크 |
| 가속기 |
| 기어 변속기 |
| Toggle Ligh |
| ... |
---------------
--데이터(data)--
| 100km(속도) |
| 4(기어상태) |
| Light 상태 |
| ... |
--------------
------------------------------
실제세계의 지동차가 할 수 있는 동작을 메소드를 통해 구현시키고, 자동차가 지닌 상태를 데이터를 통해 저장합
니다. 이렇게 실세계의 자동차가 지닌 수많은 동작을 소프트웨어의 객체의 메소드를 통해 구현할 수 있습니다. 소
프트웨어 객체로 만든 자동차 객체를 이용하고자 하는 곳에서 요청(메세지)를 받아 자동차 객체의 메소드는 상태
인 데이터를 참조해 요청에 대해 작업을 처리한 후 메세지를 보내 메세지의 처리를 의뢰한 곳에 다시 결과[응답]
를 되돌려 보내줍니다.
-----------------------------------------------------------------
위의 객체에 대해 초보자분들께서 이해할 수 있게 설명을 해보려 했는데, 어느 정도 이해가 돼는지 모르겠군요.
아무든 자바 언어에서의 객체는 상태와 동작을 가지고있으며, 메세지를 받아 데이터를 참조하여 메소드에서 작업
을 처리한 후 메시지를 보낸 곳에 결과를 다시 돌려준다는 것 정도는 알아두시기 바랍니다.
자바개념(2) / 객체지향(2) / 캡슐화
--------------------------------------------------------------------------------
자바 언어에서는 프로그래밍 과정에서 객체를 캡슐화시켜 외부(다른객체)에게 자신의 세부사항을 숨기는 것입니
다. 잘 모르시겠죠. 이렇게 생각해 보세요.
사람을 하나의 객체로 생각해 봅시다. 사람마다 특유의 성격이나 행동등이 모두 다를것입니다. 그런데 이런 성격
이나 행동을 묶은 하나의 사람 객체 자신은 자신의 성격이나 행동인 그 사람 자신만의 정보를 남에게 알리고 싶은
사람은 거의 없을 것입니다.
그와 마찬가지로 자바 언어에서도 프로그래밍에 사용되는 객체들은 자신만의 특유한 정보를 지니고 있으며, 이런
정보들을 다른 객체에게 접근을 거부할 것인지, 아니며 접근을 허락하여 객체 정보를 내줄 것인지를 객체의 캠슐
화를 통해 객체의 내부를 보호할 수 있습니다.
객체를 객체의 내부와 외부로 나누어 본다면, 객체의 내부처리에서는 자기 자신의 객체를 이용하는 것이기 때문
에 객체의 정보의 접근에 그다지 제한을 두지 않을 것이다. 그러나 외부(다른 객체)에게는 객체의 정보를 꼭 필요
한 곳을 제외하고는 숨길 필요가 있다. 다른 객체에게 자신의 세부적인 정보나 처리과정을 보여줄 필요는 없다.
객체의 외부를 인터페이스라 부르는데, 왜냐하면 다른 객체들은 오직 인터페이스를 통해서만 객체와 통신해야 하
고, 객체의 내부의 작동으로부터 보호를 받기 때문이다. 그리고 외부의 프로그램은 객체의 내부 동작에 접근할 수
가 없으므로, 객체 내부 동작은 프로그램의 다른 부분에 어떤 영향도 미치지 않고 자신만의 단독으로 변경될 수
있다. 이러한 것을 모듈화라고 한다.
자바 언어에서 캡슐화가 주는 장점은 크게 두가지이다.
1. 정보은폐
2. 모듈화
정보은폐는 객체의 내부 동작의 보호를 의미하며, 객체는 public인터페이스와 내부 데이터와 메소드로 이루어진
private부분으로 구성된다. 내부 데이터와 메소드는 객체의 숨겨진 부분이다. 주요한 장점은 이들 부분이 프로그램
의 다른 부분에 영향을 미치지 않고 변경될 수 있다는 것이다.
위 글에 캡슐화의 핵심적인 내용이 있는데 객체의 내부 데이터와 메소드를 private로 접근 제한을 하여 외부로부
터의 직접 접근을 막았고, 객체의 외부를 public인터페이스로 구성하여 외부로부터의 접근을 public 인터페이스을
통해 접근하도록 하였습니다.
모듈화는 객체가 다른 객체와 독립해서 유지될 수 있음을 뜻한다. 객체의 안의 소스코드는 인터페이스와 분리되
어 유지되기 때문에, 객체가 어떤 문제를 일으키지 않는다면 확신하에 자유롭게 변경될 수 있다.
쉽게 예를 들어 보도록 하겠습니다.
지구상에 있는 모든 나라들을 각각의 객체라고 생각해 보세요. 그리고 각 나라의 내부에는 그 나라만의 현재의
상태(정보)가 있고 또한 그 안에서 수많은 동작들이 이루어지고 있을 것입니다. 이런 나라 객체에 안에서 현재 가
진 수많은 정보와 동작들을 일종의 국가기밀이라고 할 수 있습니다. 이런 국가기밀에 해당하는 정보를 외부의 객
체에 해당하는 다른 나라에게 알려지게 그냥 두지 않고 엄격한 접근(보안)의 제한을 둡니다. 이것이 바로 캡슐화의
정보은폐에 해당하는 것이고요.
다음으로 모듈화는 각각의 나라 객체들은 외부 객체에 해당하는 다른 나라와 별개로 독립되어 자주적으로 국가를
운영하며 그런 나라 객체안에서 다른 나라 객체에 영향을 미치지 않는 범위 내에서는 그 나라의 모든 일을 스스로
알아서 처리할 수 있습니다. 이것이 독립적으로 운영되는 모듈화의 개념이지요.
자바개념(3) / 객체지향(3) / 메세지
--------------------------------------------------------------------------------
사회의 모든 사물들이 혼자서는 그다지 할 수 있는 일이 많지 않고, 또한 혼자 존재한다는 것은 큰 의미를 지닐
수 없다. 이와 같이 객체 또한 홀로 작동하는 객체는 거의 유용하지 않다. 대부분의 객체는 무언가 일을 처리하기
위해 다른 개체를 필요로 합니다. 예를 들어 자동차 객체 자체로는 아무런 쓸모가 없습니다. 그러나 자동차를 운전
할 수 있는 운전사 객체를 더해 줌으로서 자동차 객체는 매우 유용하게 사용될 수 있습니다.
이렇듯 프로그래밍 과정에서도 연관된 객체들끼리 함께 사용한다면 큰 일을 처리할 수 있으며, 매우 유용하게 사
용될 수 있습니다. 그럼 객체와 객체간에 서로 일을 처리하기 위해서는 서로 대화를 해야 하는데 이런 것이 바로
메세지입니다. 예를 들어 운전사 객체가 자동차 개체를 가속하기를 원한다면, 운전사 객체는 자동차 객체에게 가속
하라라는 메세지를 보낼 것입니다. 또한 예로서 학교의 선생님객체와 학생객체로서 선생님객체가 학생객체에게 수
업시간에 책 읽기를 학생객체에게 시키기 위해서는 "책 몇 페이지를 읽어봐라"라는 메 세지를 학생 객체에게 전달
할 것이며, 학생 객체는 선생님 객체로부터 전달받은 책을 몇 페이지와 읽어봐라라는 메세지 정보를 통해 자신이
무엇을 해야 할 지를 정확히 알고 책을 읽을 것입니다. 그러면 선생님 객체는 학생이 책을 읽는 목소리를 듣고 자
신이 학생 객체에게 보낸 메세지에 대한 응답을 받습니다..
위의 두 예처럼 객체와 객체 사이에 어떤 일(동작)을 처리하기 위해서는 서로 메세지를 주고 받아야 함을 알 수
있습니다. 그리고 또한 메세지를 주고 받음에 있어 메세지안에 포함되어야 할 다음과 같은 정보들이 있음을 알 수
있을 것입니다.
[메세지에 포함될어야 할 정보]
----------------------------------
1. 메세지를 받는 객체(학생)
2. 수행되어야 할 동작의 이름(읽어봐라)
3. 메소드가 요구하는 파라미터(책, 몇페이지)
-----------------------------------
1번이 메세지를 받을 객체가 되고, 2번은 메세지를 받은 객체의 동작을 처리하는 메소드, 3번은 메소드의 일 처리
에 필요한 메소드 매개변수가 됩니다.
위와 같이 메세지안에 메세지를 받아 일을 처리할 객체가 어떤 일을 해야 하는지 정확히 알려줄 수 있게 매개변
수 정보를 포함하고 있어야 합니다. 그래야 학생 객체는 메세지를 받고 자신의 해야 할 일을 정확히 알고 수행을
하게 됩니다. 위 메세지의 정보중에 하나라도 빠뜨리거나 틀린 정보를 주었을 경우에는 전혀 다른 결과를 산출하
게 됩니다.
자바 언어에서는 객체의 메소드를 통해 메세지를 받을 것이며, 세부적인 정보들은 메소드 매개변수를 통해 받아
들일 수 있습니다. 아래를 보시면 정수값을 매개변수로 받아 1부터 메세지로 받은 정수까지의 합을 구하는 메소드
입니다. 이와같이 메소드 이름 뒤에 메세지 매개변수를 받을 수 있도록 정의해 주시면 됩니다. public다음에 있는
int는 이 메소드가 일을 처리한 후 메세지를 전달한 객체에게 결과값을 돌려주기 위한 값의 데이터 타입을 정의해
준 것입니다.
public int myWork(int endCount){
for(int i=1; i=endCount; i++){
sum=sum+i;
}
return sum
}
메세지 전달을 보통 메소드 호출이라고 이해하시면 됩니다. 메소드 이름 우측에 보시면 가로 열고 여러개의 데이
터들이 있는 것들이 볼 수 있는데 이런 것들을 메소드 파라미터, 즉 위의 메세지 정보에 해당하지요.
잘 이해가 안되시더라도 그리 걱정할 것 없습니다. 실제 프로그래밍을 작성해 보시면 한결 이해가 빠를
것입니다.
자바개념(4) / 객체지향(4) / 클래스
--------------------------------------------------------------------------------
자바 언어의 객체지향 프로그래밍에서 객체를 객체와 가장 밀접한 관계를 맺고 있는 클래스에 대해 알아 봅시다.
클래스는 일종의 객체의 템플릿이라고 할 수 있으며, 또는 객체의 뼈대(기본)이라고 생각하시면 됩니다.
[참고] 템플릿 : 문서작성 프로그램들에서 이용자들에게 특정 문서 작성을 용이하도록 하기 위해 기본적인 문서 형
식을 미리 작성해 놓고 이곳에 필요한 부분들만을 추가하도록 한 문서형식들을 뜻함
예를 들어, 우리가 살고 있는 실제 세계에는 수많은 자동차 객체가 있습니다. 자동차마다 이름도 다르고 크기나
색깔 모양등 기능들도 제 각각 모두 다릅니다.
어떤 자동차 회사에서 자동차를 만들 때 다음과 같은 방식으로 자동차를 생산할 것입니다. 하나의 자동차로서 공
통적인 틀을 갖추 자동차 설계도를 작성한 후 이 설계도를 기초로 하여 공통적인 부분에 대해서는 이 설계도를 기
준으로 만들 것이며, 각각의 차마다 다른 색깔이나 옵션 사항등의 특성에 따라 추가적인 설계도를 작성하여 공통
적인 자동차에 그 나름대로의 특성을 부여할 것입니다.
객체지향 프로그램밍에서는, 이와 같이 일반적으로 비슷한 특징을 지닌 객체들의 공유 객체들을 지니기 때문에,
이것들을 일일이 프로그래머에게 작성하게 하는 것은 프로그램의 개발의 속도나 노력에 많은 부담을 주게 됩니다.
그래서 이와같은 여러 객체들이 공통적으로 지닌 객체의 생성에 있어 공통적인 부분들을 모두 클래스라는 객체에
포함시켜 이것을 기초로 하여 객체를 생성하게 하고 있습니다.
객체의 캡슐화가 정보의 은폐와 모듈화의 이점을 제공한다면, 클래스는 한 번 작성한 클래스 객체의 재사용의 이
점을 제공한다고 볼 수 있습니다. 프로그래머들은 이미 정의된 클래스 패키지를 사용함으로서 기본적으로 구현되
어 있는 기능들이나 데이터에 새로운 기능과 데이터를 추가하거나 기본 데이터를 변경하여 사용하기만 하면 되므
로 프로그램의 개발 시간을 많이 단축시켜 줄 수 있을 것이다.
쉽게 말해 어떤 데이터와 메소드를 통해 일을 처리할 수 있는 객체들에게는 서로 공통적인 부분들이 많이 있는
데, 이런 부분들을 클래스로서 정의해 놓음으로서 객체의 생성시 공유된 클래스를 사용하여 공통적 부분들에 대한
처리를 쉽게 할 수 있으며, 클래스를 확장해 필요한 기능만을 추가함으로서 객체의 기능을 쉽게 추가할 수 있도록
한 것이 바로 클래스입니다.
한가지 중요한 점은 클래스에 있는 데이터와 메소드를 객체가 사용함에 있어 클래스의 메소드는 객체에서 공유되
지만 데이터는 그 객체를 위해 생성된다는 점입니다.
자바개념(5) / 객체지향(5) / 계승(1)
--------------------------------------------------------------------------------
계승의 개념에 대해 알아 봅니다.
계승이라 하면 실세계에서는 일종의 전통이라고 할 수 있습니다.
프로그래머가 작성하고자 하는 프로그램이 이미 작성되어 있는 어떤 프로그램과 매우 비슷한 기능을 하는 것이라
할때 그 프로그래머는 새로운 프로그램의 작성을 위해 처음부터 모든것을 작성할 필요는 없습니다. 이미 작성되어
있는 프로그램에서 자신의 프로그램과 비슷한 기능을 하는 부분들을 계승하고 부가된 특징들을 프로그램에 첨가하
여 프로그램을 만들면 될 것입니다.
이렇듯 계승은 새로운 클래스에 부가된 특징과 함께, 이미 존재하는 클래스의 특징을 가진 새로운 클래스를 생성
하는 것입니다. 계승은 프로그램을 조직하하고 구조화하기 위한 강력하고 자연스러운 매커니즘을 제공합니다.
자바 언어에서의 클래스는 데이터와 메소드를 정의하는 일련의 작업을 통해 객체에게 어떤 일을 처리하도록 합니
다. 이런 클래스를 다른 클래스를 기반으로해서 생성할 수 있는데, 다른 클래스를 기반으로 하게 되면, 그것은 다
른 클래스의 데이터와 메소드를 포함한 모든 특징을 계승합니다.
계승을 받는 클래스는 서브 클래스(자식 클래스)라고 하며, 계승할 정보를 제공하는 클래스는 수퍼 클래스(부모
클래스)라고 합니다.
자동차의 예를 들면, 자식 클래스는 자동차 클래스로부터 휘발유 자동차, 가스 자동차, 전기 충전차로 계승될 수
있습니다. 3개의 새로운 자동차 클래스는 모두 일반적인 자동차의 특징을 공유하지만, 다음과 같은 그들 자신만의
특징이 첨가되어야 할 것입니다.
휘발유 자동차 클래스 : 휘발유, 휘발유 연료 탱크
가스 자동차 클래스: 가스연료, 가스 연료 탱크
전기 자동차 : 배터리, 재충전 플러그
위의 3가지 자동차 클래스의 계승을 다음과 같이 표현할 수 있습니다.
자동차 클래스 객체
|
---------------------------------
| | |
휘발유 자동차 가스 자동차 전기 자동차
자동차로서 기본 특징은 모두 자동차 클래스에서 정의된 것을 계승하여 사용하고 각각의 자동차마다 다른 특징들
에 대한 것들만 새로운 클래스 객체를 만들 때 추가해 주면 됩니다.
자바개념(6) / 객체지향(6) / 계승(2)
--------------------------------------------------------------------------------
부모 클래스의 상태와 동작을 계승하는 것만으로는 자식 클래스를 만드는 어떠한 이득도 얻을 수 없습니다. 진정
한 장점은 어떤 특징을 계승하고 새로운 것을 첨가할 수 있는 능력입니다.
자식 클래스는 부모 클래스로부터 계승받은 클래스에 새로운 변수와 메소드를 첨가할 수 있습니다. 계승에 대한
글 1에서 휘발유, 전기, 가스 자동차 모두 자동차 클래스를 계승하여 사용하였지만, 자신만의 특성에 맞게 변수를
생성하거나 새로운 기능을 할 수 있도록 새로운 메소드를 만들거나 아니면 부모 클래스인 자동차 클래스의 메소드
를 재정의하여 부모 클래스의 메소드의 기능을 변경시킬 수 있습니다.
자바 언어 클래스의 계승구조는 JDK(자바 개발 도구)의 자바 클래스 패키지 문서를 보면 알겠지만 모든 클래스
는 java.lang.Object클래스로부터 계승되어 지고 있습니다.Obejct 클래스로부터 계승구조의 아래로 내려 갈수록 클
래스의 데이터나 메소드의 기능들의 좀더 세밀하고 확장되어 집니다.
자바 JDK패키지의 소스를 에디터로 보시면 대부분의 클래스들이 extends라는 키워드를 사용해 extends의 오른쪽
에 기입되어 있는 클래스를 계승하고 있으며 소스 코드안에는 계승된 부모 클래스의 기능을 추가하는 내용들을 기
입해 놓았음을 알 수 있을 것입니다.
자바 프로그래머는 단순히 이런 자바 JDK패키지를 계승하여 사용함으로서 프로그램의 코딩시간과, 잠재적인 버
그, 부모 클래스의 코드를 여러번 재사용할 수 있는 이점이 있습니다.
계승에 대해 또 한가지 중요한 점은 자식 클래스를 위한 템플릿으로만 사용되는 부모 클래스를 만드는 것이 때로
는 유용하다는 것입니다.
부모 클래스는 자식 클래스에 의해서 공유되는 일반적인 클래스의 기능을 위한 추상 외에는 제공하지 않습니다.
쉽게 말해 자식 부모 클래스(추상 클래스)는 자식 클래스에게 기본적인 뼈대만을 제공하기 위한 것입니다. 이러한
이유는 이런 형태의 부모 클래스들을 추상 클래스라 부릅니다. 추상 클래스는 인스턴스화하지 않는데, 이것은 어떤
객체도 추상 클래스로부터는 생성되지 않는다는 것입니다. 추상 클래스가 인스턴스화되지 않는 이유는 그 일부분
이 실행될 수 없는 형태로 되어 있기 때문입니다. 추상 클래스들은 추상 메소드로서 아직 실행될 수 없는 메소드
로 구성되어 있기 때문입니다.
한 예를 들어 보겠습니다. 계승에 대한 글 1에서 자동차 클래스(부모 클래스)에는 자식 클래스들에서 자동차를 달
리게 할 수 있는 가속 메소드만을 정의해 놓아 자식 클래스들이 이 부모(추상)클래스를 계승하여 자신만의 특징인
엔진의 형태, 휘발유의 종료, 엔지 모터의 능력 등의 자식 클래스 안에서 서로 다르게 정의하여 부모 클래스의 가
속 메소드를 자신의 특성에 맞게 이용할 수 있을 것입니다.
이와 같이 자식 클래스는 부모 클래스의 추상기능을 계승하여, 자신에게 필요한 기능을 추가하여 인스턴스화(객체
화)할 수 있지만, 부모 클래스의 경우에는 자식 클래스들을 위한 공통적이고 일반적인 데이터와 메소드들을 정의해
놓아 자식 클래스에게 계승의 역할만을 할 수 있고 그 자체로는 실행할 수 있는 인스턴스화(객체)가 될 수 없는
것입니다.
이론적인 부분이 좀 많이 나오는데, 이런 개념적인 것을 잘 알아두셔서 프로그래밍에 적용하시면 큰 도움이 되
실 것입니다.
자바개념(7) / 클래스 계승 구조
--------------------------------------------------------------------------------
저번 객체지향의 글에서 자바 클래스의 계승 구조에 따라 모든 클래스들이 java.lang.Object클래스로부터 계승되
어 점점 더 세부적인 기능들을 추가해 나가며 다음과 같은 디렉토리 구조를 지님을 알 수 있습니다.
[클래스의 일반적인 계승 형태]
------------------------------------
Object
|
--------------
| |
클래스A 클래스D
|
--------------
| |
클래스B 클래스C
------------------------------------
위와 같이 모든 자바 언어에서 사용되는 패키지 클래스는 물론이고, 사용자(프로그래머)가 작성하는 애플리케이션
이나 애플릿 자바 프로그램 역시 위와 같은 클래스 구조의 계승 형식에 따라 Obect클래스로부터 파생되어 나온 다
양한 자바 패키지 클래스들을 사용하여 작성하게 됩니다.
간단히 요약해 Object클래스는 모든 자바 클래스들의 근원이며, 부모 클래스로서 자바 언어에서 클래스를 생성하
기 위해 최소한의 계승되어야 할 클래스인 것입니다.
자바개념(8) / 클래스 이름 선언
--------------------------------------------------------------------------------
여러분들이 자바 언어를 사용하여 어떤 프로그램을 짤 것인지 정하였다면 이젠 정해진 프로그램에 맞게 자바 클
래스 파일를 생성하여야 하는데, 클래스 파일을 생성하기 위해서는 기존의 에디터 편집기나 자바 작성 툴을 이용
하여 자바 소스 코드를 자바 문법과 만들고자 하는 프로그램의 내용에 맞게 작성하여 자바 컴파일러를 이용해 컴
파일시켜 주면 소스코드에 대한 바이트 코드가 생성되는데, 이것이 바로 사용자 프로그램의 클래스 파일입니다.
[참고] 자바 언어를 사용한 모든 프로그램은 클래스 파일로 되어야만이 실행이 가능하므로, 프로그램에서 이용하고
자 하는 데이터와 메소드등의 객체들을 클래스안에 일련의 작업을 할 수 있도록 정의해 줌으로서 코드의 작성을
하며, 자바 컴파일러(javac)를 이용해 자바 바이트 코드인 클래스 파일을 생성하여 자바 가상 머신(java)에서 실행
시킬 수 있습니다.
위와 같이 사용자(프로그래머)가 자바 가상 머신에서 실행할 수 있는 바이트 코드인 클래스 파일을 만들기 위해
서는 제일 먼저 만들고자 하는 프로그램에 맞게 자바 소스 코드를 작성해야 함을 알 수 있는데, 이런 자바 코드를
작성함에 있어서 제일 먼저 해야 할 일이 프로그램에 맞는 적절한 이름으로 클래스의 이름을 선언하는 것입니다.
자 그럼, 클래스 선언에 대해 알려드리도록 하겠습니다.
자바 언어에서 클래스 이름의 선언 형식은 다음과 같습니다.
[클래스 이름 선언하기]
------------------------
class 클래스이름{
...
}
------------------------
[설명]
---------------------------------------------------------------
프로그래머가 작성하고자 하는 자바 프로그램의 클래스 이름을 class다음에 적당히 적어 주시면 됩니다. 이렇게
선언된 자바 코드에는 위에서 보듯이 아무런 클래스도 계승하지 않고 있는데, 사실은 모든 클래스들은 Object클래
스를 기본적으로 계승하게 되어 있기 때문에, extends키워드를 이용해 굳이 Obejct 클래스를 계승할 필요가 없으
며, 자바 컴파일러는 위와 같이 선언된 사용자 클래스 파일을 컴파일할 때 알아서 Object클래스를 사용자 클래스
파일에 계승시켜 줍니다.
수입문장(import) 역시, 기본 수입 패키지(자바 프로그램의 실행에 있어 기본적으로 꼭 필요한 기능만을 모아둔
패키지이다. 모든 자바 프로그램은 자동으로 import됩니다.)인 java.lang.*에 Object클래스가 포함되어 있으므로 굳
이 Obejct클래스를 수입할 필요가 없다.
---------------------------------------------------------------
자바개념(9) / 클래스 몸체 / 데이터 선언
--------------------------------------------------------------------------------
자바 프로그램 작성을 위한 클래스의 이름까지 짖었다면 이젠, 클래스의 몸체를 작성할 차례이다. 앞에 여러 글들
에서도 이미 수 차례 말했지만 자바 언어에서의 모든 처리는 객체가 주 단위로 처리가 됩니다. 지금부터 작성하고
자 하는 자바 프로그램 역시 하나의 클래스 객체이므로, 상태를 저장할 수 있는 데이터와 메세지를 받아 데이터를
참조하여 어떤 작업을 처리할 수 있는 메소드로 구성되어 집니다.
클래스의 몸체가 데이터와 메소드로 구성되어 진다는 것을 알았으니, 이젠 실제로 클래스의 몸체를 작성해 보도
록 하겠습니다. 쉽게 이해를 도모하기 위해 자동차 게임 클래스를 예제로 작성해 보도록 하겠습니다.
우선 자동차가 가질 수 있는 여러 상태(데이터)를 저장할 수 있는 변수를 정의해야 겠지요.
[자동차 클래스 몸체 / 데이터 선언]
------------------------------
class carGame{
int carStep;
Color carColor;
int energy;
}
------------------------------
[자동차 클래스 객체의 데이터들]
------------------------------------------
int carStep; // 자동차의 기어 상태
Color carColor; // 자동차의 색깔
int energy; // 자동차의 에너지 상태
-------------------------------------------
자동차 클래스 객체는 자동차의 여러 상태를 저장할 수 있는 데이터를 지녔습니다.
위와 같이 자동차 클래스의 데이터를 선언했습니다. 그러나 위의 데이터만을 가지고 있는 자동차 클래스는 자신
의 상태만을 저장할 수 있을 뿐 어떤 동작도 할 수 없습니다. 그럼 자동차 클래스에 어떤 동작(작업)을 할 수 있도
록 하기 위해서는 어떻게 해야 할까요? 바로 메소드(method)의 추가입니다. 메소드를 추가함으로서 데이터를 가지
고 특정 동작(일)을 처리 할 수 있습니다.
자바개념(10) / 클래스 몸체 / 메소드 형식
--------------------------------------------------------------------------------
메소드의 일반적인 선언형식부터 알아보고 자동차 클래스를 위한 메소드를 만들어 보도록 하겠습니다. 자바 언어
에서 메소드의 일반적인 선언 형식은 다음과 같습니다.
[자바 클래스의 메소드 형식]
---------------------------------------
ReturnType methodName(Parameter){
MethodBody
}
---------------------------------------
반환값타입 메소드이름(메소드 매개변수){
메소드 몸체
}
---------------------------------------
아래 것은 위의 것을 쉽게 한글로 표기한 것입니다.
그럼 위의 메소드의 형식을 하나씩 살펴봅시다.
[클래스 메소드 형식 설명]
---------------------------------------------------------------
1. ReturnType(반환값) : 전에 객체지향에 대해 알려드릴 때 메세지에 대해 말한바 있습니다. 그때 객체의 메소드
는 외부로부터 메세지를 받아 데이터를 참조하여 일을 처리한 후 메세지를 보낸 곳에 다시 응답을 돌려
준다고 알려 드린바 있습니다. 바로 이것이 메세지를 보낸 메소드를 호출한 곳에 돌려 줄 결과값(데이
터)에 대한 데이터형 타입을 정의하는 곳입니다.
메소드 결과에 대한 반환값을 위와 같이 정의해 줌으로서 메소드의 작업을 모두 처리한 후 return키
워드를 사용해 결과를 되돌려 보낼 때 메소드의 반환값과 정의된 데이터 타입이 일치하지 않을 경우 자
바 컴파일러는 에러 메세지를 표시해 줍니다.
2. methodName(메소드 이름) : 말 글대로 클래스 객체에 대한 메소드의 이름을 정의하는 곳이다. 이것은 메시지
를 통해 호출되는 이름과 동일해야 한다.
쉽게말해 carGame클래스에 A()메소드와 B()메소드가 있다고 하면 다음과 같이 메세지를 보내야 할
것이다. carGame.A();, carGame.B()와 같이 carGame클래스의 메소드에 메세지를 보내 그 메소드에서
일을 처리하게 되는데 이때 사용되는 메세지에 해당하는 호출 메소드의 이름으로 정의된 메소드가
carGame클래스 안에 정의되어 있어야 한다.
3. Parameter(메소드 매개변수) : 2번의 글에서 carGame.A()메세지를 이용해 carGame클래스의 A()메소드를 호출
할 때 만약 A()메소드가 가속 기능을 할 수 있는 메소드라고 생각해 보자. 그럼 이 메소드가 가속의 기
능을 하기 위해서는 현재의 기어가 몇 단인지, 또는 현재 에너지 상태등을 알아야 하고 가속할 수 있는
상태인지 얼마나 속력을 낼 수 있는 상태인지에 따라 메소드의 동작이 다르게 실행될 것입니다.
이와 같이 메세지를 보내 특정 메소드를 실행시킬 경우 위와 같은 메소드 실행에 따른 정보를 매개변
수 주어줄 필요가 있는데 이것이 바로 메소드 매개변수입니다. 보통 다음과 같이 메소드 매개변수를 주
고 받습니다.
[메소드 매개변수의 사용]
-----------------------------------------------------------------
carGame.A(1, red, 7);
ReturnType A(int, carStep1, Color carColor1,int energy1)
-----------------------------------------------------------------
위의 예제에서
첫번째 매개변수를 기어의 상태를 1단 기어로,
두번째 매개변수를 달릴 자동차의 색깔을,
세번째 매개변수를 자동차 에너지의 상태를
각각 메세지로 carGame클래스의 A()메소드에 전달하였습니다.
그리고 carGame클래스의 A메소드는 첫번째 매개변수로 주어진 기어상태를 자신의 메소드 블록 범위에서 사용가
능 하도록 정수 데이터형 carStep1을 생성하고 그곳을 통해 받아들였습니다. 두번째, 세번째 매개변수 역시 색깔을
저장할 수 있는 객체와 에너지의 상태를 정수형 데이터로 표현해 저장할 수 있는 변수를 생성하여 메세지에 포함
된 메소드 매개변수를 받아들여 메소드의 블록({}) 범위내에서 이용할 수 있도록 하였습니다
[참고] 실제 자동차 게임 등에서는 매우 많은 메세지들이 사용되며, 또한 메세지에 포함되어 메소드에 전달되는 메
소드 매개변수들도 위해 매개변수 말고도 몇 배나 많습니다. 그러나 초보자님들의 이해를 목적으로 몇가지만을 가
지고 한 것입니다.
4. MethodBody(메소드 몸체) : 메세지를 받아 어떤 동작(일)을 처리할 것인지를 자바 문법에 맞게 적절히 작성해
주시면 됩니다.
------------------------------------------------------------------
자바개념(11) / 클래스 몸체 / 메소드 선언
--------------------------------------------------------------------------------
이전 글의 설명을 통해 메소드를 정의하는 형식을 알아보았습니다.
그럼 실제 carGame클래스의 메소드를 메소드 형식을 바탕으로 간단히 작성해 보도록 하겠습니다.
아래 작성해볼 carGame예제 메소드는 실제 프로그래밍 과정에 적용하기에는 무리가 있습니다. 다만 초보자분들
의 메소드 생성에 대한 쉬운 이해를 도모하기 위해 작성한 것임을 알려드립니다.
[carGame클래스의 가속 메소드]
----------------------------------------------------------------
void accelerationMethod(int, carStep1, Color carColor1, int energy1){
while(energy1 > 0){
if(carColor==Color.red){
...
switch(carStep){
case 0:
case 1:
case 2:
...
case 5:
case 6:
}
}
}
}
----------------------------------------------------------------
위와 같이 carGame클래스의 가속 동작을 처리할 수 있는 accelerationMethod라는 메소드를 생성해 보았습니다.
이전의 메소드 형식에서도 설명이 되었지만 추가적인 내용을 설명을 해보도록 하겠습니다.
void accelerationMethod(int, carStep1, Color carColor1, int energy1){
첫번째 위 문장에서 메소드 결과에 대한 리턴값의 데이터 타입이 void로 되어 있음을 알 수 있는데, 이것은 이 메
소드가 어떤 결과값도 돌려줄 것이 없다는 것을 의미합니다. void의 공허함과 같은 의미처럼 메소드의 타입을
void로 선언한 경우에는 메세지를 받은 메소드는 자신의 일만을 처리하고 나서 메소드를 호출한 메세지 문장의 다
음 문장을 실행합니다. 이전의 글에서 carGame.A()처럼 A()메소드에 메세지를 보낸 호출하였을 경우 이 carGame
클래스의 A()메소드에서 응답으로 리턴될 결과값을 저장하는 대입 문장의 형식으로 사용되지 않았기 때문에 이와
같은 메소드 호출은 void형 메소드를 호출하고 있음을 알 수 있습니다.
accelerationMethod부분은 단순히 메세지를 통해 호출될 메소드의 이름입니다. accelerationMethod메소드의 ()안에
메소드의 매개변수가 3개가 정의되어 있는데 이것은 accelerationMethod가 자동차를 가속하기 위해 필요한 정보(데
이터)들을 메세지를 통해 받아들이는 부분이며, 받아들인 매개변수의 데이터를 데이터형의 선언으로 새로운 변수에
저장하여 accelerationMethod메소드의 블록 범위 안에서만 이 변수 데이터를 사용한다는 것을 알 수 있습니다.
메세지 들어오는 정보는 위와 같이 메소드 매개변수를 통해 메소드의 지역 범위 변수로서 정의할 수 있습니다.
int, carStep1, Color carColor1, int energy1은 자동차의 기어정보, 색깔 정보, 에너지 정보를 메세지의 정보로부터
받아들여 메소드 범위에서 사용할 수 있는 지역적인 변수를 만들어 메세지 정보를 저장시킨 것입니다.
나머지 메소드의 몸체 부분은 자동차의 에너지 상태에 따른 달릴 수 있는지, 색깔의 상태에 따른 달릴 자동차의
선택, 기어 상태에 따른 어느 정도의 속도를 낼 것인지를 메소드의 몸체를 통해 일련의 자바 문장들을 이용하여
시행하도록 한 것입니다.
메소드의 몸체의 경우 아직 배우지 않은 여러 연산자나 제어구조의 문장들이 많이 사용됩니다. 이런 내용들을 배
운 후 메소드의 몸체에 대해 살펴보도록 하고, 이 글의 요점인 메소드를 선언하고 생성하는 방법에 대해 잘 알아
두시기 바랍니다.
자바개념(12) / 클래스 유도 계승
--------------------------------------------------------------------------------
지금까지 알려드린 클래스 선언 방법에서는 Object클래스로부터 계승된 사용자 클래스를 생성하는 것에 제한되어
있었지만, 이 글을 통해 알려드릴 클래스 유도 상속의 방법을 사용하면 Object클래스가 아닌 다른 클래스로부터
사용자 클래스 프로그램으로 클래스를 계승하여 사용하실 수 있습니다.
지금까지의 예제로 들어본 클래스는 Object클래스를 계승하여 사용하였는데, 이것은 그다지 좋은 계승이 안입니
다. 왜냐하면 Object클래스는 자바 패키지 중에 가장 부모(수퍼)클래스로서의 역할을 하므로, Object클래스에는 기
본적인 자바 클래스가 되기 위한 최소한의 정의 정도의 기능밖에 없을 것이므로, 이 Object를 계승하여 만들어진
사용자 프로그램에서는 자신의 프로그램에서 필요한 모든 데이터와 메소드를 모두 정의하고, 구현해 주어야 합니
다.
그렇기 때문에 사용자 자바 프로그램을 작성할 때, Object클래스를 계승하여 사용하기보다는 이미 Object클래스를
계승하여 여러 가지 데이터나 메소드 등을 추가하여 많은 기능을 할 수 있도록 작성된 Object클래스를 계승하는
많은 자바 패키지 클래스들을 계승하여 사용하는 것이 사용자 프로그램 작성에 있어 매우 편리할 뿐만 아니라 객
체지향의 진수를 맛보실 수도 있습니다.
자바 패키지의 계승구조를 보면, 부모 클래스쪽으로 갈수록 일반적이고 그 하위 클래스들에 위해서 공유되는 기
능들을 정의해 놓은 것이고, 하위 클래스 쪽으로 갈수록 세부적이고, 그 자신의 클래스에서만의 어떤 기능을 할 수
있도록 점점 많은 데이터와 메소드등을 추가하여 사용됨을 알 수 있습니다.
[extends 예약어 사용]
-------------------------------------------------------------------
위와 같은 기본으로 계승되는 Obejct 클래스가 아닌 다른 클래스를 계승하여 사용
하고자 할 때는 extends 예약어를 사용하는 방법이 있습니다.
-------------------------------------------------------------------
[extends 예약어 형식]
extends예약어를 사용하는 형식은 다음과 같습니다.
-------------------------------------------------------------------
class className extends SuperClassName {
}
-------------------------------------------------------------------
className : 사용자 클래스 프로그램의 이름
extends : 오른쪽의 클래스를 왼쪽의 사용자 클래스 프로그램에 클래스를 계승시킴
SuperClassName : 계승될 클래스(className의 부모 클래스가 됨)
자 그럼 예를 들어 설명해 보도록 하겠습니다.
이전에 자동차 클래스의 계승에서 휘발유 자동차, 전기 자동차, 가스 자동차로 자동차 클래스가 계승되는 것을 예
로 들어 보도록 하겠습니다.
자동차 클래스는 기본적인 자동차의 뼈대만을 설계해 놓은 것입니다. 이 설계도를 계승하여 휘발유 자동차, 전기
자동차, 가스 자동차는 자동차 클래스의 기본적인 상태나 부품, 동작 이외에 각각의 자동차에서 필요한 여러가지
부품이나 상태, 그리고 일어날 수 있는 동작을 정의하는 부모 클래스인 자동차 클래스보다는 더욱 구체화된 클래
스가 될 것입니다. 이와 같이 세부적인 사항들을 추가하여 각각의 자동차 객체를 위한 세부적인 클래스들이 완성
되었다면, 이젠 실제로 자동차를 만들기 위해서는 이런 세부적인 클래스를 가지고 실제 자동차 모델을 설계할 것
입니다. 그때 각각의 자동차마다 색깔이나 옵션 사항 등 다른 부분만 실제 모델의 설계부분에서 정의해 주면 되는
것입니다.
위 아래 예제처럼 2번째에 있는 3가지의 휘발유, 전기, 가스 자동차의 클래스는 이미 자동차 클래스를 계승하여
자신만의 특유한 기능들을 더하였습니다. 그러므로 실제 모델에서 휘발유 자동차를 만들 경우에는 휘발유 자동차
클래스를 계승하고, 전기 자동차를 만들경우는 전기 자동차 클래스를 계승하는 등과 같이 자동차 클래스를 계승할
필요가 없이, 이미 많은 기능들을 추가한 2번째 클래스를 계승하여 사용하면 더욱 빠르게 자동차를 생산할 수 있
을 것입니다.
[클래스 계승 예제]
-------------------------------------------------------------------
1. 자동차 클래스 : 자동차의 뼈대, 바퀴의 갯수, 핸들, 브레이크,
2. 휘발유, 전기, 가스 자동차 클래스 : 1클래스계승, 엔진의 종류, 에너지 탱크, 각자 필요한 부품
3. 실제 모델 : 2번 클래스 계승, 색깔, 옵션사항
-------------------------------------------------------------------
마지막으로 이 글의 클래스 유도에서 중요한 점은 사용자 프로그램이 계승하고자 하는 부모 클래스의 이름을 수
입문장을 통해 import해주셔야 한다는 것입니다.
자바 소스 코드에 보면 코드의 맨 앞의 문장에 import문장을 기술해 주셔야 합니다. 또는 유도 계승하고자 하는
클래스의 이름을 아래와 같이 직접 모두 적어 주셔도 됩니다.
[import문장 사용시]
--------------------------------------
import java.applet.Applet;
class myClass extends Applet{
--------------------------------------
[직접 지정시]
--------------------------------------
class myClass extends java.applet.Applet{
--------------------------------------
자바개념(13) / 메소드 오버라이딩
--------------------------------------------------------------------------------
자바 언어에서는 유도된 클래스, 즉 어떤 부모 클래스를 계승한 자식 클래스에서 부모 클래스의 메소드를 재정의
하여 사용할 수 있게 해주는 메소드 오버라이딩(overriding)이라는 개념으로 사용할 수 있습니다.
기존의 부모 클래스에서 이미 어떤 기능이나 동작을 하도록 정의되어 있는 특정메소드를 이 클래스를 계승하는
자식 클래스에서 다른 동작이나 새로운 동작을 시키려고 할 경우 부모 클래스의 메소드 이름과 똑같은 이름으로
다시 오버라이딩(재정의)하면 자식 클래스에서는 자신의 클래스 안에서 오버라이딩된 메소드가 호출되어 사용되어
집니다.
[참고] 자식 클래스에서 어떤 메소드를 호출하였을 때 그 자신의 클래스 객체 안에서 메소드를 찾아 실행하고, 없
을 경우 자식 클래스가 계승하는 부모 클래스 안에 호출된 메소드가 있는지 검사하여 있으며 실행할 것이며, 없으
며 에러가 발생할 것입니다.
이전의 글에서 carGame클래스에 게임에 등장할 자동차 객체들을 여러 개 만들어야 하므로 자동차의 공유된 특징
들을 하나의 자동차 클래스에 두어 이것을 계승하여 여러 개의 자동차 객체를 만들었다고 가정해 봅시다. 그리고
이 자동차 클래스에는 일반적으로 게임에 사용될 자동차들이 공통적으로 움직일 수 있는 방향인 전진과 후진동작
을 처리할 수 있는 메소드인 carMove()라는 메소드가 있다고 합시다.
위와 같은 상황에서 자동차 게임에 등장하는 자동차들 모두가 전진과, 후진만을 할 수 있다면 게임은 그다지 재
미가 없을 것입니다. 그러므로 사용자가 작성하고자 하는 carGame클래스에서는 부모 클래스의 carMove()메소드를
다시 재정의 하여 옆으로도 이동할 수 있는 기능을 추가여 어떤 자동차 객체는 옆이나 앞뒤로 이동할 수 있고, 어
떤 자동차 객체는 부모 클래스의 메소드를 사용하여 앞뒤로만 움직이게 하는 등 게임에 사용되는 자동차의
carMove()메소드를 오버라이딩 함으로서 부모 클래스의 메소드와는 다른 동작이나 새로운 동작을 하도록 할 수
있습니다.
자바개념(14) / 메소드 오버로딩
--------------------------------------------------------------------------------
메소드 오버라이딩과 함께 강력한 객체지향 기술이 바로 메소드 오버로딩(overloading)의 기술입니다. 메소드 오
버로딩은 서로 다른 종류의 메세지 정보(메소드 매개변수)를 하나의 메소드로 전달하여, 매개변수의 갯수에 따라
다른 동작을 하도록 정의하는 것입니다.
메소드를 오버로딩하려면 아래와 같이 같은 이름을 같지만, 다른 메소드 파라미터를 가진 메소드들을 선언해야
합니다.
[메소드 오버로딩 예제]
-------------------------------
class carGame{
void carMove(){
..
}
void carMove(int x, int y){
..
}
}
--------------------------------
위의 메소드 오버로딩의 예제에서 두 메소드 간의 차이점은 오직 메소드 매개변수인 파라미터뿐입니다. 첫 번째
carMove()메소드는 파리미터가 없지만, 두 번째 carMove()는 두개의 정수를 파라미터로 받아들입니다.
위와 같이 메소드를 오버로딩한 후 이 메소드를 메세지를 통해 호출할 때 메시지 정보 없이 호출할 것이라면 메
소드 매개변수를 받아들이지 않는 carMove()메소드가 호출되어 동작할 것이고, 메소드 호출시 메소드 매개변수로
두개의 정수와 함께 호출할 경우에는 carMove(int x, int y)메소드가 호출될 것입니다.
위의 예제는 carMove()를 호출할 경우 자동차의 일방적인 동작 처리에, carMove(int x, int y)를 호출할 경우 특
정 좌표상으로 이동할 때 유용하게 사용될 수 있습니다.
간단히 메소드 오버로딩이란, 같은 이름의 메소드이지만 메소드 매개변수의 갯수에 따라 서로 다른 동작을 하도
록 같은 이름의 메소드를 여러개 정의하는 것입니다.
자바개념(15) / 변경자 / 접근 변경자 의미
--------------------------------------------------------------------------------
자바 클래스 안의 변수와 메소드에 접근하는 것은 접근 변경자(Access Modifier)를 통해 이루어집니다. 접근 변경
자를 클래스 멤버(데이터 변수나 메소드)와 바깥 객체(다른 객체)간의 다양한 수준의 접근 권한을 정의함으로서 외
부 객체로부터의 접근을 통제할 수 있도록 해줍니다.
접근 변경자는 멤버 변수의 타입이나 메소드의 리턴 타입 앞에 선언하도록 되어 있으며, 다음과 같은 4가지 접근
변경자가 있습니다.
[접근 변경자]
------------
default
public
protected
private
------------
위와 같은 접근 변경자를 사용함으로서, 데이터 정보나, 클래스 객체의 동작을 외부로부터 숨길수 있는 것입니다.
접근 변경자는 클래스 멤버(변수나 메소드)의 접근 권한에만 영향을 미치는 것이 아니라, 그 클래스 자신에게도
외부 패키지인지, 자신이 속한 패키지인지에 따라 접근의 제한을 둘 수 있습니다.
다음 글에서는 위 4가지 접근 변경자의 사용법과 기능에 대해 알려드리도록 하겠습니다.
자바개념(16) / 변경자 / 접근 변경자 종류
--------------------------------------------------------------------------------
default, public, protected, private 4가지의 접근 변경자가 있다는 것을 알았으니 이젠 이 접근 변경자들의 기능과
사용법에 대해 알아봅시다.
[참고] 같은 패키지 클래스란 자바 API패키지에서 클래스의 계승구조에 따른 분류를 말하는 것으로, 여러 가지의
클래스들을 lang, awt, net, util, math, sql, rmi, applet, io등 관련 클래스들끼리 한데 묶어 놓은 것을 패키지화 한
것입니다.
쉽게 생각해서 자신이 속한 클래스 패키지를 한 식구라도 생각할 수 있고, 자신이 속하지 않은 다른 패키지들을
친척이라고 생각할 수 있습니다.
[default 의미]
------------------------------------------------------------------
디폴트 접근 변경자는 같은 패키지의 클래스만이 클래스의 변수와 메소드에 접근헐 수 있다는 것을 의미합니다.
그러므로 디폴트 접근 권한을 가진 클래스는 멤버는 같은 패키지 안의 다른 클래스들에게만 접근이 허락이 됩니
다.
디폴트 접근 변경자를 사용하기 위한 실질적인 자바 예약어는 존재하지 않습니다. 그렇기 때문에 아래처럼 접근
변경자를 변수나 메소드 클래스에 선언하지 않았을 경우, 디폴트 접근 변경자로 자바 컴파일러는 해석을 합니다.
[default접근 변경자의 예제]
------------------------
class myClass // 클래스 접근 변경자
int myInt; // 변수 접근 변경자
void myMethod(){ // 메소드 접근 변경자
------------------------
-------------------------------------------------------------------
[public 의미]
--------------------------------------------------------------------
public접근 변경자는 클래스의 변수와 메소드가 클래스의 안과 밖의 어떤 객체에게도 접근이 가능하다는 것을 의
미하며, 접근 변경자들 중에서 가장 공개적입니다.
애플릿의 경우 웹을 통해 다운받아 실행해야 하고 인터넷을 통해 모든 클래스들의 자원이 접근이 되므로 public
으로 클래스 접근 변경자를 설정해 주어야 접근이 되어 실행이 될 것입니다.
[public접근 변경자의 예제]
---------------------------
public myClass{
public int myInt;
public boolean myMethod(){
---------------------------
--------------------------------------------------------------------
[protected 의미]
--------------------------------------------------------------------
protected접근 변경자는 클래스의 멤버들이 그 클래스 자신과 서브 클래스에 의해서만 접근이 가능함을 의미합니
다. 자기 자신의 객체들과 자신의 계승하는 어떤 클래스에게만 접근이 가능하다는 뜻이죠.
[protected 접근변경자의 예제]
---------------------------
protected char myChar;
protected char myMethod()
---------------------------
--------------------------------------------------------------------
[private 의미]
--------------------------------------------------------------------
private 접근 변경자는 클래스의 멤버들이 그들이 정의된 클래스 안에서만 접근이 가능함을 의미합니다. 서버 클
래스에게도 조차 접근이 허락되지 않는, 가장 폐쇄적인 제한의 기능을 합니다.
[private접근 변경자의 사용 예제]
-----------------------------
private String myString;
private String myString()
-----------------------------
--------------------------------------------------------------------
자바개념(17) / 변경자 / 접근 변경자 예제
--------------------------------------------------------------------------------
접근 변경자를 사용해 실제 예를 들어 설명해 보도록 하겠습니다. 아래 코드는 a클래스에서 default, public,
protected, private 네 가지 접근 변경자로 각각의 a1(), a2(), a3(), a4()메소드의 접근을 제한하여 선언한 것입니다.
그리고 b클래스에서 a클래스의 제각기 다른 접근 변경자를 지닌 메소드에 접근해 보도록 하겠습니다.
[a.java]
------------------------------------------------------------------
public class a{
static void a1(){
System.out.println("default hello");
}
public static void a2(){
System.out.println("public hello");
}
protected static void a3(){
System.out.println("protected hello");
}
private static void a4(){
System.out.println("private hello");
}
public static void main(String args[]){
System.out.println("main hello");
a1();
a2();
a3();
a4();
}
}
------------------------------------------------------------------
[b.java]
-----------------------------------------------------------------
class b{
public static void main(String args[]){
a aObject=new a();
aObject.a1();
aObject.a2();
aObject.a3();
// aObject.a4();
}
}
-----------------------------------------------------------------
[설명]
------------------------------------------------------------------
-------------------------
1. a클래스를 실행시켰을 경우
-------------------------
맨 처음 a클래스만을 작성하여 컴파일 후 실행하면 아래와 같은 결과가 나옵니다.
[a클래스 실행 결과]
-----------------
main hello
default hello
public hello
protected hello
private hello
-----------------
위에 결과에서 보듯이 자기 자신의 클래스의 멤버의 경우 어떤 접근 제한 변경자를 사용하더라도 모두 접근이 됨
을 알 수 있습니다.
-------------------
2. b클래스의 컴파일시
-------------------
b클래스를 컴파일 할 때 aObject.a4();부분의 주석을 제거하여 a클래스의 private 접근 변경자로 제한된 a4()메
소드에 접근하려고 하면 다음과 같은 컴파일 에러가 나옵니다.
No method matching a4() found in class a.
aObject.a4();
^
a클래스에서 a4()메소드를 private로 접근 제한을 하였기 때문에 접근이 되지 않아 그런 에러가 발생하는 것입
니다. 즉 private로 접근을 제한하면 그 클래스의 멤버 이외의 다른 외부 객체나 서브 객체에게도 접근할 수 있는
어떠한 인터페이스도 알려지지 않았기 때문에 자바 컴파일러는 위와 같은 에러 메세지를 출력합니다.
-------------------------
3. b클래스를 실행시켰을 경우
-------------------------
b클래스에서 컴파일시 에러가 나는 aObject.a4()부분을 주석 처리하거나 삭제한 후 컴파일하여 실행시켰을 경
우, 아래와 같은 결과가 나옵니다.
[b클래스 실행 결과]
-----------------
default hello
public hello
protected hello
-----------------
위 결과에서 알 수 있듯이
a클래스의 접근 변경자가 public이므로 b클래스는 쉽게 a클래스의 멤버에 접근할 수 있다.
default접근 변경자는 a클래스와 b클래스가 같은 패키지 안에 속한 클래스 객체이므로 서로 접근이 가능해 실행이
되었고 public접근 변경자는 모든 외부의 객체에게 접근이 가능하므로 실행이 되었음
protected접근 변경자의 a3()메소드는 외부 객체인 b클래스에서 a aObject=new a();와 같이 a클래스의 객체를
aObject라는 객체에 상속(참조)하여 사용하였기 때문에 b클래스는 aObject객체를 통하여 서브 클래스화 할 수 있
으며 a클래스의 a3()메소드에 접근을 할 수 있어 실행이 된 것입니다.
자바개념(18) / 변경자 / static 변경자
--------------------------------------------------------------------------------
이전의 접근 변경자의 글을 통해 특정 클래스 객체 멤버(변수나 메소드)의 접근을 제한하는 방법을 알아보았습니
다. 이미 알아본 접근 변경자는 말 그대로 접근에 대한 제한을 두는 변경자이고, 지금부터 알아볼 변경자는 객체
멤버의 속성을 변경할 수 있는 변경자입니다. 쉽게 생각해 객체의 변수나 메소드에 특정한 성격을 부여할 수 있는
변경자인 것입니다.
static, final, synchronized, native변경자 이렇게 네 가지가 있습니다.
이 글에서는 첫 번째로 static변경자에 대해 알아보고 다음 글에서 차례대로 하나씩 알려드리도록 하겠습니다.
[static 변경자]
--------------------------------------------------------------------
- 특정 클래스의 모든 객체들을 위한 일반적인 변수와 메소드가 필요할 때 static 변경자를 사용하여 static 변수나
메소드가 모든 객체에게 동일한 영역을 재사용하게 사용할 수 있게 해줍니다.
- 여러분이 어떤 정수 변수 value를 선언하고, 매번 new키워드를 사용하여 매번 변화하는 어떤 정수값을 넣는다고
생각해 보세요. value변수는 한번만 선언하지만 매번 new키워드를 통해 새로운 변수 객체를 만드는 인스턴스화를
거친다면, 매번 인스턴스화시킬 때마다 메모리의 할당이 이루어질 것이므로, 시스템 자원의 낭비가 심화될 것입니
다.
그러나 아래와 같이 static 변경자의 속성을 부여한다면 정수 value는 아무리 많은 정수 value의 객체가 인스턴
스화 되었는지에 관계없이 오직 한 번만 메모리에 할당이 됩니다.
static int value;
- 쉽게 말해 위와 같이 static변수로 설정할 경우 메모리 할당이 단 한번만 이루어지므로 정수 value에 어떤 값을
대입하던 간에 상관없이 value의 데이터 값이 저장될 수 있는 공간이 정적으로(확고하게) 한 자리고 자리잡아 지
므로, 정수 value의 값이 한번 변경이 되었을 경우 value의 정적인 저장 공간의 데이터가 변경이 되므로 모든 객체
에서 변경된 값을 참조하게 되는 것입니다.
- static메소드는 그 실행이 특정 클래스의 모든 객체에 완전히 똑같이 적용됩니다.
위의 글과 같이 static메소드 역시 메모리에 한번 할당이 되고, 정적인 메모리 영역을 메소드의 처리를 위해 사
용하기 때문에, 모든 객체에 있어서 똑같은 처리결과를 합니다.
- static메소드의 동작이 위와 같이 모든 객체에 있어 동일한 처리를 하므로, static변수에 만 접근하여 처리되어야
지 객체의 참조에서 변화가 생길 수 있는 일반적인 변수에 접근이 되어서는 안됩니다. 자바 컴파일러 역시 static
메소드는 static변수에만 접근하도록 하고 있습니다.
[static 변경자 변수와 메소드 선언]
-------------------------------
static int myValue;
static int myMethod()
-------------------------------
static변수나 메소드의 선언의 위와 같이 변수형 타입 앞이나 메소드의 리턴 타입 앞에 선언해 주시면 됩니다.
- static멤버(변수나 메소드)부수 효과는, 그들이 클래스의 인스턴스를 생성하지 않고서도 접근할 수 있다는 것입니
다. 이미 Hello. World!프로그램을 통해 보았던 System.out.prtinln() 메소드를 기억하는지요? 그때 System객체를
생성하지 않고 out멤버를 사용하였는데 시스템 콘솔에 Hello, World!라는 문자열을 출력하였습니다.
위와 같이 System클래스의 out멤버변수는 static멤버 변수이므로, 기본적으로 사용자 프로그램에 로드되는 기능
중에 static멤버일 경우 메모리에서 가장 먼저 할당되어 생성되기 때문에 System객체를 실제로 생성(인스턴스화)하
지 않아도 사용자가 사용할 수 있었던 것입니다.
--------------------------------------------------------------------------
[좋은 예가 생각이 나서 덧붙임]
실세계의 예로 한 교실에 50명의 학생이 있고, 앉을 수 있는 의자가 딱 하나가 있다고 생각해 보세요. 이 의자에
앉을 수 있는 사람은 50명중에 단 한 명입니다. 그리고 앉은 사람이 이 의자에서 떠나야 다른 사람이 앉을 수 있
습니다. 이때 전덕찬이라는 학생이 의자에 앉아 있다고 할 때 의자에 앉아있는 전덕찬의 이름을 가진 학생과 대
화를 할 수 있는 나머지 모든 학생 49명은 의자에 전덕찬이라는 친구가 앉아 있을을 알 수 있으며, 덕찬이가 이
의자에서 벗아나기 전까지는 모두 의자에 앉아 있는 사람과 대화를 하기 위해서는 덕찬이와 대화를 해야 합니다,
그러나 다른 듀크라는 학생이 았다면 듀크가 앉았다는 것을 역시 49명의 모든 학생이 알 수 있을 것입니다. 이젠
덕찬이가 아닌 듀크라는 학생과 대화를 해야 합니다.
위 실세계의 예처럼 static변경자를 이용하면 멤버 변수나 메소드에 대해 단 한 공간만이 사용되므로 모든 객체에
서 동일한 참조 및 동작을 합니다.
자바개념(19) / 변경자 / final 변경자
--------------------------------------------------------------------------------
[final 변경자 의미]
-----------------------------------------------------------------
final변경자는 클래스 멤버(변수나 메소드)에 대해 그 클래스에 허용된 처음이자 마지막 인스턴스가 됨을 의미합
니다.
final변경자를 변수 앞에 지정하여 사용하면 그 변수는 선언시 초기값을 주어야하고 그값이 처음값이자 다시는
변경될 수 없는 확정된 데이터임을 뜻합니다. 메소드 역시 final 변경자를 붙여주면, 메소드에 대해 선언이 확정되
었기 때문에 서브 클래스에서 오버라이트(재정의)할 수가 없습니다.
final변경자는 클래스의 멤버중 선언과 동시에 초기화되어야 하며, 그 값은 결코 변경될 수 없습니다.
-----------------------------------------------------------------
[final 변경자 형식 예제]
--------------------------
final public int myValue=1234;
final int myMethod()
--------------------------
[final 실제 코드 예제]
--------------------------------------------
class finalTest{
final public static int myValue1=1234;
public static int myValue2=5678;
public static void main(String args[]){
System.out.println(myValue1);
// myValue1=4321;
System.out.println(myValue1);
System.out.println(myValue2);
myValue2=8765;
System.out.println(myValue2);
}
}
-------------------------------------------
[final사용 예제 코드 분석]
---------------------------------------------------------------
1. 위 코드에서 클래스 변수(전역 변수)범위의 정수 myValue1를 final로 선언하였고, myValue2는 public으로 변수
에 대해 접근 변경자를 두어 선언하였습니다.
2. myValue1,2는 선언과 동시에 값을 주어 똑같이 초기화시켜 주었습니다.
final public static int myValue1=1234;
public static int myValue2=5678;
3. 그러나 myValue1은 final변경자로 선언되었기 때문에 위에서 주석처리(//)된 부분을 제거하여 myValue1에 새로
운 값을 대입하려고 하면 자바 컴파일러는 다음과 같은 에러를 출력합니다.
Can't assign a value to a final variable: myValue1
myValue1=4321;
^
즉, final로 선언된 변수는 선언과 동시에 값을 주어 초기화시켜 주어야 하며 한번 초기화된 값은 변경할 수가
없습니다.
4. 그러나 myValue2는 public으로 선언되었기 때문에 언제든지 myValue2=8765;와 같이 값을 바꾸어 주셔도 됩니
다.
5. 위의 코드를 컴파일하여 실행하면 다음과 같은 결과가 나옵니다.
-----------------------------------------------------------------
[실행 결과]
----------
1234
1234
5678
8765
----------
[참고]
-----------------------------------------------------------------
위의 myValue1이 final과 public이 동시에 사용되어 초보자 분들께서 혼동이 되실 것 같군요. final은
값이 선언과 동시에 확정되어 변경할 수가 없다는 의미에서 사용되었고요, public의 의미를 다른 외부 객체들에게
접근 제한을 허용하겠다는 의미에서 사용된 것입니다.
final의 경우 멤버의 속성을, public의 경우 접근 제한을 의미
static의 사용은 main메소드가 static메소드이므로 static변수만을 사용하기 때문에 static으로 선언한 것
입니다.
-----------------------------------------------------------------
[실세계의 예제]
----------------------------------------------------------------
이전 글의 static을 학생과 의자에 비유한다면, final은 학생을 가르치는 교사에 비유될 수 있습니다. 새 학기가 시
작되면 담임이 정해지고 1년 동안 계속해서 정해진 담임이 한 반을 꾸준히 이끌어가듯이, 자바 프로그램이 시작될
떼 final의 값이 정해지면 프로그램이 끝날 때까지 계속해서 그 값을 유지하지요.
----------------------------------------------------------------
자바개념(20) / 변경자/synchronized변경자
--------------------------------------------------------------------------------
[synchronized 변경자 의미]
------------------------------------------------------------------
synchronized 변경자는 메소드(method)가 쓰레드 safe상태에 있다는 것을 의미하는 데 사용됩니다.
자바 언어에서는 쓰레드(thread)라는 개념을 사용하여 여러 작업을 동시에 수행할 수 있는 능력을 지니고 있는데,
이런 쓰레드를 이용하여 수많은 객체들이 어떤 메소드를 실행시킬 경우 동시에 같은 메소드에 여러 개의 작업이
진행되어야 하므로 하나의 작업에 이상이 있을 경우 모든 메소드를 호출한 객체에 잘못된 결과를 돌려주기 마련이
다.
이러한 문제를 해결하기 위한 것이 바로 synchronized 변경자인데 synchronized 변경자를 주어 메소드를 한번에
하나의 쓰레드 실행만을 실행하도록 함으로서 메소드의 실행을 안정된 상태로 만들어 주어 메소드 처리에 안정을
주어 호출한 곳에 올바른 결과를 돌려줄 수 있다.
------------------------------------------------------------------
[synchronized 변경자 형식]
---------------------------
synchronized int myMethod()
---------------------------
자세한 예제는 문법란을 통해 쓰레드에 대해 설명시 다루도록 하겠습니다.
[실세계의 예제]
-----------------------------------------------------------------
지하철을 타기 위해 표를 확인하고 들어가기 위해서는 한 명씩 차례대로 줄을 서서 지하철 표를 확인하는 매표기
에 표를 넣어야지 여러 사람이 한꺼번에 이용하려고 하면 오히려 무질서한 상태가 될 것입니다.
-----------------------------------------------------------------
자바개념(21) / 변경자 / native 변경자
--------------------------------------------------------------------------------
[native 변경자의 의미]
--------------------------------------------------------------------
native 변경자는 본래의(native)실행을 가지고 있는 메소드를 의미하는데 사용되며, 메소드의 실행이 외부의 C파
일에 존재함을 가리킵니다.
native변경자를 사용한 메소드는 기존의 C언어의 함수를 호출하여 실행하고자 할 경우 사용됩니다.
native메소드는 아래의 예제처럼 메소드의 실행부분 즉, 메소드 몸체가 없습니다. 왜냐하면 C언어의 특정 함수를
호출만 하고 실행을 그쪽 함수에게 넘기고 단지 결과만을 받거나 실행만을 시키기 때문입니다.
native int cFunction();
위와 같이 native변경자로 선언된 메소드는 단지 C언어의 함수를 호출만 할뿐이기 때문에 메소드의 범위가 존재
하지 않으므로 브레이스({})또한 사용할 필요가 없으므로 단지 세미콜론(;)을 통해 메소드의 끝임을 자바 컴파일러
에게 알려주면 됩니다.
--------------------------------------------------------------------
자바 언어의 개발 회사측이 선사에서는 pure java라는 명칭으로 자바 프로그램을 작성할 경우 순수 100% 자바
언어로만 작성할 것을 권유하고 있습니다. 기존의 C언어 프로그래머들이 아직은 자바 언어에 익숙하지 않고 자바
언어로 아직 구현하기 어려운 부분들에 대해 native등의 변경자를 사용하여 기존의 C코드로 구현하도록 할 수 있
게 했는데, 차차 모든 분야에서 자바 언어로의 구현이 가능함에 따라 점차 native가 사용되지 않고 있습니다. 순
수 자바 언어만으로 기존 C언어의 거의 모든 부분을 구현할 수 있게 되면 점차 사라질 것 같습니다.
자바개념(22) / 변경자 / abstract 변경자
--------------------------------------------------------------------------------
abstract 변경자는 추상 클래스와 메소드를 뜻하는데 사용됩니다.
이미 클래스 계승에 대한 글을 통해 추상 클래스와 메소드에 대해 대략 알려드린바 있습니다. 이 글을 통해 추상
클래스와 메소드에 대해 좀 더 자세히 알아보도록 하겠습니다.
우선 추상 클래스에 대해 알아보도록 합시다.
[추상 클래스]
-----------------------------------------------------------
추상 클래스는 부분적으로만 실행 가능하며, 그 목적은 오로지 디자인(사용자 프로그램) 작성의 편의를 돕기 위한
것이기 때문에, 선언은 되지만 몸체가 없는 실제로 어떤 작업을 할 수 없는, 하나 또는 그 이상의 추상 메소드로
구성되어 있습니다.
-----------------------------------------------------------
[추상 클래스 / 메소드 만들기]
-----------------------------------------------------------
추상 클래스로 만들기 위해서는 아래처럼 abstract 자바 예약어를 사용하여야 합니다. [참고] abstract는 추상이라
는 의미로 사용되었음
전에 예로 들었던 carGame클래스를 추상 클래스로 만든다면 다음과 같이 abstract를 사용하시면 됩니다.
abstract class carGame{
abstract void move();
abstract void move(int x, int y);
}
carGame 클래스를 선언하기 전에 abstract예약어를 기입해 줌으로서 자바 컴파일러에서 carGame클래스를 인스턴
스화가 될 수 없는 추상 클래스로서만 사용할 것을 알려줍니다. move메소드 역시 추상 메소드임을 나타내기 위해
리턴값 앞에 abstract예약어를 사용하였습니다.
-----------------------------------------------------------
abstract 예약어를 사용하는 데에는 다음과 같은 규칙이 있으니 주의하셔야 합니다.
[abstract사용 규칙]
-------------------------------------------------------------
- Constructor Method(생성 메소드)는 abstract 할 수 없다.
[참고] 생성 메소드 : 클래스 이름과 동일하며, 클래스 생성시 초기화 문들을 초기화하고자 할 때 사용하는 메
소드, 생략가능
- Static method는 abstract 할 수 없다.
- Private method는 abstract 할 수 없다.
- Abstract method는 abstract method가 선언되어있는 class의 subclass에 정의한다.
- Superclass의 method로부터 override된 method는 abstract 할 수 없다.
- Abstract method와 overriding 하지 않고 abstract method를 상속받은 class를 abstract class라고 한다.
- Abstract class를 instantiate하거나, abstract method를 직접 호출하면 compile-time error를 내보낸다.
-------------------------------------------------------------
Abstract method는 subclass들간의 규약을 정하기 위한 superclass 또는 interface의 기능을 제공한다. Abstract
method는 subclass에서는 반드시 정의를 해야 한다.
Abstract method는 method body가 없고, 대신 선언은 세미콜론(semicolon)으로 끝난다.
추상 메소드를 가지고 있는 수퍼 클래스로부터 클래스를 계승받을 때, 모든 추상 메소드를 오버라이드(재정의)하
고, 실행 부분을 첨가하거나, 추상 그 자체로 남아있을 수 있도록 새로운 클래스를 인스턴스화하지 못하게 해야 한
다.
abstract의 사용하는 예를 차후 추상 클래스의 한 종류인 인터페이스(Interface)에 대해 알려드릴 때 알아보기로
합시다.
자바개념(23) / 클래스 캐스팅
--------------------------------------------------------------------------------
자바 이야기 문법메뉴의 타입 캐스팅이라는 글을 통해 이미 데이터형 간의 캐스팅(casting:형 변환)하는 방법을
알려드린바 있습니다. 클래스도 마찬가지로 클래스간의 캐스팅을 할 수 있는데, 수퍼 클래스에서 서브 클래스로 서
브 클래스에서 수퍼 클래스로 캐스팅 할 수 있습니다.
[클래스 캐스팅 형식]
----------------------------------------------------------------
- 명시적이거나 암묵적으로 캐스팅할 수 있습니다.
[서브 클래스 -> 수퍼 클래스로 캐스팅의 경우]
- 암묵적이란 프로그래머가 아무 표시도 해주지 않아도 되는 것을 의미하며, Number myNumber=myDouble1
[수퍼 클래스 -> 서브 클래스로 캐스팅의 경우]
- 명시적이란 아래처럼 캐스팅 괄호 안에 클래스 타입을 제공해야함을 의미함.
Double myDouble2=(Double)myNumber;
---------------------------------------------------------------
다음 클래스 캐스팅의 예제로 보면서 설명하도록 하겠습니다.
---------------------------------------------------------------
public class a {
public static void main(String args[]){
Double myDouble1=new Double(5.234);
Number myNumber1=(Number)myDouble1;
Number myNumber2=myDouble1;
System.out.println(myNumber1);
System.out.println(myNumber2);
Double myDouble3=(Double)myNumber1;
// Double myDouble4=myNumber1; // 에러발생
System.out.println(myDouble3);
// System.out.println(myDouble4);
// Long myLong1=myDouble1; // 에러발생
// Long myLong2=(Long)myDouble1; // 에러발생
// System.out.println(myLong2);
}
}
---------------------------------------------------------------
Byte, Integer, Short, Double, float, Long등 숫자 저장할 수 있는 클래스의 데이터형은 모두 Number클래스의 서
브 클래스 상속(계승)하여 만들어 졌습니다.
Double myDouble1=new Double(5.234);
Number myNumber1=(Number)myDouble1;
Number myNumber2=myDouble1;
위의 문장은 서브 클래스를 수퍼 클래스로 캐스팅하는 부분입니다.
Byte, Integer, Short, Double, float, Long클래스의 객체들은 Number클래스부터 계승 계승되었기 대문에 Double
객체 myDouble1에는 이미 Number클래스에 대한 정보가 포함되어 있기 때문에, 수퍼 클래스 Number객체로 캐스
팅하고자 할 경우 명시적으로 (Number)와 같은 myDouble1이 어떤 클래스형인지를 기입해 줄 필요가 없습니다.
기입을 해줘도 위처럼 에러는 발생하지 않습니다.
Double myDouble3=(Double)myNumber1;
// Double myDouble4=myNumber1; // 에러발생
위의 문장은 수퍼 클래스를 서브 클래스로 캐스팅 하는 부분입니다.
Number클래스 객체인 myNumber1를 Double클래스형 데이터로 만들기 위한 캐스팅 밥법으로 수퍼 클래스 객체
인 myNumber1는 서브 클래스인 Double에 대한 어떤 정보도 가지고 있지 않기 때문에 명시적으로 ()안에 변환하
고자 하는 서브 클래스형을 기입해 줌으로서 자바 컴파일러에게 Double형으로 캐스팅할 것임을 알려줍니다.
두 번째 것은 명시적으로 (Double)를 기입해 주지 않았기 때문에 다음과 같은 에러가 나옵니다.
Incompatible type for declaration. Explicit cast needed to convert java.lang.
Number to java.lang.Double
위 에러 메세지는 명시적으로 캐스팅형을 기입해 달라는 메세지입니다.
// Long myLong1=myDouble1; // 에러발생
// Long myLong2=(Long)myDouble1; // 에러발생
위 문장은 형제 클래스끼리의 클래스 캐스팅이 허용되지 않음을 나타냅니다.
Invalid cast라는 에러 메세지가 나옵니다.
자바개념(24) / 생성자 메소드
--------------------------------------------------------------------------------
프로그래머가 어떤 클래스 객체를 생성할때 일반적으로 멤버 변수를 초기화 하기를 원합니다. 생성 메소드는 변
수들을 초기화하고 객체가 클래스로부터 생성될 때 필요한 다른 연산을 수행할 수 있는 모든 클래스에서 실행될
수 있는 특별한 메소드입니다.
[생성자 메소드]
--------------------------------------------------------------
- 객체가 생성될 때마다 불려지는 메소드이다.
- 클래스 이름과 동일하다.
- 반환값을 가지지 않는다.
- 메소드 변성자는 publoic, protected, privated만이 가능하다.
- 생성자 메소드의 선두에 현재 클래스 안의 다른 생성자를 부르는 thid()나 부모 클래스의 생성자를 부르는
super()형태의 메소드를 호출하여 사용할 수 있다.
- 생성자 메소드를 명시하지 않으면(생략하면) 수퍼 클래스의 생성자 메소드를 호출하여 실행한다.
---------------------------------------------------------------
생성자 메소드의 예제를 들어 설명해 보도록 하겠습니다.
[생섬자 메소드 예제]
---------------------------------------------------------------
import java.awt.*;
class myCar {
protected Color color; // 자동차 색
protected int energy; // 에너지 양
protected int step; // 기어 상태
public myCar(){
System.out.println("생성자 메소드안의 변수 초기화 시작");
color=Color.blue;
energy=100;
step=1;
}
public myCar(Color myColor, int myEnergy, int myStep){
System.out.println("생성자 메소드안의 변수 초기화 시작");
color=myColor;
energy=myEnergy;
step=myStep;
}
public static void main(String args[]){
myCar junCar=new myCar(); // junCar인스턴스시 생성자 메소드 호출
myCar dukCar=new myCar(Color.red, 70, 1);
System.out.println("junCar객체 인스턴스후 실행");
}
}
---------------------------------------------------------------
myCar라는 클래스 객체를 만들고 이것을 실제로 작동시킬 수 있도록 junCar라는 실제 인스턴스를 다음에 배울
new키워드를 통하여 메모리에 인스턴스 객체를 생성할 경우 myCar클래스 이름과 똑같은 myCar()생성자 메소드
를 호출하여 그 안의 초기화 문장을 실행함을 알 수 있습니다. 이렇게 해주는 이유는 myCar 클래스를 이용해 많
은 수의 인스턴스 객체를 메모리에 만들 수 있는데 각각의 객체가 생성될 때 필요한 초기화 문장을 생성자 메소드
를 통해 정의해 주기 위함입니다.
생성자 메소드 역시 전에 배운 메소드 오버로드의 기술을 이용하여 위의 예제처럼 메소드의 이름은 같지만 메소
드 매개변수가 다르게 하여 여러 개를 정의할 수 있으며, 객체를 new키워드를 통해 인스턴스화 하고자 할때
myCar dukCar=new myCar(Color.red, 70, 1);와 같이 메소드 매개변수를 호출할 경우 myCar생성자 메소드중 매개
변수와 맞는 생성자 메소드를 호출하여 실행하게 됩니다.
위와 같이 생성자 메소드를 적절히 활용함으로서 클래스 객체를 실제로 인스턴스화 시킬때 각각의 객체에 서로
다른 상태를 가지게 할 수 있습니다.
[참고]
----------------------------------------------------------------
객체를 인스턴스화 한다는 의미에 대해 잘모르시는 분을 위해 간단히 설명을 하도록 하겠습니다.
객체(클래스)를 일반적인 상태와 동작을 지닌 모든 사람에 해당한다면, 인스턴스는 이런 사람객체 중에서도 특정
한 사람인 영희나, 철수 등과 같은 실제로 살아 있어 표현될 수 있으며 동작할 수 있는 객체을 의미합니다.
만약 어떤 회사에서 신입사원을 뽑은 후 신입사원에 대한 프로필 프로그램을 만든다면 다음과 같이 하겠죠.
신입사원 홍길동=new 신입사원(1, 27, 711111,1111111);
신입사원 이영희=new 신입사원(2, 23, 731111,2222222);
신입사원메소드(int 성별, int 나이, int 주민앞번호, int 주민뒤번호){
sex=성별;
age=나이;
code1=주민앞번호1;
code2=주민뒤번호2;
}
위처럼 신입사원이라는 클래스 객체를 실제 홍길도, 이영희라는 인스턴스 객체로 만들기 위해서는 다음에 대울
new연산자를 이용하였고, 생성자 메소드에게 매개변수를 전달하여 각각의 인스턴스 객체의 정보를 초기화하도록
하였습니다.
----------------------------------------------------------------
생성자 메소드는 인스턴스 객체를 생성시 변수 초기화나 미리 정의해야 하는 일등에 사용됨을 알아두시면 됩니
다.
자바개념(25) / 객체 / 객체 생성
--------------------------------------------------------------------------------
자바 언어에서 객체지향 프로그래밍의 디자인 작업 대부분이 클래스를 생성하는 것이지만, 실제로 클래스의 인스
턴스를 생성하기 전까지는 작업으로부터 얻는 것이 아무 것도 없습니다.
프로그램 내에서 클래스를 사용하기 위해서는 클래스의 인스턴스를 생성해야 합니다. 클래스가 데이터와 메소드
를 가지고 지녔다면 인스턴스 객체를 생성함으로서 클래스를 움직일 수 있는 이름의 의미를 부여하고 동작시킬 수
있을 것입니다.
자 그럼 객체를 생성하기 위해서는 어떻게 해야 하는지 알아봅시다.
[인스턴스 생성]
------------------------------------------------------------------
인스턴스 객체를 생성하기 위해서는 어떤 클래스 객체에 대한 참조할 수 있는 특정한 이름으로 선언한 후, new
키워드를 사용해 실제로 그 클래스에 대한 인스턴스 객체를 메모리에 생성시켜 주어야 합니다.
new키워드를 사용하여 메모리에 생성하기 전까지는 클래스의 데이터나 메소드는 아무런 의미를 지닐 수가 없습
니다.
-------------------------------------------------------------------
[인스턴스 형식]
---------------------------------------------------
클래스이름 인스턴스이름=new 클래스이름();
또는
클래스이름 인스턴스이름=new 클래스이름(생성자매개변수);
---------------------------------------------------
[인스턴스 예제]
-------------------------------------------------------------------
이전의 생성자 메소드에서 예제로 보았던 신입사원 클래스를 예로 들어보도록 하겠습니다.
class 신입사원{
protected int sex;
protected int age;
protected int code1, code2;
신입사원생성자메소드(int 성별, int 나이, int 주민앞번호, int 주민뒤번호){
sex=성별;
age=나이;
code1=주민앞번호1;
code2=주민뒤번호2;
}
신입사원활동메소드(){
업무처리;
}
public static void main(String args[]){
신입사원 홍길동=new 신입사원(1, 27, 711111,1111111);
신입사원 이영희=new 신입사원(2, 23, 731111,2222222);
}
}
위 예제에서 신입사원이라는 클래스는 여러 명의 신입사원 전체를 의미하며, 신입사원들의 공통적인 정보를 표
현할 수는 있는 형식을 제공할 뿐이고, 실제 신입사원 클래스의 인스턴스 객체인 홍길동은 신입사원에 속하면서
신입사원으로서의 자신만의 고유한 데이터를 가질 수 있으며, 신입사원으로서의 어떤 정의된 동작인 업무처리를
할 수 있습니다.
------------------------------------------------------------------
위 예제처럼 클래스 자체는 단지 생성된 인스턴스 객체가 지닐 수 있는 정보나 할 수 있는 종작의 선언(정의)에
불과하며, new키워드를 통하여 인스턴스 객체가 생성되어야만이 클래스의 데이터와 메소드를 작동시킬 수 있는 주
체가 되어 프로그램이 실행됨을 알 수 있습니다.
자바개념(26) / 객체 / 객체 생성 예제
--------------------------------------------------------------------------------
객체 생성의 실제 예제를 들어보도록 하겠습니다.
이전의 글에서 예를 들었던 신입사원 클래스의 인스턴스 객체를 생성하는 실제 사용 가능한 신입사원 인스턴스
객체를 만들어 보도록 하겠습니다.
[실제 인스턴스 사용예제]
---------------------------------------------------------------
class newMan{
protected int sex;
protected int age;
protected int code1, code2;
newMan(int 성별, int 나이, int 주민앞번호, int 주민뒤번호){
sex=성별;
age=나이;
code1=주민앞번호;
code2=주민뒤번호;
}
public static void main(String args[]){
newMan 홍길동=new newMan(1, 27, 711111,1111111);
System.out.println("홍길동 성별="+홍길동.sex);
System.out.println("홍길동 나이="+홍길동.age);
System.out.println("홍길동 주민앞번호="+홍길동.code1);
System.out.println("홍길동 주민뒤번호="+홍길동.code2);
newMan 이영희=new newMan(2, 23, 731111,2222222);
}
}
---------------------------------------------------------------
위 코드는 실제 실행이 되는 예제로 홍길동 신입사원 인스턴스 객체를 만들고 홍길동 객체로부터 정보 데이터를
화면에 출력하는 예제입니다.
newMan클래스 자체는 newMan의 인스턴스 객체가 생성되기, new키워드를 통해 홍길동, 이영희라는 신입사원
인스턴스 객체가 메모리상에 실제로 만들어지기 전까지는 단지 newMan클래스를 인스턴스화 하는 객체가 가질 수
있는 상태와 동작할 수 있는 메소드를 정의해준 것에 불과합니다.
newMan 홍길동=new newMan(1, 27, 711111,1111111);
newMan 이영희=new newMan(2, 23, 731111,2222222);
처럼 newMan클래스의 인스턴스 객체를 메모리에 생성(할당)해 줌으로서 홍길동 객체와 이영희 객체는
newMan이 지닌 데이터에 메소드를 홍길동.sex와 같이 접근하여 그 객체의 값을 얻을 수 있습니다.
인스턴스 객체를 만들때 (1, 27, 711111,1111111)와 같은 생성자 매개변수를 줌으로서 자신만의 특정한 변수값으로
초기화시킬 수 있습니다.
System.out.println("홍길동 성별="+홍길동.sex);
System.out.println("홍길동 나이="+홍길동.age);
System.out.println("홍길동 주민앞번호="+홍길동.code1);
System.out.println("홍길동 주민뒤번호="+홍길동.code2);
위와 같이 인스턴스 객체에서 데이터를 얻기 위해서는 인스턴스 객체이름과 "." 다음 원하는 인스턴스 변수를 정
의함으로서 얻을 수 있습니다.
실제로 위 코드를 작성하여 실행해 보시면 객체 생성에 많은 이해가 되실 것입니다.
자바개념(27) / 객체 / 객체 소멸
--------------------------------------------------------------------------------
객체(인스턴스 객체)가 범위를 벗어날 때 메모리로부터 제거되거나 삭제됩니다. 객체가 생성될 깨 호출되는 생성
메소드가 있다면, 객체가 삭제 될때는 소멸(종결) 메소드를 정의하여 불필요한 객체들을 소멸시킬 수 있습니다.
생성 메소드가 클래스 이름과 동일한 것과는 달리, 소멸 메소드는 finalize(종결자)라 불리며, 다음과 같은 형식으
로 되어 있습니다.
[ 객체 종결자의 형식]
-------------------
void finalize(){
}
-------------------
finalize메소드는 객체가 자신만의 영역(범위)를 벗어난다고 해도 곧바로 호출되어지지 않습니다. 왜냐하면 자바
언어는 프로그램의 실행시 프로그램 실행에 더 이상 필요가 없다고 판단되거나 불필요하게 할당된 시스템 자원등
을 쓰레기 수집기(garbage collection)를 수행시켜 필요 없는 객체를 메모리로부터 삭제하거나 불필요하게 낭비되는
시스템 자원을 메모리로부터 제거해줍니다.
가베지 콜렉션(garbage collection)인 쓰레기 수집기가 수행되기 전까지는 실제로 객체가 메모리에서 삭제되기 않기
때문에 종결자(finalize)가 호출되기 않습니다.
기존의 C언어 등에서는 프로그램의 실행에서 시스템 자원의 낭비를 막기위해 종결자등을 통해 할당된 자원을 당
아 주어야만 했으나 자바 언어는 프로그래머들에게 이런 부분들은 신경쓰지 않아도 되도록 가베지 콜렉션을 두어
프로그램 코딩 작성을 편리하게 해주었습니다.
대다수의 자바 프로그램에서 종결자를 정의할 필요가 없는데, 가베지 콜렉션이 알아서 필요 없는 객체를 없애주
며 finalize()역시 자동으로 호출되어 실행이 되기 때문입니다. 그러나 자신이 꼭 필요한 시기에 어떤 객체나 자원
을 소멸하기 위한다면 종결자를 사용하실 수 있습니다.
자바개념(28) / 패키지 / 정의
--------------------------------------------------------------------------------
자바 언어는 하나의 단위에 연관된 클래스와 인터페이스(참고1)를 함께 그룹화할 수 있는 방법을 제공하는데, 그
것이 바로 패키지(package)입니다.
[패키지]
--------------------------------------------------------------------
- 패지지는 연관된 클래스와 인터페이스의 그룹을 뜻합니다.
- 패키지는 클래스 이름의 충돌을 막으면서 많은 클래스와 인터페이스를 제어하는 편리한 매커니즘을 제공합니다.
- 자바 API는 그 자체가 패키지화 된 그룹으로 구성되어 있습니다.
--------------------------------------------------------------------
[참고1 / 인터페이스]
--------------------------------------------------------------------
인터페이스 : 자바 언어의 다중 상속의 문제로 인해 여러 클래스들의 메소드를 정의를 한데 묶어 놓은 추상 클래
스이며, 이것을 첨가하여 자바 프로그램에서는 다중 상속을 구현할 수 있다. 서브 클래스는 인터페이스에서 구현된
메소드를 모두 오버라이드(재정의)해 주어야만 한다.
// 패키지에 대한 글 다음에 알아 보기로 하겠습니다.)
--------------------------------------------------------------------
자바 jdk1.02에서는 8개의 패키지로 구성되어 있으나 jdk1.1.4의 경우 아래처럼 24개의 패키지로 구성되어 있습니
다. jdk1.1.4를 기준으로 살펴 보도록 하겠습니다.
[jdk1.1.4패키지]
-----------------------------------------------------------
01. java.applet // 애플릿 관련
02. java.awt // 사용자 인터페이스 관련
03. java.awt.datatransfer // 데이터 전송 관련
04. java.awt.event // 이벤트 관련
05. java.awt.image // 이미지 조작 관련
06. java.awt.peer // 피어 오브젝트 관련
07. java.beans // 자바빈즈 관련
08. java.io // 입출력 관련
09. java.lang // 언어 일반 관련
10. java.lang.reflect // 리플렉트 관련
11. java.math // 수학 연산 관련
12. java.net // 네트웍 관련
13. java.rmi // 원격 메소드 호출 관련
14. java.rmi.dgc // 서버쪽 가베지 콜련션 관련
15. java.rmi.regisrty // 원격 메소드 등록 관련
16. java.rmi.server // 원격 메소드 서버쪽 관련
17. java.security // 보안 관련
18. java.security.acl // 접근 제어 관련
19. java.security.interfaces // 보안 인터페이스 관련
20. java.sql // 데이터베이스 관련
21. java.text // 텍스트 조작 관련
22. java.text.resources // 로케일 관련
23. java.util // 유틸리티 관련
24. java.util.zip // zip관련
------------------------------------------------------------
자바개념(29) / 패키지 / 형식, 규칙
--------------------------------------------------------------------------------
보통 기본 자바 API패키지를 사용하여 프로그램을 작성하지만, 자신만의 특정 클래스를 패키지화하여 수입 사용
하고자 한다면 다음과 같이 하시면 됩니다.
우선 패키지를 만드는 데 알아야 할 형식과 규칙에 대해 알아봅시다.
[패키지 형식]
------------------------
package 패키지 계층구조명;
------------------------
[패키지 규칙]
--------------------------------------------------------------------
1. 사용자 패키지를 만들려면 어떤 패키지로 만들것인가 사용자 패키지명을 정하여 클래스의 어떤 문장의 선언도
오기 전에 컴파일 단위의 맨 앞에 package문장과 사용자 패키지 계층의 이름을 기입해 주셔야 합니다.
2. 자바 API패키지처럼 각각의 관련 클래스별로 분산시켜 패키지를 그룹화 할 수 있습니다. 이전의 글에서
JDK1.1.4의 패키지 구조를 보았듯이 관련 클래스들을 24개의 패키지로 구분하여 그룹화시켜 주었습니다.
3. 패키지가 패키지 안에 중첩(포함)할 수 있습니다.
4. 사용자 패키지를 수입(import)해 사용할 때, 자바 인터프리터는 사용자가 정의한 사용자 패키지 계층구조에 따
라 디렉토리를 찾을 것이며, 실행 가능한 클래스가 있는지 검사하며, 컴파일시에는 사용자 패키지로 지정된 위치에
실행 가능한 클래스가 있는지 검사할 것입니다.
5. 자바를 만든 선에서는 클래스를 패키지화 하고자 할 경우 자신의 사이트 주소를 역으로 사용한 구조로 패키지
명을 작성할 것을 권하고 있습니다. 예로 선의 Java Foundation Classes의 패키지명 구조를 보면 다음과 같다.
[JFC패키지 클래스 swing.jar, rose.jar의 패키지 구조]
com.sun.java.swing.*;
이 예제를 보듯이 java.sun.com의 사이트 주소를 역으로 사용하여 패키지명으로 사용함으로서, 어느 회사에서
이 패키지가 만들어졌는지를 쉽게 알 수 있다.
[참고] 참고로 위의 JFC패키지명이 아직 기본 자바 API패키지명인 java로 시작이 되지 않고 있는 것을 알 수
있는데, 이것은 이 JFC가 아직 0.51정도의 베타 단계의 버전이고 안정성 면이나 브라우저에서의 지원여부가 불투
명하기 때문에 기본 자바 API패키지로 포함되지 않고 독립되어 있는 것인데 다음 버전인 JDK1.2에서는 JFC가 기
본 패키지로 포함될 것으로 보입니다.
-------------------------------------------------------------------
자바개념(30) / 패키지 / 선언
--------------------------------------------------------------------------------
실제 사용자 패키지를 만들는 방법을 알려드리도록 하겠습니다.
[우선 이해를 도모하기 위해 다음 자료를 받으세요.]
-------------------------------------------------------------------
자바 이야기 자료실에 있는 자료실 자료번호 1번 자료 "Package.tar"를 받아서 적당한 디렉토리를 만들고 tar로
묶음을 폴어 주세요.(winzip으로도 해제가능) 제가 사용자 패키지 만드는 것을 테스트 해 본 것입니다. 테스트 환
경을 리눅스에서 했지만, 윈도우95도 똑같습니다.
------------------------------------------------------------------
[사용자 패키지 만들기]
------------------------------------------------------------------
1. Package.tar를 tar xvf Package.tar로 d:test라는 적당한 디렉토리에 풀면 다음과 같은 구조로 디렉토리가 생
성됩니다. (winzip으로도 해제가능)
[디렉토리 구조] [디렉토리 안의 파일]
----------------------------------------------------
d:test
d:testjava ------> dukciPackCall.java
------> dukciPackCall.class
d:testjavainfo
d:testjava\shop ------> dukciPackage.java
------> dukciPackage.class
----------------------------------------------------
2. 전 글에서 알려드린 패키지의 규칙대로 자신이 사용하고자 하는 패키지명의 디렉토리를 만듭니다.
java -> info -> shop
3.. d:testjava\shop디렉토리 안의 duckiPackage.java자바 코드가 바로 사용자 패키지로 만들 클래스인데 아래 소
스를 보시면 알겠지만 코드의 맨 앞에 사용자 패키지 계층구조 패키지명이 디렉토리의 구조대로 선언이 되어 있
습니다.
4. 코드의 맨앞에 package문장으로 사용자 작성할 패키지명을 기입한다.
package java.info.shop;
public class dukciPackage{
public static void main(String args[]){
dukciPackage dp=new dukciPackage();
}
public String dukci(){
String packageString="package java info shop";
return packageString;
}
}
5.. 사용자 패키지로 만들고자 하는 패키지 명대로 디렉토리 구조를 만들어 주시고, 디렉토리 안에 사용자 패키지
로 만들고자 하는 클래스를 위치시킨 후, 클래스의 코드 맨 앞에 위 예처럼 package문장을 디렉토리 구조대로 적
어주면 자바 컴파일러가 이 클래스를 사용자 패키지로 인식하여 다른 클래스(dukciPackCall.java)등에서 수입문장
(import)을 통해 사용자 패키지로 정의된 클래스를 적재시킬 수 있습니다.
--------------------------------------------------------------------
[주의] 수입문장을 통해 적재 할 경우 패키지 계층의 상위 계층까지는 classpath를 autoexec.bat에 설정해 주셔야
자바 컴파일러가 클래스 패스가 설정된 곳에서부터 수입문장을 통해 기입되는 사용자 패키지명의 순서대로 디렉토
리를 찾아내려 가면서 사용자 패키지 클래스를 찾을 수 있습니다.
수입문장을 통한 적재는 다음의 글에서 알려드리도록 하겠습니다.
자바개념(31) / 패키지 / 포함
--------------------------------------------------------------------------------
패키지의 선언방법까지 알아 보았으니, 이젠 이렇게 선언된 패키지를 실제 프로그래밍 과정에서 어떻게 불러들여
사용하는지, 작성하고자 하는 프로그램에 패키지의 포함시키는 방법을 알아보도록 하겠습니다.
패키지를 프로그램에 포함시키는 방법은 대략 3가지 형태로 나눠볼 수 있다.
[패키지 포함 3형태]
-------------------------------------------------------------
1. 수입문장을 통한 한 패키지 전체를 포함
ex) import java.awt.*;
2. 수입문장을 통한 프로그램에 필요한 개별적인 패키지 클래스만을 포함
ex) import java.awt.Color;
3. 개개의 객체에 대한 명시적인 참조에 의한 포함
ex) java.awt.Color color
-------------------------------------------------------------
위 패키지 포함의 3가지 형태를 하나씩 살펴봅시다.
[패지지 포함 형태 분석]
---------------------------------------------------------------
우선 작업중인 자바 프로그램에 자바 기본 API나 사용자 정의 패키지등 패키지를 포함시켜 사용하고자 할 때는
수입문장(import)을 사용함과 수입문장의 사용을 프로그램 코드 작성시 어떤 문장보다도 먼저 맨 앞에 와야 함을
알아두자
- 첫 번째 형태는 자바 기본 API의 awt패키지 관련 클래스를 현재 작업중인 프로그램 코드에 포함시킴을 의미합
니다.
작성하고자 하는 프로그램에 awt패키지와 관련된 모든 클래스가 포함되었기 때문에 awt관련 모든 객체들(버튼,
라벨, 체크박스, 칼라, 폰트, 등등)을 만들어 사용할 수 있습니다.
- 두 번째 형태는 자바 기본 API의 awt패키지 안에 위치하고 있는 Color클래스만을 포함시킵니다.
java.awt.Color클래스만을 지정하여 포함시켰기 때문에, 칼라의 정보를 저장할 수 있는 Color객체만을 프로그램
에서 사용할 수 있습니다.
- 세 번째 형태는 클래스(프로그램)의 코드 작성시 명시적 패키지 참조(explicit package referencing)방법으로 사용
함으로서 패키지 포함을 위해 수입문장을 사용할 필요가 없이 개개의 클래스 객체를 생성하고자 할 때 객체변수명
앞에 위의 예처럼 객체가 속한 패키지명을 직접 명시(기입)해 주면 됩니다. 이 명시적인 패키지 포함 방법은 매번
객체 선언시마다 패키지명을 기입해 주어야 하므로 코드의 읽기가 어려워질 수 있다.
---------------------------------------------------------------
[참고] [수입문장에서의 * 사용]
---------------------------------------------------------------
위의 첫 번째 방법에서 java.awt.*로 하면 awt관련 패키지를 모두 수입하지만 java.*; 와 같이 하면 모든 클래스를
수입할 수 있을 것이라 생각하지 마세요.
자바 언어는 import java.*;와 같은 패키지 수입할 수 없는데, 왜냐하면 java패키지 아래 awt라는 패키지명의로
된 것이 아래처럼 여러 개가 있으므로 자바 프로그램에서 Color객체를 사용할 경우 어디에서 찾아야 할지를 모르
지 때문이다. 그렇기 때문에 패키지명이 중복되지 않는 범위에서 *를 통한 한 패키지를 수입문장을 통해 포함시킬
수 있는 것입니다.
02 java.awt // 사용자 인터페이스 관련
03. java.awt.datatransfer // 데이터 전송 관련
04. java.awt.event // 이벤트 관련
05. java.awt.image // 이미지 조작 관련
06. java.awt.peer // 피어 오브젝트 관련
---------------------------------------------------------------
자바개념(32) / 인터페이스 / 정의
--------------------------------------------------------------------------------
인터페이스란 완전히 미완성된 채로 남겨진, 즉 인터페이스(interface)안의 어떤 메소드(method)도 메소드 몸체가
존재하지 않아 실행 부분이 존재하지 않는 클래스를 위한 템플릿으로서의 기능을 수행하는 추상 클래스의 한 종류
입니다.
C언어에서 지원하는 다중 계승은 여러 개의 부모 클래스로부터 클래스를 유도(상속)할 수 있게 해주지만, 구현이
복잡하고 많은 문제점을 야기한다. 자바 언어의 설계자들은 이런 다중 상속의 문제점을 없애고, 다중 상속과 비슷
한 기능을 할 수 있는 인터페이스라는 개념을 만들어 냈다.
인터페이스의 의미에 대해 더 자세히 알아봅시다.
[인터페이스]
---------------------------------------------------------------
1. 기존의 C언어 등에서 지원되는 다중상속(여러 클래스 상속)이 많은 문제점 지니기 때문에 자바 언어에서는 다
중상속의 개념을 인터페이스라는 개념으로 변형하여 인터페이스를 통해 다중상속을 구현하는 방법을 지원하고 있
습니다.
2. 인터페이스 안에는 변수와 메소드 몸체가 없는 추상 메소드만으로 구성되어 집니다. 대부분이 추상 메소드로 구
성되어 있다.
3. 인터페이스 안의 메소드들은 변경자을 명시하지 않아도 public으로 설정이 되어 클래스에 첨가(implement)함으
로서 바로 접근이 될 수 있는 것입니다.
4. 인터페이스의 멤버변수인 데이터 역시 변경자를 명시하지 않아도 기본 상수(primitive constant)인 final static의
변경자로 설정이 됩니다.
5. 클래스에게 다중(여러개) 인터페이스를 첨가(implement)하여 실행하도록 자바 언어는 지원한다.
6. 클래스에서 인터페이스를 첨가하여 사용할 경우 인터페이스 안에서 정의된 모든 메소드를 구현해 주어야 한다.
이것이 추상 클래스와 인터페이스의 주요한 차이점입니다.
7. 자바 API패키지마다 추상 클래스와 더불어 많은 인터페이스들로 구성되어 있어, 프로그래머들은 이런 인터페이
스를 프로그램에 첨가함으로서 여러 클래스 메소드를 다중 상속한 것처럼 프로그램을 구현할 수 있다.
---------------------------------------------------------------
자바 기본 패키지 안의 API계층구조를 살펴보시면 많은 인터페이스의 모양에 대해 알 수 있습니다. 자바 툴인
KAWA2.5이상 버전을 이용하시면 쉽게 API를 탐색하실 수 있습니다.
다음 글을 통해 인터페이스를 클래스 프로그램에 첨가하는 방법을 알아봅시다.
자바개념(33) / 인터페이스 / 선언
--------------------------------------------------------------------------------
인터페이스는 클래스의 내부 구현을 제와한 참조형만을 선언한 것이므로, 인터페이스 안의 변수는 선언만이 가능
하며, 객체를 생성하는 것은 불가능하다. 그리고 메소드 또한 메소드의 이름만을 정의하여야 합니다.
[인터페이스 선언 형식]
------------------------------------------------------------
1. 인터페이스 선언형식
[public] interface 인터페이스이름 [extends interface1, interface2,..]{
}
[설명]
- public : 선언된 인터페이스의 접근 제한자를 의미
인터페이스는 모든 클래스에서 첨가하여 실행될 수 있어야 하므로 public접근 제한자를 사용하여야 한
다. 보통 생략되어 지며, 명시하지 않으며 public으로 설정됨
- interface : 인터페이스이름으로 인터페이스를 정의하겠다는 의미
- 인터페이스이름 : 정의하고자 하는 인터페이스 이름
- extends interface1, interface2.. : 인터페이스는 다른 인터페이스를 상속 할 수 있다. 다른 인터페이스를 상속은
대개 하나의 인터페이스에 많은 인터페이스 기능을 구현해 놓아 프로그램 작성시 이것만을 첨가해 주면 되므로 여
러 인터페이스의 기능을 사용해야 할 때 하나로 만들어 사용하도록 한 것이다.
------------------------------------------------------------
[인터페이스 선언 예제]
------------------------------------------------------------
자바 기본 패키지인 API의 계승구조를 보면 많은 인터페이스가 있지만, 그 중에서 lang패키지의 Runnable인터페
이스를 살펴보도록 하겠습니다.
Runnable인터페이스의 계승구조는 아래와 같습니다.
java -> lang -> interface -> Runnable
Runable인터페이스의 정의는 아래와 같습니다.
interface Runnable {
public abstract void run();
}
------------------------------------------------------------
위처럼 대개 Thread클래스의 run()메소드를 인터페이스의 추상 메소드로 정의해 놓았으며, 메소드의 몸체가 없음
을 알 수 있습니다.
프로그래머는 자바 프로그램 작성시 다중상속이 안되므로 위와 같이 선언된 인터페이스를 implements를 구해 구
현(첨가)해 줌으로서 다중상속을 구현할 수 있고 첨가된 인터페이스의 메소드를 프로그램에 정의해 줌으로서 클래
스를 통해 상속한 것처럼 인터페이스에 구현된 메소드를 사용할 수 있습니다.
[인터페이스 메소드 정의]
------------------------------------------------------------
[참고] extends키워드를 사용한 클래스의 상속은 자식 클래스에서 처리되지 않는 메소드는 부모 클래스의 메소드
가 호출되어 처리되지만, 인터페이스를 통한 다중 상속의 경우 메소드의 실행이 인터페이스로 넘어가지 않으므로
인터페이스를 구현한 클래스에서는 첨가한 인터페이스의 모든 메소드를 정의해 주어야 하는 것입니다.
------------------------------------------------------------
다음 인터페이스의 첨가에 대해 알려드리도록 하겠습니다.
자바개념(34) / 인터페이스 / 구현
--------------------------------------------------------------------------------
인터페이스는 클래스를 위한 템플릿이기 때문에, 사용 가능한 인터페이스가 되기 위해서는 자바 프로그램에서 인
터페이스를 구현하여 주어야 하는데 이런 기능을 하는 것이 "implements"예약어를 통해 이루어집니다
자 그럼 이미 정의된 인터페이스를 자바 프로그램의 코드에 구현하는 형식을 살펴보도록 합시다.
[인터페이스 구현 형식]
--------------------------------------------------------------
class 클래스이름 implements 인터페이스1, 인터페이스2,...{
}
or
class 클래스이름 extends 부모클래스이름 implements 인터페이스1,2 ...{
}
--------------------------------------------------------------
위와 같이 형식으로 프로그램에 인터페이스를 구현해 주면, 클래스는 인터페이스 안에 속해 있는 메소드를 모두
자신의 코드 상에 정의해 하고, 실행부분을 추가해 줌으로서 인터페이스의 다중상속의 개념을 활용할 수 있습니다.
이전의 글에서 살펴본 Runnable인터페이스를 아래와 같이 첨가할 수 있다. 잘 살펴보자. 만약 public void run(){}
을 제외해 구현된 인터페이스의 메소드를 프로그램에서 정의하지 않았을 경우 다음과 같은 에러가 발생할 것입니
다.
-------------------------------------------------------------
public class a extends Frame implements Runnable{
^
class a must be declared abstract. It does not define void run() from
interface java.lang.Runnable
a ainterface=new a();
^
class a is an abstract class. It can't bt instantisted
-------------------------------------------------------------
인터페이스의 메소드를 구현해 주지 않을 경우 위의 예처럼 인터페이스 메소드를 구현할 것과 인터페이스를 구현
할 클래스를 인스턴스화 할 수 없습니다. 그러니 아래처럼 implements예약어를 이용해 구현된 인터페이스의 메소
드를 모두 클래스에 재정의해 주어야 함을 명심하세요. 실제 프로그래머가 프로그램 작성시 자주 잊어 버리는 일
중 하나입니다.
--------------------------------------------------------------
import java.awt.Frame;
public class a extends Frame implements Runnable{
public static void main(String args[]){
a ainterface=new a();
}
public void run(){
}
}
-------------------------------------------------------------
위 클래스 a는 Frame클래스는 수퍼(부모)클래스로부터 상속된 기능으로서 Frame의 기능을 가짐과 동시에
Runnable인터페이스를 구현하고 있으므로 인터페이스에서 정의된 Thread클래스의 run()메소드의 기능 역시 상속
받게 됩니다. 자바 언어의 다중상속을 위처럼 인터페이스로 구현할 수 있는 것입니다
'차근차근 > JAVA JSP' 카테고리의 다른 글
| if문 equals / == (0) | 2014.07.26 |
|---|---|
| hashmap 의 value에 다른 배열 넣기/value에 값 여러개 주기 (0) | 2014.07.26 |
| request.getParameterValues,URLEncoder.encode (0) | 2014.07.26 |
| request.getParameterValues/삼항연산자 ? : (0) | 2014.07.26 |
| ${ } , c:forEach ,객체와 스트링의 차이 , 스트링과 스트링버퍼의 차이 (0) | 2014.07.26 |