반응형





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
/* Character function */
 
/* concat(char1, char2) or || : 문자열 연결*/
 
select concat('Hello','Bye'), concat('Good','Bad') 
from dual;
 
 
select 'Hello'||'Bye', 'Good'||'Bad' 
from dual;
 
 
 
/* initcap(char) : 첫문자 대문자 변환 */
 
select initcap('good mornig') 
from dual;
 
 
select initcap('good/bad mornig') 
from dual;
 
 
 
/* Lower(char) : 소문자로 변환 */
 
select lower('GOOD') 
from dual;
 
 
 
/* Upper(char) : 대문자로 변환 */
 
select upper('good') 
from dual;
 
 
 
/* Lpad(expr1,n,expr2) : expr1을 n만큼 왼쪽으로 늘려서 반환 */
 
select lpad('good',6) "LAPD1",
       lpad('good',6,'@') "LPAD2",
       lpad('good',8,'L') "LPAD3"
from dual;
 
 
 
/* 
   Rpad(expr1,n,expr2) : expr1을 n만큼 오른쪽으로 늘려서 반환 
   한글은 한글자를 2byte로 계산하여 나머지를 늘임
*/
 
select rpad('good',6) "RPAD1",
       rpad('good',7,'#') "RPAD2",
       rpad('good',8,'L') "RPAD3",
       rpad('안녕',7,'#') "RPAD4"
from dual;
 
 
 
/* Ltrim(char,set) : char에서 set으로 지정된 물자를 왼쪽에서 제거 */
 
select ltrim('goodbye') 
from dual;
 
 
select ltrim('goodbye',' ') 
from dual;
 
 
select ltrim('goodbye','g'), ltrim('goodbye','o'), ltrim('goodbye','go') 
from dual;
 
 
 
/* Rtrim(char,set) : char에서 set으로 지정된 물자를 오른쪽에서 제거 */
 
select rtrim('goodbye') 
from dual;
 
 
select rtrim('goodbye','go') 
from dual;
 
 
select rtrim('goodbye','e'), rtrim('goodbye','ye') 
from dual;
 
 
/* Substr(char,pos,leng) : 문자열 일부 반환 */
 
select substr('good morning john',8,4) 
from dual;
 
 
select substr('good morning john',8) 
from dual;
 
 
select substr('good morning john',-4) 
from dual;
 
 
select substr('good morning john',-4,2) /*pos가 음수이므로 문자열 끝에서부터 2자리 가져옴*/
from dual; 
 
 
select substr('good morning john',-4,0)  /*length가 0이므로 결과 없음*/
from dual;
 
 
 
/* Substrb(char,pos,byte) : 문자열 일부 반환 */
 
select substrb('good morning john',8,4)  /*byte 수 만큼 가져옴*/
from dual;
 
 
 
/* Replace(char,src_str,rep_str) : 문자열 일부를 대체해서 반환 */
 
select replace('good morning Tom','morning','evenning') 
from dual;
 
 
 
/* Translate(expr,frm_str,to_str) : 문자자체를 일대일로 대응, 변환 */
 
select replace('You are not alone', 'You', 'We') replaces, 
/*결과 We are not alone*/
       translate('You are not alone', 'You', 'We')translates  
/*결과 We are net alene : 문자'o'를 'e'로 변환*/
from dual;
 
 
/* Trim([Leading,Trailing,Both],[trim_chr][FROM]trim_src) : 
trim_src에서 trim_chr을 앞,뒤 혹은 모두에서 제거한 결과 반환 */
 
select trim(leading from 'good') 
from dual;
 
 
select length(trim(leading from ' good ')) 
from dual; /*앞(왼쪽)의 공백 삭제하므로 결과 5출력*/
 
 
select length(trim(trailing from ' good ')) 
from dual; /*뒤(오른쪽)의 공백 삭제하므로 결과 5출력*/
 
 
select length(trim(both from ' good ')) 
from dual; /*양쪽의 공백 삭제하므로 결과 4출력*/
 
 
select trim(leading 'g' from 'good') 
from dual; /*왼쪽의 g를 삭제하므로 결과 ood출력*/
 
 
select trim(trailing 'd' from 'good') 
from dual; /*오른쪽의 d를 삭제하므로 결과 ood출력*/
 
 
select trim(both 'g' from 'good') 
from dual; /*양쪽의 g를 삭제하므로 결과 ood출력*/
 
 
 
/* ASCII(char) : ASCII코드 값 반환 */
 
select ascii('A') 
from dual;
 
 
/* Instr(string,src_str,pos,occur) : 특정 문자열의 위치를 찾아 반환 */
 
select instr('good morning john','or',1) 
from dual;
 
 
select instr('good morning john','n', 1,3) 
from dual;
 
 
 
/* Length(char) : 문자열 길이 반환 */
 
select length('good') 
from dual;
 
 
  cs


반응형
저작자표시 비영리 변경금지

'프로그래밍 > SQL' 카테고리의 다른 글

[Oracle SQL] 날짜함수  (0) 2017.08.06
[Oracle SQL] 숫자함수  (0) 2017.08.04
[Oracle SQL] Select 문 And,OR, NOT, BETWEEN  (0) 2017.07.29
[Oracle SQL] 토드 설치  (0) 2017.07.29
[SQL] 기초함수 예제  (0) 2017.07.07
반응형






1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
select * from tab;
 
 
select * from employees;
 
 
 
select employee_id, last_name 
from employees 
where last_name= 'Smith';
 
 
desc employees; 
 
 
select employee_id, salary 
from employees 
where last_name='Smith';
 
 
 
select employee_id, first_name, salary 
from employees 
where last_name='Smith';
 
 
 
select employee_id as "종업원", salary as "SAL" 
from employees;
 
 
 
select employee_id "ID", salary "SAL" 
from employees;
 
 
 
select employee_id "종업원", salary "연봉" 
from employees 
where last_name='Smith';
 
 
 
select distinct JOB_ID 
from employees;
 
 
 
select first_name, last_name, salary 
from employees 
where salary >= 5000;
 
 
 
select first_name, last_name, hire_date 
from employees 
where hire_date >= '04/01/01';
 
 
 
/* AND */
 
select first_name, last_name, job_id, department_id 
from employees
where department_id = 50 and job_id = 'SH_CLERK';
 
 
 
select first_name, last_name, department_id, manager_id 
from employees
where department_id = 50 and manager_id = 124;
 
 
 
/* OR */
 
select first_name, last_name, department_id, manager_id 
from employees
where department_id = 50 or manager_id = 124;
 
 
 
 
/* NOT */
 
