1998년부터 운영된 오라클자바커뮤니티(www.oraclejavanew.kr)에서 설립
운영되고 있는 오엔제이 프로그래밍실무학원(www.onjprogramming.co.kr )은 개발자를 위한 SKILL UP, 실무개발교육 6년차 교육센터
입니다.
(2008년5월부터 오엔제이시스템즈에서 운영하던 "오라클자바교육센터"는 2013년5월 양도 하였으며
새로운 오엔제이 프로그래밍 실무교육센터에서 개발자 실무 교육을 이어갈 수 있도록 더욱 더 노력 하겠습니다.)
자바,
오라클의 기초부터 자바프레임워크(Struts, Spring), 오라클 튜닝, 모델링, 고급SQL, Xinternet(GAUCE,
Miplatform, XPlatform), 닷넷(C#, ASP.Net), 스마트폰앱개발교육(안드로이드, 아이폰)까지 실무전문 교육을 진행하고
있습니다.
(본원은 TOBESOFT에서 공인 교육기관 입니다.)
자바, 스프링,
오라클 교육 받으셨는데 이론으로 교육을 받으셨다고요? IT프로그래밍 교육은 실전예제, 실습을 통해 이론을 습득을 해야 합니다. 본원은 모든
강좌가 실습을 통해 이론을 취득하는 실무중심 교육 입니다.
한번 방문 하시어 실무전문 교육의 진수를 느껴 보시기
바랍니다.
감사합니다.
3D프린팅,아두이노알고리즘프로그래밍,로봇제작,스프링프레임워크,스프링시큐리티,스프링소셜,NODE.JS,AngulerJS,안드로이드 마시멜로,아이폰 Swift,닷넷, C#, Xamarin 실무개발바교육,구로디지털단지역2분,초역세권
2013년 8월 23일 금요일
2013년 8월 16일 금요일
오라클 Optimizer Mode Setting 방법
오라클 Optimizer Mode Setting 방법
대한민국오라클학원/오라클학원/오라클교육/오라클강의/구로 오라클/가산오라클/오라클강
--------------------------
1. Instance 수준의 셋팅 방법
--------------------------
- DB의 설정 파일(initSID.ora or spfileSID.ora)에 전체적으로 적용이 되도록 정의하는 방법이며 다음과 같이 기술하며 OPTIMIZER MODE는 REUL, CHOOSE, ALL_ROOWS, FIRST_ROWS와 같은 종류가 있습니다. CHOOSE인 경우 한테이블이라도 Analyzed되어 있는 경우엔 비용기반 접근 방식을 이용하는 것이며 RULE인 경우 규칙기반 접근 방식을 사용, ALL_ROWS인 경우 비용기반 옵티마이저의 한 방법이며 모든 ROW들을 처리한다고 할 때 그 비용을 최소화 하는 방법으로 실행계획을 수립하며, FIRST_ROWS인 경우엔 최초 ROW를 추출하는데 드는 비용을 최소화 하도록 실행 계획을 구성하는 것입니다.
- 예) OPTIMIZER_MODE=FIRST_ROWS
- 만약 initSID or spfileSID.ora에 아무 내용도 정의하지 않은 경우 기본적으로 CHOOSE 방식이 됩니다.
-------------------------
2. Session 수준의 셋팅 방법
-------------------------
- alter session이라는 명령을 이용하면 현재 접속된 세션 레벨에서 옵티마이저 모드를 정의할 수 있습니다.
- 예) alter session set optimizer_goal=rule 앞과 같이 정의하면 해당 세션이 끝나기 전까지는 규칙 기반(,RULE-BASED) 옵티마이저 모드를 이용하게 됩니다.
--------------------------
3. Statement 수준의 셋팅 방법
--------------------------
- 힌트(Hint) 구문을 이용한다면 매 SQL 문장마다 서로 다른 옵티마이저 모드를 적용할 수 있습니다.
- 예) SELECT /*+ FIRST_ROWS */
ENAME,
SAL,
JOB
FROM EMP
WHERE SAL > (SELECT MAX(SAL)
FROM EMP
WHERE DEPTNO = 10)
대한민국오라클학원/오라클학원/오라클교육/오라클강의/구로 오라클/가산오라클/오라클강
--------------------------
1. Instance 수준의 셋팅 방법
--------------------------
오라클자바커뮤니티에서 설립한 개발자중심! 오엔제이프로그래밍 실무교육센터
(신입사원채용무료교육, 오라클, SQL, 튜닝, 자바, 스프링, Ajax, jQuery, 안드로이드, 아이폰, 닷넷, C#, ASP.Net) www.onjprogramming.co.kr
- DB의 설정 파일(initSID.ora or spfileSID.ora)에 전체적으로 적용이 되도록 정의하는 방법이며 다음과 같이 기술하며 OPTIMIZER MODE는 REUL, CHOOSE, ALL_ROOWS, FIRST_ROWS와 같은 종류가 있습니다. CHOOSE인 경우 한테이블이라도 Analyzed되어 있는 경우엔 비용기반 접근 방식을 이용하는 것이며 RULE인 경우 규칙기반 접근 방식을 사용, ALL_ROWS인 경우 비용기반 옵티마이저의 한 방법이며 모든 ROW들을 처리한다고 할 때 그 비용을 최소화 하는 방법으로 실행계획을 수립하며, FIRST_ROWS인 경우엔 최초 ROW를 추출하는데 드는 비용을 최소화 하도록 실행 계획을 구성하는 것입니다.
- 예) OPTIMIZER_MODE=FIRST_ROWS
- 만약 initSID or spfileSID.ora에 아무 내용도 정의하지 않은 경우 기본적으로 CHOOSE 방식이 됩니다.
-------------------------
2. Session 수준의 셋팅 방법
-------------------------
- alter session이라는 명령을 이용하면 현재 접속된 세션 레벨에서 옵티마이저 모드를 정의할 수 있습니다.
- 예) alter session set optimizer_goal=rule 앞과 같이 정의하면 해당 세션이 끝나기 전까지는 규칙 기반(,RULE-BASED) 옵티마이저 모드를 이용하게 됩니다.
--------------------------
3. Statement 수준의 셋팅 방법
--------------------------
- 힌트(Hint) 구문을 이용한다면 매 SQL 문장마다 서로 다른 옵티마이저 모드를 적용할 수 있습니다.
- 예) SELECT /*+ FIRST_ROWS */
ENAME,
SAL,
JOB
FROM EMP
WHERE SAL > (SELECT MAX(SAL)
FROM EMP
WHERE DEPTNO = 10)
2013년 8월 13일 화요일
오라클실행계획 해석
실행계획 해석하는 방법입니다. ORACLE TUNING을 위한 가장 기본적인 입니다.
오라클자바커뮤니티에서 설립한 오엔제이프로그래밍 실무교육센터
실행계획은 해당 SQL을 수행하기 위한 절차이며 옵티마이저에 의해 만들어 집니다. 해석을 위해서는 Row Source Operartors Tree 또는 Row Source Level을 이용하여 해석하는데 아래 예를 들어보도록 하죠.
1. Row Source Operators Tree는 Serial Execution에 대한 Tree를 보여주는 것인데 실행계획은 Row Source로 구성되며 각각의 Row Source들을 Tree 형태로 구성하여 해석을 하는 것을 말합니다.
SQL> select ename, dname
2 from emp e, dept d
3 where e.deptno = d.deptno;
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE (Cost=5 Card=14 Bytes=252)
1 0 HASH JOIN (Cost=5 Card=14 Bytes=252)
2 1 TABLE ACCESS (FULL) OF 'DEPT' (Cost=2 Card=4 Bytes=44)
3 1 TABLE ACCESS (FULL) OF 'EMP' (Cost=2 Card=14 Bytes=98)
Row Source Parent Key(0,1,2,3)
Row Source Key(0,1,1)
각각의 행을 Row Source 또는 Access Operation 이라 한다.
위 실행계획을 도식화 하기 위해서는 Row Source Key와 Row Source Parent Key를 알고 있으면 되는데 Row Source Key 1번은 Parent가 0번이며, 2번/3번은 1번이다. 이를 도식화하여 해것을 하는 것이다. (해석은 밑에서 위로, 좌에서 우측으로 진행을 하면 된다)
2.Row Source Level을 통한 해석
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE (Cost=5 Card=14 Bytes=252)
1 0 HASH JOIN (Cost=5 Card=14 Bytes=252)
2 1 TABLE ACCESS (FULL) OF 'DEPT' (Cost=2 Card=4 Bytes=44)
3 1 TABLE ACCESS (FULL) OF 'EMP' (Cost=2 Card=14 Bytes=98)
Level 1
Level 2
Level 3
가장 안쪽의 Level 3부터 해석을 하며 같은 레벨의 경우 위쪽부터 해석을 하면 된다.
DEPT 테이블을 FULL Scan한 후 DEP 테이블을 FULL Scan하여 HASH Join 후 원하는 데이터를 추출하는 실행 계획이다.
다음의 예를 보도록 하자.
SQL> select ename, dname
2 from emp e, dept d
3* where trim(e.deptno) = trim(d.deptno);
ENAME DNAME
---------- --------------
CLARK ACCOUNTING
KING ACCOUNTING
MILLER ACCOUNTING
SMITH RESEARCH
……
14 개의 행이 선택되었습니다.
Execution Plan
---------------------------------------------------------
0 SELECT STATEMENT Optimizer=HINT: RULE
1 0 MERGE JOIN
2 1 SORT (JOIN)
3 2 TABLE ACCESS (FULL) OF 'DEPT'
4 1 SORT (JOIN)
5 4 TABLE ACCESS (FULL) OF 'EMP'
위 실행계획에 대한 해석은
Level 4 : DEPT 테이블을 FULL SCAN + EMP 테이블을 FULL SCAN
Level 3 : SORT(JOIN) + SORT(JOIN) DEPT 테이블을 SORT한것과 EMP 테이블을 SORT한 두개의 집합이 된다.
Level 2 : MERGE JOIN Level 3에서 만들어진 두개의 집합을 Merge
Level 1 : SELECT STATEMENT Merge Join을 수행하여 선택된 결과를 추출
오라클자바커뮤니티에서 설립한 오엔제이프로그래밍 실무교육센터
(신입사원채용무료교육, 오라클SQL, 튜닝, 힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷)
실행계획은 해당 SQL을 수행하기 위한 절차이며 옵티마이저에 의해 만들어 집니다. 해석을 위해서는 Row Source Operartors Tree 또는 Row Source Level을 이용하여 해석하는데 아래 예를 들어보도록 하죠.
1. Row Source Operators Tree는 Serial Execution에 대한 Tree를 보여주는 것인데 실행계획은 Row Source로 구성되며 각각의 Row Source들을 Tree 형태로 구성하여 해석을 하는 것을 말합니다.
SQL> select ename, dname
2 from emp e, dept d
3 where e.deptno = d.deptno;
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE (Cost=5 Card=14 Bytes=252)
1 0 HASH JOIN (Cost=5 Card=14 Bytes=252)
2 1 TABLE ACCESS (FULL) OF 'DEPT' (Cost=2 Card=4 Bytes=44)
3 1 TABLE ACCESS (FULL) OF 'EMP' (Cost=2 Card=14 Bytes=98)
Row Source Parent Key(0,1,2,3)
Row Source Key(0,1,1)
각각의 행을 Row Source 또는 Access Operation 이라 한다.
위 실행계획을 도식화 하기 위해서는 Row Source Key와 Row Source Parent Key를 알고 있으면 되는데 Row Source Key 1번은 Parent가 0번이며, 2번/3번은 1번이다. 이를 도식화하여 해것을 하는 것이다. (해석은 밑에서 위로, 좌에서 우측으로 진행을 하면 된다)
2.Row Source Level을 통한 해석
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE (Cost=5 Card=14 Bytes=252)
1 0 HASH JOIN (Cost=5 Card=14 Bytes=252)
2 1 TABLE ACCESS (FULL) OF 'DEPT' (Cost=2 Card=4 Bytes=44)
3 1 TABLE ACCESS (FULL) OF 'EMP' (Cost=2 Card=14 Bytes=98)
Level 1
Level 2
Level 3
가장 안쪽의 Level 3부터 해석을 하며 같은 레벨의 경우 위쪽부터 해석을 하면 된다.
DEPT 테이블을 FULL Scan한 후 DEP 테이블을 FULL Scan하여 HASH Join 후 원하는 데이터를 추출하는 실행 계획이다.
다음의 예를 보도록 하자.
SQL> select ename, dname
2 from emp e, dept d
3* where trim(e.deptno) = trim(d.deptno);
ENAME DNAME
---------- --------------
CLARK ACCOUNTING
KING ACCOUNTING
MILLER ACCOUNTING
SMITH RESEARCH
……
14 개의 행이 선택되었습니다.
Execution Plan
---------------------------------------------------------
0 SELECT STATEMENT Optimizer=HINT: RULE
1 0 MERGE JOIN
2 1 SORT (JOIN)
3 2 TABLE ACCESS (FULL) OF 'DEPT'
4 1 SORT (JOIN)
5 4 TABLE ACCESS (FULL) OF 'EMP'
위 실행계획에 대한 해석은
Level 4 : DEPT 테이블을 FULL SCAN + EMP 테이블을 FULL SCAN
Level 3 : SORT(JOIN) + SORT(JOIN) DEPT 테이블을 SORT한것과 EMP 테이블을 SORT한 두개의 집합이 된다.
Level 2 : MERGE JOIN Level 3에서 만들어진 두개의 집합을 Merge
Level 1 : SELECT STATEMENT Merge Join을 수행하여 선택된 결과를 추출
[오라클자바community강좌]JAva Sort 알고리즘(자바 셸정렬)
오라클자바커뮤니티에서 설립한 오엔제이프로그래밍 실무교육센터
(신입사원채용무료교육, 오라클SQL, 튜닝, 힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷)
www.onjprogramming.co.kr
셸정렬(Shell Sort) 이란 버블정렬의 경우 데이터가 제 위치에서 멀리 떨어져 있으면 여러 번 교환이 필요하게 된다.이것이 버블정렬의 취약점으로서 인접한 데이터만 비교하기 때문에 발생하게 된다.
이러한 문제를 해결하기 위해 멀리 있는 레코드들 끼리도 비교가 가능하게 효율을 높인 정렬 방법이 고안자인 셸(Donald L.Shell)의 이름을 딴 셸 정렬 이다.
원리는 주어진 입력 리스트를 적당한 매개변수의 값만큼 서로 떨어진 레코드들과 비교하여 교환하는 과정을 매개변수 값을 바꾸어 가면서 되풀이 하는 것이다.(매개변수의 값은 줄어들면서 1이되면 종료한다.)이때 떨어져 있는 레코드들은 하나의 부분리스트를 구성하여 보통 다른방법(삽입정렬)에 의해 개별적으로 정렬된다
O(log n) 수행시간이 O(n2)보다 우수함은 자명하다. 그러나 일반적으로 O(n2)은 알고리즘이 간단하고 프로그래밍이 용이 한 반면 O(log n) 의 알고리즘은 복잡하다. 따라서 n이 작은 경우 O(n2)의 알고리즘이 오히려 효과적이다. 셸 정렬은 이러한 수행시간의 효율성을 잘 반영한 정렬기법으로서 레코드 집단을 작은 부분으로 나눈 후 작은 부분집단을 O(n2) 인 삽입 정렬 등으로 빠르게 정렬한다.
셸정렬의 속도는 Bubble Sort, Selection Sort, Insertion Sort등에 비해 상당히 빠르다. 난수상태의 10000개를 정렬하는 경우 Bubble Sort에 비해 200배, Selection Sort에 비해 110배, Insertion Sort에 비해 80배 ?(N2)의 효율을 나타내는 알고리즘(Quick Sort, Heap Sort, Merge Sort)에 비해 다소 떨어지나 “코드의 간결함, 추가적인 메모리(스택)를 사용하지 않음” 등을 가만하면 별은 무의미 하다.
import java.util.Random;
class ShellSort {
//셸 정렬
int[] sort(int a[]) {
int inc=1;
//증분 inc에 대해 가능한 큰 br> for(int i=inc; i<a.length; i++) {
int temp = a[i];
int j = i;
//j가 증분치보다 크거나 같고 우측이 작으면 바꿈(삽입정렬)
while(j&nb경우란면 아래의 수식에 의해 계속 1이 리턴
inc = inc/3 + 1;
}
return a;
}
public static void main(String[] args){
int&emp = new int[10000];
long startTime, elapsedTime, counter;
ShellSort mySort = new ShellSort();
//----------------- 난수 발생시킴
Random r = new Random();
for(int i=0; i<10000; i++) {
nansu[i] = r.nextInt(10000);
}
//-----------------------------------
//------------------------------------------------------------------------------
//우선 난수를 정렬하고, 정렬된 상태(최선의상황)을 다시 정렬시킴
//------------------------------------------------------------------------------
counter=0;
sortedArray = mySort.sort(nansu);
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.sort(sortedArray);
} while (System.currentTimeMillis() - startTime < 1000);
elapsedTime = (System.currentTimeMillis()- startTime) / counter;
System.out.println("[최선의 상황 수행시간] " + elapsedTime + "ms");
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
//반쯤 정열후 ...
//-------------------------------------------------------------------------------
counter=0;
halfSortedArray = sortedArray;
for(int i=0; i<5000; i++) {
halfSortedArray[i] = r.nextInt()*10000;
}
startTime = System.currentTimeMilli.currentTimeMillis()- startTime) / counter;
System.out.println("[반쯤 정렬 수행시간] " + elapsedTime + "ms");
//------------------------------------------------------------------------------- <.length;i++) {
reverseArray[sortedArray.length-i-1] = sortedArray[i];
}
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.sort(reverseArray)置嬋챨?] " + elapsedTime + "ms");
//--------------------------------------------------------------------------------
}
}?
이러한 문제를 해결하기 위해 멀리 있는 레코드들 끼리도 비교가 가능하게 효율을 높인 정렬 방법이 고안자인 셸(Donald L.Shell)의 이름을 딴 셸 정렬 이다.
원리는 주어진 입력 리스트를 적당한 매개변수의 값만큼 서로 떨어진 레코드들과 비교하여 교환하는 과정을 매개변수 값을 바꾸어 가면서 되풀이 하는 것이다.(매개변수의 값은 줄어들면서 1이되면 종료한다.)이때 떨어져 있는 레코드들은 하나의 부분리스트를 구성하여 보통 다른방법(삽입정렬)에 의해 개별적으로 정렬된다
O(log n) 수행시간이 O(n2)보다 우수함은 자명하다. 그러나 일반적으로 O(n2)은 알고리즘이 간단하고 프로그래밍이 용이 한 반면 O(log n) 의 알고리즘은 복잡하다. 따라서 n이 작은 경우 O(n2)의 알고리즘이 오히려 효과적이다. 셸 정렬은 이러한 수행시간의 효율성을 잘 반영한 정렬기법으로서 레코드 집단을 작은 부분으로 나눈 후 작은 부분집단을 O(n2) 인 삽입 정렬 등으로 빠르게 정렬한다.
셸정렬의 속도는 Bubble Sort, Selection Sort, Insertion Sort등에 비해 상당히 빠르다. 난수상태의 10000개를 정렬하는 경우 Bubble Sort에 비해 200배, Selection Sort에 비해 110배, Insertion Sort에 비해 80배 ?(N2)의 효율을 나타내는 알고리즘(Quick Sort, Heap Sort, Merge Sort)에 비해 다소 떨어지나 “코드의 간결함, 추가적인 메모리(스택)를 사용하지 않음” 등을 가만하면 별은 무의미 하다.
import java.util.Random;
class ShellSort {
//셸 정렬
int[] sort(int a[]) {
int inc=1;
//증분 inc에 대해 가능한 큰 br> for(int i=inc; i<a.length; i++) {
int temp = a[i];
int j = i;
//j가 증분치보다 크거나 같고 우측이 작으면 바꿈(삽입정렬)
while(j&nb경우란면 아래의 수식에 의해 계속 1이 리턴
inc = inc/3 + 1;
}
return a;
}
public static void main(String[] args){
int&emp = new int[10000];
long startTime, elapsedTime, counter;
ShellSort mySort = new ShellSort();
//----------------- 난수 발생시킴
Random r = new Random();
for(int i=0; i<10000; i++) {
nansu[i] = r.nextInt(10000);
}
//-----------------------------------
//------------------------------------------------------------------------------
//우선 난수를 정렬하고, 정렬된 상태(최선의상황)을 다시 정렬시킴
//------------------------------------------------------------------------------
counter=0;
sortedArray = mySort.sort(nansu);
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.sort(sortedArray);
} while (System.currentTimeMillis() - startTime < 1000);
elapsedTime = (System.currentTimeMillis()- startTime) / counter;
System.out.println("[최선의 상황 수행시간] " + elapsedTime + "ms");
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
//반쯤 정열후 ...
//-------------------------------------------------------------------------------
counter=0;
halfSortedArray = sortedArray;
for(int i=0; i<5000; i++) {
halfSortedArray[i] = r.nextInt()*10000;
}
startTime = System.currentTimeMilli.currentTimeMillis()- startTime) / counter;
System.out.println("[반쯤 정렬 수행시간] " + elapsedTime + "ms");
//------------------------------------------------------------------------------- <.length;i++) {
reverseArray[sortedArray.length-i-1] = sortedArray[i];
}
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.sort(reverseArray)置嬋챨?] " + elapsedTime + "ms");
//--------------------------------------------------------------------------------
}
}?
JAVA Sort 알고리즘(자바 셸정렬)
오라클자바커뮤니티에서 설립한 오엔제이프로그래밍
실무교육센터
(신입사원채용무료교육, 오라클SQL, 튜닝, 힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷)
www.onjprogramming.co.kr
셸정렬(Shell Sort) 이란 버블정렬의 경우 데이터가 제 위치에서 멀리 떨어져 있으면 여러 번 교환이
필요하게 된다.이것이 버블정렬의 취약점으로서 인접한 데이터만 비교하기 때문에 발생하게 된다.
이러한 문제를 해결하기 위해 멀리 있는 레코드들 끼리도 비교가 가능하게 효율을 높인 정렬 방법이 고안자인 셸(Donald L.Shell)의 이름을 딴 셸 정렬 이다.
원리는 주어진 입력 리스트를 적당한 매개변수의 값만큼 서로 떨어진 레코드들과 비교하여 교환하는 과정을 매개변수 값을 바꾸어 가면서 되풀이 하는 것이다.(매개변수의 값은 줄어들면서 1이되면 종료한다.)이때 떨어져 있는 레코드들은 하나의 부분리스트를 구성하여 보통 다른방법(삽입정렬)에 의해 개별적으로 정렬된다
O(log n) 수행시간이 O(n2)보다 우수함은 자명하다. 그러나 일반적으로 O(n2)은 알고리즘이 간단하고 프로그래밍이 용이 한 반면 O(log n) 의 알고리즘은 복잡하다. 따라서 n이 작은 경우 O(n2)의 알고리즘이 오히려 효과적이다. 셸 정렬은 이러한 수행시간의 효율성을 잘 반영한 정렬기법으로서 레코드 집단을 작은 부분으로 나눈 후 작은 부분집단을 O(n2) 인 삽입 정렬 등으로 빠르게 정렬한다.
셸정렬의 속도는 Bubble Sort, Selection Sort, Insertion Sort등에 비해 상당히 빠르다. 난수상태의 10000개를 정렬하는 경우 Bubble Sort에 비해 200배, Selection Sort에 비해 110배, Insertion Sort에 비해 80배 ?(N2)의 효율을 나타내는 알고리즘(Quick Sort, Heap Sort, Merge Sort)에 비해 다소 떨어지나 “코드의 간결함, 추가적인 메모리(스택)를 사용하지 않음” 등을 가만하면 별은 무의미 하다.
import java.util.Random;
class ShellSort {
//셸 정렬
int[] sort(int a[]) {
int inc=1;
//증분 inc에 대해 가능한 큰 br> for(int i=inc; i<a.length; i++) {
int temp = a[i];
int j = i;
//j가 증분치보다 크거나 같고 우측이 작으면 바꿈(삽입정렬)
while(j&nb경우란면 아래의 수식에 의해 계속 1이 리턴
inc = inc/3 + 1;
}
return a;
}
public static void main(String[] args){
int&emp = new int[10000];
long startTime, elapsedTime, counter;
ShellSort mySort = new ShellSort();
//----------------- 난수 발생시킴
Random r = new Random();
for(int i=0; i<10000; i++) {
nansu[i] = r.nextInt(10000);
}
//-----------------------------------
//------------------------------------------------------------------------------
//우선 난수를 정렬하고, 정렬된 상태(최선의상황)을 다시 정렬시킴
//------------------------------------------------------------------------------
counter=0;
sortedArray = mySort.sort(nansu);
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.sort(sortedArray);
} while (System.currentTimeMillis() - startTime < 1000);
elapsedTime = (System.currentTimeMillis()- startTime) / counter;
System.out.println("[최선의 상황 수행시간] " + elapsedTime + "ms");
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
//반쯤 정열후 ...
//-------------------------------------------------------------------------------
counter=0;
halfSortedArray = sortedArray;
for(int i=0; i<5000; i++) {
halfSortedArray[i] = r.nextInt()*10000;
}
startTime = System.currentTimeMilli.currentTimeMillis()- startTime) / counter;
System.out.println("[반쯤 정렬 수행시간] " + elapsedTime + "ms");
//------------------------------------------------------------------------------- <.length;i++) {
reverseArray[sortedArray.length-i-1] = sortedArray[i];
}
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.sort(reverseArray)置嬋챨?] " + elapsedTime + "ms");
//--------------------------------------------------------------------------------
}
}?
이러한 문제를 해결하기 위해 멀리 있는 레코드들 끼리도 비교가 가능하게 효율을 높인 정렬 방법이 고안자인 셸(Donald L.Shell)의 이름을 딴 셸 정렬 이다.
원리는 주어진 입력 리스트를 적당한 매개변수의 값만큼 서로 떨어진 레코드들과 비교하여 교환하는 과정을 매개변수 값을 바꾸어 가면서 되풀이 하는 것이다.(매개변수의 값은 줄어들면서 1이되면 종료한다.)이때 떨어져 있는 레코드들은 하나의 부분리스트를 구성하여 보통 다른방법(삽입정렬)에 의해 개별적으로 정렬된다
O(log n) 수행시간이 O(n2)보다 우수함은 자명하다. 그러나 일반적으로 O(n2)은 알고리즘이 간단하고 프로그래밍이 용이 한 반면 O(log n) 의 알고리즘은 복잡하다. 따라서 n이 작은 경우 O(n2)의 알고리즘이 오히려 효과적이다. 셸 정렬은 이러한 수행시간의 효율성을 잘 반영한 정렬기법으로서 레코드 집단을 작은 부분으로 나눈 후 작은 부분집단을 O(n2) 인 삽입 정렬 등으로 빠르게 정렬한다.
셸정렬의 속도는 Bubble Sort, Selection Sort, Insertion Sort등에 비해 상당히 빠르다. 난수상태의 10000개를 정렬하는 경우 Bubble Sort에 비해 200배, Selection Sort에 비해 110배, Insertion Sort에 비해 80배 ?(N2)의 효율을 나타내는 알고리즘(Quick Sort, Heap Sort, Merge Sort)에 비해 다소 떨어지나 “코드의 간결함, 추가적인 메모리(스택)를 사용하지 않음” 등을 가만하면 별은 무의미 하다.
import java.util.Random;
class ShellSort {
//셸 정렬
int[] sort(int a[]) {
int inc=1;
//증분 inc에 대해 가능한 큰 br> for(int i=inc; i<a.length; i++) {
int temp = a[i];
int j = i;
//j가 증분치보다 크거나 같고 우측이 작으면 바꿈(삽입정렬)
while(j&nb경우란면 아래의 수식에 의해 계속 1이 리턴
inc = inc/3 + 1;
}
return a;
}
public static void main(String[] args){
int&emp = new int[10000];
long startTime, elapsedTime, counter;
ShellSort mySort = new ShellSort();
//----------------- 난수 발생시킴
Random r = new Random();
for(int i=0; i<10000; i++) {
nansu[i] = r.nextInt(10000);
}
//-----------------------------------
//------------------------------------------------------------------------------
//우선 난수를 정렬하고, 정렬된 상태(최선의상황)을 다시 정렬시킴
//------------------------------------------------------------------------------
counter=0;
sortedArray = mySort.sort(nansu);
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.sort(sortedArray);
} while (System.currentTimeMillis() - startTime < 1000);
elapsedTime = (System.currentTimeMillis()- startTime) / counter;
System.out.println("[최선의 상황 수행시간] " + elapsedTime + "ms");
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
//반쯤 정열후 ...
//-------------------------------------------------------------------------------
counter=0;
halfSortedArray = sortedArray;
for(int i=0; i<5000; i++) {
halfSortedArray[i] = r.nextInt()*10000;
}
startTime = System.currentTimeMilli.currentTimeMillis()- startTime) / counter;
System.out.println("[반쯤 정렬 수행시간] " + elapsedTime + "ms");
//------------------------------------------------------------------------------- <.length;i++) {
reverseArray[sortedArray.length-i-1] = sortedArray[i];
}
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.sort(reverseArray)置嬋챨?] " + elapsedTime + "ms");
//--------------------------------------------------------------------------------
}
}?
[오라클자바강좌]JAVA Sort 알고리즘(퀵정렬-재귀호출이용) 예제 입니다. JAVA강좌
java,java교육,java강좌,oraclejava,javaoracle,오라클자바,자바,자바교육,자바강좌,구로디지털자바,구로디지털오라클,오라클자바교육
퀵 정렬(Quick Sort) 이란 주어진 입력리스트를 특정한 키(Control Key, Pivot)로 분리하여 왼쪽에는 키 값보다 작은 값, 우측에는 키 값보다 큰 값을 갖는 서브 리스트로 분리한다. 그런 다음 각각의 서브리스트에서도 같은 방법을 반복적으로 수행하여 정렬하는 방법이다.
오라클자바커뮤니티에서 설립한 오엔제이프로그래밍 실무교육센터
다음의 예제를 보자...
import java.util.Random;
class QuickSort3{
//퀵 정렬(재귀방법)
int[] qsort(int a[]) {
//low와 high 값을 parameter로 던지자.
quicksort(0, a.length-1, a);
return a;
}
void quicksort(int low, int high, int[] a) {
if (low < high){
//서브리스트로 분할
int pivot = split(low, high, a);
//생성된 pivot값을 기준으로 재귀호출
quicksort(low, pivot-1, a);
quicksort(pivot+1, high, a);
}
}
//pivot 값이 제위치에 정렬되도록 위치를 계산하고
//입력된 레코드를 재배열
private int split(int low, int high, int[] a) {
int avg = (low + high)/2; //pivot위치를 찾는다.
exchange(low, avg, a);
int last = low;
for(int i=low+1; i<=high; i++) {
//i값이 pivot값(low위치 값) 보다
//작으면 바꾼다.
//last를 1증가후 i위치값과 low위치값을 바꿈
if (a[i] < a[low]){
last++;
exchange(last, i, a);
}
}
exchange(low, last, a);
return last;
}
private void exchange(int low, int high, int[] a) {
int temp = a[low];
a[low] = a[high];
a[high] = temp;
}
public static void main(String[] args){
int nansu[] = new int[10000];
int[] sortedArray = new int[10000];
int[] halfSortedArray = new int[10000];
int[] reverseArray = new int[10000];
int[] temp = new int[10000];
long startTime, elapsedTime, counter;
QuickSort3 mySort = new QuickSort3();
//----------------- 난수 발생시킴
Random r = new Random();
for(int i=0; i<10000; i++) {
nansu[i] = r.nextInt(100000);
}
//-----------------------------------
//------------------------------------------------------------------------------
//난수를 정렬
//------------------------------------------------------------------------------
counter=0;
startTime = System.currentTimeMillis();
do {
counter++;
sortedArray = mySort.qsort(nansu);
} while (System.currentTimeMillis() - startTime < 1000);
elapsedTime = (System.currentTimeMillis()- startTime) / counter;
System.out.println("[난수일때의 수행시간] " + elapsedTime + "ms");
//------------------------------------------------------------------------------
// 정렬된 상태(최선의상황)을 다시 정렬시킴
//------------------------------------------------------------------------------
counter=0;
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.qsort(sortedArray);
} while (System.currentTimeMillis() - startTime < 1000);
elapsedTime = (System.currentTimeMillis()- startTime) / counter;
System.out.println("[최선의 상황 수행시간] " + elapsedTime + "ms");
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
//반쯤 정열후 ...
//-------------------------------------------------------------------------------
counter=0;
halfSortedArray = sortedArray;
for(int i=0; i<5000; i++) {
halfSortedArray[i] = r.nextInt()*10000;
}
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.qsort(halfSortedArray);
} while (System.currentTimeMillis() - startTime < 1000);
elapsedTime = (System.currentTimeMillis()- startTime) / counter;
System.out.println("[반쯤 정렬 수행시간] " + elapsedTime + "ms");
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
//역순상태
//-------------------------------------------------------------------------------
counter=0;
for(int i=0;i<sortedArray.length;i++) {
reverseArray[sortedArray.length-i-1] = sortedArray[i];
}
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.qsort(reverseArray);
} while (System.currentTimeMillis() - startTime < 1000);
elapsedTime = (System.currentTimeMillis()- startTime) / counter;
System.out.println("[역순 상태 수행시간] " + elapsedTime + "ms");
//--------------------------------------------------------------------------------
}
}
퀵 정렬(Quick Sort) 이란 주어진 입력리스트를 특정한 키(Control Key, Pivot)로 분리하여 왼쪽에는 키 값보다 작은 값, 우측에는 키 값보다 큰 값을 갖는 서브 리스트로 분리한다. 그런 다음 각각의 서브리스트에서도 같은 방법을 반복적으로 수행하여 정렬하는 방법이다.
오라클자바커뮤니티에서 설립한 오엔제이프로그래밍 실무교육센터
(신입사원채용무료교육, 오라클SQL, 튜닝, 힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷)
다음의 예제를 보자...
import java.util.Random;
class QuickSort3{
//퀵 정렬(재귀방법)
int[] qsort(int a[]) {
//low와 high 값을 parameter로 던지자.
quicksort(0, a.length-1, a);
return a;
}
void quicksort(int low, int high, int[] a) {
if (low < high){
//서브리스트로 분할
int pivot = split(low, high, a);
//생성된 pivot값을 기준으로 재귀호출
quicksort(low, pivot-1, a);
quicksort(pivot+1, high, a);
}
}
//pivot 값이 제위치에 정렬되도록 위치를 계산하고
//입력된 레코드를 재배열
private int split(int low, int high, int[] a) {
int avg = (low + high)/2; //pivot위치를 찾는다.
exchange(low, avg, a);
int last = low;
for(int i=low+1; i<=high; i++) {
//i값이 pivot값(low위치 값) 보다
//작으면 바꾼다.
//last를 1증가후 i위치값과 low위치값을 바꿈
if (a[i] < a[low]){
last++;
exchange(last, i, a);
}
}
exchange(low, last, a);
return last;
}
private void exchange(int low, int high, int[] a) {
int temp = a[low];
a[low] = a[high];
a[high] = temp;
}
public static void main(String[] args){
int nansu[] = new int[10000];
int[] sortedArray = new int[10000];
int[] halfSortedArray = new int[10000];
int[] reverseArray = new int[10000];
int[] temp = new int[10000];
long startTime, elapsedTime, counter;
QuickSort3 mySort = new QuickSort3();
//----------------- 난수 발생시킴
Random r = new Random();
for(int i=0; i<10000; i++) {
nansu[i] = r.nextInt(100000);
}
//-----------------------------------
//------------------------------------------------------------------------------
//난수를 정렬
//------------------------------------------------------------------------------
counter=0;
startTime = System.currentTimeMillis();
do {
counter++;
sortedArray = mySort.qsort(nansu);
} while (System.currentTimeMillis() - startTime < 1000);
elapsedTime = (System.currentTimeMillis()- startTime) / counter;
System.out.println("[난수일때의 수행시간] " + elapsedTime + "ms");
//------------------------------------------------------------------------------
// 정렬된 상태(최선의상황)을 다시 정렬시킴
//------------------------------------------------------------------------------
counter=0;
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.qsort(sortedArray);
} while (System.currentTimeMillis() - startTime < 1000);
elapsedTime = (System.currentTimeMillis()- startTime) / counter;
System.out.println("[최선의 상황 수행시간] " + elapsedTime + "ms");
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
//반쯤 정열후 ...
//-------------------------------------------------------------------------------
counter=0;
halfSortedArray = sortedArray;
for(int i=0; i<5000; i++) {
halfSortedArray[i] = r.nextInt()*10000;
}
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.qsort(halfSortedArray);
} while (System.currentTimeMillis() - startTime < 1000);
elapsedTime = (System.currentTimeMillis()- startTime) / counter;
System.out.println("[반쯤 정렬 수행시간] " + elapsedTime + "ms");
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
//역순상태
//-------------------------------------------------------------------------------
counter=0;
for(int i=0;i<sortedArray.length;i++) {
reverseArray[sortedArray.length-i-1] = sortedArray[i];
}
startTime = System.currentTimeMillis();
do {
counter++;
temp = mySort.qsort(reverseArray);
} while (System.currentTimeMillis() - startTime < 1000);
elapsedTime = (System.currentTimeMillis()- startTime) / counter;
System.out.println("[역순 상태 수행시간] " + elapsedTime + "ms");
//--------------------------------------------------------------------------------
}
}
[ORACLEJAVA커뮤니티]자바 팩토리얼 예제 참고 하세요~
[ORACLEJAVA커뮤니티]자바 팩토리얼 예제 참고 하세요~
오라클자바커뮤니티에서 설립한 오엔제이프로그래밍 실무교육센터
오라클자바커뮤니티에서 설립한 오엔제이프로그래밍 실무교육센터
(신입사원채용무료교육, 오라클SQL, 튜닝, 힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷)
/* 인수로 숫자를 입력받아 그 수까지의 팩토리얼을 계산하는 프로그램 */
public class FactorialFor {
public static void main(String[] args) {
long fact=1;
if (args.length<1) {
System.out.println("Usage : java Factirial Number");
System.exit(1);
}
for(int i=Integer.parseInt(args[0]);i>=1;i--) {
for(int j=1;j<=i;j++) {
fact *= j;
}
System.out.println(i+"! = " + fact);
fact = 1;
}
}
}
/* 인수로 숫자를 입력받아 그 수까지의 팩토리얼을 계산하는 프로그램 */
public class FactorialWhile {
public static void main(String[] args) {
long fact=1;
if (args.length<1) {
System.out.println("Usage : java Factirial Number");
System.exit(1);
}
int i = Integer.parseInt(args[0]); int j=1;
while(i>=1) {
while(j<=i) {
fact *= j; j++;
}
System.out.println(i+"! = " + fact);
fact = 1; i--; j=1;
}
}
}
public class FactorialDoWhile {
public static void main(String[] args) {
long fact=1;
if (args.length<1) {
System.out.println("Usage : java Factirial Number");
System.exit(1);
}
int i = Integer.parseInt(args[0]); int j=1;
do {
do {
fact *= j; j++;
} while(j<=i);
System.out.println(i+"! = " + fact);
fact = 1; i--; j=1;
} while(i>=1);
}
}
public class FactorialFor {
public static void main(String[] args) {
long fact=1;
if (args.length<1) {
System.out.println("Usage : java Factirial Number");
System.exit(1);
}
for(int i=Integer.parseInt(args[0]);i>=1;i--) {
for(int j=1;j<=i;j++) {
fact *= j;
}
System.out.println(i+"! = " + fact);
fact = 1;
}
}
}
/* 인수로 숫자를 입력받아 그 수까지의 팩토리얼을 계산하는 프로그램 */
public class FactorialWhile {
public static void main(String[] args) {
long fact=1;
if (args.length<1) {
System.out.println("Usage : java Factirial Number");
System.exit(1);
}
int i = Integer.parseInt(args[0]); int j=1;
while(i>=1) {
while(j<=i) {
fact *= j; j++;
}
System.out.println(i+"! = " + fact);
fact = 1; i--; j=1;
}
}
}
public class FactorialDoWhile {
public static void main(String[] args) {
long fact=1;
if (args.length<1) {
System.out.println("Usage : java Factirial Number");
System.exit(1);
}
int i = Integer.parseInt(args[0]); int j=1;
do {
do {
fact *= j; j++;
} while(j<=i);
System.out.println(i+"! = " + fact);
fact = 1; i--; j=1;
} while(i>=1);
}
}
2013년 8월 8일 목요일
[오라클자바커뮤니티,자바교육]자바의 자료형
JAVA자료형에 대해 계속 보도록 하겠습니다.
오라클자바커뮤니티에서 설립한 오엔제이프로그래밍
실무교육센터
(오라클SQL, 튜닝, 힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷 실무전문 강의)
1. 정수 자료형 (byte,short,int,long)
자바에서 제공하는 정수 자료형은 byte, short, int, long 4가지가 있습니다.(1,2,4,8 바이트 순)
C언어의 unsigned는 지원하지 않습니다.
short, byte에 연산을 하면 무조건 int형이 됩니다. 아래의 예를 보죠...
short a=0, b=0;
short c = a + b;
만약 위의 코드 부분이 컴파일 되다면 다음과 같은 오류가 날것 입니다.
---------- javac ----------
test.java:10: possible loss of precision
found : int
required: short
short c = a + b;
^
1 error
int형이 아닌 long형으로 데이터를 다루기 위해선 숫자 끝에 소문자 l이나 대문자 L을 표시한다.
Int : 12 (10진수), 012 (8진수), 0x12 (16진수)
Long : 12L, 12l
2. 부동소수 자료형 (float ,double)
자바에서 제공하는 부동소수 자료형은 float와 double이 있습니다.
부동소수 자료형 뒤에 아무것도 붙이지 않거나 ‘d’ 또는 ‘D’ 가 붙으면 기본적으로 double 형이 되며 ‘f’, ‘F’를 붙이면 float 자료형이 됩니다.
유효 10진 자리수
float : 6자리, double : 15자리
2진수로 표현하므로 표현 오차 발생하며 보다 정확한 표현을 하려면 BigDecimal 이용하세요~
리터럴
float --> 1e1f, 2.F, .3f, 6.02E+23f, 1.4039846e-45f ~ 3.40282347e+38f
double --> 1e1, 2.D, .3, 6.02E+23d, 4.94065645841246544e-324 ~ 1.79769313486231570e+308
[예제]
// FloatPointTest.java
class FloatingPointTest
{
public static void main( String[] args )
{
System.out.println( 1.2345678901234567890123456789 ); // 1.2345678901234567
System.out.println( 2e3 ); // 2000.0
System.out.println( 0.1 + 1.6 ); // 1.7000000000000002
System.out.println( 3.0 / 0.0 ); // Infinity
System.out.println( 0.0 / 0.0 ); // NaN
}
}
3. 진리 자료형 (boolean)
boolean Literal : true, false
boolean 형은 다른 데이터형과 연산이 불가하며 boolean형은 boolean 형과 연산이 가능 합니다.
[예제]
public class BooleanTest {
public static void main(String[] args) {
boolean b1 = true; boolean b2 = !b1;
System.out.println("b1 : " + b1);
System.out.println("!b1 : " + b2);
System.out.println(b1 & b2);
System.out.println(b1 | b2);
System.out.println(b1 == b2);
System.out.println(" 6 < 7 : " + (6 < 7));
}
}
[결과]
b1 : true
!b1 : false
false
true
false
6 < 7 : true
4. 문자 자료형 (char)
자바는 유니코드를 지원하는데 JDK1.4부터는 Unicode 2.0까지 지원합니다.
한 문자를 표현할 때는 '와 ' 사이에 단 한 글자만이 올 수 있습니다.
자바에서 문자를 표현하는 방법은 두가지가 있는데 첫번째 방법은 있는 그대로 쓰는 것이며 두번째 방법은 유니코드로 표현하는 방법이다. 예)char c = ‘A’, char c = ‘\u0041’
[예]
class CharTest {
public static void main(String[] args) {
char c1 = 'A'; char c2 = '\u0041';
char c3 = '가'; char c4 = '\uac00';
System.out.println("c1:"+c1+",c2:"+c2);
System.out.println(c1 == c2);
System.out.println("c3:"+c3+",c4:"+c4);
System.out.println(c3 == c4);
}
}
[결과]
c1:A,c2:A
true
c3:가,c4:가
true
[오라클자바커뮤니티]java awt Window,Frame,Font,Color
-------------------------
java.awt.Window
-------------------------
경계바, 타이틀바, 메뉴바가 없는 컴포넌트, 거의 직접 사용되지 않습니다.
그다지 유용하지 않으며 확장하여 사용하거나, ToolTip, PopUp메뉴와 같은 특수한 용도로 사용 합니다.
Window및 그 하위컴포넌트는 다른 컴포넌트에 포함되지않는 최상위 Component
Window및 Dialog 컴포넌트는 부모 컴포넌트로 Frame 컴포넌트를 지정해야만 그 객체를 생성할 수 있습니다.
Window객체를 사용해서 팝업 메뉴를 구현할 수 있으며 창의 기본 배치 관리자는 BorderLayout
WindowOpened나 WindowClosed와 같은 창 이벤트를 생성할 수 있습니다.
생성자 : Window(Frame owner), Window(Window owner), Window(Window owner, GraphicConfiguration gc)
메소드
addNotify() : Window의 피어(peer)를 작성.
addWindowListener(WindowListener) : 지정된 Window 수신기(listener)를 추가하여 Window으로부터 Window 이벤트를 수신.
dispose() :Window에 사용한 자원을 해제 할 때 사용
getFocusOwner() : Window가 활성화된 경우에만 Focus가 있는 창의 하위 컴포넌트를 Return
getOwner() : Window의 Owner를 Return
getOwnedWindows() : 현재 Window를 소유하고 있는 Window 배열을 Return
isShowing() : Windwo가 화면에 나타나 있는지 여부를 점검 합니다.
pack() : Window의 하위 컴포넌트를 환경설정된 크기로 배치 합니다. (최적크기)
processEvent(AWTEvent) : window에 대한 이벤트를 처리 합니다.
processWindowEvent(WindowEvent) : Window에서 발생하는 Window 이벤트를 등록된 WindowListener 객체로 보내 처리 합니다.
removeWindowListener(WindowListener) : Window Event Listener를 제거
show() : Window를 표시하고 앞으로 가져 옵니다.
toBack() : Window를 뒤로 보냅니다.
toFront() : Window를 앞으로 가져 옵니다.
------------------------
java.awt.Frame
--------------------
메소드
Frame() : 초기에는 보이지 않는 Frame의 새로운 인스턴스를 구성
Frame(String) : 지정된 제목으로 초기에는 보이지 않는 새로운 Frame 객체를 구성
getTitle() : 프레임의 제목을 가져옴
setTitle(String) : 프레임의 제목을 Set
isResizable() : 프레임 크기를 재조정할 수 있는지를 표시
getIconImage() : 프레임의 아이콘 이미지를 가져 옵니다.
setIconImage(Image) : 프레임이 아이콘으로 될 때 이미지가 표시되도록 설정
getMenuBar() : 프레임의 메뉴 막대를 가져 옵니다.
setMenuBar(MenuBar) : 지정된 메뉴 막대로 프레임의 Menu component를 설정 합니다.
remove(MenuComponent) : 프레임에서 지정된 Menu Component를 제거
-----------------------
java.awt.Color
-----------------------
java.awt.Object --> java.awt.Color
Paint Interface 구현한 글래스, RGB형식을 사용하여 색을 캡슐화 --> (0,0,0) 검정, (255,255,255) 흰색
색의비교 equals(), Color객체의 getRGB()를 이용
생성자
Color(float, float, float) : 지정된 빨강, 초록, 파랑 값을 사용하여 색상을 만들며, 각 값의 범위는 0.0-1.0
Color(float, float, float, float) : 지정된 빨강, 초록, 파랑 값을 사용하여 색상을 만들며, 불투명도 추가(0.0~1.0)
Color(int) : 지정된 RGB 값으로 색을 만든다. 빨강 컴포넌트는 16-23 비트 인수, 초록 컴포넌트는 8-15 비트 인수, 파랑 컴포넌트는 0-7 비트 인수.
Color(int, int) : ,RGB색상, 불투명도를 정수(0~255)로 나타냄
Color(int, int, int) : 지정된 빨강, 초록, 파랑 컴포넌트로 색을 만듬. (0~255)
Color(int, int, int, int) : 지정된 빨강, 초록, 파랑 컴포넌트로 색을 만듬, 마지막 인자는 불투명도를 나타내는 값(0~255)
Color(ColorSpace, float[], float) : 지정된 ColorSpace, color components float배열,불투명도를 이용해 색을 만듬.
메소드
brighter() : 색을 더 밝게
darker() : 색을 더 어둡게
equals(Object) : 다른 객체가 이 색과 같은지를 결정. 색의 비교시 사용
getBlue() : 색의 파랑 컴포넌트를 가져옴. (0~255)
getColor(String) : 시스템 특성에서 색을 찾는다. String은 시스템 특성
getColor(String, Color) : 시스템 특성에서 색을 찻는다. 지정된 특성이 없거나 정수로 분석될 수 없으면, 두 번째 인수가 지정한 색상이 대신 리턴 됩니다.
getColor(String, int) : 시스템 특성에서 색을 찾습니다. 지정된 특성이 없거나 정수로 분석될 수 없으면, 정수값(int)이 대신 사용되고 색으로 변환
getGreen() : 색의 초록 컴포넌트를 가져온다. (0~255)
getRed() : 색의 빨강 컴포넌트를 가져온다. (0~255)
getRGB() : 기본 RGB ColorModel에 있는 색을 표시하는 RGB 값을 가져옵니다. 리턴되는 정수의 24-31 비트는 0xff를, 16-23 비트는 빨강 값을, 8-15 비트는 초록 값을, 0-7 비트는 파랑 값을 나타 냅니다.
--------------------------------
java.awt.Font - 사용방법
----------------------------
버튼을 생성한 후에 버튼의 라벨을 TimesRoman 형 폰트에 진한 글씨로 크기를 20으로 하고자 할 경우 다음과 같이 설정할 수 있습니다.
Button btn = new Button("확인"); Font font = new Font("TimesRoman", Font.BOLD, 20); btn.setFont(font);
그래픽 컨텍스트에 그려지는?글자에 폰트를 지정하는 방법은 다음과 같습니다.
public void paint(Graphics g) {
Font f = new Font("TimesRoman", Font.BOLD, 20);
g.setFont(f);
g.drawString("Hello, World!", 10, 10);
}
자바 폰트 이름 X 윈도우 폰트 이름 윈도우즈 폰트 이름
Helvetica adobe-hevetica Arial
TimesRoman adobe-times Times New Roman
Courier adobe-courier Courier New
Dialog b&h-lucida MS Sans Serif
DialogInput b&h-lucidatypewriter MS Sans Serif
ZapfDingbats itc-zapfdingbats WingDings
default misc-fixed Arial
[예제] // 폰트 패밀리, 논리폰트명 출력
import java.awt.*;
class FontSample {
static Font font1 = new Font("TimesRoman", Font.ITALIC, 45);
static Font font2 = new Font("Helvetica", Font.BOLD, 12);
static Font font3 = new Font("Verdana", Font.PLAIN, 16);
public static void main(String args[]) {
System.out.println("family name of font1 : " + font1.getFamily());
System.out.println("family name of font2 : " + font2.getFamily());
System.out.println("family name of font3 : " + font3.getFamily());
System.out.println("name of font1 : " + font1.getName());
System.out.println("name of font2 : " + font2.getName());
System.out.println("name of font3 : " + font3.getName());
System.out.println("style of font1 : " + font1.getStyle());
System.out.println("style of font2 : " + font2.getStyle());
System.out.println("style of font3 : " + font3.getStyle());
System.out.println("size of font1 : " + font1.getSize());
System.out.println("size of font2 : " + font2.getSize());
System.out.println("size of font3 : " + font3.getSize());
} }
[예제] // 논리 Font명 및 시스템속성
import java.awt.*;
import java.util.*;
public class SysInfo {
public static void main(String[] args) {
Toolkit thekit = Toolkit.getDefaultToolkit();
System.out.println("\n Screen Resolution : " + thekit.getScreenResolution() + "dots per inch");
Dimension screenDim = thekit.getScreenSize();
System.out.println("Screen Size : " + screenDim.width + " by "+screenDim.height + " pixels");
GraphicsEnvironment e = GraphicsEnvironment.getLocalGraphicsEnvironment();
String[] fontnames = e.getAvailableFontFamilyNames();
System.out.println("\n----- fonts available on this flatform ----");
for(int i=0; i<fontnames.length; i++) { System.out.println(fontnames[i]); }
//System Properties
System.out.println("---- System Properties...... ----");
Properties p = System.getProperties();
p.list(System.out);
}
}
[예제] // CharaterIterator/StringIterator
import java.text.*;
class CharacterIteratorSample
{ public static void main(String[] args) {
//begin index:1, end index=4-1, current:1
CharacterIterator iter= new StringCharacterIterator("abcde", 1, 4, 1);
System.out.println("CharacterIterator iter --> "+iter);
iterateBackward( iter );
}
public static void iterateBackward(CharacterIterator iter) {
for (char ch = iter.last(); ch != CharacterIterator.DONE; ch = iter.previous())
System.out.print(ch);
}
}
java.awt.Window
-------------------------
오라클자바커뮤니티에서 설립한 오엔제이프로그래밍
실무교육센터
(오라클SQL, 튜닝, 힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷 실무전문 강의)
경계바, 타이틀바, 메뉴바가 없는 컴포넌트, 거의 직접 사용되지 않습니다.
그다지 유용하지 않으며 확장하여 사용하거나, ToolTip, PopUp메뉴와 같은 특수한 용도로 사용 합니다.
Window및 그 하위컴포넌트는 다른 컴포넌트에 포함되지않는 최상위 Component
Window및 Dialog 컴포넌트는 부모 컴포넌트로 Frame 컴포넌트를 지정해야만 그 객체를 생성할 수 있습니다.
Window객체를 사용해서 팝업 메뉴를 구현할 수 있으며 창의 기본 배치 관리자는 BorderLayout
WindowOpened나 WindowClosed와 같은 창 이벤트를 생성할 수 있습니다.
생성자 : Window(Frame owner), Window(Window owner), Window(Window owner, GraphicConfiguration gc)
메소드
addNotify() : Window의 피어(peer)를 작성.
addWindowListener(WindowListener) : 지정된 Window 수신기(listener)를 추가하여 Window으로부터 Window 이벤트를 수신.
dispose() :Window에 사용한 자원을 해제 할 때 사용
getFocusOwner() : Window가 활성화된 경우에만 Focus가 있는 창의 하위 컴포넌트를 Return
getOwner() : Window의 Owner를 Return
getOwnedWindows() : 현재 Window를 소유하고 있는 Window 배열을 Return
isShowing() : Windwo가 화면에 나타나 있는지 여부를 점검 합니다.
pack() : Window의 하위 컴포넌트를 환경설정된 크기로 배치 합니다. (최적크기)
processEvent(AWTEvent) : window에 대한 이벤트를 처리 합니다.
processWindowEvent(WindowEvent) : Window에서 발생하는 Window 이벤트를 등록된 WindowListener 객체로 보내 처리 합니다.
removeWindowListener(WindowListener) : Window Event Listener를 제거
show() : Window를 표시하고 앞으로 가져 옵니다.
toBack() : Window를 뒤로 보냅니다.
toFront() : Window를 앞으로 가져 옵니다.
------------------------
java.awt.Frame
--------------------
메소드
Frame() : 초기에는 보이지 않는 Frame의 새로운 인스턴스를 구성
Frame(String) : 지정된 제목으로 초기에는 보이지 않는 새로운 Frame 객체를 구성
getTitle() : 프레임의 제목을 가져옴
setTitle(String) : 프레임의 제목을 Set
isResizable() : 프레임 크기를 재조정할 수 있는지를 표시
getIconImage() : 프레임의 아이콘 이미지를 가져 옵니다.
setIconImage(Image) : 프레임이 아이콘으로 될 때 이미지가 표시되도록 설정
getMenuBar() : 프레임의 메뉴 막대를 가져 옵니다.
setMenuBar(MenuBar) : 지정된 메뉴 막대로 프레임의 Menu component를 설정 합니다.
remove(MenuComponent) : 프레임에서 지정된 Menu Component를 제거
-----------------------
java.awt.Color
-----------------------
java.awt.Object --> java.awt.Color
Paint Interface 구현한 글래스, RGB형식을 사용하여 색을 캡슐화 --> (0,0,0) 검정, (255,255,255) 흰색
색의비교 equals(), Color객체의 getRGB()를 이용
생성자
Color(float, float, float) : 지정된 빨강, 초록, 파랑 값을 사용하여 색상을 만들며, 각 값의 범위는 0.0-1.0
Color(float, float, float, float) : 지정된 빨강, 초록, 파랑 값을 사용하여 색상을 만들며, 불투명도 추가(0.0~1.0)
Color(int) : 지정된 RGB 값으로 색을 만든다. 빨강 컴포넌트는 16-23 비트 인수, 초록 컴포넌트는 8-15 비트 인수, 파랑 컴포넌트는 0-7 비트 인수.
Color(int, int) : ,RGB색상, 불투명도를 정수(0~255)로 나타냄
Color(int, int, int) : 지정된 빨강, 초록, 파랑 컴포넌트로 색을 만듬. (0~255)
Color(int, int, int, int) : 지정된 빨강, 초록, 파랑 컴포넌트로 색을 만듬, 마지막 인자는 불투명도를 나타내는 값(0~255)
Color(ColorSpace, float[], float) : 지정된 ColorSpace, color components float배열,불투명도를 이용해 색을 만듬.
메소드
brighter() : 색을 더 밝게
darker() : 색을 더 어둡게
equals(Object) : 다른 객체가 이 색과 같은지를 결정. 색의 비교시 사용
getBlue() : 색의 파랑 컴포넌트를 가져옴. (0~255)
getColor(String) : 시스템 특성에서 색을 찾는다. String은 시스템 특성
getColor(String, Color) : 시스템 특성에서 색을 찻는다. 지정된 특성이 없거나 정수로 분석될 수 없으면, 두 번째 인수가 지정한 색상이 대신 리턴 됩니다.
getColor(String, int) : 시스템 특성에서 색을 찾습니다. 지정된 특성이 없거나 정수로 분석될 수 없으면, 정수값(int)이 대신 사용되고 색으로 변환
getGreen() : 색의 초록 컴포넌트를 가져온다. (0~255)
getRed() : 색의 빨강 컴포넌트를 가져온다. (0~255)
getRGB() : 기본 RGB ColorModel에 있는 색을 표시하는 RGB 값을 가져옵니다. 리턴되는 정수의 24-31 비트는 0xff를, 16-23 비트는 빨강 값을, 8-15 비트는 초록 값을, 0-7 비트는 파랑 값을 나타 냅니다.
--------------------------------
java.awt.Font - 사용방법
----------------------------
버튼을 생성한 후에 버튼의 라벨을 TimesRoman 형 폰트에 진한 글씨로 크기를 20으로 하고자 할 경우 다음과 같이 설정할 수 있습니다.
Button btn = new Button("확인"); Font font = new Font("TimesRoman", Font.BOLD, 20); btn.setFont(font);
그래픽 컨텍스트에 그려지는?글자에 폰트를 지정하는 방법은 다음과 같습니다.
public void paint(Graphics g) {
Font f = new Font("TimesRoman", Font.BOLD, 20);
g.setFont(f);
g.drawString("Hello, World!", 10, 10);
}
자바 폰트 이름 X 윈도우 폰트 이름 윈도우즈 폰트 이름
Helvetica adobe-hevetica Arial
TimesRoman adobe-times Times New Roman
Courier adobe-courier Courier New
Dialog b&h-lucida MS Sans Serif
DialogInput b&h-lucidatypewriter MS Sans Serif
ZapfDingbats itc-zapfdingbats WingDings
default misc-fixed Arial
[예제] // 폰트 패밀리, 논리폰트명 출력
import java.awt.*;
class FontSample {
static Font font1 = new Font("TimesRoman", Font.ITALIC, 45);
static Font font2 = new Font("Helvetica", Font.BOLD, 12);
static Font font3 = new Font("Verdana", Font.PLAIN, 16);
public static void main(String args[]) {
System.out.println("family name of font1 : " + font1.getFamily());
System.out.println("family name of font2 : " + font2.getFamily());
System.out.println("family name of font3 : " + font3.getFamily());
System.out.println("name of font1 : " + font1.getName());
System.out.println("name of font2 : " + font2.getName());
System.out.println("name of font3 : " + font3.getName());
System.out.println("style of font1 : " + font1.getStyle());
System.out.println("style of font2 : " + font2.getStyle());
System.out.println("style of font3 : " + font3.getStyle());
System.out.println("size of font1 : " + font1.getSize());
System.out.println("size of font2 : " + font2.getSize());
System.out.println("size of font3 : " + font3.getSize());
} }
[예제] // 논리 Font명 및 시스템속성
import java.awt.*;
import java.util.*;
public class SysInfo {
public static void main(String[] args) {
Toolkit thekit = Toolkit.getDefaultToolkit();
System.out.println("\n Screen Resolution : " + thekit.getScreenResolution() + "dots per inch");
Dimension screenDim = thekit.getScreenSize();
System.out.println("Screen Size : " + screenDim.width + " by "+screenDim.height + " pixels");
GraphicsEnvironment e = GraphicsEnvironment.getLocalGraphicsEnvironment();
String[] fontnames = e.getAvailableFontFamilyNames();
System.out.println("\n----- fonts available on this flatform ----");
for(int i=0; i<fontnames.length; i++) { System.out.println(fontnames[i]); }
//System Properties
System.out.println("---- System Properties...... ----");
Properties p = System.getProperties();
p.list(System.out);
}
}
[예제] // CharaterIterator/StringIterator
import java.text.*;
class CharacterIteratorSample
{ public static void main(String[] args) {
//begin index:1, end index=4-1, current:1
CharacterIterator iter= new StringCharacterIterator("abcde", 1, 4, 1);
System.out.println("CharacterIterator iter --> "+iter);
iterateBackward( iter );
}
public static void iterateBackward(CharacterIterator iter) {
for (char ch = iter.last(); ch != CharacterIterator.DONE; ch = iter.previous())
System.out.print(ch);
}
}
java awt Container, Panel [오라클커뮤니티, 자바교육, 오라클자바커뮤니티]
-------------------------------------
java.awt.Container(Abstract)
-------------------------------------
java.awt.Container(Abstract)
-------------------------------------
오라클자바커뮤니티에서 설립한 오엔제이프로그래밍
실무교육센터
(오라클SQL, 튜닝, 힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷 실무전문 강의)
java.lang.Object --> java.awt.Component --> java.awt.Container
자신의 영역안에 다른 Component를 포함할수 있는 Component
Container도 Component Class의 하위Class 이므로 그 자체도 Component로 취급되며 다른 Container에 부착될 수 있습니다.
일반적으로 GUI를 만들때는 Component를 Container에 배치하고, 그런 작은 Container를 더 큰 Container에 포함시켜서 GUI를 구성 합니다.
Frame과 Applet은 대표적인 최상위 Container이다. 최상위 Container란 다른 Container를 포함하여 맨 바깥쪽 Container로 사용되는 컨테이너를 지칭 합니다. 이에 비해 Panel은 다른 Container에 부착되어 일부 영역을 Control하는 경우에 사용 됩니다. Window는 많이 사용되지 않으며 하위 Class인 Frame이 많이 사용 됩니다.
Dialog와 FileDialog Container는 대화창에서 주로 사용 됩니다.
컴포넌트를 컨테이너에 추가할 때 색인이 지정되지 않을 경우, 목록 끝(즉, 스택 순서 아래)에 추가 됩니다.
Panel, ScollPane, Window의 상위 클래스
Window클래스나 Window 클래스의 파생클래스(Frame등)는 포함 할 수 없습니다.
Container – component 추가/제거/추출 메소드
add(Component) : 지정된 컴포넌트를 컨테이너의 끝에 추가 합니다.
add(Component, int) : 해당 위치에 있는 컨테이너에 지정된 컴포넌트를 추가 합니다.
add(Component, Object) : 지정된 컴포넌트를 컨테이너의 끝에 추가 합니다.
add(Component, Object, int) : 지정된 색인에서 지정된 제약 조건이 있는 컨테이너에 지정된 컴포넌트를 추가 합니다.
add(String, Component) : 컨테이너에 지정된 컴포넌트를 추가 합니다.
remove(Component) : 컨테이너에서 지정된 컴포넌트를 제거 합니다.
remove(int) : 컨테이너에서 index에 의해 지정된 컴포넌트를 제거 합니다.
remove() : 컨테이너에서 모든 컴포넌트를 제거합니다.
getcomponent(int) : 컨테이너에 있는 n번째 컴포넌트를 가져 옵니다.
getcomponentAt(int, int) : x,y 위치가 포함된 컴포넌트 위치를 찾습니다.
getcomponentAt(Point) : 지정된 지점이 포함된 컴포넌트를 가져 옵니다.
getcomponentCount() : 패널에 있는 컴포넌트의 수를 가져 옵니다.
getComponents() : 컴포넌트에 있는 모든 컴포넌트를 가져 옵니다.
isAncestorOf(Component) : 컨테이너의 컴포넌트 계층구조에 컴포넌트가 포함되어 있는지 확인 합니다.
Container – 그래픽/이벤트와 관련된 메소드
update(Graphics) : 컨테이너를 갱신 합니다.
paint(Graphics) : 컨테이너의 색상을 표시 합니다.
paintComponents(Graphics) : 컨테이너에 있는 각 컴포넌트의 색상을 표시 합니다.
print(Graphics) : 컨테이너를 인쇄합니다.
printComponents(Graphics) : 컨테이너의 각 컴포넌트를 인쇄 합니다.
addContainerListener(ContainerListener) : 컨테이너로부터 컨테이너 이벤트를 수신하기 위해 지정된 컨테이너 수신기(listener)를 추가 합니다.
processContainerEvent(ContainerEvent) : 등록된 ContainerListener 객체로 보내어 컨테이너에서 발생하는 컨테이너 이벤트를 처리 합니다.
processEvent(AWTEvent) : 컨테이너의 이벤트를 처리 합니다.
doLayout() : 컨테이너가 컴포넌트를 배치하도록 합니다.
getLayout() : 컨테이너의 배치 관리 프로그램을 가져 옵니다.
setLayout(LayoutManager) :컨테이너에 대한 배치 관리 프로그램을 설정 합니다.
validate() : 컨테이너와 모든 부속 컴포넌트를 확인합니다. 컨테이너와 하부 컴포넌트를 다시 배치 합니다.
invalidate() : 컨테이너와 모든 부속 컴포넌트가 다시 그려져야 한다고 표시 합니다.
Container – 기타 메소드
addNotify() : 컨테이너가 피어(peer)를 작성하도록 통지 합니다.
getAlignmentX() : x축을 따라 정렬 합니다.
getAlignmentY() : y축을 따라 정렬 합니다.
getInsets() : 컨테이너의 경계 크기를 표시하는 컨테이너의 인세트(inset)를 결정 합니다.
getMaximumSize() : 컨테이너의 최대 크기를 리턴 합니다.
getMinimumSize() : 컨테이너의 최소 크기를 리턴 합니다.
getPreferredSize() : 컨테이너의 선호 크기를 리턴 합니다.
invalidate() : 컨테이너를 무효로 합니다.
list(PrintStream, int) : 지정된 출력 스트림에 컨테이너 목록을 인쇄 합니다.
list(PrintWriter, int) : 지정된 들여쓰기 위치에서 시작하여 지정된 인쇄 작성자로 목록을 인쇄 합니다.
removeNotify() : 컨테이너와 모든 부속 컴포넌트가 피어를 제거하도록 통지 합니다.
------------------------------
java.awt.Panel
--------------------------
다른 Component나 그하위 Component들이 표시될수 있는 장소를 제공하나 , 스스로 화면에 그릴수는 업습니다.
자기를 스스로 그릴수 있는 다른 Window나 그하위의 Frame, Dialog 와 같은 Component에 포함시켜서 사용해야 합니다.
Panel Class에서만 제공하는 주요한 메소드 특별히 없습니다. 결국 다른 Component를 포함할수 있다는 점을 제외하면 Canvas와 별차이가 없다고 할수 있습니다.
Applet Class가 Panel Class를 상속합니다.
Applet은 브라우저창에서 실행되므로 자신을 그릴수 있는 기능을 제공하지 않는 Panel을 상속한다고 볼 수 있습니다.
[예제]
/* 프레임에 Panel을 올리는 예제 */
import java.awt.*;
public class PanelTest extends Frame{
public PanelTest(String s) {
super(s);
}
public static void main(String[] args) {
PanelTest f = new PanelTest("Frame에 Pamel을 넣는예제");
Panel p = new Panel();
f.setSize(300,300);
f.setLayout(null);
p.setSize(150,150);
p.setBackground(Color.blue);
f.add(p);
f.setVisible(true);
}
}
2013년 8월 6일 화요일
[ORACLEJAVA, 오라클자바교육강좌]struts DataBase 접근하기(DBCP)
DataBase 접근하기
오라클자바커뮤니티에서 설립한 오엔제이프로그래밍 실무교육센터
(오라클SQL, 튜닝, 힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷 실무전문 강의)
스트럿츠를 이용한 대부분의 개발은 데이터베이스에 대한 접근을 하게 됩니다. 가장 좋은 구성은 Action이 프리젠테이션 영역과 비즈니스 로직 영역을 연결하는 thin adapter 역할을 하도록 구성 하는 겁니다.
DAO approach인 경우 데이터에 대한 접근은 Business Interface의 뒤쪽에 숨어 있게 됩니다. 비즈니스 클래스에 대한 구현은 Connection Pool을 지원하는 DataSource를 통해 이루어 지므로 대부분의 데이터베이스에 대한 접근은 Connection Pool을 이용한다고 보면 됩니다.
Connection Pool이라는 것은 간단히 말해 DB에 연결을 맺은 Connection 객체를 미리 만들어 주어 사용자가 접속하면 할당을 하는 형태로 DB접속을 관리하는 것을 말합니다. 실제 테스트를 해보면 아시겠지만 데이터베이스에 대한 Connection을 수립하는데도 많은 비용이 드는 것은 사실이니까요… 생성과 삭제, 관리등을 Connection Pool에서 알아서 관리 해줍니다.
대부분의 컨테이너와 데이터베이스 시스템은 DataSource에 대한 구현을 번들로 제공 합니다. DataSource는 JNDI를 통해 접근이 가능하며 JNDI approach인 경우 별다른 고민 없이 DataSouce에 대한 비즈니스 클래스의 접근을 용이하게 해 줍니다.
-------------------------------
Struts DataSource Manager
-------------------------------
비즈니스 로직 계층에서는 데이터액세스에 대한 상세한 부분과 데이터베이스의 Conenction을 얻는 부분을 캡슐화 합니다. Struts에서는 DataSource Manager 라는 것이 있어 Action 클래스가 데이터 액세스 요구에 위해 리소스(DB Connection등)를 생산해 내는 것을 쉽게 만들어 줍니다.
가능하다면 데이터를 액세스 하는 경우 DAO(Data Access Object) 패턴을 사용하기를 권고 하며 그래서 Action 클래스는 내부의 메커니즘을 알 필요가 없게 되는 것입니다.
DataSource Manager는 1.X 버전과의 호환을 위해 존재하며 향후 2.x 버전에서는 사라질 예정 입니다.
DataSource Manager는 struts-config.xml 파일에서 설정하며 javax.sql.DataSource 인터페이스를 구현한 어떠한 Conenction Pool에서도 deploy해서 사용 할 수 있습니다.
만약 현재 사용하고 있는 DB or 컨테이너가 javax.sql.DataSouce 인터페이스를 구현한 클래스를 제공 하다면 있는 것을 사용하셔도 무방 합니다. 대부분의 엔터프라이즈 애플리케이션 개발에서 보다 나은 성능을 위해 다른 connection pool을 사용하고 있죠^^
이 강좌에서는 Jakarta Commons dbcp's BasicDataSource(org.apache.commons.dbcp.BasicDataSource)를 이용하여 DataSource를 사용해 보도록 하겠습니다.
DBCP는 다음 URL에서 다운 받으시기 바랍니다.
http://jakarta.apache.org/commons/dbcp/downloads.html
1. DBCP BasicDataSource를 사용하기 위한 설정은 아래와 같습니다…(struts-config.xml에 설정)
<!-- =============== for DataSource ======================= -->
<data-sources>
<!-- configuration for commons BasicDataSource -->
<data-source key="mysql" type="org.apache.commons.dbcp.BasicDataSource">
<set-property property="driverClassName" value="com.mysql.jdbc.Driver" />
<set-property property="url" value="jdbc:mysql://localhost/test" />
<set-property property="username" value="root" />
<set-property property="password" value="pw" />
<set-property property="maxActive" value="10" />
<set-property property="maxWait" value="5000" />
<set-property property="defaultAutoCommit" value="true" />
<set-property property="defaultReadOnly" value="false" />
<set-property property="maxIdle" value="10000" />
</data-source>
<data-source key="oracle" type="org.apache.commons.dbcp.BasicDataSource">
<set-property property="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
<set-property property="username" value="scott" />
<set-property property="password" value="tiger" />
<set-property property="url" value="jdbc:oracle:thin:@localhost:1521:WINK" />
<set-property property="maxActive" value="50" />
<set-property property="maxIdle" value="10000" />
<set-property property="maxWait" value="100" />
<set-property property="defaultAutoCommit" value="true" />
</data-source>
</data-sources>
2. 소스 코드에서는 아래와 같이 사용 합니다.
public ActionForward
execute(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception
{
javax.sql.DataSource dataSource;
java.sql.Connection myConnection;
try {
//for oracle
javax.sql.DataSource dataSource = getDataSource(request,"oracle");
myConnection = dataSource.getConnection();
} catch (SQLException sqle) {
getServlet().log("Connection.process", sqle);
} finally {
//enclose this in a finally block to make
//sure the connection is closed
try {
myConnection.close();
} catch (SQLException e) {
getServlet().log("Connection.close", e);
}
}
}
3. 다중 데이터 소스를 사용하는 경우에는 struts-config.xml에서 다음과 같이 선언 합니다.
<data-sources>
<data-source key="A" type="org.apache.commons.dbcp.BasicDataSource">
... properties as before ...
</data-source>
<data-source key="B" type="org.apache.commons.dbcp.BasicDataSource">
... properties as before ...
</data-source>
...
</data-sources>
4. 다중 데이터 소스인 경우 프로그램에서는 다음과 같이 사용 합니다.
...
try {
dataSourceA = getDataSource(request, "A");
dataSourceB = getDataSource(request, "B");
...
2013년 8월 1일 목요일
oracle 11g : 오라클11g : 읽기전용 테이블 , readonly table
Oracle 11g : 읽기 전용 테이블
이전 버전의 오라클에서는 테이블은 다른 사용자에게 SELECT 오브젝트 권한을 주는 경우에만 읽기전용이 가능했고 해당 Owner는 테이블에 Read/Write 둘 다 가능했으며 읽기전용으로 만드는 것은 불가능 했다.
오라클 11g에서부터 alter table 테이블명 read only 명령으로 읽기전용으로 변경이 가능하다,
[형식]
ALTER TABLE table_name READ ONLY;
ALTER TABLE table_name READ WRITE;
SQL>reate table readtest
as
select rownum id, '홍길동'||rownum name from dual;
SQL>select * from readtest;
SQL> alter table readtest read only;
테이블이 변경되었습니다.
SQL> insert into readtest values (2, '김길동');
insert into readtest values (2, '김길동')
*
1행에 오류:
ORA-12081: "SCOTT"."READTEST" 테이블에 작업을 갱신하는 것이 허용되지 않습니다
SQL> delete from readtest;
delete from readtest
*
1행에 오류:
ORA-12081: "SCOTT"."READTEST" 테이블에 작업을 갱신하는 것이 허용되지 않습니다
SQL> truncate table readtest;
truncate table readtest
*
1행에 오류:
ORA-12081: "SCOTT"."READTEST" 테이블에 작업을 갱신하는 것이 허용되지 않습니다
SQL> alter table readtest read write;
테이블이 변경되었습니다.
SQL> truncate table readtest;
테이블이 잘렸습니다.
오라클자바커뮤니티에서 설립한
오엔제이프로그래밍 실무교육센터
(오라클SQL, 튜닝,
힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷 실무전문 강의)
이전 버전의 오라클에서는 테이블은 다른 사용자에게 SELECT 오브젝트 권한을 주는 경우에만 읽기전용이 가능했고 해당 Owner는 테이블에 Read/Write 둘 다 가능했으며 읽기전용으로 만드는 것은 불가능 했다.
오라클 11g에서부터 alter table 테이블명 read only 명령으로 읽기전용으로 변경이 가능하다,
[형식]
ALTER TABLE table_name READ ONLY;
ALTER TABLE table_name READ WRITE;
SQL>reate table readtest
as
select rownum id, '홍길동'||rownum name from dual;
SQL>select * from readtest;
SQL> alter table readtest read only;
테이블이 변경되었습니다.
SQL> insert into readtest values (2, '김길동');
insert into readtest values (2, '김길동')
*
1행에 오류:
ORA-12081: "SCOTT"."READTEST" 테이블에 작업을 갱신하는 것이 허용되지 않습니다
SQL> delete from readtest;
delete from readtest
*
1행에 오류:
ORA-12081: "SCOTT"."READTEST" 테이블에 작업을 갱신하는 것이 허용되지 않습니다
SQL> truncate table readtest;
truncate table readtest
*
1행에 오류:
ORA-12081: "SCOTT"."READTEST" 테이블에 작업을 갱신하는 것이 허용되지 않습니다
SQL> alter table readtest read write;
테이블이 변경되었습니다.
SQL> truncate table readtest;
테이블이 잘렸습니다.
자바인터페이스(java interface)
자바와 다중상속
- 다중 상속이라는 것은 말 그대로 하나의 클래스가 여러개의 수평적 상위클래스를 갖는 것이다.
- 다중 상속은 사용이 어렵고 오류를 범하기 쉬울 뿐 아니라 만약 사용한다고 하더라도 문법이 복잡해져 객체지향 기술 중에서도 많이 사용되지 않는 기능이다. 물론 다중 상속을 이용하면 하나의 클래스가 여러가지 일을 할 수 있는 기능을 제공할 수 있고 덕분에 유연한 프로그래밍이 가능해진다는 장점이 있다.
- C++과 같은 언어는 이러한 다중상속을 지원하지만 Java는 다중상속을 지원하는 것을 포기했다. 자바를 만든 이유는 작고 단순하고 안전한 프로그램을 만들자는 것이었다. 다중상속은 이러한 프로그램의 안정성을 저해하는 요소가 될 수 있기에 다중상속을 포기하게 된 것이다.
- 하지만 여전히 여러가지 기능을 가지는 클래스의 존재는 객체지향언어인 자바에서는 자주 필요하게 된다. 여러가지 기능을 가진 유연한 클래스를 만들기 위해 다중상속만을 지원하는 자바는 또 다른 방법을 고안해야 했다. 이것이 바로 인터페이스이다.
인테페이스
- 인터페이스라는 단어는 두개의 장치 및 시스템을 결합하고 있는 소프트웨어 또는 하드웨어라는 의미이다.
- 상수와 추상메소드의 집합
- 인터페이스를 사용할려면 클래스에서 구현해야 한다.(implements)
- 클래스가 인터페이스를 구현하게 되면 인터페이스 내에 정의된 상수는 상속된 것 처럼 직접 사용할수 있다.
- 인터페이스의 모든 메소드는 abstract가 생략되었다고 해도 암시적으로 abstract이다.
- 메소드의 구현을 갖지 않으며, 몸체부분은 세미콜론으로 대체된다.
- 오직 abstract 메소드만을 포함할수 있으며 클래스 메소드는 abstract가 될수 없으므로 인터페이스의 모든 메소드는 인스턴스 메소드 이다.
- 직원 중 운전을 할 수 있는 직원이 있으며 이 직원은 회사에서 보유하고 있는 차량을 사용할 수 있다. 만약 모든 직원이 자동차 면허를 가지고 있다면 Employee 클래스에서 자동차 면허에 대한 필드와 메소드를 만들면 되지만 모든 직원이 자동차 면허를 가지고 있을리는 없을 것이다. 때문에 다중 상속이 지원되지 않는 자바에서 자동자 면허를 가지고 있는 직원 클래스를 따로 만들고 그 클래스를 이용해 면허를 가진 영업팀 직원, 면허를 가진 Manager, 면허를 가진영업팀장 이라는 식의 클래스를 만들어야 구현이 가능하다.
Employee 클래스와 DriverEmployee 클래스가 서로 큰 연관성이 없으며 운전을 할 줄 아는 직원을 만들기 위해DriverEmployee 클래스를 따로 만들고 각 팀 직원들도 운전하는 직원을 따로 만들어야 한다면 프로그램 개발 시 일관성이 없고 복잡해 진다. 이런 문제를 해결하기 위해 운전하는 직원을 클래스로 따로 만드는 대신 운전이라는 인터페이스를 만들어 필요할 때 사용할 수 있으면 위와 같은 문제점을 해결할 수 있을 것이다.
인터페이스는 모양은 클래스와 비슷하지만 다른 점이 있다. 클래스는 필드와 메소드로 구성되어 있고 또 그 메소드는 자신이 할 일을 구현하고 있다. 하지만 인터페이스는 선언만을 하게 된다. 만약에 2종 운전 면허에 대한 인터페이스 SmallDriver를 작성한다면 다음과 같다.
public interface SmallDriver {
void driveSmallCar(); // 메소드 선언
int maxSmall = 5; // 필드(상수)
}
클래스는 필드로 기본자료형, 클래스 등이 올 수 있지만 인터페이스는 int, double 등의 기본 자료형만이 필드로 사용될 수 있다. 또한 각 필드는 반드시 초기화가 되어야 한다. 초기화가 되어야 하는 이유는 인터페이스의 필드는 암시적으로 final과 static이 설정되어 있기 때문이다.
int maxSmall = 5 static final int maxSmall = 5;
인터페이스는 메소드를 선언만 하고 구현하지는 않는다. 그리고 인터페이스의 모든 메소드는 접근지정이 기본적으로 public으로 설정된다. 그리고 모든 메소드는 추상메소드이다. 즉 위에서 void driveSmallCar();라고 선언하고 있는데 암시적으로 설정되는 public과 abstract 키워드를 추가하면 다음과. 같이 선언되어 있는 것과 같다.
public abstract void driveSmallCar();
앞에서 만든 SmallDriver 인터페이스를 상속한 1종 운전면허 인터페이스 BigDriver를 만든다면 다음과 같다.
public interface BigDriver extends SmallDriver {
void driveBigCar();
void driveSmallCar(); // 다시 선언하는 경우
int maxBig = 15;
}
상위 인터페이스에서 선언된 메소드를 하위클래스에서 동일한 명칭으로 선언한 경우 경우에 따라 두가지로 나눌 수 있다.
첫째는 상위 인터페이스의 메소드와 하위 인터페이스의 메소드 선언이 완전히 동일한 경우이다. 상위 인터페이스의 메소드만 유효한 것으로 인정하고 컴파일 에러는 발생하지 않는다.
둘째는 상위 인터페이스의 메소드와 하위 인터페이스의 메소드가 가지는 매개변수의 갯수가 서로 틀린 경우인데 이 경우는 각각 서로 다른 메소드가 선언된 것으로 간주한다. 즉 메소드가 오버로딩 된 것으로 인식하는 것이다.
하지만 위 두가지의 경우에 해당되지 않고 이름과 매개변수가 같은데 반환형만 다른 경우는 컴파일 에러가 발생하게 된다
예를 들어 SmallDriver에 선언되어 있는 상수 maxSmall을 BigDriver에서 다시 선언한다면? 이 경우 메소드는 하나만 인정하지만 상수의 경우는 범위 규칙에 의해서 SmallDriver의 maxSmall과 BigDriver의 maxSmall을 서로 다른 것으로 인식하여 두개의 상수가 선언된 것으로 인정한다. 사용시에는 상수의 위치에 따라 인터페이스명.상수명의 형태로 사용해야 한다.
인터페이스에서 선언된 메소드의 구현은 인터페이스를 구현하도록 허락된 클래스에서 구현하게 된다. 인터페이스를 상속받는 클래스는 컴파일러에게 "나는 A 라는 클래스인데 인터페이스 B를 완성해서 도구로 사용할꺼야"라고 알려준다.
public class A implements B {
만약 영업팀 직원이 운전을 하는것을 구현할려고 하면 기존의 영업팀직원 클래스가 driveSmallCar()를 구현해야 하며 그렇게 하기 위해서는 interface를 implement한다고 클래스에 표시해야 한다.
//인터페이스 선언
interface SmallDriver {
void driveSmallCar(); // 메소드 선언
int maxSmall = 5; // 필드(상수)
}
//직원 Class
abstract class Employee {
String name; String id;
//생성자
public Employee(String name1, String id1) {
name = name1; id = id1;
}
public void gotoOffice() { System.out.println(name+"님 출근하였습니다..."); }
public void gotoHome() { System.out.println(name+"님 퇴근하였습니다..."); }
public String toString() { return "직원의 이름은 " + name + "이다."; }
abstract public void startJob();
}
//직원클래스를 상속한 영업팀직원 클래스
class SalesEmployee extends Employee implements SmallDriver{
//영업담당지역, 차종류 메소드내에서만 변수에 접근이 가능하다.
private String chargeArea, carName;
public SalesEmployee(String newName,String newID,String newArea,String carName) {
//super는 상위클래스의 생성자를 의미
super(newName, newID); this.chargeArea = newArea; this.carName = carName;
}
// SmallDrive 인터페이스의 메소드 구현
public void driveSmallCar() {
System.out.println("영업팀 직원 " + name + "은 " + this.carName + "를 운전한다.");
}
public void startJob() {
System.out.println(super.name + "님이 " + this.chargeArea + " 지역으로 영업업무를 나갑니다...");
}
}
//Main Class
class InterfaceSample1 {
public static void main(String[] args) {
// 인터페이스가 클래스의 객체를 참조하도록...
SmallDriver sm1 = new SalesEmployee("홍길동", "11111","서울", "아반테");
// 인터페이스의 메소드 사용
sm1.driveSmallCar();
}
}
- 다중 상속이라는 것은 말 그대로 하나의 클래스가 여러개의 수평적 상위클래스를 갖는 것이다.
- 다중 상속은 사용이 어렵고 오류를 범하기 쉬울 뿐 아니라 만약 사용한다고 하더라도 문법이 복잡해져 객체지향 기술 중에서도 많이 사용되지 않는 기능이다. 물론 다중 상속을 이용하면 하나의 클래스가 여러가지 일을 할 수 있는 기능을 제공할 수 있고 덕분에 유연한 프로그래밍이 가능해진다는 장점이 있다.
- C++과 같은 언어는 이러한 다중상속을 지원하지만 Java는 다중상속을 지원하는 것을 포기했다. 자바를 만든 이유는 작고 단순하고 안전한 프로그램을 만들자는 것이었다. 다중상속은 이러한 프로그램의 안정성을 저해하는 요소가 될 수 있기에 다중상속을 포기하게 된 것이다.
- 하지만 여전히 여러가지 기능을 가지는 클래스의 존재는 객체지향언어인 자바에서는 자주 필요하게 된다. 여러가지 기능을 가진 유연한 클래스를 만들기 위해 다중상속만을 지원하는 자바는 또 다른 방법을 고안해야 했다. 이것이 바로 인터페이스이다.
인테페이스
- 인터페이스라는 단어는 두개의 장치 및 시스템을 결합하고 있는 소프트웨어 또는 하드웨어라는 의미이다.
- 상수와 추상메소드의 집합
- 인터페이스를 사용할려면 클래스에서 구현해야 한다.(implements)
- 클래스가 인터페이스를 구현하게 되면 인터페이스 내에 정의된 상수는 상속된 것 처럼 직접 사용할수 있다.
- 인터페이스의 모든 메소드는 abstract가 생략되었다고 해도 암시적으로 abstract이다.
- 메소드의 구현을 갖지 않으며, 몸체부분은 세미콜론으로 대체된다.
- 오직 abstract 메소드만을 포함할수 있으며 클래스 메소드는 abstract가 될수 없으므로 인터페이스의 모든 메소드는 인스턴스 메소드 이다.
- 직원 중 운전을 할 수 있는 직원이 있으며 이 직원은 회사에서 보유하고 있는 차량을 사용할 수 있다. 만약 모든 직원이 자동차 면허를 가지고 있다면 Employee 클래스에서 자동차 면허에 대한 필드와 메소드를 만들면 되지만 모든 직원이 자동차 면허를 가지고 있을리는 없을 것이다. 때문에 다중 상속이 지원되지 않는 자바에서 자동자 면허를 가지고 있는 직원 클래스를 따로 만들고 그 클래스를 이용해 면허를 가진 영업팀 직원, 면허를 가진 Manager, 면허를 가진영업팀장 이라는 식의 클래스를 만들어야 구현이 가능하다.
Employee 클래스와 DriverEmployee 클래스가 서로 큰 연관성이 없으며 운전을 할 줄 아는 직원을 만들기 위해DriverEmployee 클래스를 따로 만들고 각 팀 직원들도 운전하는 직원을 따로 만들어야 한다면 프로그램 개발 시 일관성이 없고 복잡해 진다. 이런 문제를 해결하기 위해 운전하는 직원을 클래스로 따로 만드는 대신 운전이라는 인터페이스를 만들어 필요할 때 사용할 수 있으면 위와 같은 문제점을 해결할 수 있을 것이다.
인터페이스는 모양은 클래스와 비슷하지만 다른 점이 있다. 클래스는 필드와 메소드로 구성되어 있고 또 그 메소드는 자신이 할 일을 구현하고 있다. 하지만 인터페이스는 선언만을 하게 된다. 만약에 2종 운전 면허에 대한 인터페이스 SmallDriver를 작성한다면 다음과 같다.
public interface SmallDriver {
void driveSmallCar(); // 메소드 선언
int maxSmall = 5; // 필드(상수)
}
클래스는 필드로 기본자료형, 클래스 등이 올 수 있지만 인터페이스는 int, double 등의 기본 자료형만이 필드로 사용될 수 있다. 또한 각 필드는 반드시 초기화가 되어야 한다. 초기화가 되어야 하는 이유는 인터페이스의 필드는 암시적으로 final과 static이 설정되어 있기 때문이다.
int maxSmall = 5 static final int maxSmall = 5;
인터페이스는 메소드를 선언만 하고 구현하지는 않는다. 그리고 인터페이스의 모든 메소드는 접근지정이 기본적으로 public으로 설정된다. 그리고 모든 메소드는 추상메소드이다. 즉 위에서 void driveSmallCar();라고 선언하고 있는데 암시적으로 설정되는 public과 abstract 키워드를 추가하면 다음과. 같이 선언되어 있는 것과 같다.
public abstract void driveSmallCar();
앞에서 만든 SmallDriver 인터페이스를 상속한 1종 운전면허 인터페이스 BigDriver를 만든다면 다음과 같다.
public interface BigDriver extends SmallDriver {
void driveBigCar();
void driveSmallCar(); // 다시 선언하는 경우
int maxBig = 15;
}
상위 인터페이스에서 선언된 메소드를 하위클래스에서 동일한 명칭으로 선언한 경우 경우에 따라 두가지로 나눌 수 있다.
첫째는 상위 인터페이스의 메소드와 하위 인터페이스의 메소드 선언이 완전히 동일한 경우이다. 상위 인터페이스의 메소드만 유효한 것으로 인정하고 컴파일 에러는 발생하지 않는다.
둘째는 상위 인터페이스의 메소드와 하위 인터페이스의 메소드가 가지는 매개변수의 갯수가 서로 틀린 경우인데 이 경우는 각각 서로 다른 메소드가 선언된 것으로 간주한다. 즉 메소드가 오버로딩 된 것으로 인식하는 것이다.
하지만 위 두가지의 경우에 해당되지 않고 이름과 매개변수가 같은데 반환형만 다른 경우는 컴파일 에러가 발생하게 된다
예를 들어 SmallDriver에 선언되어 있는 상수 maxSmall을 BigDriver에서 다시 선언한다면? 이 경우 메소드는 하나만 인정하지만 상수의 경우는 범위 규칙에 의해서 SmallDriver의 maxSmall과 BigDriver의 maxSmall을 서로 다른 것으로 인식하여 두개의 상수가 선언된 것으로 인정한다. 사용시에는 상수의 위치에 따라 인터페이스명.상수명의 형태로 사용해야 한다.
인터페이스에서 선언된 메소드의 구현은 인터페이스를 구현하도록 허락된 클래스에서 구현하게 된다. 인터페이스를 상속받는 클래스는 컴파일러에게 "나는 A 라는 클래스인데 인터페이스 B를 완성해서 도구로 사용할꺼야"라고 알려준다.
public class A implements B {
만약 영업팀 직원이 운전을 하는것을 구현할려고 하면 기존의 영업팀직원 클래스가 driveSmallCar()를 구현해야 하며 그렇게 하기 위해서는 interface를 implement한다고 클래스에 표시해야 한다.
//인터페이스 선언
interface SmallDriver {
void driveSmallCar(); // 메소드 선언
int maxSmall = 5; // 필드(상수)
}
//직원 Class
abstract class Employee {
String name; String id;
//생성자
public Employee(String name1, String id1) {
name = name1; id = id1;
}
public void gotoOffice() { System.out.println(name+"님 출근하였습니다..."); }
public void gotoHome() { System.out.println(name+"님 퇴근하였습니다..."); }
public String toString() { return "직원의 이름은 " + name + "이다."; }
abstract public void startJob();
}
//직원클래스를 상속한 영업팀직원 클래스
class SalesEmployee extends Employee implements SmallDriver{
//영업담당지역, 차종류 메소드내에서만 변수에 접근이 가능하다.
private String chargeArea, carName;
public SalesEmployee(String newName,String newID,String newArea,String carName) {
//super는 상위클래스의 생성자를 의미
super(newName, newID); this.chargeArea = newArea; this.carName = carName;
}
// SmallDrive 인터페이스의 메소드 구현
public void driveSmallCar() {
System.out.println("영업팀 직원 " + name + "은 " + this.carName + "를 운전한다.");
}
public void startJob() {
System.out.println(super.name + "님이 " + this.chargeArea + " 지역으로 영업업무를 나갑니다...");
}
}
//Main Class
class InterfaceSample1 {
public static void main(String[] args) {
// 인터페이스가 클래스의 객체를 참조하도록...
SmallDriver sm1 = new SalesEmployee("홍길동", "11111","서울", "아반테");
// 인터페이스의 메소드 사용
sm1.driveSmallCar();
}
}
자바 상속(JAVA EXTENDS), 자바실무강좌,오라클실무강좌,OnJ,ORACLEJAVA
상속 개념 이해 바랍니다.
상속은 한 클래스를 확장하여 새로운 클래스를 만드는 것을 말한다. 이렇게 새로 만들어지는 클래스를 하위클래스(SubClass)라고 부른다. 그리고 원래의 클래스는 상위클래스(SuperClass)라고 부른다. 하위클래스는 상위클래스에서 정의한 메쏘드와 변수들을 그대로 가지고 있을 수 있다. (물론 이것도 접근변경자를 통해 조절이 가능하다) 여기에 추가로 하위 클래스 자체적으로 정의된 메쏘드와 변수들을 가질 수 있다. 어떤 클래스에 대해서, 상속받는 하위 클래스는 여러 개가 될수 있다.
이미 만들어놓은 클래스를 기반으로 원하는 기능이 추가된 새로운 클래스를 쉽게 만들어낼 수 있다
자바의 모든 클래스는 상속의 대상이 되는 상위클래스(SuperClass)가 반드시 하나 존재한다
프로그램의 재사용성과 확장성을 높인다.
class Employee {
String name; String id;
//생성자
public Employee(String name1, String id1) {
name = name1; id = id1;
}
public void gotoOffice() {
System.out.println(name+"님 출근하였습니다...");
}
public void gotoHome() {
System.out.println(name+"님 퇴근하였습니다...");
}
}
Employee Class를 상속한 Manager Class가 있다….
//직원클래스를 상속한 일반관리자 Class
class Manager extends Employee {
String chargeDept;
public Manager(String newName,String newID,String newDept) {
//super는 상위클래스의 생성자를 의미
super(newName, newID);
this.chargeDept = newDept;
}
public void startJob() {
System.out.println(this.chargeDept + " " + super.name + "님이 관리업무를 시작합니다...");
}
}
Employee Class를 상속한 SalesEmployee Class가 있다….
//직원클래스를 상속한 영업팀직원 클래스
class SalesEmployee extends Employee {
//영업담당지역, 메소드내에서만 변수에 접근이 가능하다.
private String chargeArea;
public SalesEmployee(String newName,String newID,String newArea) {
//super는 상위클래스의 생성자를 의미
super(newName, newID);
this.chargeArea = newArea;
}
public void startJob() {
System.out.println(super.name + "님이 “ + this.chargeArea + “ 지역으로 영업업무를 나갑니다...");
}
}
상속을 위해서는 extends keyword를 사용한다. (class a extends b b로 부터 상속을 받음)
extends키워드를 이용해 클래스를 상속받으면 상속받은 클래스는 상위클래스의 필드와 메소드를 상속받는다.
(예) 앞의 Manager Class instance화 했다면
Manager m = new Manager(“홍길동”, “12345”,”관리부”);
String id = m.id;
m.gotoOffice();
등과 같이 사용이 가능하다… 물론 m.startJob() 처럼 자신의 Method를 사용이 가능하다.
하위클래스는 객체를 생성할 때 상위클래스의 객체를 먼저 생성해야 한다. 하위클래스는 크게 상위클래스 객체부와 자기 자신의 객체부로 나눌 수 있다. 즉 new 키워드를 사용하여 하위클래스를 생성하면 상위클래스의 부분과 하위클래스 고유의 부분이 나뉘어 생성된다는 것이다. 이때 상위클래스 부분을 super라고 한다. 그리고 상위클래스 객체부를 생성하기 위해 사용하는 것이 바로 상위클래스 생성자 super()이다.
(예) 만약 Manager Class에서 super(newName, newID)를 생략하면 다음과 같은 에러가 난다. 생략시에는 default로 super() 이 삽입되는데ㅡ Employee에는 파라미터가 없는 생성자가 선언되지 않았기때문에 ….
Example.java:22: cannot resolve symbol symbol : constructor Employee ()
location: class Employee public Manager(String newName,String newID,String newDept) {
하위클래스에서 상위클래스의 멤버를 호출하고자 할때는 .(점) 연산자를 사용하여 나타낼 수 있다.
(예) Manager Class에서 super.name
public void startJob() {
System.out.println(this.chargeDept +” “+ super.name + "님이 직원관리 업무 를 시작합니다...");
}
이제 SaleEmployee(영업부직원)을 상속한(확장한) SalesChief(영업팀장) Class를 만들어보자.
영업팀장 Class는 영업부직원과 같이 id,이름,영업담당 지역을 가지면서 자신만의 속성을 가진다.
//영업팀직원 클래스를 상속한 영업팀장 클래스
class SalesChief extends SalesEmployee {
int salesTarget; //영업팀 목표 매출액
public SalesChief(String newName,String newID,String newArea, int newSalesTarget) {
//super는 상위클래스의 생성자를 의미
super(newName, newID, newArea);
this.salesTarget = newSalesTarget;
}
//영업팀장의 업무는 더이상 확장이 안된다는 의미, 상속할수가 없다는 의미
final public void startJob() {
System.out.println(super.name + "님이 영업팀 직원을 관리한다...");
System.out.println(super.name + "님이 관리하는 영업팀의 매출목표는 "+ this.salesTarget + "만원 입니다...");
}
}
SalesChief Class의 경우 SalesEmployee의 startJob() 메소드를 재정의(Override) 했다.
메소드의 재정의라고 하는 것은 상속의 관계에 있는 클래스들 사이에서 상위클래스에 있는 메소드를 하위클래스에서 다시 정의하여 사용하는 것을 말한다. 이 경우 하위클래스의 메소드는 상위클래스의 메소드와 이름도, 매개변수 타입도, 그리고 반환형도 같다. 하지만 내부적으로 하는 일은 다르다.
만약 SalesChief Class의 startJob 메소드에서 다음과 같이 정의한다면,,,
public void startJob() {
System.out.println(super.chargeArea);
System.out.println(super.name + "님이 영업팀 직원을 관리한다...");
System.out.println(super.name + "님이 관리하는 영업팀의 매출목표는 "+ this.salesTarget + "만원 입니다...");
}
아래와 같은 오류발생…
Example.java:59: chargeArea has private access in SalesEmployee
System.out.println(super.chargeArea);
객체지향 언어에서는 정보의 은닉(캡슐화,Encapsulation) 을 위해서 위와 같은 접근지정을 할 수 있다. 즉 SaleEmployee의 자료중 정보 은닉의 필요가 있는 필드나 메소드는 접근지정자를 사용해 접근을 제한할 수 있는 것이다.
현재 작성한 클래스나 클래스의 멤버를 다른 클래스에게 상속시키고자 하지 않을경우엔 final 키워드를 사용한다.예를 들어 한 회사에 영업팀장은 그 만의 고유한 업무를 가지고 영업팀장의 업무를 관리하는 또 다른 개체가 없을 때는 영업팀장을 상속하여 더 확장된 기능을 가진 클래스를 만들 필요가 없을 것이다. 이럴 경우 final 키워드를 사용한다.
메소드의 경우도 이와 같이 상속을 완전히 금지하는 경우가 있는데 이러한 메소드도 final이라는 키워드와 같이 사용하게 되고 종단 메소드(final method)라고 부른다.
-------------------------------
/* Class의 상속에 관한 예제 Example1.*/
//직원 Class
class Employee {
String name;
String id;
//생성자
public Employee(String name1, String id1) {
name = name1;
id = id1;
}
public void gotoOffice() {
System.out.println(name+"님 출근하였습니다...");
}
public void gotoHome() {
System.out.println(name+"님 퇴근하였습니다...");
}
}
//직원클래스를 상속한 일반관리자 Class
class Manager extends Employee {
String chargeDept;
public Manager(String newName,String newID,String newDept) {
//super는 상위클래스의 생성자를 의미
super(newName, newID); this.chargeDept = newDept;
}
public void startJob() {
System.out.println(this.chargeDept + " " + super.name + "님이 일을 시작합니다...");
}
}
//직원클래스를 상속한 영업팀직원 클래스
class SalesEmployee extends Employee {
//영업담당지역, 메소드내에서만 변수에 접근이 가능하다.
private String chargeArea;
public SalesEmployee(String newName,String newID,String newArea) {
//super는 상위클래스의 생성자를 의미
super(newName, newID); this.chargeArea = newArea;
}
public void startJob() {
System.out.println(super.name + "님이 " + this.chargeArea + " 지역으로 영업업무를 나갑니다...");
}
}
//영업팀직원 클래스를 상속한 영업팀장 클래스
class SalesChief extends SalesEmployee {
int salesTarget; //영업팀 목표 매출액
public SalesChief(String newName,String newID,String newArea, int newSalesTarget) {
super(newName, newID, newArea); this.salesTarget = newSalesTarget;
}
public void startJob() {
System.out.println(super.name + "님이 영업팀 직원을 관리한다...");
System.out.println(super.name + "님이 관리하는 영업팀의 매출목표는 "+ this.salesTarget + "만원 입니다...");
}
}
//Main Class
class Example {
public static void main(String args[]) {
Manager m = new Manager("이종철","12345","솔루션개발");
m.gotoOffice(); m.startJob(); m.gotoHome();
SalesEmployee se = new SalesEmployee("차두리","23456","서울");
se.gotoOffice(); se.startJob(); se.gotoHome();
SalesChief sc = new SalesChief("홍길동","34567","전국",9000);
sc.gotoOffice(); sc.startJob(); sc.gotoHome();
}
}
오라클자바커뮤니티에서 설립한
오엔제이프로그래밍 실무교육센터
(오라클SQL, 튜닝,
힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷 실무전문 강의)
상속은 한 클래스를 확장하여 새로운 클래스를 만드는 것을 말한다. 이렇게 새로 만들어지는 클래스를 하위클래스(SubClass)라고 부른다. 그리고 원래의 클래스는 상위클래스(SuperClass)라고 부른다. 하위클래스는 상위클래스에서 정의한 메쏘드와 변수들을 그대로 가지고 있을 수 있다. (물론 이것도 접근변경자를 통해 조절이 가능하다) 여기에 추가로 하위 클래스 자체적으로 정의된 메쏘드와 변수들을 가질 수 있다. 어떤 클래스에 대해서, 상속받는 하위 클래스는 여러 개가 될수 있다.
이미 만들어놓은 클래스를 기반으로 원하는 기능이 추가된 새로운 클래스를 쉽게 만들어낼 수 있다
자바의 모든 클래스는 상속의 대상이 되는 상위클래스(SuperClass)가 반드시 하나 존재한다
프로그램의 재사용성과 확장성을 높인다.
class Employee {
String name; String id;
//생성자
public Employee(String name1, String id1) {
name = name1; id = id1;
}
public void gotoOffice() {
System.out.println(name+"님 출근하였습니다...");
}
public void gotoHome() {
System.out.println(name+"님 퇴근하였습니다...");
}
}
Employee Class를 상속한 Manager Class가 있다….
//직원클래스를 상속한 일반관리자 Class
class Manager extends Employee {
String chargeDept;
public Manager(String newName,String newID,String newDept) {
//super는 상위클래스의 생성자를 의미
super(newName, newID);
this.chargeDept = newDept;
}
public void startJob() {
System.out.println(this.chargeDept + " " + super.name + "님이 관리업무를 시작합니다...");
}
}
Employee Class를 상속한 SalesEmployee Class가 있다….
//직원클래스를 상속한 영업팀직원 클래스
class SalesEmployee extends Employee {
//영업담당지역, 메소드내에서만 변수에 접근이 가능하다.
private String chargeArea;
public SalesEmployee(String newName,String newID,String newArea) {
//super는 상위클래스의 생성자를 의미
super(newName, newID);
this.chargeArea = newArea;
}
public void startJob() {
System.out.println(super.name + "님이 “ + this.chargeArea + “ 지역으로 영업업무를 나갑니다...");
}
}
상속을 위해서는 extends keyword를 사용한다. (class a extends b b로 부터 상속을 받음)
extends키워드를 이용해 클래스를 상속받으면 상속받은 클래스는 상위클래스의 필드와 메소드를 상속받는다.
(예) 앞의 Manager Class instance화 했다면
Manager m = new Manager(“홍길동”, “12345”,”관리부”);
String id = m.id;
m.gotoOffice();
등과 같이 사용이 가능하다… 물론 m.startJob() 처럼 자신의 Method를 사용이 가능하다.
하위클래스는 객체를 생성할 때 상위클래스의 객체를 먼저 생성해야 한다. 하위클래스는 크게 상위클래스 객체부와 자기 자신의 객체부로 나눌 수 있다. 즉 new 키워드를 사용하여 하위클래스를 생성하면 상위클래스의 부분과 하위클래스 고유의 부분이 나뉘어 생성된다는 것이다. 이때 상위클래스 부분을 super라고 한다. 그리고 상위클래스 객체부를 생성하기 위해 사용하는 것이 바로 상위클래스 생성자 super()이다.
(예) 만약 Manager Class에서 super(newName, newID)를 생략하면 다음과 같은 에러가 난다. 생략시에는 default로 super() 이 삽입되는데ㅡ Employee에는 파라미터가 없는 생성자가 선언되지 않았기때문에 ….
Example.java:22: cannot resolve symbol symbol : constructor Employee ()
location: class Employee public Manager(String newName,String newID,String newDept) {
하위클래스에서 상위클래스의 멤버를 호출하고자 할때는 .(점) 연산자를 사용하여 나타낼 수 있다.
(예) Manager Class에서 super.name
public void startJob() {
System.out.println(this.chargeDept +” “+ super.name + "님이 직원관리 업무 를 시작합니다...");
}
이제 SaleEmployee(영업부직원)을 상속한(확장한) SalesChief(영업팀장) Class를 만들어보자.
영업팀장 Class는 영업부직원과 같이 id,이름,영업담당 지역을 가지면서 자신만의 속성을 가진다.
//영업팀직원 클래스를 상속한 영업팀장 클래스
class SalesChief extends SalesEmployee {
int salesTarget; //영업팀 목표 매출액
public SalesChief(String newName,String newID,String newArea, int newSalesTarget) {
//super는 상위클래스의 생성자를 의미
super(newName, newID, newArea);
this.salesTarget = newSalesTarget;
}
//영업팀장의 업무는 더이상 확장이 안된다는 의미, 상속할수가 없다는 의미
final public void startJob() {
System.out.println(super.name + "님이 영업팀 직원을 관리한다...");
System.out.println(super.name + "님이 관리하는 영업팀의 매출목표는 "+ this.salesTarget + "만원 입니다...");
}
}
SalesChief Class의 경우 SalesEmployee의 startJob() 메소드를 재정의(Override) 했다.
메소드의 재정의라고 하는 것은 상속의 관계에 있는 클래스들 사이에서 상위클래스에 있는 메소드를 하위클래스에서 다시 정의하여 사용하는 것을 말한다. 이 경우 하위클래스의 메소드는 상위클래스의 메소드와 이름도, 매개변수 타입도, 그리고 반환형도 같다. 하지만 내부적으로 하는 일은 다르다.
만약 SalesChief Class의 startJob 메소드에서 다음과 같이 정의한다면,,,
public void startJob() {
System.out.println(super.chargeArea);
System.out.println(super.name + "님이 영업팀 직원을 관리한다...");
System.out.println(super.name + "님이 관리하는 영업팀의 매출목표는 "+ this.salesTarget + "만원 입니다...");
}
아래와 같은 오류발생…
Example.java:59: chargeArea has private access in SalesEmployee
System.out.println(super.chargeArea);
객체지향 언어에서는 정보의 은닉(캡슐화,Encapsulation) 을 위해서 위와 같은 접근지정을 할 수 있다. 즉 SaleEmployee의 자료중 정보 은닉의 필요가 있는 필드나 메소드는 접근지정자를 사용해 접근을 제한할 수 있는 것이다.
현재 작성한 클래스나 클래스의 멤버를 다른 클래스에게 상속시키고자 하지 않을경우엔 final 키워드를 사용한다.예를 들어 한 회사에 영업팀장은 그 만의 고유한 업무를 가지고 영업팀장의 업무를 관리하는 또 다른 개체가 없을 때는 영업팀장을 상속하여 더 확장된 기능을 가진 클래스를 만들 필요가 없을 것이다. 이럴 경우 final 키워드를 사용한다.
메소드의 경우도 이와 같이 상속을 완전히 금지하는 경우가 있는데 이러한 메소드도 final이라는 키워드와 같이 사용하게 되고 종단 메소드(final method)라고 부른다.
-------------------------------
/* Class의 상속에 관한 예제 Example1.*/
//직원 Class
class Employee {
String name;
String id;
//생성자
public Employee(String name1, String id1) {
name = name1;
id = id1;
}
public void gotoOffice() {
System.out.println(name+"님 출근하였습니다...");
}
public void gotoHome() {
System.out.println(name+"님 퇴근하였습니다...");
}
}
//직원클래스를 상속한 일반관리자 Class
class Manager extends Employee {
String chargeDept;
public Manager(String newName,String newID,String newDept) {
//super는 상위클래스의 생성자를 의미
super(newName, newID); this.chargeDept = newDept;
}
public void startJob() {
System.out.println(this.chargeDept + " " + super.name + "님이 일을 시작합니다...");
}
}
//직원클래스를 상속한 영업팀직원 클래스
class SalesEmployee extends Employee {
//영업담당지역, 메소드내에서만 변수에 접근이 가능하다.
private String chargeArea;
public SalesEmployee(String newName,String newID,String newArea) {
//super는 상위클래스의 생성자를 의미
super(newName, newID); this.chargeArea = newArea;
}
public void startJob() {
System.out.println(super.name + "님이 " + this.chargeArea + " 지역으로 영업업무를 나갑니다...");
}
}
//영업팀직원 클래스를 상속한 영업팀장 클래스
class SalesChief extends SalesEmployee {
int salesTarget; //영업팀 목표 매출액
public SalesChief(String newName,String newID,String newArea, int newSalesTarget) {
super(newName, newID, newArea); this.salesTarget = newSalesTarget;
}
public void startJob() {
System.out.println(super.name + "님이 영업팀 직원을 관리한다...");
System.out.println(super.name + "님이 관리하는 영업팀의 매출목표는 "+ this.salesTarget + "만원 입니다...");
}
}
//Main Class
class Example {
public static void main(String args[]) {
Manager m = new Manager("이종철","12345","솔루션개발");
m.gotoOffice(); m.startJob(); m.gotoHome();
SalesEmployee se = new SalesEmployee("차두리","23456","서울");
se.gotoOffice(); se.startJob(); se.gotoHome();
SalesChief sc = new SalesChief("홍길동","34567","전국",9000);
sc.gotoOffice(); sc.startJob(); sc.gotoHome();
}
}
JAVA, JAR EXAMPLE(자바 JAR, 자바실무교육, 오라클자바실무, 오엔제이프로그래밍)
JAR 명령어는 UNIX TAR와 비슷해서 공부하기도 쉽습니다.
Jar c|t|u|x[f][m][M][0][v] [jar파일의이름] [menifest] [-C directory] [files]
Jar –I[jar]
- 처음 Option의 첫번째 문자(기본적인 연산을 지정)
c : 새로운 Jar Archive를 생성, 마지막인자로 입력파일등을 표시, 새롭게 생성된 JAR File
은 첫번째 엔트리로 META-INF/MENIFEST.MF 파일을 가지며 이파일은 JAR File의
내용을 나열하며 각각의 파일에 대한 메시지 요약을 포함한다.
t : Jar Archive의 내용을 나열한다.
u : Jar Archive 파일의 내용을 갱신, 커맨드라인에 나열된 파일은 이 아카이브에 추가된다.
m 옵션과 같이 사용된 경우에는 지정된 메니페스트 정보를 Jar File 에 추가한다.
x : JAR Archive의 내용을 추출한다.
- 한정자 옵션(4개의 명령지정문 뒤에서 연산에 관한 자세한 정보를 제공)
f: jar가 Command Line의 지정된 이름의 JAR File에 대해 수행되는 것임을 나타낸다.
지정되지 않으면 표준입력으로 JAR File을 읽고 표준출력으로 JAR File을 쓴다.
m : 메니페스트 템플릿이 코맨드라인에 지정되었음을 JAR 명령에게 알린다.,(c,u Option과
함께사용)
M : jar가 기본 메니페스트 파일을 생성하지 않도록 함(c, u와 함께 사용)
v : 여러 가지 출력을 내보내도록 함
0 : jar가 압축 없이 파일을 JAR 아카이브에 저장 하도록 함
첫번째 옵션이 f를 포함한다면 jar파일의 이름을 기술하며, m을 포함한다면 menifest파일이름을 기술한다. 만약 첫번째 Option이 f,m을 모두 포함한다면 이와 동일한 순서로 나열해야 한다. Files에는 JAR Archive에 포함시킬 파일을 나열한다.
** 추가옵션
-C Directory : Jar가 다음파일및 디렉토리를 처리하는중에 지정된 dir을 바꾸도록 한다. –C Option은 몇개라도 사용이 가능하며, 다음 –C Option이 올때까지 유효하다.
-I jarfile : c,t,u,x 대신 사용, Jar File의 파일구조등의 인덱스를 산출하도록, META-INF/INDEX.LIST 파일에 저장
추후 자바인터프리터나 애플릿뷰어등이 알고리즘의 최적화하고 불필요한 Jar File을 다운로드 하지 않기 위해서 이 인덱스 정보를 이용활수 있다.
jar cvf hello.jar HelloWorld*.class
jar cf hello.jar HelloWorld*.class -> 위의 것과 동일하나 화면에 출력이 나타나지 않는다.
jar cmf myMenifest test.jar HelloWorld.class -> test.jar File을 만들면서 myMenifest 라는 파일의 내용을 MENIFEST.MF File에 첨가한다.
Jar ufm test.jar myMenifest -> 이미 만들어져 있는 test.jar File의 MENIFEST.MF File을 myMenifest 를 참조하여 갱신한다.
Jar umf myMenifest test.jar
D:\자바프로그래밍\예제>jar tvf hello.jar
0 Fri Jun 28 19:07:24 KST 2002 META-INF/
95 Wed Jul 03 00:08:38 KST 2002 META-INF/MANIFEST.MF
430 Fri Jun 28 18:30:38 KST 2002 HelloWorld.class
D:\자바프로그래밍\예제>jar tf test.jar
META-INF/
META-INF/MANIFEST.MF
HelloWorld.class
D:\자바프로그래밍\예제>jar uf test.jar HelloWorld1.class
D:\자바프로그래밍\예제>jar uf test.jar HelloWorld2.class
D:\자바프로그래밍>jar cvf sample.jar -C 예제/ . sample.jar file은 예제 dir에 생김
D:\자바프로그래밍\예제>jar tvf test.jar
0 Fri Jun 28 19:07:24 KST 2002 META-INF/
95 Wed Jul 03 00:08:38 KST 2002 META-INF/MANIFEST.MF
430 Fri Jun 28 18:30:38 KST 2002 HelloWorld.class
391 Fri Jun 28 17:35:00 KST 2002 HelloWorld1.class
354 Fri Jun 28 17:35:00 KST 2002 HelloWorld2.class
오라클자바커뮤니티에서 설립한
오엔제이프로그래밍 실무교육센터
(오라클SQL, 튜닝,
힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷 실무전문 강의)
Jar c|t|u|x[f][m][M][0][v] [jar파일의이름] [menifest] [-C directory] [files]
Jar –I[jar]
- 처음 Option의 첫번째 문자(기본적인 연산을 지정)
c : 새로운 Jar Archive를 생성, 마지막인자로 입력파일등을 표시, 새롭게 생성된 JAR File
은 첫번째 엔트리로 META-INF/MENIFEST.MF 파일을 가지며 이파일은 JAR File의
내용을 나열하며 각각의 파일에 대한 메시지 요약을 포함한다.
t : Jar Archive의 내용을 나열한다.
u : Jar Archive 파일의 내용을 갱신, 커맨드라인에 나열된 파일은 이 아카이브에 추가된다.
m 옵션과 같이 사용된 경우에는 지정된 메니페스트 정보를 Jar File 에 추가한다.
x : JAR Archive의 내용을 추출한다.
- 한정자 옵션(4개의 명령지정문 뒤에서 연산에 관한 자세한 정보를 제공)
f: jar가 Command Line의 지정된 이름의 JAR File에 대해 수행되는 것임을 나타낸다.
지정되지 않으면 표준입력으로 JAR File을 읽고 표준출력으로 JAR File을 쓴다.
m : 메니페스트 템플릿이 코맨드라인에 지정되었음을 JAR 명령에게 알린다.,(c,u Option과
함께사용)
M : jar가 기본 메니페스트 파일을 생성하지 않도록 함(c, u와 함께 사용)
v : 여러 가지 출력을 내보내도록 함
0 : jar가 압축 없이 파일을 JAR 아카이브에 저장 하도록 함
첫번째 옵션이 f를 포함한다면 jar파일의 이름을 기술하며, m을 포함한다면 menifest파일이름을 기술한다. 만약 첫번째 Option이 f,m을 모두 포함한다면 이와 동일한 순서로 나열해야 한다. Files에는 JAR Archive에 포함시킬 파일을 나열한다.
** 추가옵션
-C Directory : Jar가 다음파일및 디렉토리를 처리하는중에 지정된 dir을 바꾸도록 한다. –C Option은 몇개라도 사용이 가능하며, 다음 –C Option이 올때까지 유효하다.
-I jarfile : c,t,u,x 대신 사용, Jar File의 파일구조등의 인덱스를 산출하도록, META-INF/INDEX.LIST 파일에 저장
추후 자바인터프리터나 애플릿뷰어등이 알고리즘의 최적화하고 불필요한 Jar File을 다운로드 하지 않기 위해서 이 인덱스 정보를 이용활수 있다.
jar cvf hello.jar HelloWorld*.class
jar cf hello.jar HelloWorld*.class -> 위의 것과 동일하나 화면에 출력이 나타나지 않는다.
jar cmf myMenifest test.jar HelloWorld.class -> test.jar File을 만들면서 myMenifest 라는 파일의 내용을 MENIFEST.MF File에 첨가한다.
Jar ufm test.jar myMenifest -> 이미 만들어져 있는 test.jar File의 MENIFEST.MF File을 myMenifest 를 참조하여 갱신한다.
Jar umf myMenifest test.jar
D:\자바프로그래밍\예제>jar tvf hello.jar
0 Fri Jun 28 19:07:24 KST 2002 META-INF/
95 Wed Jul 03 00:08:38 KST 2002 META-INF/MANIFEST.MF
430 Fri Jun 28 18:30:38 KST 2002 HelloWorld.class
D:\자바프로그래밍\예제>jar tf test.jar
META-INF/
META-INF/MANIFEST.MF
HelloWorld.class
D:\자바프로그래밍\예제>jar uf test.jar HelloWorld1.class
D:\자바프로그래밍\예제>jar uf test.jar HelloWorld2.class
D:\자바프로그래밍>jar cvf sample.jar -C 예제/ . sample.jar file은 예제 dir에 생김
D:\자바프로그래밍\예제>jar tvf test.jar
0 Fri Jun 28 19:07:24 KST 2002 META-INF/
95 Wed Jul 03 00:08:38 KST 2002 META-INF/MANIFEST.MF
430 Fri Jun 28 18:30:38 KST 2002 HelloWorld.class
391 Fri Jun 28 17:35:00 KST 2002 HelloWorld1.class
354 Fri Jun 28 17:35:00 KST 2002 HelloWorld2.class
자바의 특성(객체지향적) , ORACLE JAVA OOP 실무강좌
******** 자바의 특성(객체지향적) ************
추상화(Abstraction) : 실제 사물을 명사화/동사화 시켜서 프로그램에 적용할수 있는 형태로 만드는 것
상속성(Inheritance) : 미리 만들어진 소스를 가지고 공유하며 재사용하고, 또한 특별한 부분에 대 해서는 다시 재정의해서 사용하는 것 자바에서 상속은 한 클래스를 확장하여 새로운 클래스를 만드는 것을 말한다. 이렇게 새로 만들어지는 클래스를 하위클래스(subclass)라고 부른다. 그리고 원래의 클래스는 상위클래스(superclass)라고 부른다.
다형성(Polymorphism) : 상속을 받은 것을 그대로 사용하지 않고 입맛에 맞게 바꾸어 줄 수 있도록 하는것이며 이 때문에 다형성 함수는 전달하는 변수의 타입을 고려하지 않게된다.
캡슐화(Encapsulation) : 캡슐화는 사용자로부터 객체 내부의 데이터를 감추는 것이다. 데이터를 변수로 나타내며, 클래스의 함수와 프로시저는 메소드(Method)라고 한다. 클래스가 다른 클래스의 데이터를 다루려면 메소드를 통해야 한다. 이러한 캡슐화는 객체 내부의 처리과정을 알 필요없이 그것을 다루는 메소드에 대해서만 알면 된다는 점에서 편리하다. 변수들(외부에서 임의로 조작되었을때 원하지 않는 결과가 나오는것들 또는 잘못된 결과가 나오는것들) 에대해서 외부로 부터 접근제한을 시키는 것이 바로 encapsulation, 즉 객체내부의 데이터와 메소드 항목을 정의할때 private로 지정하여 클래스 외부에서의 접근을 제한하는것.
다중 쓰레드를 지원한다.
- 프로세스는 실행중인 프로그램을 뜻하는 말입니다. 보통 프로세스가 운영 체제의
여 러 자원을 사용하는 기본 단의 입니다.
- 쓰레드(Thread)란 프로세스 내부에서 실행되는 일련의 명령 흐름을 뜻합니다.
프로세스내의 제어의 단일 순차 흐름을 의미하며, 때때로 수행 문맥
(execution context)또는 가벼운 프로세스(lightweight peocess)라함
- 프로세스가 실행되면서 하나의 흐름만을 갖는 것이 아니라 여러 개의 흐름으로
분기할 수 있으며 하나의 프로세스가 같은 시간에 여러 가지 일을 수행하기
위해서 여러 개의 스레드를 만들게 됩니다.
- 다중 쓰레드란 하나의 프로그램내에서 동시에 수행되며 서로 다른 작업들을
수행하는 복수개의 쓰레드들을 의미한다.
[예제]
class Employee {
String name;
String id;
//생성자
public Employee(String name1, String id1) {
name = name1;
id = id1;
}
public void gotoOffice() {
System.out.println(name+"님 출근하였습니다...");
}
public void gotoHome() {
System.out.println(name+"님 퇴근하였습니다...");
}
}
class Manager extends Employee {
String chargeDept;
public Manager(String newName,String newID,String newDept) {
//super는 상위클래스의 생성자를 의미
super(newName, newID);
this.chargeDept = newDept;
}
public void startJob() {
System.out.println(this.chargeDept +” “+ super.name + "님이 직원관리를 시작합니다...");
}
}
class Example {
public static void main(String args[]) {
Manager m = new Manager("이종철","12345","솔루션개발부");
m.gotoOffice();
m.startJob();
m.gotoHome();
Manager m1 = new Manager("홍길동","12346","고객관리부");
m1.gotoOffice();
m1.startJob();
m1.gotoHome();
}
}
추상화(Abstraction) : 실제 사물을 명사화/동사화 시켜서 프로그램에 적용할수 있는 형태로 만드는 것
상속성(Inheritance) : 미리 만들어진 소스를 가지고 공유하며 재사용하고, 또한 특별한 부분에 대 해서는 다시 재정의해서 사용하는 것 자바에서 상속은 한 클래스를 확장하여 새로운 클래스를 만드는 것을 말한다. 이렇게 새로 만들어지는 클래스를 하위클래스(subclass)라고 부른다. 그리고 원래의 클래스는 상위클래스(superclass)라고 부른다.
다형성(Polymorphism) : 상속을 받은 것을 그대로 사용하지 않고 입맛에 맞게 바꾸어 줄 수 있도록 하는것이며 이 때문에 다형성 함수는 전달하는 변수의 타입을 고려하지 않게된다.
캡슐화(Encapsulation) : 캡슐화는 사용자로부터 객체 내부의 데이터를 감추는 것이다. 데이터를 변수로 나타내며, 클래스의 함수와 프로시저는 메소드(Method)라고 한다. 클래스가 다른 클래스의 데이터를 다루려면 메소드를 통해야 한다. 이러한 캡슐화는 객체 내부의 처리과정을 알 필요없이 그것을 다루는 메소드에 대해서만 알면 된다는 점에서 편리하다. 변수들(외부에서 임의로 조작되었을때 원하지 않는 결과가 나오는것들 또는 잘못된 결과가 나오는것들) 에대해서 외부로 부터 접근제한을 시키는 것이 바로 encapsulation, 즉 객체내부의 데이터와 메소드 항목을 정의할때 private로 지정하여 클래스 외부에서의 접근을 제한하는것.
다중 쓰레드를 지원한다.
- 프로세스는 실행중인 프로그램을 뜻하는 말입니다. 보통 프로세스가 운영 체제의
여 러 자원을 사용하는 기본 단의 입니다.
- 쓰레드(Thread)란 프로세스 내부에서 실행되는 일련의 명령 흐름을 뜻합니다.
프로세스내의 제어의 단일 순차 흐름을 의미하며, 때때로 수행 문맥
(execution context)또는 가벼운 프로세스(lightweight peocess)라함
- 프로세스가 실행되면서 하나의 흐름만을 갖는 것이 아니라 여러 개의 흐름으로
분기할 수 있으며 하나의 프로세스가 같은 시간에 여러 가지 일을 수행하기
위해서 여러 개의 스레드를 만들게 됩니다.
- 다중 쓰레드란 하나의 프로그램내에서 동시에 수행되며 서로 다른 작업들을
수행하는 복수개의 쓰레드들을 의미한다.
[예제]
class Employee {
String name;
String id;
//생성자
public Employee(String name1, String id1) {
name = name1;
id = id1;
}
public void gotoOffice() {
System.out.println(name+"님 출근하였습니다...");
}
public void gotoHome() {
System.out.println(name+"님 퇴근하였습니다...");
}
}
class Manager extends Employee {
String chargeDept;
public Manager(String newName,String newID,String newDept) {
//super는 상위클래스의 생성자를 의미
super(newName, newID);
this.chargeDept = newDept;
}
public void startJob() {
System.out.println(this.chargeDept +” “+ super.name + "님이 직원관리를 시작합니다...");
}
}
class Example {
public static void main(String args[]) {
Manager m = new Manager("이종철","12345","솔루션개발부");
m.gotoOffice();
m.startJob();
m.gotoHome();
Manager m1 = new Manager("홍길동","12346","고객관리부");
m1.gotoOffice();
m1.startJob();
m1.gotoHome();
}
}
2013년 7월 30일 화요일
[오라클강의,자바강의,오라클자바교육,오라클교육,자바교육,자바오라클]Oracle Explicitly Named Indexes(9i이상)
oracle pk index
오라클 9i이상
에서 인덱스는 Primary Key와 Unique
Key와는 별도로 CREATE TABLE의
USING INDEX구
안에 CREATE INDEX 문법을 이용해서 정의하는 것이 가능해 졌습니다.
오라클자바커뮤니티에서 설립한
오엔제이프로그래밍 실무교육센터
(오라클SQL, 튜닝,
힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷 실무전문 강의)
아마도 대부분의 사용자들은 다음과 같은 방식을 알고
계실텐데…
예제를 보시면서 어떤 것이 바뀌었는지 확인해 보도록
하죠.
SQL> create table test (
2 c1 varchar2(4) not
null,
3 c2
number(10) not null,
4
constrint pk_test primary key(c1) using index
4 );
테이블이
생성되었습니다.
위의 create table문은
pk_test라는 이름을 가지는 primary key 제약 조건을 만들며 아울러 pk_test라는 이름을 가진 인덱스를 만듭니다. 이
두가지는 user_ind_colums 뷰와
user_constraints 뷰에서 table_name = ‘TEST’라는 조건을 주시면 확인이 가능합니다.
그러나 9i이후에서는 인덱스에 대해 명시적으로 이름을 주는 것이 가능해
졌는데…
우선 아래의
예제를 참고 하도록 하죠…
SQL> create table test (
2 c1 varchar2(4) not
null,
3 c2 number(7),
4 constraint pk_test primary
key(c1)
5 using index
6 (create index idx_test_c1 on
test(c1))
7 );
테이블이
생성되었습니다.
이 경우는
테이블을 만들면서 primary key를 만드는데
(원래는 default로 pk를 만들게 되면
그 컬럼으로 유니크 인덱스를 만듭니다.) 인덱스의 이름은 primary
key 이름과 다르게 주기 위해 using index 구안에 create index문을 이용해서 인덱스를 생성했습니다.
--------------------------------------------------------------------
아래의 SQL문중 하나를 이용해 인덱스는 놔두고
PK만 삭제할 수 있습니다.
--------------------------------------------------------------------
SQL> alter table test drop primary key keep index;
테이블이
변경되었습니다.
또는
SQL> alter table test drop constraint pk_test;
테이블이
변경되었습니다.
[출처]오라클자바커뮤니티
피드 구독하기:
글 (Atom)