검색결과 리스트
Hello,World?에 해당되는 글 49건
- 2013.07.25 팩토리 메소드 패턴
- 2013.07.25 탬플릿 메소드 패턴
- 2013.07.25 디자인 패턴 2
- 2013.07.10 DATA BASE _ 기초
- 2013.06.12 [JAVA] OOP 다형성 - 오버로딩
- 2013.06.12 [JAVA] OOP Encapsulation 캡슐화
- 2013.06.12 [JAVA] OOP BASIC (객체지향 프로그래밍 기초)
- 2013.06.12 [JAVA] 자바기본2: For, While 문을 이용한 구구단, 별 찍기, 알파벳 출력 등
- 2013.06.11 [JAVA] 자바기본1: 연산자, 형변환, 문자열 출력, if문, 윤년출력
글
템플릿 메소드 패턴과 마찬가지로 상속을 통해 기능을 확장하게 하는 패턴이다. 그래서 구조도 비슷하다
슈퍼클래스 코드에서는 서브클래스에서 구현할 메소드를 호출해서 필요한 타입의 오브젝트를 가져와 사용한다.
이 메소드는 주로 인터페이스 타입으로 오브젝트를 리턴하므로 서브클래스에서 정확히 어떤 클래스의 오브젝트를 만들어 리턴할지는 슈퍼클래스에서는 알지 못한다 사실 관심도 없다.
서브클래스는 다양한 방법으로 오브젝트를 생성하는 메소드를 재정의 할 수 있다.
이렇게 서브클래스에서 오브젝트 생성 방법과 클래스를 결정할 수 있도록 미리 정의해둔 메소드를 팩토리 메소드라고 하고
이 방식을 통해 오브젝트 생성 방법을 나머지 로직, 즉 슈퍼클래스의 기본 코드에서 독립시키는 방법을 팩토리 메소드 패턴이라고 한다.
자바에서 오브젝트를 생성하는 기능을 가진 메소드를 팩토리 패턴이라고 부르기도 한다. 의미가 다르므로 혼동X
참고- 토비의 스프링3.0
'JAVA > 디자인 패턴' 카테고리의 다른 글
| 탬플릿 메소드 패턴 (0) | 2013.07.25 |
|---|---|
| 디자인 패턴 (2) | 2013.07.25 |
설정
트랙백
댓글
글
상속을 통해 슈퍼클래스의 기능을 확장할 때 사용하는 가장 대표적인 방법.
변하지 않는 기능은 슈퍼클래스에 만들어 두고 자주 변경되며 확장할 기능은 서브클래스에서 만들도록 한다.
슈퍼클래스에서는 미리 추상 메소드 또는 오버라이드 가능한 메소드를 정의해두고 이를 활용해 코드의 기본 알고리즘을 담고 있는 템플릿 메소드를 만든다.
슈퍼클래스에서 디폴트 기능을 정의해두거나 비워뒀다가 서브클래스에서 선택적으로 오버라이드할 수 있도록 만들어둔 메소드를 훅(hook) 메소드라고 한다. 서브클래스에서는 추상 메소드를 구현하거나, 훅 메소드를 오버라이드하는 방법을 이용해 기능의 일부를 확장한다.
public abstract class Super {
//기본 알고리즘 코드
hookMethod();
abstractMethod();
...
}
proteted void hookMethod(){} //선택적으로 오버라이드 가능한 훅 메소드
public abstract oid abstractethod(); //서브클래스에서 반드시 구현해야 하는 추상 메소드
public class Sub1 extends Super {
protected void hookMethod(){
...
}
public void abstractMethod(){
...
}
}
참고 - 토비의 스프링 3.0
'JAVA > 디자인 패턴' 카테고리의 다른 글
| 팩토리 메소드 패턴 (0) | 2013.07.25 |
|---|---|
| 디자인 패턴 (2) | 2013.07.25 |
설정
트랙백
댓글
글
디자인 패턴이란?
소프트웨어 설계 시 특정 상황에서 자주 만나는 문제를 해결하기 위해 사용할 수 있는 재사용 가능한 솔루션
장점 : 패턴의 이름으로 설계 의도, 해결책을 한번에 해결 할 수 있다.
패턴의 설계 구조:
대부분 객체지향적인 설계로부터 문제를 해결하기 위해 적용 가능한 확장성 추구 방법은 두 가지로 정리된다.
1. 클래스 상속
2. 오브젝트 합성
따라서 패턴의 결과로 나온 코드 설계 구조는 대부분 비슷하다.
중요 포인트:
각 패턴의 핵심이 담긴 목적, 의도
-> 패턴을 적용할 상황, 해결해야 할 문제 솔루션의 구조와 각 요소의 역할. 핵심 의도를 기억해야 한다.
참고: 토비의 스프링3.0
'JAVA > 디자인 패턴' 카테고리의 다른 글
| 팩토리 메소드 패턴 (0) | 2013.07.25 |
|---|---|
| 탬플릿 메소드 패턴 (0) | 2013.07.25 |
설정
트랙백
댓글
글
SELECT * FROM TAB;
DESC DEPT;
SELECT * FROM DEPT;
DESC EMP;
SELECT EMPNO,ENAME,JOB,SAL,DEPTNO FROM EMP;
DESC EMP;
SELECT EMPNO AS 사원번호,ENAME 사원이름,SAL 본봉,SAL*1.2 AS 총급여 FROM EMP;
SELECT EMPNO,ENAME,COMM,COMM+100, SAL,SAL+COMM AS 총급여 FROM EMP;
SELECT ENAME ||' 의 직업은 '||JOB || '입니다.' AS "이름 직업" FROM EMP;
-- 중복행제거
/*
중복행제거
여러줄주석
*/
SELECT DISTINCT JOB FROM EMP;
SELECT EMPNO,ENAME,JOB,DEPTNO
FROM EMP
WHERE DEPTNO=30;
SELECT *
FROM EMP
WHERE JOB='CLERK';
SELECT * FROM EMP;
SELECT * FROM EMP WHERE HIREDATE='81/11/17';
SELECT *
FROM EMP
WHERE SAL<=1000;
SELECT *
FROM EMP
WHERE SAL>=100 AND SAL <=2000;
SELECT EMPNO,ENAME,SAL
FROM EMP
WHERE SAL BETWEEN 1000 AND 2000;
SELECT EMPNO,ENAME,COMM
FROM EMP
WHERE COMM IS NULL;
SELECT EMPNO,ENAME,COMM
FROM EMP
WHERE EMPNO IN(7369,7654,7934);
SELECT EMPNO,ENAME,JOB,COMM
FROM EMP
WHERE JOB IN('CLERK','SALESMAN');
SELECT *
FROM EMP
WHERE ENAME LIKE 'A%';
SELECT *
FROM EMP
WHERE ENAME LIKE '%T%';
SELECT *
FROM EMP
WHERE ENAME LIKE '_L%';
SELECT *
FROM EMP
WHERE ENAME LIKE '%\_%' ESCAPE '\' ;
SELECT *
FROM EMP
WHERE COMM IS NULL;
SELECT *
FROM EMP
WHERE COMM IS NOT NULL;
/*
INSERT INTO EMP VALUES
(9000,'M_BEER','CLERK',7782,to_date('23-1-1982','dd-mm-yyyy'),1300,NULL,10);
DELETE FROM EMP WHERE EMPNO=9000;
commit;
*/
SELECT *
FROM EMP
WHERE ENAME LIKE '%\_%' ESCAPE '\';
SELECT * FROM EMP;
SELECT EMPNO,ENAME,HIREDATE FROM EMP
ORDER BY HIREDATE ASC;
SELECT EMPNO,ENAME,SAL*12 FROM EMP
ORDER BY SAL*12 ASC;
SELECT EMPNO,ENAME,SAL*12 FROM EMP
ORDER BY 3 ASC;
SELECT EMPNO,ENAME FROM EMP
ORDER BY ENAME DESC;
SELECT EMPNO,ENAME,SAL FROM EMP
ORDER BY SAL DESC ,EMPNO ASC;
--단일행함수
DESC DUAL;
SELECT DUMMY FROM DUAL;
SELECT ROUND(45.528,2),ROUND(45.582,0),ROUND(45.582,-1) FROM EMP;
SELECT ROUND(45.528,2),ROUND(45.582,0),ROUND(45.582,-1) FROM DUAL;
SELECT TRUNC(45.528,2) ,TRUNC(45.528,0),TRUNC(45.528,-1),TRUNC(45.528,-2) FROM DUAL;
SELECT MOD(42342,7) FROM DUAL;
SELECT EMPNO,ENAME,SAL,MOD(SAL,10) FROM EMP;
SELECT CEIL(15.3),CEIL(-15.3) FROM DUAL;
SELECT FLOOR(15.3),FLOOR(-15.3) FROM DUAL;
SELECT HIREDATE FROM EMP;
SELECT SYSDATE FROM DUAL;
SELECT SYSTIMESTAMP FROM DUAL;
SELECT EMPNO,ENAME,SYSDATE,HIREDATE,TRUNC((SYSDATE - HIREDATE)/7,0) FROM EMP;
SELECT EMPNO,ENAME,TRUNC(MONTHS_BETWEEN(SYSDATE,HIREDATE),0) FROM EMP;
SELECT EMPNO,ENAME,HIREDATE,ADD_MONTHS(HIREDATE,6) FROM EMP;
SELECT SYSDATE,ADD_MONTHS(SYSDATE,6) FROM DUAL;
ALTER SESSION SET NLS_LANGUAGE='AMERICAN';
SELECT SYSDATE,NEXT_DAY(SYSDATE,'SUN') FROM DUAL;
ALTER SESSION SET NLS_LANGUAGE='KOREAN';
SELECT EMPNO,ENAME,HIREDATE,ROUND(HIREDATE,'MONTH'),SYSDATE,ROUND(SYSDATE,'MONTH') FROM EMP;
SELECT EMPNO,ENAME,HIREDATE,ROUND(HIREDATE,'YEAR'),SYSDATE,ROUND(SYSDATE,'YEAR') FROM EMP;
SELECT EMPNO,ENAME,HIREDATE,TRUNC(HIREDATE,'MONTH'),SYSDATE,TRUNC(SYSDATE,'MONTH') FROM EMP;
SELECT EMPNO,ENAME,HIREDATE,TRUNC(HIREDATE,'YEAR'),SYSDATE,TRUNC(SYSDATE,'YEAR') FROM EMP;
SELECT * FROM EMP;
--변환함수
SELECT EMPNO,ENAME FROM EMP WHERE EMPNO='7839';
SELECT EMPNO,ENAME FROM EMP WHERE EMPNO=TO_NUMBER('7839');
SELECT EMPNO,ENAME,HIREDATE FROM EMP WHERE hiredate='82/01/23';
-- 1982-01-23 , 1982 01 23
SELECT EMPNO,ENAME,HIREDATE FROM EMP WHERE hiredate=to_date('82/01/23','RR/MM/DD');
ALTER SESSION SET NLS_LANGUAGE='AMERICAN';
SELECT EMPNO,ENAME,HIREDATE
FROM EMP
WHERE hiredate=to_date('1982 JANUARY 23','YYYY MONTH DD');
select hiredate,to_char(hiredate,'YYYY/MM/DD') from emp;
select sysdate,to_char(sysdate,'YEAR MONTH DD DAY HH:MI:SS') from dual;
select empno,ename,sal,to_char(sal,'L99,999.99') from emp;
select empno,ename,sal,to_char(sal,'$99,999.90') from emp;
select empno,ename,sal,comm,sal*12+comm, sal*12+NVL(comm,0) 총급여 from emp;
select empno,ename,sal,comm,sal*12+comm, sal*12+NVL2(comm,comm,0) 총급여 from emp;
select empno,ename,sal,comm,sal*12+comm, NVL2(comm,sal*12+comm,sal*12) 총급여 from emp;
select empno,ename,sal,
case job when 'ANALYST' then sal*1.1
when 'CLERK' then sal*1.2
when 'MANAGER' then sal*1.3
when 'PRESIDENT' then sal*1.4
when 'SALESMAN' then sal*1.5
else sal
end "급여"
from emp;
select empno,ename,sal,
case when job='ANALYST' then sal*1.1
when job='CLERK' then sal*1.2
when job='MANAGER' then sal*1.3
when job='PRESIDENT' then sal*1.4
when job='SALESMAN' then sal*1.5
else sal
end "급여"
from emp;
select empno,ename,sal,
case when sal>=1000 then sal*1.1
else sal
end "급여"
from emp;
--GROUP FUNCTION
select sum(sal),avg(sal),min(sal),max(sal) from emp;
select count(*),count(comm),count(nvl(comm,0)),sum(comm),round(avg(nvl(comm,0)),2) from emp;
select deptno,avg(sal)
from emp
group by deptno;
select deptno,job,avg(sal)
from emp
group by deptno,job
order by deptno asc;
select deptno ,sum(sal)
from emp
where sal>800
group by deptno
having sum(sal)>9000
order by deptno asc;
SELECT DEPTNO ,
DECODE( JOB , 'CLERK', SAL) CLERK,
DECODE( JOB , 'MANAGER', SAL) MANAGER FROM EMP;
--ANSI JOIN
SELECT EMPNO,ENAME,DNAME
FROM DEPT,EMP;
SELECT EMP.EMPNO,EMP.ENAME,DEPT.DNAME,DEPT.LOC
FROM EMP,DEPT
WHERE EMP.DEPTNO=DEPT.DEPTNO;
SELECT e.EMPNO,e.ENAME,e.DEPTNO,d.DEPTNO,d.DNAME,d.LOC
FROM EMP e,DEPT d
WHERE e.DEPTNO=d.DEPTNO AND e.EMPNO = 7788;
SELECT e.EMPNO,e.ENAME,e.SAL,s.GRADE
FROM EMP e,SALGRADE s
WHERE e.SAL BETWEEN s.LOSAL AND s.HISAL;
SELECT e.EMPNO,e.ENAME,e.SAL,s.GRADE
FROM EMP e,SALGRADE s
WHERE e.SAL>=s.LOSAL AND e.SAL<=s.HISAL;
SELECT e.EMPNO,e.ENAME,e.DEPTNO,d.DEPTNO,d.DNAME,d.LOC
FROM EMP e,DEPT d
WHERE e.DEPTNO(+)=d.DEPTNO;
INSERT INTO EMP VALUES(9999,'홍길동','MANAGER',7839,sysdate,2450,NULL,NULL);
SELECT * FROM EMP;
SELECT e.EMPNO,e.ENAME,e.DEPTNO,d.DEPTNO,d.DNAME,d.LOC
FROM EMP e,DEPT d
WHERE e.DEPTNO = d.DEPTNO(+);
rollback;
select * from emp;
select a.ename "사원" ,b.ename "관리자"
from emp a,emp b
where a.mgr = b.empno(+);
--SQL 1999 JOIN
select empno,ename,dname,loc
from emp cross join dept;
select empno,ename,dname,loc
from emp natural join dept;
select empno,ename,dname,loc
from emp join dept using(deptno);
select empno,ename,dname,loc
from emp join dept
on emp.deptno=dept.deptno and dept.deptno=10;
select empno,ename,sal,dname,loc
from emp join dept
on emp.deptno=dept.deptno and sal in(800,3000,5000);
select e.empno,e.ename,d.dname,e.sal,s.grade
from emp e join dept d
on e.deptno=d.deptno
join salgrade s
on e.sal between s.losal and s.hisal;
select a.ename "사원", b.ename "관리자"
from emp a join emp b
on a.mgr=b.empno;
INSERT INTO EMP VALUES(9999,'홍길동','MANAGER',7839,sysdate,2450,NULL,NULL);
select empno,ename,dname,loc
from emp right outer join dept
on emp.deptno=dept.deptno;
select empno,ename,dname,loc
from emp left outer join dept
on emp.deptno=dept.deptno;
select empno,ename,dname,loc
from emp full outer join dept
on emp.deptno=dept.deptno;
select sal from emp where ename='SCOTT';
select empno,ename,sal from emp where sal > 3000;
select empno,ename,sal
from emp
where sal >(select sal
from emp
where ename='SCOTT');
--DML
insert into dept(deptno,dname,loc) values(90,'인사과','서울');
insert into dept values(80,'인사과','서울');
insert into dept(loc,dname,deptno) values('서울','인사과',70);
select * from dept;
desc dept;
/*
desc dept
이름 널 유형
------ -------- ------------
DEPTNO NOT NULL NUMBER(2)
DNAME VARCHAR2(14)
LOC VARCHAR2(13)
*/
insert into dept(deptno,dname) values(91,'인사과');
insert into dept values(92,'인사과',null);
desc emp;
/*
desc emp
이름 널 유형
-------- -------- ------------
EMPNO NOT NULL NUMBER(4)
ENAME VARCHAR2(10)
JOB VARCHAR2(9)
MGR NUMBER(4)
HIREDATE DATE
SAL NUMBER(7,2)
COMM NUMBER(7,2)
DEPTNO NUMBER(2)
*/
insert into emp(empno,ename,job,mgr,hiredate,sal,comm,deptno)
values(9000,user,'연구원',7839,sysdate,5000,null,90);
select * from emp where empno >=9000;
insert into emp(empno,ename,job,mgr,hiredate,sal,comm,deptno)
values(9001,'홍길동','MANAGER',7839,'2012/03/22',2000,null,90);
insert into emp(empno,ename,job,mgr,hiredate,sal,comm,deptno)
values(9002,'임꺽정','MANAGER',7839,
to_date('2012/03/20','YYYY/MM/DD'),2000,null,30);
create table dept_1(deptno number(2),dname varchar2(14),loc varchar2(13));
desc dept_1;
insert into dept_1(deptno,dname,loc) select deptno,dname,loc from dept;
select * from dept_1;
select * from dept;
update dept
set dname='경리과',loc='부산'
where deptno=90;
select * from emp where empno=9001;
update emp
set job=(select job
from emp
where empno=7900
),
sal=(select sal
from emp
where empno=7844
)
where empno=9001;
update dept_1
set dname=(
select dname
from dept
where deptno=30)
where deptno=(
select deptno
from dept
where dname='SALES');
select * from dept_1 where deptno=30;
select * from dept_1;
delete from emp
where deptno=91;
delete emp
where deptno=(select deptno
from dept
where dname='경리과');
select deptno,dname from dept;
select * from emp;
rollback;
select * from emp;
select * from dept;
delete from dept where deptno=91;
delete from dept where deptno=70;
delete from dept where deptno=80;
delete from dept where deptno=92;
select * from dept;
commit;
delete from emp;
select * from emp;
rollback;
--DDL
create table dept_2(deptno number(2),dname varchar2(10),loc varchar2(10));
desc dept_2;
create table scott.dept_3(deptno number(2),dname varchar2(10),loc varchar2(10));
desc dept_3;
create table def_table(num number(2),writeday date);
create table def_table2(num number(2),writeday date default sysdate);
insert into def_table(num) values(1);
insert into def_table(num,writeday) values(2,sysdate);
insert into def_table2(num) values(1);
insert into def_table2(num,writeday) values(2,default);
select * from def_table;
select * from def_table2;
create table new_tmp(tmp_id number(2),w_day date,w_day2 timestamp);
desc new_tmp;
insert into new_tmp values(1,sysdate,sysdate);
select * from new_tmp;
create table new_tmp2(tmp_id number ,w_day timestamp with time zone);
desc new_tmp2;
insert into new_tmp2 values(1,sysdate);
insert into new_tmp2 values(2,sysdate);
insert into new_tmp2 values(3,sysdate);
insert into new_tmp2 values(4,sysdate);
insert into new_tmp2 values(5,sysdate);
select * from new_tmp2;
create table new_tmp3(tmp_id number ,w_day timestamp with local time zone);
insert into new_tmp3 values(1,sysdate);
insert into new_tmp3 values(2,sysdate);
insert into new_tmp3 values(3,sysdate);
insert into new_tmp3 values(4,sysdate);
insert into new_tmp3 values(5,sysdate);
insert into new_tmp3 values(6,sysdate);
insert into new_tmp3 values(7,sysdate);
insert into new_tmp3 values(8,sysdate);
insert into new_tmp3 values(9,sysdate);
insert into new_tmp3 values(10,sysdate);
select * from new_tmp3;
SELECT SESSIONTIMEZONE, DBTIMEZONE, localtimestamp FROM dual;
alter session set time_zone = '+09:00';
commit;
create table new_tmp4
( time1 interval year to month,
time2 interval day to second);
desc new_tmp4;
insert into new_tmp4 values(
interval '10-1' year to month,
interval '10 10:10:10' day to second);
select to_char(sysdate,'YYYY/MM/DD HH24:MI:SS'),
to_char(sysdate+time1,'YYYY/MM/DD HH24:MI:SS'),
to_char(sysdate+time1+time2,'YYYY/MM/DD HH24:MI:SS')
from new_tmp4;
create table deptA
as
select * from dept;
desc deptA;
select * from deptA;
create table deptB(no,name)
as
select deptno,dname from dept;
desc deptB;
select * from deptB;
create table deptC
as
select * from dept where 1=2;
select count(*) from deptC;
--constraint
create table sawon(
s_no number(4),
s_name varchar2(10) not null,
s_hiredate date constraint sawon_s_hiredate_nn not null
);
desc sawon;
select * from user_constraints where table_name='SAWON3';
insert into sawon values(1,'길동',sysdate);
insert into sawon values(2,'춘향',sysdate);
select * from sawon;
--column level
create table sawon2 (
s_no number(2),
s_name varchar2(10),
s_email varchar2(20) constraint sawon2_s_email_uk unique
);
insert into sawon2 values(1,'홍길동','adb@abc.com');
insert into sawon2 values(2,'유관순','adb@abc.co.kr');
--insert into sawon2 values(3,'강감찬','adb@abc.co.kr');
-- table level
create table sawon3 (
s_no number(2),
s_name varchar2(10),
s_email varchar2(20),
constraint sawon3_s_email_uk unique(s_email)
);
create table sawon4 (
s_no number(2),
s_name varchar2(10),
s_email varchar2(20),
constraint sawon4_s_email_s_name_uk unique(s_name, s_email)
);
INSERT INTO SAWON4 VALUES (1, '홍길동', 'ABC@ABC.CO.KR');
INSERT INTO SAWON4 VALUES (2, '유관순', 'ABC@ABC.CO.KR');
-- INSERT INTO SAWON4 VALUES (3, '유관순', 'ABC@ABC.CO.KR'); --unique constraint (%s.%s) violated
INSERT INTO SAWON4 VALUES (3, '이순신', NULL);
INSERT INTO SAWON4 VALUES (4, NULL, NULL);
INSERT INTO SAWON4 VALUES (5, NULL, NULL); --유니크에 안걸려서 중복삽입 가능.
SELECT * FROM SAWON4;
--12.16 PRIMARY KEY 제약조건
/*
: 테이블에 기본키를 의미하며, 한 개의 테이블에는 오직 한 개의 기본키를 만들 수 있다.
: UNIQUE + NOT NULL 제약조건 특성을 갖는다.
: 테이블 수준 및 컬럼 수준 , 2 가지 방법 모두 사용 가능하다.
: UNIQUE 와 마찬가지로 INDEX 가 자동 생성된다.
CONSTRAINT 이름 UNIQUE,NOTNULL,PRIMARY 해주면 된다.
*/
CREATE TABLE SAWON5 (
S_NO NUMBER(2) CONSTRAINT SAWON5_S_NO_PK PRIMARY KEY,
S_NAME VARCHAR2(10),
S_SAL NUMBER(10)
); --방법1
INSERT INTO SAWON5 VALUES(1, '이순신', 2000);
-- INSERT INTO SAWON5 VALUES(1, '김순신', 2000); --"unique constraint (%s.%s) violated"
CREATE TABLE SAWON6 (
S_NO NUMBER(2),
S_NAME VARCHAR2(10),
S_SAL NUMBER(10),
CONSTRAINT SAWON6_S_NO_PK PRIMARY KEY (S_NO)); -- 방법2
select * FROM user_constraints WHERE TABLE_NAME = 'SAWON6';
--12.17FOREIGN KEY 제약조건
/*
: 참조 무결성 제약조건이라고도 한다.
: 반드시 다른 테이블의 기본키나 또는 UNIQUE 컬럼의 값을 참조하도록 제한한다. ( NULL허용)
*/
CREATE TABLE DAPT2
( DEPTNO NUMBER(2) CONSTRAINT DEPT2_DEPTNO_PK PRIMARY KEY,
DNAME VARCHAR2(10),
LIC VARCHAR2(10)
);
RENAME DAPT2 TO DEPT2;
INSERT INTO DEPT2 VALUES (10, '인사', '서울');
-- INSERT INTO DAPT2 VALUES (10, '총무', '서울'); --unique constraint (SCOTT.DEPT2_DEPTNO_PK)
INSERT INTO DEPT2 VALUES (20, '인사', '부산');
SELECT * FROM DEPT2;
-- 외래키참조
CREATE TABLE EMP2
( EMPNO NUMBER (4) CONSTRAINT EMP2_EMPNO_KO PRIMARY KEY,
ENAME VARCHAR2(10),
SAL NUMBER(10),
DEPTNO NUMBER(2) CONSTRAINT EMP2_DEPTNO_FK REFERENCES DAPT2(DEPTNO) );
SELECT * FROM user_constraints WHERE TABLE_NAME = 'EMP2';
INSERT INTO EMP2 VALUES (1111,'이효리',5600, 10);
INSERT INTO EMP2 VALUES (2222,'강수지',5600, 20);
-- INSERT INTO EMP2 VALUES (2222,'강수지',5600, 14); --unique constraint (SCOTT.EMP2_EMPNO_KO) violated
SELECT * FROM EMP2;
CREATE TABLE EMP3
( EMPNO NUMBER (4) CONSTRAINT EMP3_EMPNO_PK PRIMARY KEY,
ENAME VARCHAR2 (10),
SAL NUMBER(10),
DEPTNO NUMBER(2),
CONSTRAINT EMP3_DEPTNO_FK FOREIGN KEY (DEPTNO) REFERENCES DEPT2(DEPTNO));
INSERT INTO EMP3 VALUES (1111,'이효리',5600, 10);
INSERT INTO EMP3 VALUES (2222,'강수지',5600, 20);
SELECT * FROM EMP3;
/*
FOREIGN KEY 추가옵션
- 부모 테이블의 행 삭제 시 문제될 수 있는 자식테이블 행 설정법.
: ON DELETE CASCADE
- FK 제약조건에 의해 참조되는 테이블( 부모 테이블)의 행이 삭제되면,
해당 행 을 참조하는 테이블(자식 테이블)의 행도 같이 삭제되도록 한다.
: ON DELETE SET NULL
- FK 제약조건에 의해 참조되는 테이블( 부모 테이블)의 행이 삭제되면,
해당 행 을 참조하는 테이블(자식 테이블)의 행을 NULL 로 설정한다.
*/
--CHECK CONSTRAINT
CREATE TABLE SAWON7
( S_NO NUMBER(4),
S_NAME VARCHAR2(10),
S_SAL NUMBER (10) CONSTRAINT SAWON7_S_SAL_CHK CHECK(S_SAL > 500) ); --행 레벨
CREATE TABLE SAWON8
( S_NO NUMBER(4),
S_NAME VARCHAR2(10),
S_SAL NUMBER (10), CONSTRAINT SAWON8_S_SAL_CHK CHECK(S_SAL > 500) ); --테이블레벨
--INSERT INTO SAWON7 VALUES (1, '김미은', 400); --check constraint (SCOTT.SAWON7_S_SAL_CHK) violated
INSERT INTO SAWON7 VALUES (2, '김미숙', 600);
SELECT * FROM USER_CONSTRAINTS WHERE TABLE_NAME ='SAWON7';
--DROP
/*
데이터베이스에서 해당 테이블을 제거하는 것이다.
: 테이블에 저장된 모든 데이터와 관련 INDEX가 삭제된다.
*/
DROP TABLE SAWON8;
DESC SAWON8;
-- TRUNCATE:
/*테이블잘라내기
: 테이블의 모든 행들을 삭제할수있다.
: 테이블이 사용하고 있던 저장 공간을 해제하여 다른 테이블들이 사용 할 수 있도록 한다.
: DELETE 명령은 저장공간을 해제하지 않는다.
: ROLLBACK 정보를 발생시키지 않아서 DELETE 보다 수행속도가 빠르다
단, DELETE와 달리 ROLLBACk 은 불가능하다.
*/
TRUNCATE SAWON8;
----------------- 2013.03.26 화요일
--CH13. 기타스키마 객체
-- 13.3 VIEW
CREATE VIEW EMP_VIEW
AS
SELECT EMPNO, ENAME, SAL, HIREDATE
FROM EMP
WHERE DEPTNO= 10; -- "insufficient privileges" -> 권한 줘야 함. sys에서 grant create view to scott;
desc emp_view ;
select * from emp_view;
create view dept_view
as
select deptno as no, dname name
from dept;
desc dept_view;
select * from dept_view;
-- 13.4 view 수정
create or replace view dept_view
as
select deptno no, dname name, loc location
from dept;
desc dept_view;
select * from dept_view;
-- 13.4 복합 뷰 생성
create view emp_dept_view
as
select empno, ename, dname
from emp, dept
where emp.deptno = dept.deptno
and dept.deptno = 30;
desc emp_dept_view;
select * from dept_view;
select * from emp_view;
delete from emp_view where empno = 7782;
--13.6 제약조건
create or replace view emp_view
as
select * from emp
where deptno = 10
with check option constraint empview10_check;
select * from emp;
update emp_view
set deptno = 10 where ename = 'KING';
select * from emp;
-- 13.6 WITH READ ONLY
create or replace view dept_view
as
select * from dept
where deptno = 10
with read only;
delete from dept_view; -- cannot perform a DML operation on a read-only view
select * from emp;
--13.9 시퀀스 사용
create sequence emp_empno_seq
increment by 1
start with 100;
desc user_sequences;
select * from user_sequences;
insert into emp values (emp_empno_seq.nextval, '김수미', '인사', null, sysdate, 2500, 300, 40);
select * from emp;
select emp_empno_seq.currval from dual; -- 현재 값 보기
select emp_empno_seq.nextval from dual; -- nextval 할 때 마다 값이 증가
alter sequence emp_empno_seq
increment by 2; -- 다시 되돌려줌
select emp_empno_seq.nextval from dual;
select emp_empno_seq.currval from dual;
drop sequence emp_empno_seq; -- sequence EMP_EMPNO_SEQ이(가) 삭제되었습니다.
-- 13.11 인덱스 -> 넘어갈게요. 회사가서 하시면됩니다.
--01. 사용자관리
-- 1.5 사용자에게 권한 부여
-- grant create session, create table to suin; --권한주기(suin 이 conn 생성가능)
select * from session_privs;
-- 1.7 객체권한 부여
grant select on dept to OSI;
grant select on emp to OSI;
grant update(dname) on dept to OSI;
'DATABASE' 카테고리의 다른 글
| [펌] UNION과 UNION ALL 의 차이 및 주의 사항 (0) | 2014.02.28 |
|---|---|
| [펌] 트랜잭션 로그 백업(Transaction Log Backup)에 관하여 (0) | 2013.11.05 |
| TRUNCATE (0) | 2013.09.25 |
| CRUD 의 중요도? (0) | 2013.08.02 |
| DECODE, RANK()OVER(), UNION/UNION ALL (1) | 2013.08.02 |
설정
트랙백
댓글
글
/*
오버로딩(다중정의)
1. 자바 다형성구현기법 중의하나이다.
2. 정의: 같은메쏘드 이름으로 여러개를 정의하는방법
- 규칙:
* 메쏘드의 이름이 같아야한다.
* 메쏘드의 인자의 숫자가 다르거나
* 메쏘드의 인자의 타입이 달라야한다.
* 메쏘드의 리턴타입,접근지정자는 상관없다.
*/
//------ Printer.java ------
public class Printer {
public void print (int a){
System.out.println("int print: "+a);
}
public void print (char c){
System.out.println("char print: "+c);
}
public void print (String str){
System.out.println("String print: "+str);
}
public void print (boolean b){
System.out.println("boolean print: "+b);
}
public void booleanprint (boolean b){
System.out.println("boolean print2: "+b);
}
public static void main(String[] args) {
Printer p = new Printer();
p.print(false);
p.booleanprint(true); //얘는 오버로딩 안하고 그냥 쓰는거.
p.print("U");
p.print(7);
p.print("HAVE A GOOD TIME");
}
}
//------ Overloading.java ------
public class Overloading {
public void method (){
System.out.println("public void method ()");
}
public void method (int a){
System.out.println("public void method (int a)= "+a);
}
//인자의 타입
public void method (float a){
System.out.println("public void method (float a)= "+a);
}
public void method (char a){
System.out.println("public void method (char a)= "+a);
}
//인자의 수
public void method (int a, int b){
System.out.println("public void method (int a, int b)= "+a+", "+b);
}
/*
//메소드 리턴타입
public void method1 (){
}
public int method1 (){
return 0;
}
//접근 지정자
public void method2 (){
}
private void method2 (){
}
*/
public static void main(String[] args) {
Overloading ol = new Overloading();
ol.method() ;
ol.method(3.1f);
ol.method(3);
ol.method('K');
ol.method(1, 2);
}
}
'JAVA > 자바실습' 카테고리의 다른 글
| [JAVA] OOP Encapsulation 캡슐화 (0) | 2013.06.12 |
|---|---|
| [JAVA] OOP BASIC (객체지향 프로그래밍 기초) (0) | 2013.06.12 |
| [JAVA] 자바기본2: For, While 문을 이용한 구구단, 별 찍기, 알파벳 출력 등 (0) | 2013.06.12 |
| [JAVA] 자바기본1: 연산자, 형변환, 문자열 출력, if문, 윤년출력 (0) | 2013.06.11 |
설정
트랙백
댓글
글
/* OOP 의 원칙
* 1. 캡슐화
* 2. 상속성
* 3. 다형성(오버로딩,오바라이딩,객체형변환)
*/
/*
* 1. 캡슐화
* - 외부클래스나 객체에서 멤버변수에 접근을 막고
* 멤버 메쏘드에만 접근할수있도록 클래스를 설계하는방법
* - 구현 : 멤버변수의 접근제한자를 private
* 멤버메소드의 접근제한자는 public 으로한다.
* public ==> 어떤 외부클래스에서든지 접근가능
* private==> 어떤 외부클래스에서든지 접근불가능
*/
Account
/*
* - 은행의 계좌 객체를 추상화한 클래스이다.
* - 은행계좌의 데이터를 가지고 있는 클래스이다.
*
*/
public class Account {
private String no; //계좌번호
private String owner; //계좌주
private int balance; //잔액
private float iyul; //이율
/*
* 입금하다
*/
/**
*
* @param money 입금금액
*/
public void ipGum (int money){
this.balance = this.balance + money;
System.out.println(" << 입 금 완 료 >> ");
System.out.println("입 금 금 액: " + money);
this.print();
}
/*
* 출금하다
*/
/**
*
* @param money 출금금액
* @return 출금가능 여부
*/
public boolean chulGum(int money){
boolean isSuccess = false;
if (this.balance < money){
isSuccess = false;
}
else {
this.balance = this.balance - money;
isSuccess = true;
}
return isSuccess;
}
/*
* 계좌정보를 출력하다.
*/
/**
* 계좌 정보를 인출한다.
*/
public void print (){
System.out.println("==========================");
System.out.println("계 좌 번 호: "+ this.no +"\n"
+ "계 좌 주 명: " + this.owner +"\n"
+ "계 좌 잔 액: "+ this.balance +"\n"
+ "계 좌 이 율: "+ this.iyul);
System.out.println("==========================");
}
public String getNo() {
return no;
}
public String getOwner() {
return owner;
}
public int getBalance() {
return balance;
}
public float getIyul() {
return iyul;
}
public void setNo(String no) {
this.no = no;
}
public void setOwner(String owner) {
this.owner = owner;
}
public void setBalance(int balance) {
this.balance = balance;
}
public void setIyul(float iyul) {
this.iyul = iyul;
}
}
AccountMain
public class AccountMain {
public static void main(String[] args) {
Account acc1 = new Account();
/*
acc1.no ="111";
acc1.owner ="김경수";
acc1.balance =5000;
*/
acc1.setNo("111");
acc1.setOwner("김경수");
acc1.setBalance(5000);
acc1.setIyul(4.5f);
//입금
// acc1.balance = acc1.balance + 3000;
acc1.ipGum(3000);
//출금
boolean isSuccess = acc1.chulGum(56000);
if (isSuccess == true){
System.out.println(" << 출 금 완 료 >>"
+"\n 잔액: "+acc1.getBalance());
}
else {
System.out.println(" << 잔 액 부 족 >>"
+"\n 잔액: "+acc1.getBalance());
}
isSuccess = acc1.chulGum(4000);
if (isSuccess == true){
System.out.println(" << 출 금 완 료 >>"
+"\n 잔액: "+acc1.getBalance());
}
else {
System.out.println(" << 잔 액 부 족 >>"
+"\n 잔액: "+acc1.getBalance());
}
//출력
acc1.print();
}//end main
}//end class
'JAVA > 자바실습' 카테고리의 다른 글
| [JAVA] OOP 다형성 - 오버로딩 (0) | 2013.06.12 |
|---|---|
| [JAVA] OOP BASIC (객체지향 프로그래밍 기초) (0) | 2013.06.12 |
| [JAVA] 자바기본2: For, While 문을 이용한 구구단, 별 찍기, 알파벳 출력 등 (0) | 2013.06.12 |
| [JAVA] 자바기본1: 연산자, 형변환, 문자열 출력, if문, 윤년출력 (0) | 2013.06.11 |
설정
트랙백
댓글
글
OOP: 객체지향 프로그래밍(Object Oriented Programming)
- 우리 일상에서이루어지고있는 업무를 객체(Object)를 사용해서 프로그래밍하는방법
- ex)
* 1. 실제 주차장관리 업무파악
* (객체를 도출하고 그객체들의 관계에의한 업무파악)
* 2. 프로그램으로 작성
* (1번에서 파악된업무를 메모리상에서 그대로구현)
*
* ex> 주차관리 프로그램
*
*
* - 객체(업무):실제이루어지고있는 업무(주차장)에서 보여지고구체화되어있는 사물(차)
*
* - 객체(프로그램):실제이루어지고있는 업무(주차장)에서 보여지고
* 구체화되어있는 사물을 메모리의 데이타로
* 표현한것(차의데이타)
OOP 의 원칙
1. 캡슐화
2. 상속성
3. 다형성(오버로딩,오바라이딩,객체형변환)
//------ Car.java ------
/*TIP:
* class 선언
* - 형식
* 접근제한자 class 클래스이름{
* - 접근제한자:public,protected,없는거
*
* }
* ex> public class Car{
* }
*
* -구성요소
* 1.멤버변수선언(속성)
* 접근제한자(public,proected,없는거,private) 타입 indentifier;
* ex> public String carName;
*
* 2.멤버메쏘드 선언(행위)
* 접근제한자 리턴타입 메쏘드이름(인자){
* -인자: 나를 호출한놈이 데이타를 넣어줄 통로
* -리턴타입: 나를 호출한놈에게 줄 데이타타입
* void --> 줄데이타가 없는경우
* }
* ex> public int test(int a){
*
* }
*/
/**
*
* 이 클래스는 Car 클래스이다.
* 차 번호와 입차, 출차시간, 요금을 받는다.
* @author : SUIN
* @version: ver0.1
*
*/
public class Car {
/**
* 차량의 번호
*/
public String no ;
public int inTime;
public int outTime;
/** 요금저장 */
public int fee;
}
//------ CarMain.java ------
public class CarMain {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//1. 차가 들어온다. (입차)
//변수선언 : 타입 식별자 -> Car 타입
//차 클래스 사용해서 차 객체 생성 후 Car 변수 초기화
//*Car 타입의 기억장소 c1이라는 식별자 할당,
//*Car 클래스(틀)을 활용해서 객체 생성
Car c1 = new Car(); //차 객체 찍기
//차 객체 안의 멤버변수 초기화
c1.no ="1234";
c1.inTime = 12;
c1.outTime = 0;
c1.fee = c1.outTime - c1.inTime;
//시간이 흐른 후 (2hr)
//2. 요금계산
c1.outTime = 14;
c1.fee = (c1.outTime - c1.inTime)*1000;
//3. 출력
System.out.println("****************");
System.out.println("차량번호: "+c1.no
+"\n입차시간: "+c1.inTime
+"\n출차시간: "+c1.outTime
+"\n주차요금: "+c1.fee+"원");
System.out.println("****************");
/*****************************************/
//String str;
Car c2 = new Car();
c2.no ="4962";
c2.inTime = 14;
c2.outTime = 0;
c2.fee = 0;
c2.outTime = 17;
c2.fee = (c2.outTime - c2.inTime)*1000;
System.out.println("****************");
System.out.println("차량번호: "+c2.no
+"\n입차시간: "+c2.inTime
+"\n출차시간: "+c2.outTime
+"\n주차요금: "+c2.fee+"원");
System.out.println("****************");
}
}
//------ CarMethod.java ------
/* class 선언
* - 형식
* 접근제한자 class 클래스이름{
* - 접근제한자:public,protected,없는거
*
* }
* ex> public class Car{
* }
*
* -구성요소
* 1.멤버변수선언(속성)
* 접근제한자(public,proected,없는거,private) 타입 indentifier;
* ex> public String carName;
*
* 2.멤버메쏘드 선언(행위)
* 접근제한자 리턴타입 메쏘드이름(인자){
* -인자: 나를 호출한놈(클래스,객체)이 데이타를 넣어줄 통로
* -리턴타입: 나를 호출한놈에게 줄 데이타타입
* void --> 줄데이타가 없는경우
* }
* ex> public int test(int a){
*
* }
*/
/**
* @author : SUIN
* @since 201302
*
*/
public class CarMethod {
/**
* 차량의 번호 : String 형태
*/
public String no ;
/**
* 입차시간
*/
public int inTime;
public int outTime;
public int fee;
public static int moneyPerHour = 1000;
/*
* 기능 (메서드)
* 1. 요금을 계산하다
* 2. 출력하다
*/
//요금 계산
/**
* 요금 계산 메소드
*/
public void calculateFee() {
this.fee = (this.outTime - this.inTime)*moneyPerHour;
//같은 클래스 안에서는 자기자신의 레퍼런스이므로 this. 해주면 됨.
//안해줘도 default 로 생략가능.(처음엔 생략하지 말 것)
// this = 셀프참조변수
}
//출력
/**
* 차량의 주차정보 출력 메소드
*/
public void print(){
System.out.println("****************");
System.out.println("차량번호: "+this.no
+"\n입차시간: "+inTime
+"\n출차시간: "+outTime
+"\n주차요금: "+fee+"원");
System.out.println("****************");
}
//초기화
/**
* 차량의 데이터를 SET
*
* @param no :차량 번호 입력
* @param inTime :입차시간
* @param outTime :출차시간
* @param fee :주차요금
*
*/
public void setData(String no, int inTime, int outTime, int fee){
this.setNo(no);
this.setInTime(inTime);
this.setOutTime(outTime);
this.setFee(fee);
}
/*
* 멤버필드 데이터 메소드(set, get)
* 1. setter method
* 2. getter method
*/
//setter method
public void setNo (String no){ //검정은 로컬변수
this.no = no; //파랑은 멤버(전역)변수
//
}
public void setInTime(int inTime){
this.inTime = inTime;
}
public void setOutTime(int outTime){
this.outTime = outTime;
}
public void setFee(int fee) {
this.fee = fee;
}
//getter method
/**
* 차량 번호를 반환하는 메소드
* @return
*/
public String getNo (){ //get : 다른 클래스(사용자) 입장에서 get
return this.no;
}
public int getInTime (){
return this.inTime;
}
public int getOutTime() {
return outTime;
}
public int getFee() {
return fee;
}
//Source - Generate getter and setter -> 자동으로 만들어줌. 대박!
}
//------ CarMethodMain.java ------
public class CarMethodMain {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//1. 차가 들어온다. (입차)
//변수선언 : 타입 식별자 -> Car 타입
//차 클래스 사용해서 차 객체 생성 후 Car 변수 초기화
//*Car 타입의 기억장소 c1이라는 식별자 할당,
//*Car 클래스(틀)을 활용해서 객체 생성
CarMethod c1 = new CarMethod(); //차 객체 찍기
//차 객체 안의 멤버변수 초기화
c1.no ="3456";
c1.inTime = 12;
c1.outTime = 0;
c1.fee = 0;
//시간이 흐른 후 (2hr)
c1.outTime = 14;
//2. 요금계산
c1.outTime = 14;
c1.fee = (c1.outTime - c1.inTime)*1000;
//3. 출력
System.out.println("****************");
System.out.println("차량번호: "+c1.no
+"\n입차시간: "+c1.inTime
+"\n출차시간: "+c1.outTime
+"\n주차요금: "+c1.fee+"원");
System.out.println("****************");
/******************클래스에 메소드추가***************************/
CarMethod c2 = new CarMethod(); //번지수 입력, this = c2의 주소
c2.no ="1212";
c2.inTime = 13;
c2.outTime = 0;
c2.fee = 0;
c2.outTime = 17;
c2.calculateFee(); //요금 계산 함수
c2.print(); //요금 출력 -> 우와 편해졌다!
/********************getter,setter*************************/
CarMethod c3 = new CarMethod();
//데이터에 관련된 메소드. setter method, getter method
//1. 입차
c3.setData("1234", 16, 0, 0);
//2. 시간이 흐른 후
c3.setOutTime(17);
c3.calculateFee();
//3. 출력
c3.print();
//*.번호 알아보기
String no = c3.getNo();
System.out.println("no="+no);
/*
* Car 클래스를 사용하는 사용자에게
* Car 클래스의 멤버에 대해 설명하지 않아도 됨.
* 메소드만 설명하면 되고, 사용자가 멤버변수를 몰라도 됨.
*
* => 다른 클래스, 객체의 멤버변수 접근을 막는다.
*/
//시간당 요금 출력
System.out.println("시간당 요금: "+CarMethod.moneyPerHour);
}
}
//------ MemberField.java ------
public class MemberField {
//선언과 동시에 초기화 가능
/*
* 객체 생성 후 멤버변수의 초기 기본값
*
* 참조변수 (클래스변수, 객체변수) : null
* integer : 0
* boolean : false
* double :0.0
*
*/
public String member1 = "멤버변수연습";
public int member2 = 130222;
public char member3 ;
public boolean member4 ;
public float member5 ;
}
//------ MemberFieldMain.java ------
public class MemberFieldMain {
public static void main(String[] args) {
/*선언*/
MemberField mf;
//MemberField.class가 존재해야 레퍼런스 변수 선언 가능
//선언하면 멤버필드 템플릿이 메모리 위로 올라옴.
//mf = MemberField 객체의 주소값을 가짐
/*초기화*/
mf = new MemberField();
// 보통 선언과 동시에 초기화 MemberField mf = new MemberField();
/*
* << 멤버(객체)변수 접근 방법 >>
*
* - 참조변수.멤버변수의 식별자
*
* ex> Student st = new Student();
* st.no = 1234;
*
*/
mf.member1 ="문자열";
mf.member3='c';
mf.member5=3.14159f;
System.out.println(mf.member1);
System.out.println(mf.member2);
System.out.println(mf.member3);
System.out.println(mf.member4);
System.out.println(mf.member5);
//tip: Ctrl+마우스 왼클릭 = 해당 변수가 정의 된 곳으로 이동
//tip: Ctrl+Alt+↓,↑ = 해당 드래그 된 내용 복사 붙여넣기
}
}
//------ MemberMethod.java ------
/*
* -구성요소
* 1.멤버변수선언(속성)
* 접근제한자(public,protected,없는거,private) 타입 indentifier;
* ex> public String carName;
*
* 2.멤버메쏘드 선언(행위)
* 접근제한자 리턴타입 메쏘드이름(인자){
* -인자: 나를 호출한놈이 데이타를 넣어줄 통로
* -리턴타입: 나를 호출한놈에게 줄 데이타타입
* void --> 줄데이타가 없는경우
* }
* ex> public int test(int a){
*
* }
*
* //리턴타입과 메쏘드이름 사이는 떨어지면 안된다.
*/
public class MemberMethod {
public void method1 () {
System.out.println("method1()실행");
}
public void method2 (int a){
System.out.println("method2(int a)실행: "+a);
}
public void method3(int a, int b){
System.out.println("method3(int a, int b)실행: "+a+","+b);
}
public int method4 (int a){
a = a+1;
System.out.print("mothod4(int a)실행: ");
return a;
}
public int method5 (int a, int b){
int result = a+b ;
System.out.print("mothod5(int a, int b)실행: ");
return result;
}
}
//------ MemberMethodMain.java ------
public class MemberMethodMain {
public static void main(String[] args) {
MemberMethod mm = new MemberMethod();
/*
* 멤버(객체)메쏘드에 접근하는방법
*
* -형태: 참조(객체)변수.메쏘드이름();
* ex> mm.method1();
*/
mm.method1();
mm.method2(3);
mm.method3(1, 2);
int result = mm.method4(999);
System.out.println(result);
/*
* public int method5(int x, int y);
*/
result = mm.method5(34, 34457833);
System.out.println(result);
}
}
'JAVA > 자바실습' 카테고리의 다른 글
| [JAVA] OOP 다형성 - 오버로딩 (0) | 2013.06.12 |
|---|---|
| [JAVA] OOP Encapsulation 캡슐화 (0) | 2013.06.12 |
| [JAVA] 자바기본2: For, While 문을 이용한 구구단, 별 찍기, 알파벳 출력 등 (0) | 2013.06.12 |
| [JAVA] 자바기본1: 연산자, 형변환, 문자열 출력, if문, 윤년출력 (0) | 2013.06.11 |
설정
트랙백
댓글
글
//------ CH02. ForTest- for 문 기본 ------
/*
for문
-형식:
for(1;2;3){
//1.반복변수(선언,초기화가능)
* -> 타입과 identifier -> 변수의 구조와크기
//2.반복변수의 조건검사(논리형데이타)
//3.반복변수증,감(++,--)
}
ex>
for(int i=0;i<10;i++){
stmt1;
}
ex>무한루프
for(;;){
}
* -> 무한루프도 OCJP출제
*/
public class ForTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i, j;
//****구구단*****
System.out.println("\n===============구구단 출력==============");
for (i=1; i<10; i++){
for (j=2;j<10; j++){
System.out.print(j+" X "+i+" = "+i*j+"\t");
}
System.out.println();
}
System.out.println("\n===============modular for test ==============");
//*****modular 4*******
System.out.print("1~10 중 4로 나누어 떨어지는 수는 ");
for (i=1; i<=10; i++){
if (i%4 == 0){
System.out.print(i+", ");
}
}
System.out.println("이다.");
//******1~10 중 홀수 합
System.out.println("\n==============sum of odd while 1 to 10===============");
int sum=0;
for (i=1; i<=10; i++){
if(i%2 ==1){
sum+=i;
/*
* 연산 후 대입 연산자
*
* a+=b; == a=a+b;
* a-=b; == a=a-b;
* a*=b; == a=a*b;
* a/=b; == a=a/b;
*
*/
}
}
System.out.println("1~10까지 홀수의 합은 "+sum+"이다.");
//******알파벳 소문자 출력
System.out.println("\n==============small alphabet print===============");
char alphabet = 'a';
int count=0;
for (alphabet = 'a'; alphabet<= 'z' ; alphabet++){
System.out.print(alphabet+" ");
count ++;
if (count%4 == 0){
System.out.println();
}
}
//감소
count =0;
System.out.println("\n==============for 감소===============");
for (alphabet = 'z'; alphabet>= 'a' ; alphabet--){
System.out.print(alphabet+" ");
count ++;
if (count%4 == 0){
System.out.println();
}
}
//2씩 증가
System.out.println("\n==============2씩 증가===============");
for (i =0; i<100; i+=2){
System.out.print(i+" ");
}
//2씩 감소
System.out.println("\n==============2씩 감소===============");
for (i=100; i>0; i-=2){
System.out.print(i+" ");
}
}//end main
}
===============구구단 출력============== 2 X 1 = 2 3 X 1 = 3 4 X 1 = 4 5 X 1 = 5 6 X 1 = 6 7 X 1 = 7 8 X 1 = 8 9 X 1 = 9 2 X 2 = 4 3 X 2 = 6 4 X 2 = 8 5 X 2 = 10 6 X 2 = 12 7 X 2 = 14 8 X 2 = 16 9 X 2 = 18 2 X 3 = 6 3 X 3 = 9 4 X 3 = 12 5 X 3 = 15 6 X 3 = 18 7 X 3 = 21 8 X 3 = 24 9 X 3 = 27 2 X 4 = 8 3 X 4 = 12 4 X 4 = 16 5 X 4 = 20 6 X 4 = 24 7 X 4 = 28 8 X 4 = 32 9 X 4 = 36 2 X 5 = 10 3 X 5 = 15 4 X 5 = 20 5 X 5 = 25 6 X 5 = 30 7 X 5 = 35 8 X 5 = 40 9 X 5 = 45 2 X 6 = 12 3 X 6 = 18 4 X 6 = 24 5 X 6 = 30 6 X 6 = 36 7 X 6 = 42 8 X 6 = 48 9 X 6 = 54 2 X 7 = 14 3 X 7 = 21 4 X 7 = 28 5 X 7 = 35 6 X 7 = 42 7 X 7 = 49 8 X 7 = 56 9 X 7 = 63 2 X 8 = 16 3 X 8 = 24 4 X 8 = 32 5 X 8 = 40 6 X 8 = 48 7 X 8 = 56 8 X 8 = 64 9 X 8 = 72 2 X 9 = 18 3 X 9 = 27 4 X 9 = 36 5 X 9 = 45 6 X 9 = 54 7 X 9 = 63 8 X 9 = 72 9 X 9 = 81 ===============modular for test ============== 1~10 중 4로 나누어 떨어지는 수는 4, 8, 이다. ==============sum of odd while 1 to 10=============== 1~10까지 홀수의 합은 25이다. ==============small alphabet print=============== a b c d e f g h i j k l m n o p q r s t u v w x y z ==============for 감소=============== z y x w v u t s r q p o n m l k j i h g f e d c b a ==============2씩 증가=============== 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98 ==============2씩 감소=============== 100 98 96 94 92 90 88 86 84 82 80 78 76 74 72 70 68 66 64 62 60 58 56 54 52 50 48 46 44 42 40 38 36 34 32 30 28 26 24 22 20 18 16 14 12 10 8 6 4 2//------ CH02. ForGuGuDan- for문을 이용한 구구단 ------
public class ForGuGuDan {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i, j;
//****구구단*****
System.out.println("\n===============구구단 출력==============");
for (i=1; i<10; i++){
for (j=2;j<10; j++){
System.out.print(j+" X "+i+" = "+i*j+"\t");
}
System.out.println();
}
}
}
//------ CH02. ForNested- for문으로 별 찍기 ------
/*
☆★★★★
★☆★★★
★★☆★★
★★★☆★
★★★★☆
*/
public class ForNested {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i, j;
System.out.println("*****별 찍기 1*****\n");
for (i=0; i<5; i++){
for (j=0; j<5; j++){
if (i == j){
System.out.print("☆");
}
else{
System.out.print("★");
}
}
System.out.println();
}
System.out.println("*****별 찍기 2*****\n");
/*
★☆☆☆☆
★★☆☆☆
★★★☆☆
★★★★☆
★★★★★
*/
for (i=0; i<5; i++){
for (j=0; j<=i; j++){
System.out.print("★");
}
for (int k=4; k>i; k--){
System.out.print("☆");
}
System.out.println("");
}
System.out.println("*****별 찍기 3*****\n");
/*
☆☆☆☆★
☆☆☆★★
☆☆★★★
☆★★★★
★★★★★
*/
for (i=0; i<5; i++){
for (j=4; j>i; j--){
System.out.print("☆");
}
for (int k=0; k<=i; k++){
System.out.print("★");
}
System.out.println();
}
System.out.println("*****별 찍기 4*****\n");
/*
★★★★★
★★★★
★★★
★★
★
*/
for (i=0; i<5; i++){
for (j=5; j>i; j--){
System.out.print("★");
}
System.out.println();
}
}//end main
}
//------ CH02. Switch,While - 정수 홀짝 구분, 알파벳 출력 ------
import java.util.Scanner;
/*
* 1.정수를 입력받아서 짝수인지 홀수인지 출력(switch)
2.알파벳 대문자출력(4개찍고 개행)(while)
ex> ABCD
EFGH
IJKL
...
*/
public class HomeWork_3_0220 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//정수를 입력받아서 짝수인지 홀수인지 출력(switch)
Scanner sc = new Scanner(System.in);
int num;
int nextLine =0;
int alphabet =65;
char alpha ='A'; //int 65
System.out.println("숫자하나 입력");
num = sc.nextInt();
num = num%2;
switch (num){
case 1:
System.out.println("홀수");
break;
case 0:
System.out.println("짝수");
break;
}
//알파벳 대문자출력(4개찍고 개행)(while)
num =0;
while (num < 26){
System.out.print(alpha);
nextLine++;
while (nextLine > 4){
System.out.println("");
nextLine =0;
}
num++;
alpha++;
}
}
}
//------ CH02. SwitchScoreTest - switch 문으로 점수 구분하기 ------
import java.util.Scanner;
public class SwitchScoreTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int kor,eng,math;
kor=71;
eng=52;
math=91;
System.out.println("국어,영어,수학 점수 입력");
kor = sc.nextInt();
eng = sc.nextInt();
math = sc.nextInt();
int total = kor+eng+math;
float everage = (float)total/3;
char hakjum;
everage = everage*100;
int trans = (int)everage;
everage = (float)trans/100;
int switch_triger = (int)everage/10;
/**점수 타당성 검사 **/
if (kor<0 || kor>100){
System.out.println("ERROR, SCORE is Between 0 to 100");
return; //해당 경우에 하위 문장을 실행하지 않고 return
}
if (eng<0 || eng>100){
System.out.println("ERROR, SCORE is Between 0 to 100");
return; //해당 경우에 하위 문장을 실행하지 않고 return
}
if (math<0 || math>100){
System.out.println("ERROR, SCORE is Between 0 to 100");
return; //해당 경우에 하위 문장을 실행하지 않고 return
}
System.out.println("************************");
System.out.println("국어: "+kor);
System.out.println("영어: "+eng);
System.out.println("수어: "+math);
System.out.println("총점: "+total);
System.out.println("평균: "+everage);
switch (switch_triger){
case 10:
hakjum='S';
break;
case 9:
hakjum = 'A';
break;
case 8:
hakjum = 'B';
break;
case 7:
hakjum = 'C';
break;
case 6:
hakjum ='D';
break;
default:
hakjum ='F';
}
System.out.println("평점: "+hakjum);
System.out.println("************************");
}
}
//------ CH02. whileGuGuDan- while문을 이용한 구구단 ------
public class WhileGuGuDan {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i=1, j=2;
while (i<10){
while (j<10){
System.out.print(j+" X "+i+" = "+i*j+"\t");
j++;
}
j =2;
System.out.println();
i++;
}
}//end main
}//and class
'JAVA > 자바실습' 카테고리의 다른 글
| [JAVA] OOP 다형성 - 오버로딩 (0) | 2013.06.12 |
|---|---|
| [JAVA] OOP Encapsulation 캡슐화 (0) | 2013.06.12 |
| [JAVA] OOP BASIC (객체지향 프로그래밍 기초) (0) | 2013.06.12 |
| [JAVA] 자바기본1: 연산자, 형변환, 문자열 출력, if문, 윤년출력 (0) | 2013.06.11 |
설정
트랙백
댓글
글
//------ CH01. ArithmaticOperator - 산술 연산자 ------
/*
산술연산자
- 형태: +,-,*,/,%
*/
public class ArithmaticOperator {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a = 1, b = 2;
int result = a + b;
float result1;
System.out.println("a+b = " +result );
result = a - b;
System.out.println("a-b = " +result );
result = a * b;
System.out.println("a*b = " +result );
result1 = (float)a/b;
System.out.println("a/b = " +result1 );
result = a % b;
System.out.println("a%b = " +result );
result = 452%52;
System.out.println("452%52 = "+result);
}
}
//------ CH01. BitOrerator - 비트 연산자 ------ /*
비트연산자
-형태: | , & ,~,>>,<<
* ~ : not (모든 비트 반전)
Bit or 연산( | ) -->양쪽비트가 모두 0인경우에만 0을반환
Bit and 연산 ( & ) -->양쪽비트가 모두 1인경우에만 1을반환
*||, &&와 다른 점: |, &는 양쪽이 논리형(t,f)이면 논리형 연산을 함
*정수형이면 정수형 연산을 함.
Shift 연산자 >>,<< --> bit를 좌우측으로 이동
*/
public class BitOrerator {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i1 = 3;
int i2 = 5;
int i3 = 7;
int result = i1 | i2;
System.out.println("3|5 = "+result);
/*
* 3 = 0000 0000 0000 0000 0000 0000 0000 0011 (4byte = 8bit)
* 5 = 0000 0000 0000 0000 0000 0000 0000 0101
* 3|5 = 0000 0000 0000 0000 0000 0000 0000 0111 = 7
* 3&5 = 0000 0000 0000 0000 0000 0000 0000 0001 = 1
*/
result = ~i1;
System.out.println("~3 = "+result);
/*
* 2의 보수 역과정
* 3 = 0000 0000 0000 0000 0000 0000 0000 0011
* ~3 = -4
* *읽는 방법: 모든 비트를 뒤집음 -> 값 +1 (보수를 취한 후 +1)
* 1111 1111 1111 1111 1111 1111 1111 1100 ->뒤집음
* 값 +1
* 1111 1111 1111 1111 1111 1111 1111 1101
* 다시 역과정을 거치면
* 0000 0000 0000 0000 0000 0000 0000 0010 -> 4인데
* 아까 뒤집을 때 맨 앞이 1이니까 -4가 답이 된다.
* */
int i = 1;
result = i<<5;
System.out.println("1<<1"+result);
boolean bresult = true | false;
System.out.println("true|false = "+bresult);
}
}
//------ CH01. CastingExam - 형 변환 예제 ------ /*
형변환(Casting)--> 숫자형데이타간에만 가능
- 형식 : (데이타타입)변수or상수;
- 자동형변환(작은데이타-->큰데이타 기억장소)upcasting
byte-->short-->int-->long-->float-->double
묵시적 형 변환
- 강제형변환(큰데이타-->작은데이타)downcasting
double-->float-->long-->int-->short-->byte
명시적 형 변환
*/
//upcasting(promotion)
public class CastingExam {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//암시적 형 변환
byte bt = 10; //내부적으로 형 변환이 일어남 int -> byte
short st = bt;
float ft =st;
//명시적 형 변환
int i =29;
short s = (short)i;
double d = 32.1241213;
int i1 = (int)d;
System.out.println(i);
System.out.println("(int)"+d+" = "+i1);
//연산시의 형 변환
//(가장 큰 항의 데이터 타입으로 모든 항이 UpCasting된 후 연산)
byte bb = 34;
short ss = 23;
int ii = 143;
long ll = 12423435234L;
float ff = 23.45f;
double dd = 234.23423211;
double result = bb+ss+ii+ll+ff+dd;
/***예외 : byte와 short의 연산은 무조건 int로 UpCasting 후에 진행***/
byte bbb =89;
short sss = 90;
int sResult = bbb+sss;
}
}
//------ CH01. HelloWorld - 문자열 출력 ------ public class HelloWorld {
public static void main (String[] args){
//문자열 출력 명령문 (주석)
System.out.println("Hello java");
System.out.println("안녕자바!");
}
}
//------ CH01. IfNested - 중첩 if문 ------ import java.util.Scanner;
/*중첩 if문
*
*
*/
public class IfNested {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int kor , eng, math;
char hakjum = ' ';
Scanner sc = new Scanner(System.in);
System.out.println("Enter Your KOR Score");
kor = sc.nextInt();
if (kor>=0 && kor<=100){
if (kor > 90){
hakjum ='A';
}else if (kor >80){
hakjum ='B';
}else if (kor > 70){
hakjum ='C';
}else if (kor > 60){
hakjum ='D';
}else {
hakjum ='F';
}
System.out.println("Your MATH Grade is "+hakjum);
}
else{
System.out.println("ERROR, SCORE is Between 0 to 100");
}
System.out.println("\nEnter Your MATH Score");
math = sc.nextInt();
if (math<0 || math>100){
System.out.println("ERROR, SCORE is Between 0 to 100");
return; //해당 경우에 하위 문장을 실행하지 않고 return
}
if (math >=90){
hakjum = 'A';
}else if (math >=80){
hakjum = 'B';
}else if (math >=70){
hakjum = 'C';
}else if (math >=60){
hakjum ='D';
}else {
hakjum ='F';
}
System.out.println("Your MATH Grade is "+hakjum);
} //end main
}//end class
//------ CH01. IfOddEven - if문 홀짝 ------ import java.util.Scanner;
public class IfOddEven {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int su ;
Scanner sc = new Scanner(System.in);
System.out.println("숫자를 입력 해주세요.");
su = sc.nextInt();
String msg ="";
if ( su % 2 ==0){
msg = "짝수";
}
else{
msg = "홀수";
}
System.out.println(su+"은( "+msg+" 입니다");
}
}
//------ CH01. IfScoreTest- if문을 이용한 성적 출력 ------ /*
//Casting을 사용하는 것이 관건!
* 값이 어떻게 잘리는지 알자 :)
*
국어,영어,수학 점수를 가지고
총점,평균,평점(A,B,C....)을 출력하시요....
- 100점이 넘는 수나 음수가 입력되면 메세지를 출력하세요
- 평균은 소수점이하 2자리수까지만 출력하세요
- 출력포맷
************************
국어: 78
영어: 56
수학: 77
총점:256
평균:78.56
평점: C
************************
*/
import java.util.Scanner;
public class IfScoreTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int kor,eng,math;
kor=71;
eng=52;
math=91;
System.out.println("국어,영어,수학 점수 입력");
kor = sc.nextInt();
eng = sc.nextInt();
math = sc.nextInt();
int total = kor+eng+math;
float everage = (float)total/3;
char hakjum;
everage = everage*100;
int trans = (int)everage;
everage = (float)trans/100;
/**점수 타당성 검사 **/
if (kor<0 || kor>100){
System.out.println("ERROR, SCORE is Between 0 to 100");
return; //해당 경우에 하위 문장을 실행하지 않고 return
}
if (eng<0 || eng>100){
System.out.println("ERROR, SCORE is Between 0 to 100");
return; //해당 경우에 하위 문장을 실행하지 않고 return
}
if (math<0 || math>100){
System.out.println("ERROR, SCORE is Between 0 to 100");
return; //해당 경우에 하위 문장을 실행하지 않고 return
}
System.out.println("************************");
System.out.println("국어: "+kor);
System.out.println("영어: "+eng);
System.out.println("수어: "+math);
System.out.println("총점: "+total);
System.out.println("평균: "+everage);
if (everage >=90){
hakjum = 'A';
}else if (everage >=80){
hakjum = 'B';
}else if (everage >=70){
hakjum = 'C';
}else if (everage >=60){
hakjum ='D';
}else {
hakjum ='F';
}
System.out.println("평점: "+hakjum);
System.out.println("************************");
}
}
//------ CH01. IfTest- if문을 이용한 True, False ------ /*
제어문
1. if 문
-형식 :
stmt0;
if(조건문 ){
//조건문 --> 논리형데이타가 반환되는 연산
// 혹은 논리형상수
stmt1;
}else{
stmt2;
}
stmt3;
조건데이타가 true인경우 stmt0-->stmt1-->stmt3;
조건데이타가 false인경우 stmt0-->stmt2-->stmt3;
*/
public class IfTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int x= 20, y= 30;
System.out.println("stmt1");
if (x > y){
System.out.println(x+" > "+y);
}
else {
System.out.println(x+" <= "+y);
}
System.out.println("stmt2");
if (x > y){
System.out.println(x+" > "+y);
}
System.out.println("stmt3");
if (x == y)
System.out.println(x+" == "+y);
System.out.println("stmt4");
if (x!=y)
System.out.println(x+" != "+y);
else
System.out.println(x+"=="+y);
}//end main
}//end class
//------ CH01. LogicalOperator - 논리 연산자 ------ import java.util.Scanner;
/*
논리연산자
- 형태: ||(Logical OR) , && (Logical AND) ( |,& )
- 좌우측의항이 논리형데이타이다.
- 결과도 논리형데이타이다.
ex> true || false, false && false
*/
public class LogicalOperator {
private static Scanner sc;
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
boolean b1, b2;
boolean result;
b1 = true;
b2 = false;
result = b1 || b2;
System.out.println("true || false = "+result);
result = b1 && b2;
System.out.println("true && false = "+result);
b1 = false;
result = b1 || b2;
System.out.println("false || false = "+result);
result = b1 && b2;
System.out.println("flase && false = "+result);
boolean flag = false;
result = !flag;
System.out.println("!false="+result);
//수의 범위 체크
int score = 0;
boolean IsValid ;
sc = new Scanner(System.in); //static으로 상단에서 지정
System.out.println("***Input Your Score***");
score = sc.nextInt();
IsValid = (score >= 0) && (score <= 100);
System.out.println("1. score is "+IsValid);
IsValid = ! ((score<0) || (score>100));
System.out.println("2. score is "+IsValid);
}
}
//------ CH01. RelationalOerator - 관계 연산자 ------ import java.util.Scanner;
/*
관계(비교)연산
- 형태: >,<,>=,<=,==,!=
- 관계연산의 결과값은 논리형 데이타이다(true,false)
*/
public class RelationalOerator {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a = 10;
int b = 20;
boolean result;
Scanner sc = new Scanner(System.in);
a = sc.nextInt();
result = a > b;
System.out.println("10 > 20 = "+result);
result = a == b;
System.out.println("10 == 20 = "+result);
result = a != b;
System.out.println("10 != 20 = "+result);
}
}
//------ CH01. UnaryOperator - 단항 연산자 ------ /*
단항연산자
- 증가,감소연산자
ex> i++ , i-- , ++i , --i
-자기자신의값을 정수 1만큼 증가시키거나 감소시키는
연산자
*/
public class UnaryOperator {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i=0;
System.out.println("i = "+ i);
System.out.println("i = "+ i++);
System.out.println("i = "+ ++i);
int i1=4, j1=4;
int result1, result2;
result1 = ++i1;
result2 = j1++;
System.out.println("i1 = "+i1);
System.out.println("j1 = "+j1);
System.out.println("r1 = "+result1);
System.out.println("r2 = "+result2);
}
}
//------ CH01. VariableDeclare - 다양한 표현식 ------ public class VariableDeclare{
public static void main(String[] args){
//자바의 단문주석
/*
자바의 장문주석1
자바의 장문주석2
*/
/*
자바변수의선언
- 형태 : 타입 식별자(identifier);
ex> int level;
*/
//1.변수의 선언
int score;
int score1=8888;//선언 & 초기화
int _score2=9999;
int 스코어3=1000;
/*
int 2score;
int my score;
int super*score;
int public;
*/
//2.변수의 초기화
score = 7777;
System.out.println("score="+score);
System.out.println("score1="+score1);
System.out.println("_score="+_score2);
System.out.println("스코어3="+스코어3);
}
}
//------ CH01. VariableTypes - 다양한 타입 ------ //단문주석
/*
장문주석1
장문주석2
*/
/*
변수의선언
- 의미:JVM 에게메모리를할당해달라고
요청하는작업
- 형태:
데이타타입 이름;
ex> int number;
- 변수식별자규직(클래스이름,변수이름,메쏘드이름)
- 영문이나,한글로시작
- 특수문자사용불가(_,$)
- 키워드 사용금지
*/
public class VariableTypes {
public static void main (String[] args){
//1. 논리형(논리형상수 -> T,F는 그 자체 값 바꿀 수 X)
boolean b1, b2;
b1 = true;
b2 = false; //java는 boolean값으로 0,1 지원X
System.out.println ("b1 = "+b1);
System.out.println ("b2 = "+b2);
//2. 문자형
char munja1, munja2, munja3, munja4;
munja1 = 'a';
munja2 = 'ㅁ';
munja3 = '김';
munja4 = 44608;
int munja5 = '김';
System.out.println ("munja1="+munja1);
System.out.println ("munja2="+munja2);
System.out.println ("munja3="+(int)munja3);
System.out.println ("munja4="+munja4);
System.out.println ("munja5="+munja5);
int i=97;
for (i=97; i<123; i++){
System.out.print ((char)i+" ");
}
System.out.println ();
//3. 숫자
//3-1. 정수형 (정수형 상수)
/********byte********/
byte b = 100; //-128~127 (1byte)
/*
4바이트상수에 100을 넣고나서 byte에 넣더라도
byte 범위 안에 감당할 수 있는 값이면 넣어준다.
= 자동casting해준다.
*/
/* byte by;
int ii1 = 100;
by = ii1; //possible loss of precision 이건 int->byte니까 무조건안됨.
*/
/********shotr********/
short s = 200; //-32768~32767 (2byte)
/********int********/
int i1; //(4byte)
i1 = 2147483647; //int범위= -2147483648~2147483647
/*
i1 = 2147483648;
error:integer number too large: 2147483648
*/
/********long********/
long l1 = 2147483648L; //(8byte)
/*
long l1 = 2147483648;
상수는 무조건 4byte로 잡힌 다음에 들어가기 때문에
long으로 선언해도 error, 그래서 숫자 뒤에L써줌
*/
System.out.println ("i1 = "+i1);
System.out.println ("l1 = "+l1);
//3-2. 실수형 (실수형 상수 (0.2, 500.1, 45.12)기본 8byte double)
float f1, f2;
f1 = 3.141592f;
System.out.println ("f1 = "+f1);
double d1;
d1 = 0.012345678;
System.out.println ("d1 = "+d1);
/********String Type (문자열형)********/ String str1, str2;
str1 = "열심히 살자";
str2 = "될 놈은 된다";
String str3 = str1+str2;
System.out.println ("str3 = "+str3);
/* tip: sysout + Ctrl+space = System.out.println();
* cf: Help - KeyAssist*/
}
}
//------ CH01. YearTest - 윤년 출력 ------ import java.util.Scanner;
/*
*
* ① 4로 나누어 떨어지는 해는 우선 윤년으로 하고
② 그 중에서 100으로 나누어 떨어지는 해는 평년으로 하며
③ 다만 400으로 나누어 떨어지는 해는 다시 윤년으로 정하였다
good
String result="";
if(year%4==0 && year%100!=0 || year%400==0) result="윤년";
else result="평년";
System.out.println(year+"년은 "+result+"입니다.");
*/
public class YearTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int year;
String youn_year = null;
Scanner sc = new Scanner(System.in);
year = sc.nextInt();
if (year <= 0){
System.out.println("년도 입력은 양수만 가능합니다.");
return; //해당 경우에 하위 문장을 실행하지 않고 return
}
if (year%4 == 0){
if (year%100 == 0){
if (year%400 == 0){
System.out.println(year+"년도는 윤년 입니다.");
}
else{
System.out.println(year+"년도는 평년 입니다.");
}
}
else{
System.out.println(year+"년도는 윤년 입니다.");
}
}
else{
System.out.println(year+"년도는 평년 입니다.");
}
}
}
'JAVA > 자바실습' 카테고리의 다른 글
| [JAVA] OOP 다형성 - 오버로딩 (0) | 2013.06.12 |
|---|---|
| [JAVA] OOP Encapsulation 캡슐화 (0) | 2013.06.12 |
| [JAVA] OOP BASIC (객체지향 프로그래밍 기초) (0) | 2013.06.12 |
| [JAVA] 자바기본2: For, While 문을 이용한 구구단, 별 찍기, 알파벳 출력 등 (0) | 2013.06.12 |
RECENT COMMENT