select first_name, last_name, job_id, department_id 
from employees
where not (department_id =50);
 
 
 
select first_name, last_name, job_id, department_id 
from employees
where department_id <>40;
 
 
 
/* salary 4000 ~ 8000*/
select first_name, last_name, salary 
from employees 
where salary >= 4000 and salary <= 8000;
 
 
 
/* BETWEEN */
select first_name, last_name, salary 
from employees 
where salary between 4000 and 8000;
 
 
 
/* salary 4000 ~ 8000 END*/
select first_name, last_name, salary 
from employees 
where salary = 6500 or salary = 7700 or salary = 13000;
 
 
 
select first_name, last_name, salary 
from employees 
where salary in (6500, 7700, 13000);
 
 
select first_name, last_name 
from employees
where first_name like 'D%';
 
select first_name, last_name from employees
where first_name like '%d';
 
cs


반응형
저작자표시 비영리 변경금지

'프로그래밍 > SQL' 카테고리의 다른 글

[Oracle SQL] 숫자함수  (0) 2017.08.04
[Oracle SQL] 문자 함수  (0) 2017.08.03
[Oracle SQL] 토드 설치  (0) 2017.07.29
[SQL] 기초함수 예제  (0) 2017.07.07
[SQL] 기초함수 1  (0) 2017.07.06
반응형







1. 토드월드 접속

https://www.toadworld.com/ 


2. downloads 접속


3. Toad for Oracle 선택


4. OS에 맞는 것 선택


5. Download


====

1) Equal Join (두 개의 테이블 데이터 row가 동일 할 경우 사용)


select e.ename, d.dname

from emp e, dept d

where e.deptno = d.deptno;




====


select * from dept;

=


select * from emp where deptno=10;

=



2) Non-Equal Join (​범위에 대한 Join)


select * from salgrade;

=


select ename, sal from emp where rownum <5;

=


select e.ename, e.sal, s.grade

from emp e, salgrade s

where e.sal between s.losal and s.hisal;


두 개의 테이블 데이터 중 where이하에 있는 e.sal의 데이터 값이 s.losal과 s.hisal의 범위에 알맞은 s.grade를 출력하라는 의미


=====


3) Outer Join (두개의 테이블 row가 같지 않을 경우 사용)


select e.ename, d.deptno, d.dname from emp e, dept d

where e.deptno (+) = d.deptno;


테이블 row가 부족한 부분에 (+)를 붙임


=====


4) Self Join (하나의 테이블 내에서 두 개의 컬럼데이터가 동일한 데이터를 가지고 있을 때 사용)


select empno, ename, job, mgr from emp;

=


select a.ename || '의 상사는 ' || b.ename ||' 이다. ' as 직속상사관계

from emp a, emp b

where a.mgr = b.empno;



===

(연습문제)

select * from emp;

select * from dept;


1. 사원 테이블에서 사원번호, 사원명, 부서번호 출력 ( 5개)

select empno, ename, deptno from emp where rownum < 6;


2.

select empno, ename, deptno from emp order by sal desc;


3.

select empno, ename, comm from emp where job='SALESMAN' and comm is not null;


4.

select ename, sal, hiredate from emp;


5.

select ename, sal, to_char(hiredate,'yyyy-mm-dd') hh from emp;


6.

select empno, ename, deptno from emp where to_char(hiredate,'yyyy') = '1980'


7.

select ename||'('||empno||')' from emp where ename='SMITH'


8.

select e.empno, e.ename, d.dname, e.hiredate from emp e join dept d on e.deptno = d.deptno


9.

select * from emp where deptno = (select deptno from emp where ename='SMITH')


10.

select * from emp where deptno = (select deptno from emp where ename='SMITH') and sal>(select sal from emp where ename='SMITH') 


11.

select ename,deptno,sal from emp where sal = (select max(sal) from emp where deptno = (select deptno from emp where ename='SMITH'))



12.

select b.* from 
    (select rownum rn, a.* from 
        (select ename, sal from emp order by sal desc) a
    ) b
where rn <=5;


13.
select b.* from 
    (select rownum rn, a.* from 
        (select ename, sal from emp order by sal desc) a
    ) b
where 4<rn and rn<11;


14.
select ename from emp where ename like '%S$_%' escape '$';

=======


select ename,sal from emp where rownum < 5;

select ename,sal from emp order by sal desc;

select rownum, ename, sal from emp;

select rownum, ename, sal from emp where rownum <= 5;

select rownum, ename, sal from emp where rownum <5 order by sal desc;

select rownum, ename, sal from emp order by sal desc;

select rownum, ename, sal from emp where rownum >2 ;


select rownum rn, a.* from (select rownum rn, ename, sal from emp) a where rn > 2;


반응형
저작자표시 비영리 변경금지

'프로그래밍 > SQL' 카테고리의 다른 글

[Oracle SQL] 숫자함수  (0) 2017.08.04
[Oracle SQL] 문자 함수  (0) 2017.08.03
[Oracle SQL] Select 문 And,OR, NOT, BETWEEN  (0) 2017.07.29
[SQL] 기초함수 예제  (0) 2017.07.07
[SQL] 기초함수 1  (0) 2017.07.06
반응형

           

  JAVA Study







6. 추상클래스 (abstract class)


- 미완성 메서드(추상메서드)를 포함한 미완성 클래스 (추상메서드가 없어도 키워드를 붙여 추상클래스로 지정 가능)


- 추상클래스 자체로는 클래스로서의 역할을 다하지 못함, but 새로운 클래스를 작성할 때 바탕이 되는 조상클래스로서 중요한 의미를 가짐


- 추상클래스는 키워드 abstract를 붙이기만 하면 됨


- 추상클래스에도 생성자는 존재, 멤버변수와 메서드도 가질 수 있음


- 추상메서드 없이 완성된 클래스여도 추상클래스로 지정되면 클래스의 인스턴스를 생성할 수 없음


- 추상 메서드 

: 선언부만 작성하고 구현부는 작성하지 않은 메서드

: 실제 내용은 상속받는 클래스에서 구현하도록 비워둠

: 키워드 abstract를 앞에 붙여줌, 구현부가 없으므로 {}대신 ;을 붙임

: 추상클래스를 상속받은 자손클래스에서 오버라이딩을 통해 추상클래스의 추상메서드들을 모두 구현해야 함

- 만약 하나라도 구현하지 않으면 자손클래스역시 추상클래스로 지정해주어야 함


- 추상클래스 작성

: 여러 클래스에 공통적으로 사용될 수 있는 클래스를 바로 작성

: 기존 클래스의 공통 부분을 뽑아 조상클래스를 만듦

: 추상화 - 클래스간의 공통점을 찾아내 공통의 조상을 만드는 작업

: 구체화 - 상속을 통해 클래스를 구현, 확장하는 작업



7. 인터페이스 (interface)


- 일종의 추상클래스, 추상메서드를 갖지만 추상클래스보다 추상화정도가 높아 추상클래스와달리 몸통을 갖춘 일반 메서드 또는 멤버변수를 구성원으로 가질 수 없음


- 오직 추상메서드와 상수만을 멤버로 가질 수 있으며, 그 외의 다른 어떠한 요소도 허용하지 않음


- 인터페이스 작성

: 인터페이스를 작성하는 것은 클래스 작성과 같다, 키워드로 class 대신 interface를 사용한다

: 접근제어자로 public 또는 default를 사용할 수 있다.


interface 인터페이스 이름 {

public static final 타입 상수이름 = 값;

public abstract 메서드이름(매개변수목록);

}


: 인터페이스 제약사항

- 모든 멤버변수는 public static final 이어야하며, 이를 생략할 수 없음

- 모든 메서드는 public abstract 이어야하며, 이를 생략할 수 없음 (단, static메서드와 default메서드 제외)


- 인터페이스 상속

: 인터페이스는 인터페이스로부터만 상속받을 수 있음, 다중상속 가능

: 자손 인터페이스는 조상 인터페이스에 정의된 멤버를 모두 상속받음


- 인터페이스 구현

: 그 자체로는 인스턴스생성할 수 없음 -> 인터페이스를 구현하는 클래스를 작성해야 함 

: implements를 사용해 구현하는 인터페이스의 메서드 중 일부만 구현한다면 abstract를 붙여서 추상클래스로 정의해야 함

: 상속 (extends)과 구현(implements)을 동시에 할 수 있음


class Fighter extends Unit implements Fightable{

}


- 인터페이스를 이용한 다중상속

: 인터페이스는 static상수만 정의할 수 있으므로 조상클래스의 멤버변수와 충돌하는 경우는 거의 없고 충돌된다 하더라도 클래스 이름을 붙여서 구분이 가능함


- 인터페이스를 이용한 다형성

: 인터페이스 타입의 참조변수로 이를 구현한 클래스의 인스턴스를 참조할 수 있으며, 인터페이스 타입으로 형변환 가능

: 인터페이스 타입의 매개변수가 갖는 의미는 메서드 호출 시 해당 인터페이스를 구현한 클래스의 인스턴스를 매개변수로 제공해야 한다는 것

: 리턴타입이 인터페이스라는 것은 메서드가 해당 인터페이스를 구현한 클래스의 인스턴스를 반환한다는 것을 의미


package apple;


interface Parseable{

// 구문 분석작업을 수행

public abstract void parse(String fileName);

}


class ParserManager{

// 리턴타입이 Parseable인터페이스

public static Parseable getParser(String type){

if(type.equals("XML")){

return new XMLParser();

} else{

Parseable p = new HTMLParser();

return p;

//return new HTMLParser();

}

}

}


class XMLParser implements Parseable{

public void parse(String fileName){

//구문 분석 작업을 수행하는코드를 적는다.

System.out.println(fileName+"- XML parsing completed.");

}

}


class HTMLParser implements Parseable{

public void parse(String fileName){

//구문 분석 작업을 수행하는 코드를 적는다.

System.out.println(fileName+"-HTML parsing completed.");

}

}

public class ParserTest {


public static void main(String[] args) {

Parseable parser = ParserManager.getParser("XML");

parser.parse("document.xml");

parser = ParserManager.getParser("HTML");

parser.parse("document2.html");

}


}


: Parseable인터페이스는 구문분석(parsing)을 수행하는 기능을 구현할 목적으로 추상메서드 'parse(String fileName)'을 정의

: XMLParser클래스와 HTMLParser클래스는 Parseable인터페이스를 구현

: 매개변수로 넘겨받은 타입값에 따라 XMLParser인스턴스 또는 HTMLParse인스턴스를 반환


- 인터페이스의 장점

: 개발시간 단축

: 표준화 가능

: 서로 관계없는 클래스들에게 관계를 맺어줄 수 있음

: 독립적인 프로그래밍 가능


- 인터페이스의 이해

: 클래스를 사용하는 쪽(User)과 클래스를 제공하는 쪽(Provider)이 있다.

: 메서드를 사용(호출)하는 쪽(User)에서 사용하려는 메서드(Provider)의 선언부만 알면된다.(내용은 몰라도 됨)


- 디폴트 메서드와 static메서드
: 디폴트 메서드
- 추상메서드의 기본적인 구현을 제공하는 메서드
- 추상메서드가 아니기 때문에 디폴트메서드가 추가되어도 해당 인터페이스를 구현한 클래스를 변경하지 않아도 됨
- 여러 인터페이스의 디폴트 메서드간 충돌
: 인터페이스를 구현한 클래스에서 디폴트 메서드를 오버라이딩
- 디폴트 메서드와 조상 클래스의 메서드 간 충돌
: 조상 클래스의 메서드가 상속되고, 디폴트 메서드는 무시

8. 내부클래스 (inner class)


- AWT나 Swing같은 GUI어플리케이션의 이벤트처리 외에는 잘 사용하지 않음


- 클래스 내에 선언된 클래스

: 두 클래스가 긴밀한 관계이기 때문에 내부에 선언


- 내부클래스 장점

: 내부 클래스에서 외부 클래스의 멤버들을 쉽게 접근할 수 있음

: 코드의 복잡성을 줄일 수 있음 (캡슐화)


- 내부클래스의 종류와 특징

: 변수의 선언위치에 따른 종류와 같음

: 인스턴스 클래스

- 외부 클래스의 멤버변수 선언위치에 선언

- 외부 클래스의 인스턴스멤버처럼 다루어짐

- 외부클래스의 인스턴스멤버들과 관련된 작업에 사용될 목적으로 선언

: static 클래스

- 외부 클래스의 멤버변수 선언위치에 선언

- 외부 클래스의 static멤버처럼 다루어짐

- 외부 클래스의 static멤버, 특히 static메서드에서 사용될 목적으로 선언

: 지역 클래스

- 외부 클래스의 메서드나 초기화블럭 안에 선언

- 선언된 영역 내부에서만 사용될 수 있음

: 익명 클래스

- 클래스 선언과 객체의 생성을 동시에 하는 이름없는 클래스 (일회용)


- 내부 클래스의 선언

: 변수의 선언위치와 동일한 위치에 선언

: 각 선언위치에 따라 같은위치의 변수와 동일한 유효범위, 접근성을 가짐


- 내부 클래스 제어자와 접근성

: 변수와 동일

: 내부 클래스 중 static클래스만 static멤버를 가질 수 있음


- 익명 클래스 

: 이름이 없음

: 클래스의 선언과 객체 생성을 동시에 하기 때문에 단 한번만 사용될 수 있고, 오직 하나의 객체만 생성할 수 있는 일회용 클래스

: 이름이 없으므로 생성자도 가질 수 없음

: 조상클래스의 이름이나 구현하고자 하는 인터페이스의 이름을 사용해서 정의하기 때문에 하나의 클래스로 상속받는 동시에 인터페이스를 구현하거나 둘 이상의 인터페이스를 구현할 수 없음

: 이름이 없기 때문에 '외부 클래스명 $숫자.class'의 형식으로 클래스파일명이 결정됨

반응형
저작자표시 비영리 변경금지

'프로그래밍 > JAVA' 카테고리의 다른 글

[JAVA] 7 객체지향 프로그래밍 2-2  (0) 2017.07.21
[JAVA] 7 객체지향 프로그래밍 2-1  (0) 2017.07.11
[JAVA] 6 객체지향 프로그래밍1  (0) 2017.07.05
[JAVA] 배열 예제  (0) 2017.07.04
[JAVA] 5 배열 (Array)  (0) 2017.07.03
반응형

           

  JAVA Study






3. package와 import


- 패키지란 클래스의 묶음이다

: 클래스 또는 인터페이스를 포함시킬 수 있음

: 서로 관련된 클래스들끼리 그룹 단위로 묶어놓음으로써 클래스를 효율적으로 관리할 수 있음

: 패키지는 물리적으로 하나의 디렉토리

: 하나의 소스파일에 첫 번째 문장으로 단 한 번의 패키지 선언을 허용

: 모든 클래스는 반드시 하나의 패키지에 속함

: 패키지는 점(.)을 구분자로하여 계층구조로 구성가능

: 클래스 파일(.class)을 포함하는 하나의 디렉토리


- 패키지 선언

package 패키지명;

: 패키지명은 대소문자를 모두 허용하지만 클래스명과 구분하기 위해 소문자를 사용

: 모든 클래스는 반드시 하나의 패키지에 포함되어야 함, 패키지를 선언하지 않을 경우 기본으로 제공되는 'unnamed package'에 속함


- import 문

: 사용하고자 하는 클래스의 패키지를 미리 명시해줌

: 컴파일러에게 소스파일에 사용된 클래스의 패키지에 대한 정보를 제공


- import문 선언

:한 소스파일에 여러 번 선언 가능

import 패키지명.클래스명;

import 패키지명.*; // '*'은 패키지에 속하는 모든 클래스를 의미함


- static import문

: static 멤버를 호출할 때 클래스 이름을 생략할 수 있음

: 특정 클래스의 static멤버를 자주 사용할 때 편리

import static java.lang.Integer.*;  // Integer 클래스의 모든 static메서드


4. 제어자 (modifier)


- 제어자는 클래스, 변수, 메서드 선언부에 함께 사용되어 부가적 의미를 부여


- 접근 제어자와 그 외의 제어자로 구분

: 접근 제어자 - public / protected / default / private

: 그 외 제어자 - static / final / abstract / native / transient / synchronized / volatile / strictfp


- 하나의 대상에 대해 여러 제어자를 조합하여 사용 가능


- 접근 제어자는 한 번에 하나만 선택해서 사용가능


- static ( 클래스의, 공통적인 )
: 클래스변수는 인스턴스에 관계없이 같은 값을 가짐
: 하나의 변수를 모든 인스턴스가 공유
: static이 붙은 멤버변수와 메서드, 초기화 블럭은 인스턴스가 아닌 클래스에 관계된 것이므로 인스턴스를 생성하지 않고 사용 가능
: 인스턴스 메서드와 static 메서드의 근본적인 차이는 메서드 내에서 인스턴스 멤버를 사용하는가의 여부에 있음
: 멤버변수 / 메서드 / 초기화 블럭에서 사용 가능

- final ( 마지막의, 변경될 수 없는 )
: 거의 모든 대상에 사용될 수 있음 ( 클래스 / 메서드 / 멤버변수 / 지역변수 )
: 변수에 사용되면 값을 변경할 수 없는 상수가 됨
: 메서드에 사용되면 오버라이딩을 할 수 없게 됨
: 클래스에 사용되면 자신을 확장하는 자손 클래스를 정의할 수 없음
: 생성자를 이용한 final 멤버 변수의 초기화
- final이 붙은 변수는 상수이므로 일반적으로 선언과 초기화를 동시에 함
- 인스턴스변수의 경우 생성자에서 초기화 되도록 할 수 있음
: 클래스 내에 매개변수를 갖는 생성자를 선언하여, 인스턴스를 생성할 때 final이 붙은 멤버변수를 초기화하는데 필요한 값을 생성자의 매개변수로부터 제공받는 것

- abstract ( 추상의, 미완성의 )
: 메서드의 선언부만 작성하고 실제 수행내용은 구현하지 않음
: 클래스 / 메서드에서 사용 가능
: 클래스 - 클래스 내에 추상 메서드가 선언되어 있음을 의미
: 메서드 - 선언부만 작성하고 구현부는 작성하지 않은 추상 메서드임을 알림
: 추상 클래스는 아직 완성되지 않은 메서드가 존재하기 때문에 인스턴스를 생성할 수 없음
: 추상 클래스만으로는 쓸모가 없지만 다른 클래스가 이 클래스를 상속받아서 오버라이딩해 사용함

- 접근 제어자 ( access modifier )
: 멤버, 클래스에 사용되어 해당 멤버 또는 클래스를 외부에서 접근하지 못하도록 제한하는 역할을 함
: 클래스 / 멤버변수 / 메서드 / 생성자에서 사용됨
: private - 같은 클래스 내에서만 접근 가능
: default - 같은 패키지 내에서만 접근 가능
: protected - 같은 패키지 내에서, 그리고 다른 패키지의 자손 클래스에서 접근이 가능
: public - 접근 제한 없음
: public > protected > default > private

- 접근 제어자를 이용한 캡슐화
: 접근제어자를 사용하는 이유는 클래스의 내부에 선언된 데이터를 보호하기 위해서이다.
- 외부로부터 데이터 보호
- 외부에 불필요한, 내부적으로만 사용되는 부분을 감추기 위해
: 데이터 감추기 (data hiding) - 데이터가 유효한 값을 유지하도록 또는 비밀번호와 같은 데이터를 외부에서 함부로 변경하지 못하도록 하기 위해 외부로부터의 접근을 제한하는 것 => 객체지향의 캡슐화
: 클래스 내에서만 사용되는, 내부 작업을 위해 임시로 사용되는 멤버변수나 부분작업을 처리하기 위한 메서드 등의 멤버들을 클래스 내부에 감추기 위해

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Time {
    private int hour;    // 접근 제어자를 private으로 하여 외부에서 직접 접근 불가
    private int minute;
    private int second;
 
    public int getHour() {
        return hour;
    }
    public void setHour (int Hour) {
        if (Hour <0 ||  Hour > 23) return;
        this.hour = hour;
    }
 
    public int getMinute() {
        return Minute;
    }
    public void setMinute (int minute) {
        if (minute<0 ||  minute> 23) return;
        this.minute= minute;
    }
 
    public int getSecond() {
        return second;
    }
    public void setHour (int second) {
        if (second<0 ||  second> 23) return;
        this.second= second;
    }
}
cs


- getter 
: get으로 시작하는 메서드는 멤버변수의 값을 반환하는 일
: 멤버변수의 값을 읽는 메서드의 이름을 'get멤버변수 이름'으로 작성

- setter
: set으로 시작하는 메서드는 매개변수에 지정된 값을 검사하여 조건에 맞으면 멤버변수 값을 변경
: 멤버변수의 값을 변경하는 메서드의 이름을 'set멤버변수 이름'으로 작성

- 생성자의 접근 제어자
: 생성자에 접근 제어자를 사용함으로 인스턴스 생성을 제한할 수 있음
: 보통 생성자의 접근제어자는 클래스의 접근제어자와 같지만 다르게 사용할 수 있음
: 생성자가 private인 클래스는 다른 클래스의 조상이 될 수 없다
- 자손클래스의 인스턴스 생성 시 조상클래스의 생성자를 호출해야하는데 private이므로 호출이 불가하기 때문
: 따라서 생성자가 private인 클래스 앞에 final을 붙여 상속할 수 없는 클래스임을 알리는 것이 좋다

- 제어자 조합
: 메서드에 static과 abstract를 함께 사용할 수 없음
- static 메서드는 몸통이 있는 메서드에만 사용할 수 있음
: 클래스에 abstract와 final을 동시에 사용할 수 없음
- 클래스에 사용되는 final은 클래스를 확장할 수 없다는 의미, abstract는 상속을 통해서 완성되어야 한다는 의미이기 때문
: abstract메서드의 접근제어자가 private일 수 없음
- abstract메서드는 자손클래스에서 구현해 주어야 하는데 접근제어자가 private이면, 자손클래스에서 접근할 수 없기 때문
: 메서드에 private과 final을 같이 사용할 필요 없음
- 접근 제어자가 private인 메서드는 오버라이딩 될 수 없기 때문, 둘 중 하나만 사용해도 의미 충분히 전달됨

5. 다형성 (polymorphism)


- 상속과 깊은 관계가 있음

- 여러가지 형태를 가질 수 있는 능력을 의미

- 한 타입의 참조변수로 여러 타입의 객체를 참조할 수 있도록 함으로써 다형성을 구현

: 조상클래스 타입의 참조변수로 자손클래스의 인스턴스를 참조할 수 있도록 하는 것


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Car{
    String color;    
    int door;    
 
    void drive() {    // 운전하는 기능
        System.out.println("drive, Brrr");
    }
    void stop() {    // 멈추는 기능
        System.out.println("stop!!");
    }
 
}
 
class FireEngine extends Car{    //소방차
    void drive() {    // 소방차운전
        System.out.println("drive,fire!!");
    }
}
 
 
class Ambulance extends Car{
    void siren() {    // 사이렌 울리는 기능
        System.out.println("siren!!");
    }
}
 
cs




: 인스턴스 타입과 참조변수 타입이 일치하는 것이 보통이지만 클래스가 서로 상속관계에 있을 경우 조상클래스 타입의 참조변수로 자손 클래스의 인스턴스를 참조하도록 하는 것도 가능하다


FireEngine e = new FireEngine();

car c = new FireEngine();       // 조상 타입의 참조변수로 자손 인스턴스를 참조

=> 자손의 인스턴스를 참조하므로 c.drive()의 결과는 drive, fire이 된다.

=> 둘 다 같은 타입의 인스턴스지만 참조변수의 타입에 따라 사용할 수 있는 멤버의 개수가 달라짐





반응형
저작자표시 비영리 변경금지

'프로그래밍 > JAVA' 카테고리의 다른 글

[JAVA] 7 객체지향 프로그래밍 2-3  (0) 2017.07.22
[JAVA] 7 객체지향 프로그래밍 2-1  (0) 2017.07.11
[JAVA] 6 객체지향 프로그래밍1  (0) 2017.07.05
[JAVA] 배열 예제  (0) 2017.07.04
[JAVA] 5 배열 (Array)  (0) 2017.07.03
반응형

           

  JAVA Study





1. 상속 (inheritance)


- 기존 클래스를 재사용하여 새로운 클래스를 작성하는 것 


- 보다 적은 양의 코드로 새로운 클래스 작성 가능 & 코드를 공통적으로 관리할 수 있기 때문에 코드의 추가 및 변경이 매우 용이


- 새로 작성하고자 하는 클래스 이름 뒤에 상속받고자 하는 클래스의 이름을 키워드 'extends'와 함께 써줌


class child extends parent{

// parent 클래스를 상속받은 child 클래스

}


- 상속해주는 클래스를 조상클래스, 상속 받는 클래스를 자손클래스라고 함

: 조상클래스 - 부모 클래스, 상위클래스, 기반 클래스

: 자손클래스 - 자식 클래스, 하위클래스, 파생된 클래스


- 자손 클래스는 조상 클래스의 모든 멤버를 상속 받음

: child 클래스는 parent 클래스의 모든 멤버들을 포함

: child 클래스에 새로운 코드가 추가되어도 조상인 parent클래스는 아무 영향을 받지 않음

: 자손클래스는 조상 클래스의 모든 멤버를 상속받으므로 항상 조상 클래스보다 같거나 많은 멤버를 갖음


- 생성자와 초기화 블럭은 상속되지 않음, 멤버만 상속


- 자손 클래스의 멤버 개수는 조상 클래스보다 항상 같거나 많음


class parent { }

class child extends parent { }

class child2 extends parent { }


: child와 child2클래스 모두 parent클래스를 상속받음

: 클래스 간 관계에서 형제관계는 없음

: child와 child2 클래스에 공통적으로 추가되어야 하는 멤버변수나 메서드가 있다면 공통조상인 parent에 작성


class parent { }

class child extends parent { }

class grandchild extends child{ }


: 자손 클래스는 조상 클래스의 모든 멤버를 물려받으므로 grandchild클래스는 child 클래스의 모든 멤버, child클래스의 조상인 parent 클래스로부터 상속받은 멤버까지 상속받게 됨

: grandchild 클래스는 child의 자손이면서 parent의 자손이기도 함

: child클래스는 grandchild클래스의 직접조상, parent 클래스는 grandchild 클래스의 간접 조상이 됨

: parent클래스에 변수를 추가하면 parent를 상속받고 있는 child, grandchild클래스에 변수가 공통적으로 추가됨


- 자손 클래스의 인스턴스를 생성하면 조상 클래스의 멤버도 함께 생성되므로 따로 조상클래스의 인스턴스를 생성하지 않아도 조상클래스의 멤버들을 사용할 수 있음


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class Tv{
    boolean power; //전원상태 on/off
    int channel; //채널
    
    void power(){
        power = !power;
    }
    
    void channelUp(){
        ++channel;
    }
    
    void channelDown(){
        --channel;
    }
    
}
 
class CaptionTv extends Tv{
    boolean caption; //캡션상태 on/off
    void displayCaption (String text){
        if(caption){ //캡션 상태가 on(true)일 때만 text를 보여준다.
            System.out.println(text);
        }
    }
}
 
public class CaptionTvTest{
 
    public static void main(String[] args) {
    
        CaptionTv t = new CaptionTv(); //자손 클래스의 인스턴스를 생성하면 조상클래스의 변수와 메서드를 사용할 수 있다.
        
        t.channel = 10;   // 조상 클래스에서 상속받은 멤버
        t.channelUp();      // 조상 클래스에서 상속받은 멤버 
        System.out.println(t.channel); // channel은 11
        
        t.displayCaption("Hello world1"); // 캡션 상태가 on이 아니므로 출력되지 않음
        t.caption = true;
        t.displayCaption("Hello world2"); // Hello world2 출력
    }
}
cs


- 클래스간의 관계 (포함관계)

: 클래스 간에 포함관계를 맺어 상속외에 클래스를 재사용하는 방법

: 한 클래스의 멤버변수로 다른 클래스 타입의 참조변수를 선언하는 것을 뜻함


1
2
3
4
5
6
7
8
9
10
class Circle{
    int x;    // 원점의 x좌표
    int y;    // 원점의 y좌표
    int r;    // 반지름
}
 
class Point{
    int x;    // x좌표
    int y;    // y좌표
}
cs


: Point 클래스를 재사용해서 Circle 클래스를 작성


1
2
3
4
5
6
7
8
9
class Circle{
    Point c = new Point(); //원점
    int r;    // 반지름
}
 
class Point{
    int x;    // x좌표
    int y;    // y좌표
}
cs
   

- 클래스간의 관계 결정하기

: 상속관계를 맺을 지, 포함관계를 맺을지 결정

- ~은 ~이다. : 상속관계

- ~은 ~을 가지고 있다. : 포함관계

ex. 원은 점이다 / 원은 점을 가지고 있다. => 원은 점을 가지고 있다가 더 자연스러우므로 포함관계를 맺는 것이 옳다


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
class DrawShap{
    public static void main(String args[]){
        Point[] p = {
                new Point(100,100),
                new Point(140,50),
                new Point(200,100)
        };
        
        Triangle t = new Triangle(p);
        Circle c = new Circle(new Point(150,150),50);
        
        t.draw(); //삼각형을 그린다
        c.draw(); //원을 그린다
    }
}
 
class Shap{
    String color="black";
    void draw(){
        System.out.print("color = "+color);
    }
}
 
class Point{
    int x;
    int y;
    
    Point(int x, int y){
        this.x = x;
        this.y = y;
    }
    Point(){
        this(0,0);
    }
    String getXY(){
        return "("+x+","+y+")"; //x와 y의 값을 문자열로 반환
    }
}
 
class Circle extends Shape{
    Point center;
    int r;
    
    Circle(){
        this(new Point(0,0),100); // Circle(Point center,int r)를 호출
    }
    
    Circle(Point Center, int r){
        this.center =center;
        this.r = r;
    }
    
    void draw(){ //원을 그리는 대신에 원의 정보를 출력하도록 했다.
        System.out.print("");
    }
}
 
class Triangle extends Shape {
    Point[] p = new Point[3];
    
    Triangle(Point[] p){
        this.p = p;
    }
    
    void draw(){
         System.out.print("[p1]=("+p[0].getXY()+"), [p2]=("+p[1].getXY()+"), [p3]=("+p[2].getXY()+")");
    }
    
}
 
 
 
 
cs



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
package apple2;
 
public class DectTest {
 
    public static void main(String[] args) {
        Deck d = new Deck(); // 카드 한 벌 만듦
        Card c = d.pick(0);  // 섞기 전 제일 위의 카드를 뽑는다.
        System.out.println(c); //뽑은 카드 확인
        
        d.shuffle(); // 카드를 섞음
        c = d.pick(0); // 섞은 후 제일 위의 카드를 뽑는다.
        System.out.println(c); //뽑은 카드 확인
    }
}
 
class Deck{
    final int CARD_NUM =52; // 카드의 개수
    Card cardArr[] = new Card[CARD_NUM]; // Card 객체 배열 포함
    
    Deck(){ // Deck의 카드를 초기화
        int i=0;
        
        for(int k=Card.KIND_MAX; k>0; k--){
            for(int n=0; n<Card.NUM_MAX; n++){
                cardArr[i++] = new Card(k, n+1);
            }
        }
    }
    
    Card pick(int index){    // 지정된 위치에 있는 카드 하나를 꺼내서 반환
        return cardArr[index];
    }
    
    Card pick(){ // Deck에서 카드하나 선택
        int index = (int)(Math.random() * CARD_NUM);
        return pick(index);
    }
    
    void shuffle(){ // 카드의 순서를 섞는다
        for(int i=0; i<cardArr.length; i++){
            int r = (int)(Math.random() * CARD_NUM);
            
            Card temp = cardArr[i];
            cardArr[i] = cardArr[r];
            cardArr[r] = temp;
        }
    }
    
}
 
class Card{
    static final int KIND_MAX = 4; // 카드 무늬의 수
    static final int NUM_MAX = 13; // 무늬별 카드 수
    
    static final int SPADE = 4;
    static final int DIAMOND = 3;
    static final int HEART = 2;
    static final int CLOVER = 1;
    
    int kind;
    int number;
    
    Card() {
        this(SPADE,1);
    }
    
    Card(int kind, int number){
        this.kind = kind;
        this.number = number;
    }
    
    public String toString(){
        String[] kinds = {"","CLOVER","HEART","DIAMOND","SPADE"};
        String numbers = "0123456789XJQK"; //숫자10은 X로 표현
        
        return "kind : "+kinds[this.kind] + ", number : "+numbers.charAt(this.number);
    }
}
cs



- 단일 상속 (Single inheritance)

: 자바는 단일상속만을 허용한다 -> 하나 이상의 클래스로부터 상속받을 수 없음


- Object 클래스 - 모든 클래스의 조상

: Object 클래스는 모든 클래스 상속계층도의 최상위에 있는 조상클래스

: 다른 크랠스로부터 상속 받지 않는 모든 클래스들은 자동적으로 Object클래스로부터 상속받게 함

: 모든 클래스의 조상이 되는 클래스

: 만일 다른 클래스를 상속받더라도 상속계층도를 따라 조상클래스를 올라가다보면 마지막 최상위 조상은 Object클래스임



2. 오버라이딩 (overriding)


- 조상 클래스로부터 상속받은 메서드의 내용을 변경하는 것


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Point {
    int x;
    int y;
 
    String getLocation() {
        return "x : "+x + "y : "+y;
    }
}
 
class Point3D extends Point {
    int z;
    
    String getLocation() {
        return "x : "+x+", y : "+y+", z : "+z;
    }
}
cs

 

: Point 클래스의 getLocation() 은 한 점의 x,y좌표를 문자열로 반환하도록 작성되었다.

: 이 두 클래스는 서로 상속관계에 있으므로 Point3D클래스는 Point 클래스로부터 getLocation()을 상속받은 후 자신에 맞게 z축의 좌표를 포함하여 반환하도록 오버라이딩 하였다


- 오버라이딩 조건

: 자손클래스에서 오버라이딩하는 메서드는 조상 클래스의 메서드와 이름 / 매개변수 / 반환타입이 같아야 한다

: 선언부가 서로 일치해야 함

: 접근 제어자와 예외는 제한된 조건 하에서만 다르게 변경할 수 있음

- 접근 제어자는 조상 클래스의 메서드보다 좁은 범위로 변경할 수 없음

- 조상 클래스의 메서드보다 많은 수의 예외를 선언할 수 없음

- 인스턴스메서드를 static메서드로 또는 그 반대로 변경할 수 없음


- 오버로딩 vs 오버라이딩

: 오버로딩 (overloading) - 기존에 없는 새로운 메서드를 정의하는 것(new)

: 오버라이딩(overriding) - 상속받는 메서드의 내용을 변경하는 것(change, modify)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Point {
    int x;
    int y;
 
    String getLocation() {
        return "x : "+x + "y : "+y;
    }
}
 
class Point3D extends Point {
    int z;
    
    String getLocation() { //
        return "x : "+x+", y : "+y+", z : "+z;
    }
    String getLocation(int i){ //오버로딩
    }
}
cs



- super

: 자손클래스에서 조상 클래스로부터 상속받은 멤버를 참조하는데 사용되는 참조변수

: 멤버변수와 지역변수의 이름이 같을 때 this를 붙여서 구별했듯이 상속받은 멤버와 자신의 클래스에 정의된 멤버의 이름이 같을 때 super를 붙여서 구별할 수 있음

: 조상 클래스로 상속받은 멤버도 자손 클래스의 멤버이므로 super대신 this를 사용할 수 있음

: 조상 클래스의 멤버와 자손클래스의 멤버가 중복 정의되어 서로 구별해야하는 경우에만 super를 사용하는 것이 좋음

: 모든 인스턴스변수에는 자신이 속한 인스턴스 주소가 지역변수로 저장되는데, 이것이 참조변수인 this와 super의 값이 됨

: static메서드는 인스턴스와 관련없기때문에 super를 사용할 수 없음  (인스턴스에서만 사용할 수 있음)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Point {
    int x;
    int y;
 
    String getLocation() {
        return "x : "+x + "y : "+y;
    }
}
 
class Point3D extends Point {
    int z;
    
    String getLocation() { //오버라이딩
        return "x : "+x+", y : "+y+", z : "+z;
        return super.getLocation() + ", z : "+z; //조상 메서드 호출
    }
 
}
cs


: 조상클래스의 메서드의 내용에 추가적으로 작업을 덧붙이는 경우 super를 사용해 조상클래스의 메서드를 포함시키는 것이 좋음 

- 후에 조상 클래스의 메서드가 변경되더라도 변경된 내용이 자손클래스의 메서드에 자동적으로 반영될 것이기 때문


- super()

: 조상 클래스의 생성자를 호출하는데 사용됨

: 자손 클래스의 인스턴스를 생성하면, 자손과 조상의 멤버가 모두 합쳐진 하나의 인스턴스가 생성되는데, 이 때 조상 클래스 멤버의 초기화 작업이 수행되어야 함 -> 자손클래스의 생성자에서 조상 클래스의 생성자를 호출

: Object클래스를 제외한 모든 클래스의 생성자의 첫 줄에서 조상클래스의 생성자를 호출, 그렇지 않으면 컴파일러가 생성자의 첫 줄에 'super();'를 자동적으로 생성


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class PointTest {
    public static void main (String args[]) {
        Point3D p3 = new Point3D(1,2,3);
    }
}
 
class Point {
    int x, y;
    
    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    String getLocation() {
        return "x : "+x+", y : "+y;
    }
}
 
class Point3D extends Point {
    int z;
 
    Point3D(int x, int y, int z) {
        super(x,y);    // 조상클래스 생성자 
       // this.x = x;
       // this.y = y;
        this.z = z;
    }
 
    String getLocation() {
        return "x : "+x+", y : "+y+", z : "+z;
    }
}
 
cs






반응형
저작자표시 비영리 변경금지

'프로그래밍 > JAVA' 카테고리의 다른 글

[JAVA] 7 객체지향 프로그래밍 2-3  (0) 2017.07.22
[JAVA] 7 객체지향 프로그래밍 2-2  (0) 2017.07.21
[JAVA] 6 객체지향 프로그래밍1  (0) 2017.07.05
[JAVA] 배열 예제  (0) 2017.07.04
[JAVA] 5 배열 (Array)  (0) 2017.07.03
반응형





 SQL Study





1. 테이블 생성 : 테이블명 (flower) / 컬럼명 (name, color) / 컬럼타입 (문자열, 문자열)


CREATE TABLE flower (

name varchar(50),

color varchar(30)

);


2. 데이터 입력 : rose, red/ rose, yellow / herb, green


INSERT INTO flower (name,color) VALUES ('rose','red');

INSERT INTO flower (name, color) VALUES ('rose','yellow');

INSERT INTO flower (name,color) VALUES ('herb','green');


3. 데이터 수정 : 두 번째 데이터의 색을 pink로 update
 

UPDATE flower SET color = 'pink' WHERE color='yellow';


4. 데이터 삭제 : 세 번째 데이터를 삭제


DELETE FROM flower WHERE name='herb';

반응형
저작자표시 비영리 변경금지

'프로그래밍 > SQL' 카테고리의 다른 글

[Oracle SQL] 숫자함수  (0) 2017.08.04
[Oracle SQL] 문자 함수  (0) 2017.08.03
[Oracle SQL] Select 문 And,OR, NOT, BETWEEN  (0) 2017.07.29
[Oracle SQL] 토드 설치  (0) 2017.07.29
[SQL] 기초함수 1  (0) 2017.07.06
반응형





 SQL Study



- cmd창에서 초기 접속

c:> Mysql -uroot -papmsetup mysql


- 기초함수 익히기


 round

 반올림 값을 구함

 select round(1.58);



abs

 절대 값을 구함

 select abs(-100);



mod

 나눈 나머지 값을 구함

 select mod(35,10);



 least

 주어진 인수 값 중 가장 작은 값을 구함

 select least(1,2,3);



 greatest

 주어진 인수 값 중 가장 큰 값을 구함

 select greatest(1,2,3);



 floor

 주어진 인수 값 보다 크지 않은 최대 정수

 select floor(10.23);



 length

 내용 : 문자열의 길이를 구한다.

 select length('school');



left

 주어진 인수 값(문자)의 왼쪽에서 특정길이 만큼 보여줌

 select left('my school',2);



 right

 주어진 인수 값(문자)의 오른쪽에서 특정길이 만큼 보여줌

 select right('my school',5);



 substring

 지정 위치에서 지정 길이만큼 보여줌

 select substring('my school',4,6);



 concat

 여러 개의 문자열을 이어줌

 select concat('my','sql');



 password

 일반 문자열을 암호화

 select password('mysql');



 lpad

 지정된 길이의 부족한 공간을 왼쪽으로 채우기

 select lpad('mysql',7,'?');



 rpad

 일반 문자열을 암호화

 select rpad('mysql',7,'?');



 lcase

 영문을 소문자로 바꿈

 select lcase('MYSQL');



 ucase

 영문을 대문자로 바꿈

 select ucase('mysql');


- 중요용어정리 ( DML / DCL )


1. DDL (Data Definition Language)

: 데이터 베이스의 스키마 객체를 생성, 변경, 제거, 자료의 버림, 주석을 수행


(1) CREATE


(2) ALTER


(3) DROP


(4) TRUNCATE


(5) COMMENT


2. DML (Data Manipulation Language)

: 스키마 객체의 데이터를 입력, 수정, 조회, 삭제 등의 작업을 말함


(1) SELECT


(2) INSERT


(3) UPDATE


(4) DELETE


3. DCL (Data Control Language)

: 트랜잭션의 성격을 제어하는 것


(1) SET TRANSACTION


(2) COMMIT


(3) ROLLBACK


(4) SAVEPOINT // 작업 위치를 임시로 저장하여 롤백에 사용


- 데이터 형 (데이터 TYPE)

: 숫자 Type M : 최대 출력사이즈, D: 소숫점 자릿수


(1) TINYINT [(M)][UNSINGED]

: 가장 작은 숫자형, 부호에 있을 때 -128~127, 업을 때 0~255 까지 다룰 수 있다. (1 byte 필요) 


(2) SMALLINT[(M)][UNSINGED]

: 부호가 있을 때 -32768 ~ 32767, 없을 때 0~65535 까지 다룰 수 있다. (2 byte 필요)


(3) MEDIUMINT[(M)][UNSINGED]

: 부호가 있을 때 -8388608~ 8388607, 없을 때 0~16777215까지 다룰 수 있다. (3 byte 필요)


(4) INT[(M)][UNSINGED] / (INTEGER)

: 일반적으로 사용하는 숫자형, 부호가 있을 때 -2147483648 ~ 2147483647 (4 byte 필요)


(5) BIGINT[(M)][UNSINGED]

: 부호가 있을 때 -9223372036854775808 ~ 9223372036854775807 (8 byte 필요)


(6) FLOAT[(M,D)]

: 값의 범위는 최소 +-1.175494351E-38, 최대 +-3.402823466E+38 (4 byte 필요)


(7) DOUBLE[(M,D)]

: 값의 범위는 최소 +-1.7976931348623157E-308 (8 byte 필요)


- 문자 TYPE

(1) CHAR


(2) VARCHAR


(3) TINYBLOB / TINYTEXT (255 byte)


(4) TEXT / BLOB (65535 byte)


(5) MEDIUMTEXT (16777215 byte)


(6) LONGTEXT (429496729 byte)


(7) ENUM


- 날짜 TYPE

(1) DATE

: 1001-01-01 부터 9999-12-31 까지의 값이 들어갈 수 있음

: 저장 시 3byte 필요

: 'YYYY-MM-DD' 포맷


(2) DATETIME

: 날짜와 시간이 같이 들어감 '1001-01-01 00:00:00' 부터 '9999-12-31 23:59:59'까지의 값을 다룸

: 저장 시 8 byte 필요

: 'YYYY-MM-DD HH:MM:SS' 포맷

반응형
저작자표시 비영리 변경금지

'프로그래밍 > SQL' 카테고리의 다른 글

[Oracle SQL] 숫자함수  (0) 2017.08.04
[Oracle SQL] 문자 함수  (0) 2017.08.03
[Oracle SQL] Select 문 And,OR, NOT, BETWEEN  (0) 2017.07.29
[Oracle SQL] 토드 설치  (0) 2017.07.29
[SQL] 기초함수 예제  (0) 2017.07.07

+ Recent posts

티스토리툴바