Yi

-----------------------------
-- hr
-----------------------------

-- 테이블 생성
create table temp_emp (
id number not null,
name varchar2(12),
primary key (id)
);

-- 테이블 검색
select * from tab where tname='TEMP_EMP';

-- 테이블 구조보기
desc temp_emp;

-- commit/rollback
insert into temp_emp(id, name) values(1,'홍길동');
select name from temp_emp where id=1;
commit;
update temp_emp set name='홍인영' where id=1;
insert into temp_emp(id, name) values(2,'홍판서');
select * from temp_emp;
rollback;
commit;
select name from temp_emp where id=1;
delete temp_emp;
rollback;
select name from temp_emp where id=1;

select * from temp_emp;
update temp_emp set name='홍만석' where id=1;
savepoint a;
insert into temp_emp(id,name) values(3,'강감찬');
savepoint b;
delete from temp_emp;
rollback to savepoint a;

----------------------------
-- sys
----------------------------
-- 예약어
select keyword from v$reserved_words order by keyword;

----------------------------
-- hr
----------------------------
select * from departments;

----------------------------
-- scott
----------------------------

-- *** select

-- scott의 모든 테이블
select * from tab;
-- emp테이블의 모든 컬럼 조회
select * from emp;
-- emp테이블의 구조
desc emp;
-- emp테이블의 empno, ename 컬럼 조회
select empno, ename from emp;
-- emp테이블에 있는 job의 종류 조회
select distinct job from emp;
select job from emp;
-- emp테이블에 있는 모든 job
select all job from emp;
-- sal에 대해 정렬
select * from emp order by sal asc;
select * from emp order by sal;    
select * from emp order by sal desc;
-- 정렬시 null인 값은 마지막에
select * from emp order by comm;
-- 2차 정렬 (1차정렬이 완료된 후 2차정렬함)
select deptno, ename from emp order by deptno, ename;
-- alias (별칭)
select empno, sal 봉급, sal*0.1 보너스, sal+sal*0.1 총수령액 from emp;
-- emp테이블에서 deptno가 10
select empno, ename, deptno from emp
where deptno=10;
-- 현재 오라클이 인식하는 날짜 형식 알아내기
select value from nls_session_parameters
where parameter='NLS_DATE_FORMAT';
-- 사원들의 입사일
select hiredate from emp;
-- 1983년 이전에 입사한 사원들의 데이터
select * from emp where hiredate<'83/01/01';
-- 조건연산
select * from emp where deptno=10 and sal<3000;
-- not in 연산 (job이 SALESMAN이 아닌 데이터)
select * from emp where job not in 'SALESMAN';
-- in 연산 (job이 CLERK, MANAGER인 데이터)
select * from emp where job in ('CLERK','MANAGER');
select * from emp where job='CLERK' or job='MANAGER';
-- like 연산
-- ename에 M이 포함된 모든 데이터
select * from emp where ename like '%M%';
-- ename이 M으로 시작하는 모든 데이터
select * from emp where ename like 'M%';
-- ename이 M으로 끝나는 모든 데이터
select * from emp where ename like '%M';
-- 한글자는 _ (_자체를 표시하려면 \_)
select * from emp where ename like '_____';
-- between a and b (a, b를 포함해서 그 사이)
select empno, deptno from emp where deptno between 10 and 20;
select empno, deptno from emp where deptno>=10 and deptno<=20;
select * from emp where ename between 'A' AND 'K';
select * from emp where hiredate between '81/01/01' and '83/05/01';
-- null : 데이터 없음
select * from emp where comm is null;
select * from emp where comm is not null;
-- (X) select * from emp where comm=null;
-- 문자열 접합
select ename||'의 1년 연봉은'||sal||' 입니다!' as 연봉 from emp;
-- union (합집합)
select empno, ename from emp
union
select deptno, dname from dept;
-- union all (합집합 + 교집합)
select empno, ename from emp
union all
select deptno, dname from dept;
-- intersect (교집합)
select empno, ename from emp
intersect
select deptno, dname from dept;
-- minus (차집합)
select empno, ename from emp
minus
select deptno, dname from dept;
select deptno, dname from dept
minus
select empno, ename from emp;
-- projection : 열(컬럼) 추출
-- selection : 행(로) 추출

-- *** DML (Data Manipulation Language) - insert, update, delete
create table emp_dml(
sid number primary key,
name varchar2(12)
);
create table emp_dml2(
sid number primary key,
name varchar2(12)
);
-- insert
insert into emp_dml values (1111,'홍길동');
select * from emp_dml;
insert into emp_dml(sid, name) values(2222,'이순신');
-- null허용컬럼은 insert하지 않으면 null값 insert됨
insert into emp_dml(sid) values(3333);
-- subquery를 이용한 데이터 insert
insert into emp_dml2(sid, name) values(4444,'장화');
insert into emp_dml2(sid, name) values(5555,'홍련');
insert into emp_dml select * from emp_dml2;
-- update
update emp_dml set name='이순삼' where sid=2222;
-- subquery를 이용한 update
update emp_dml set name='박순삼'
where sid=(select sid from emp_dml2 where name='장화');
-- delete
delete from emp_dml where sid=1111;
delete from emp_dml where sid=(select sid from emp_dml2 where name='장화');
commit;

20090216-lsj403.sql

20090216_home-lsj403.sql

//Java Serializatoin 이란?
자바 객체를 저장 또는 전송하기 위하여 자바 객체의 코드를 다시 복원가능한 형태의 Stream으로 직렬화 시켜주는 것을 말함!! 

기존예제 테스트 및 압축만!!

-Swrite.java-

//Java Serializatoin 이란?
//자바 객체를 저장 또는 전송하기 위하여 자바 객체의 코드를
//다시 복원가능한 형태의 Stream으로 직렬화 시켜주는 것을 말함!! 
package serializable;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.util.Date;

public class swrite {

 public static void main(String args[])

 {

  try {
   //파일이나 데이터를 출력하기위한 출력스트림을 생성한다.
   //tmp라는 파일을 갖는 f라는 객체 생성
   FileOutputStream f = new FileOutputStream("tmp");
   //기본데이터 타입의 데이터를 쓰는 객체 s 생성
   ObjectOutput s = new ObjectOutputStream(f);
   //Object타입의 객체를 쓴다. 인자는 문자열 타입의 "Today"
   s.writeObject("Today");
   //데이터 타입을 객체로 쓴다.
   s.writeObject(new Date());
   //스트림을 보내다. 메모리해제!! 및 tmp 파일로 생성됨
   s.flush();

  }

  catch (IOException e) {
  }
  
  //투데이라는 문자열 출력
  System.out.println("Today");
  //현재의 날짜를 출력
  System.out.println(new Date());

 }
}//class

위의 프로그램은 File Stream을 열어서 tmp라는 파일에 2개의 객체("Today"라는 String 객체와 Date 객체)를 저장하고 있다.  

여기서 객체저장을 위해 writeObject라는 메쏘드가 사용되고 있다는 것을 알 수 있다. 

위의 프로그램을 실행하면 2 객체가 시리얼라이제이션이 일어나서 다시 복원가능한 형태로되어 직렬화되어

tmp라는 파일로 저장된다. 

객체를 파일로 저장하다니? 얼마나 놀라운가? 

(제대로 다시 복원만 된다면...) 

자! 그럼 tmp 파일에서 객체를 살려보자!!! 

-Sread.java-

package serializable;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.util.Date;

public class sread {

 public static void main(String args[]) {
  try {
   // 파일 입력을 받기위한 파일 입력 스트림 in 객체 생성
   // 인자는 파일 또는 "tmp"문자열 사용 가능
   FileInputStream in = new FileInputStream("tmp");

   // 입력받은 in객체를 입력을 받기위한 객체 s로 만듬
   ObjectInput s = new ObjectInputStream(in);

   // 읽어들인 객체를 문자열 today에 저장
   String today = (String) s.readObject();
   // 읽어들인 객체를 Date 타입의 date객체로 저장
   Date date = (Date) s.readObject();

   System.out.println(today);

   System.out.println(date);

  } catch (IOException e) {
  } catch (ClassNotFoundException e) {
  }
 }
}// class

-Test.java-

package serializable;

public class Test {

 //전역 문자열 변수 str
 public String str;
 
 //transient
 //나중에 다시 사용하기 위한 저장을 하지 않는,
 //짧고 제한된 수명을 갖는 소프트웨어 객체이다.

 //전력선을 통해 오직 몇 분의 1초 동안 지속되는
 //갑작스러운 여분의 전압 펄스가 들어오는 것으로서,
 //컴퓨터나 파일 등에 손상을 입힐 수 있다.
 public transient int ivalue;

 public Test(String s, int i) {
  this.str = s;
  this.ivalue = i;
 }
}//class

당연히 java.io.Serializable 인터페이스를 implements하고 있어야 한다. 

위에서 Test 클래스에 멤버변수로 String 타입의 str과 int 타입의 ivalue가 있음을 볼 수 있다. 

그런데 이기서 transient 키워드에 주목하자! 

transient 키워드는 앞에 지정하면 지정된 항목 내용은  

자바 시리얼라이제이션에서 제외된다.  

즉, 직렬화가 이루어질때 사용자가 문제의 소지가 있는 변수나 메쏘드를 제외시킬 수 있도록 해주는 것이다. 

그럼 Test 클래스를 직렬화하여 파일로 저장해보자! 

-Write.java-
package serializable;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

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

  try {
   //file.out이란 이름으로 파일 fos 객체 스트림을 생성
   FileOutputStream fos = new FileOutputStream("file.out");
   //출력스트림 객체 생성
   ObjectOutputStream oos = new ObjectOutputStream(fos);
   //태스트클래스를 이용하여 문자열, 숫자 타입의 객체를 인자로 넘겨 객체 생성
   oos.writeObject(new Test("testing", 37));
   //메모리 해제 및 파일 생성
   oos.flush();
   //스트림을 사용하였으므로ㅌ 스트림을 닫는다.
   fos.close();
  }
  catch (Throwable e){
   //출력 결과들 출력
   System.err.println(e);
  }
 }
}//class

위의 소스는 Test 객체를 file.out이라는 이름의 파일로 저장할 것이다. 

역시 writeObject를 사용했고, 초기 값으로 "testing" 이라는 문자열과 37의 값을 지정했다. 

자! 그럼 file.out 파일에서 Test 객체로 복원시켜 보자! 

-Read.java-

package serializable;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class read {

 public static void main(String args[]) {
  //테스트 클래스 타입의 객체 생성
  Test testobj = null;
  try {
   //file.out이란 파일을 읽어 입력스트림으로 변환
   FileInputStream fis = new FileInputStream("file.out");
   //파입입력스트림을 객체입력스트림 객체로 생성
   ObjectInputStream ois = new ObjectInputStream(fis);
   //읽어들인 객체를 테스트타입크랠스 객체로 저장
   testobj = (Test) ois.readObject();
   //파일 입력이 완료되었으므로 닫는다.
   fis.close();
  }
  catch (Throwable e){
   e.printStackTrace();
   //System.err.println(e);
  }
  //변환된 스트림을 출력하기 위해 만들어진 객체 타입의 필드값을 출력
  System.out.println(testobj.str);
  System.out.println(testobj.ivalue);
 }//method
}//class

-MyObject.java-

package serializable;

import java.io.Serializable;

public class MyObject implements Serializable {
 
 //객체 생성
 String name;
 int count;

 //기본 생성자
 MyObject() {
  setName();
 }

 //setter
 public void setName() {
  count++;
  name = "MyObject " + count;
 }

 //이름을 반환하는 toString메소드 재정의
 public String toString() {
  return name;
 }
}

역시... Serializable 인터페이스를 implements하고 있으며... 변수로 name과 count를 가지고 있다. 

컨스트럭터에서 setName() 메쏘드를 호출하여 count를 증가시키고 name의 String에도 숫자가 추가되고 있다. 

그러면 위의 객체를 스트림을 통하여 소켓으로 전송하기위하여 먼저 서버를 만들어보자! 

-JabberServer.java-

package serializable;

import java.io.DataInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class JabberServer {

 //포트 설정
 static final int port = 8080;

 public static void main(String[] args) {
        try {
         //빈 객체 생성
             MyObject o = new MyObject();
             //서버소켓 생성
             ServerSocket s = new ServerSocket(port);
             //생성된 서버 출력
             System.out.println("Server Started: " + s);
             //서버소켓에 접속이 이루어졌을 때 소켓을 생성
             Socket socket = s.accept();
             //접속한 클라이언트의 상태를 출력
             System.out.println("Connection accepted, socket: " + socket);
             // 접속한 클라이언트의 출력스트림을 갖는 출력 스트림 객체를 생성
             ObjectOutputStream ToClient =
                                  new ObjectOutputStream(
                                        socket.getOutputStream());
             //소켓의 입력스트림을 받는 데이터 입력스트림 객체를 생성
             DataInputStream FromClient =
                                  new DataInputStream(
                                        socket.getInputStream());
             //오브젝트객체의 카운트가 10이될 때까지 반복
             while (o.count<11) { 
              //오브젝트 객체를 사용한 횟수 출력
                  System.out.println("writing " + o);
                  //이름 설정
                  o.setName(); 
                  /**
                    Object reference를 reset한다.
                    (이 부분이 포인트)
                    이것을 안하면 첫번째 전송한 객체의 
                    reference로  계속 전송된다.
                    그래서 갱신된 data가 반영되지 못하는
                    현상이 생긴다.
                  */
                  //서버를 리셋
                  ToClient.reset();
                  //빈객체를 클라이언트객체에 쓴다.
                  ToClient.writeObject(o);
                  System.out.print("trying to received acknowledgement ... ");
                  //클라이언트에서 읽은 인트 값을 출력한다.
                  System.out.println("acknowledgement: " +
                                             FromClient.readInt()); 
                  System.out.println("succeeded");
             }
             System.out.println("closing...");
             //클라이언트의 연결을닫는다.
             ToClient.close();
             //서버 소켓을 닫는다.
             socket.close();
        } 
        catch(Exception e){
             e.printStackTrace();
        } 
    }
}

위 서버 프로그램에서는 서버 소켓을 8080 포트로 열어놓고 클라언트를 기다리다가 클라이언트가 억셉트되면 계속 동작하게 되어있다. 

계속 설명하기 전에... 클라이언트 프로그램도 같이 보도록 하자! 

-JabberClient.java-

package serializable;

import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.ObjectInputStream;
import java.net.InetAddress;
import java.net.Socket;

public class JabberClient {

 static final int port = 8080;

 public static void main(String args[]) {
        MyObject o;

        try 
        {
         //아이피 객체 생성, 이름은 없다~
            InetAddress addr = InetAddress.getByName(null);
            //얻어진 아이피 주소를 출력함.
            System.out.println("addr = " + addr);
            //네트워크를 사용할 소켓 생성, 아이피 주소와 포트번호로 한다
            Socket socket = new Socket(addr, port);
            System.out.println("socket = " + socket);
            //객체를 입력할 입력스트림 생성,
            ObjectInputStream FromServer = new
            ObjectInputStream(socket.getInputStream());
            //서버로 전송할 데이터출력 스트림을 생성
            DataOutputStream ToServer = new
            DataOutputStream(socket.getOutputStream());
 
            //카운트할 변수 선언
            int i=0; 

            while(true){
             //빈 객체에 서버로부터 읽어온 객체를 입력
                o = (MyObject)FromServer.readObject();
                System.out.print("trying to send acknowledgement ... ");
                //스레드 생성, 대기시간은 0.5초
                Thread.sleep(500);
                //출력스트림에 증가된 i값을 증가시켜서 보내줌
                ToServer.writeInt(i++);
                System.out.println("succeeded");
                System.out.println(o);
            }
       } 
       catch (EOFException f){
            System.exit(0);
       } 
       catch(Exception e){
            e.printStackTrace();
       }
   }
}//class

소켓이 맺어진 후에... 

서버에서 MyObject 객체를 생성하면 컨스트럭터에의해 카운트가 1이 된다. 

그후 setName() 메쏘드를 호출하고 나면 카운트가 2가 되고  이것을 스트림으로 바꾸어 객체를 전송하게 된다. 

클라이언트는 전송된 객체를 받아 ACK 성공 메시지를 뿌리고 카운트 값을 찍는다. 

그후 서버에서 setName() 메쏘드를 다시 호출하여 객체의 카운트 상태값을  하나 증가시켜 3으로 만든후 객체를 스트림으로 전송한다. 

클라이언트는 두번째 객체를 받아 ACK 성공 메시지를 뿌리고 카운트 값을 찍는다. 

이때 카운트 값이 갱신된 3값으로 찍혀야 하는데... 

여전히 2로 찍혀져 나온다? 

왜일까???    

이것은 자바의 버그가 아니다. 

이것은 자바 시리얼라이제이션에서는 

처음 전송한 객체의 object reference를 인위적으로

reset시켜 주지 않으면 객체의 상태가 바뀌더라도 전송되는 객체의 object reference는  처음 전송한 객체의 object reference로 계속 가지게 되므로  이와 같은 현상이 발생한다. 

이문제를 해결하려면... 

객체를 스트림으로 전송하기 전에... 

reset() 메쏘드를 통하여 같은 object reference를 사용하지 않도록 리셋시켜주어야 한다. 

즉, 

ToClient.reset(); 부분에 대한 이해가 이번 강좌의 포인트이다. 

이부분이 있고, 없고의 차이를 반드시 이해하기 바란다. 

객체를 소켓으로 계속 전송하게 될 경우... 

실수하면 위와같은 버그아닌 오류에 봉착하기 쉽다. 

Data type --- Primitive type(기본형) 8가지, 1byte~8byte까지있음
           |- Reference type(참조형) 무한대가지
long 8byte정수형을 float 4byte 실수형에 담을 수 있다. 표현 범위가 훨씬 넓기 때문에 float표현가능 범위 내에서 dataloss가 발생하지 않기 때문. bit는 적어도 표현수가 float가훨씬크다.
boolean은 내부적으론 1byte인데 다른 pc에선 2byte로 표현하는 등 정해지지 않아서 알 수 없다.

byte 2 ^ 7
short 2 ^ 15
int 2 ^ 31 bit 인 이유 : 맨 앞은 부호라서 1승을 빼준다.
long2 ^ 63

고정소수점 : 우리가쓰는방법
부동소수점 : 소수 (예 : 12.345) 뒤에 10의 몇승 방식으로 표기하는 방법(1.2345 * 10^3). 지수 표기법.

부동소수점 : 지수 표기법. 가장 근접한 수를 가질 뿐이다. 명확한 수를 뽑을 수는 없음. 표현할 수 있는 수가 한정되어있기때문.
1.xxxx 형식으로 앞에 1자리 수만 쓰는 형식을 쓴다.10.xxx 나 0.10xxx형식으론 쓰지않는다.

실수 기본값 double : 0.0  / boolean : false / int : 0

1000000000 + 2000000000 = 숫자가 표현범위를 넘어가면 숫자는 짤려나가고 나머지 값이 표현된다. -1294967296 으로.

double num; num = 3.14 + 1; 결과 : 4.140000000000001

0.0 은 0이 아니고 0에 가장 가까운 수. 예) 10.0 / 0.0 = Infinity

실수의 연산은 정확하게 나올 수 없기 때문에 소수점 아래에 수는 버리고 원하는 범위내의 수만 취득해야된다.

1byte : 8bit, 맨앞 1bit : +-부호(MSB:Most Significant Bit),  범위 : -2^7 ~(2^7)-1 

long 의 -922경 ~ +922경을 초과하는 수를 표현할 때는 BigDecimal을 사용하면 원하는 모든수를 표현할 수 있다.

10진수와 10진수의 승수(지수)를 2진수로 바꾸기 : 136page참고

double 표기 예 : 4.9e-324; // 4.9 (e-324: 10의 -324승)
double 숫자 4.9e-324; // double타입의 가장미세한 + 값
double 숫자 -4.9e-324; // double타입의 가장미세한 - 값
값이 0이 아니고 수학에서 말하는 0.0에 한없이 가까운 수라서 숫자 / 1억 을 해도 0.0이나-0.0으로나옴

부동소수점 타입의 NaN(Not a Number) : 숫자가 아니다. 표현 방법도있음. 143page참조
NaN은 0.0 등 숫자로 정의할 수 없는 수를 말한다.

유니코드Unicode char type의 내부 표현
예)char의 기본값 : '\u0000' 0000부분을 unicode.org 한글 자리 참조해서 쓴다.
char가C에선 숫자로 써서 표현가능하지만 Java에선 실제로 숫자로 저장되도 내가 숫자로 사용할 순 없다.

리터럴(literal) : 소스 상에 나와있는 데이터. 소스코드 내에 데이터 값 그대로 쓴 상수
int num = 1; 에서 1 : int 타입 리터럴
0.5, 12.0, 12. : 기본적으로 double타입 리터럴 .(점)이 붙으면 .0이 생략된걸로 간주해서 double이 됨.
리터럴 예 : float num;에 num = 12.34; 하면 12.34가 double형이라서 dataloss가 발생.
possible loss of precision 에러가 뜸. 변수를 잃어버릴 가능성이 있습니다.
024 : 8진수 정수. 숫자앞에 0으로 시작하면 8진수로 취급됨.
0x30A1 : 0x나 0X로 시작하면 16진수로 취급됨. 10~15까지의 숫자는 abcde,ABCDE로 표현함.
024L, 0x30A1L, 120L 은 long type으로 취급함. 뒤에 L을 붙이면 long type가 됨.
12e100 : 12*10^100 , e나 E 둘다 지수 표기됨.
p5 : 16의 승수, 16의 5승을 말함. 16^5
12F : float 타입이라서 12.0f의 float타입으로 됨

12.L : 12L은 되지만 12.L은 안된다. 뒤에 숫자대신 L이 와서 오류임. .(점)뒤에 L을 붙이면 12.0L로 해주지않음

''싱글쿼테션마크 안에 있는 것이 문자 1개이다. 글자가 1개라서 ''안에 표기하는것은 아님.
 예)'\n' : 줄바꿈 이라는 한 문자. 소스코드에 직접쓸수없는 문자는 escape sequence를 앞에 둬서 쓴다.
windows : \n / Unix : \n\r 가 줄바꿈 이라는 표기.
escape sequence 목록 : 155page참고
""더블퀘테션 안에 문자는 String type으로 취급한다.
""를 null string이라고 한다. null하고 null string하고 다르다. string이고 메모리에 존재하는데 문자를 가지고 있지 않은것이다.
지갑도 없으면 null(아예없는것), 지갑은 있는데 돈이 없으면 null string.

println 안에 \" 를 써야 따옴표 표시가 가능함.

println 안에 문자 접합할때 쓰는 + 기호는 내부적으로 .concat()라는것을 호출한다. 더하기가 아니다.

1. 자바 프로그램 구성요소 : 키워드, 식별자(identifier), 상수를 표현하는 단어
-키워드 : class, public, static, void
-식별자 : HelloJava, main, String, args, System, out, println

2. 키워드와 식별자의 차이 :
- 키워드 : 자바라는 언어에서 명령으로 정의하는것, 이름으로 정의할 수 없다.
   ex)abstract, for, if, do, try, void, class, while... 등등, 변수의 이름으로 줄 수 없는 것들
- 식별자 : 클래스, method의 이름이라는 뜻 .이름으로 쓰인것들.

3. 상수(constant) : 항상 정해져 있는 수(number라는 의미는 아님.)

4. 변수(variable) : 변화되는 값을 저장하는것

5. 자바의 NULL :  참조할게 없음, 메모리에 없는상태. 값이 없다는 의미는 아님.

6. 기호 :
- 대괄호[] : 배열
- 중괄호{} : 영역
- 소괄호() : 메소드의 파라미터들, 연산자 우선순위 결정할때, 메소드 호출할때 씀
- 마침표. : 참조연산자
- 세미콜론(;) : 문장의 끝을 나타내는 명령 끝 기호
- 등등

7. 데이터 :
- 문자열(string) : " "
- 문자(character) : ' '
- 정수 : .이없으면 정수
- 소수 : .이있으면 소수
- 리터럴 literal : 소스코드에 나온 데이터, "Hello, Java" : 문자열 리터럴
- 등

8. 변수 : 메모리상에 저장된 데이터의 위치를 가지고있는 하나의 메모리, 데이터를 담는 일종의 그릇

9. 변수의 3단계 :
-1) 선언(Declaration) : 변수의 메모리의 크기를 얼마나 할당 받아야 될 지를 컴파일러에게 알려주는 것
-2) 초기화(Initialization) : 선언 후 처음 변수가 값을 가짐을 초기화 과정이라하고 값은 초기값이라 함
-3) 대입, 할당 단계(Assignment) : 값을 할당 받는것, 값을 가짐
-4) 소멸 : 신경안써도 됨. 할당된 메모리를 해제함. JVM이 알아서 해줌.

*스크립트 언어들은 선언을 잘 안하고 씀(동적언어) -> 유연하지만 속도느림
*자바에서는 얼마나 쓸 지 정해놓고 써야 됨(정적언어) -> 속도가빠르다

- int num;
 -- type : int형type 선언         -- num : 4byte의 num이라는 공간을 할당       -- ; : 명령의 끝
* 자바의 모든 데이터 타입은 signed int 이다. unsigned자료형이 없고 부호가 있다.

- 대입문 : 변수에 데이터를 담는 명령문
 ex) num=10+20;
 --num이라는 변수에 10+20을 하라는 의미, 우변을 계산해서 좌변에 더한다.

**에디트 플러스에서 자바 컴파일을 하기 위한 셋팅 준비!!

에디트플러스 -> 도구 -> 사용자도구구성 -> 추가 -> 그룹이름 : java -> 메뉴제목 : javac->명령 -> 경로 bin\javac.exe선택-> 인수 : $(FileName) ->디렉토리 $(FileDir)-> 출력 내용캡쳐 선택->적용
추가 제목 : java-> 명령 : java.exe ->인수 $(FileNameNoExt)  디렉토리 $(FileDir) 적용

에디트플러스에서 ctrl+1 하면 컴파일, ctrl+2하면 실행. 세팅한거 1, 2번 실행하는것임.
ctrl + j : 한줄복사
ctrl + f : 찾기
ctrl + d : 오늘날짜
ctrl + h : 바꾸기
alt + c : 영역블럭지정(세로로도됨)
ctrl + s : 저장

**코딩을 잘하기 위해서는? 에러노트 준비해서 컴파일 과정중 오류 난 것을 모두 저장해서 해결방법 적어놓는다.

---------조건문, 반복문-----------
프로그램의 실행,흐름을 제어하는 두가지 방법
1. 조건문 : if, switch
2. 반복문 : for, for in(jdk1.5부터됨),while, do ~ while
3. 특이한 애들 : break, continue, lablebreak(goto문형식)

if 키워드를 이용한 조건문 : true 나 false만 된다.

윈도우키 + e 키 누름
C:\Program Files\EditPlus 2\template.java 에디트 해서 수정하면 자바파일 신규생성할떄 그것으로 만들어진다.
도구 -> 기본설정 ->설정및 구문강조->설정 자동 않기 하면 자동으로 안만들어진다.

부명령문(substatement):다른명령문안에포함된 명령문.
반복문(interative statement):주어진 일을 반복하는 명령문
while 안에 값을 false로 되는 값을 주어야 끝나게 된다.
예 : num= num + 1;을 while안에 넣음
while 안에 true를 넣는 등의 무한반복 실수를 하지 말것.

4. 블록, 영역(block) : 명령문들을 중괄호로 둘러싼 것. 매우 중요. 변수의 생존범위를 정함.

5. 주석(comment):
-  /* */ 안에 여러문장들은 다 주석이 된다.
-  //는 한줄주석
-  /** */ 아큐먼트 주석. 문서화 주석. API만들때 쓰임.javadoc만들때 쓰임

6. 공백문자:스페이스(SP),탭(HT)horizontal tab, ,줄바꿈 문자(CR, LF),Carrige Return, Line ...새페이지문서 (FF)

7. 로컬변수 : 메소드 안에 선언한 변수가 아니고  블럭 안에서 선언된 것들을 말함. class블럭만 제외. 종류는 3가지가 있다.
                   

8. Java변수의 종류 3가지:
-1) Static 변수(=class변수) : 정적변수, 클래스로 접근함
-2) Dynamic 변수(=객체변수,=object변수,=member변수 ), object로 접근함.
    멤버변수는 Static 멤버변수와Dynamic 멤버변수(Nonstatic)로 나뉜다.
  예) class 안에, main위에 선언된 변수 : 멤버변수
-3) local변수(지역변수)
  C에는 지역변수, 전역변수가 있지만 java는 전역변수가 없다.

  Static, non-static, local은 사는곳이 다르다.
  static은 class영역에 산다.
  local은 Stack영역에 산다.
  객체는 heap영역에 산다.

실행순서 : static(클래스,static)->heap(객체)->stack(local)

9. local변수 :
-1) 는 클래스 로딩시 메모리에 올라옴
-2), 3) 는 런타임(실행)때 메모리에 올라옴
메모리에 올라오는 순서: 1)->2)->3)

static 안에서 non-static은 사용이 안된다.

 static{
  int ssi = 200;
 }
하면 static{}안에 내용은 모두 static변수가 된다.

10. 컴파일 타임 : *.java->*.class 변환될때

11. 클래스로딩타임 : *.class를 기계어로 바꿀때 (static 자리 만든다, jvm이 실행종료될때까지 메모리에 남아있음)

13. runtime(실행시간) : heap과 stack메모리에 올릴때 (stack과 heap은 가변적으로 생기고 없어짐, static 메모리를 공유함)

14. String args[] 도 로컬변수.

선언문 기본형식 1. 타입 식별자;  2. 타입 식별자=초기값;
여러 변수를 한꺼번에 short s1, s2;처럼 사용하지 말고 2줄에 나눠서 사용해야 알아보기 쉽다.

15. 자바는 100% 순수한 객체지향 언어가 아니다.
--그 이유로 프리미티브 타입의 byte, short, int, char.... 등 기본형의 8가지 데이터 형이 있는데 이것은 객체가 아니다.
--자바의 자료형은 기본형과 참조형의 2가지가있다.

16. 기본형(primitive type) : 8가지,
- byte : 1byte,
- short : 2byte,
- int : 4byte,
- long : 8byte ,
- float : 4byte , 숫자뒤에f넣으면 4byte float
- double : 8byte , 숫자뒤에d를넣거나 안넣으면 8byte double
- char : 2byte양의정수,
- boolean : true/false
**객체형으로 만들지 않은 이유: 속도가 빠르기 때문. 객체로 만들면 속도가 느리다.

-자바는 2byte unicode체계이다.그러므로 char는 2byte이다.
-참조형(reference type) : 무제한, 만들면된다.

-변수를 넣을땐 항상 type를 생각해야된다. type가 다르면 오류가 난다.

17. 식별자 명명 규칙
- $date나 _date는 된다. da ta 같이 공백이나 _와$외에 특수문자는 사용하지 못 한다. true,false,null도 안됨
- 상수값은 대문자로 넣는 관례가 있다. 예 : MAX_NUM

18. final변수의 3가지 용법
- final변수가 class에 쓰일때 : 상속불가
- final변수가 method에 쓰일때 : overriding불가
- final변수가 variable(변수)에 쓰일때 : 초기화 한 후에는 값 변경 불가

- 컴파일시 오류는 error
- 실행시 오류는 exception

-ComplexAssing연산자(복합연산자) : +=등등 계열

-증가연산자 num++감소연산자num--가 num=num+1보다 빠르다. 임시로 저장할 공간이 필요 없기 때문.
-전치증가연산자 ++num /후치 증가 연산자num++

-num2 = num++;  // num의 값이 저장 된 후 num++이 수행된다.
-num3 = --num;  // --num이 연산이 된 후 num3에 저장된다. OpTest1.java 참조

자바의 배열
1. 정적배열 : 크기가 고정되어있다. 선언 후에 크기를 지정한 후에 사용가능하다. 크기가 할당되면 절대로 바꿀 수 없다. 속도가 빠른대신 유연하지 못하다.
   동적배열 : 스크립트언어 등이 된다. 자바는 안된다.
2. 배열내에 기본형/참조형 한가지 타입만 담을 수 있다. int면 int, String이면 String만 배열에 담을 수 있다.

예: 스크립트언어의 ECMA배열은 동적 배열이라 아무거나 다 담고 크기도 맘대로 변할 수 있다.
 - 동적 배열 : [문자'c'][숫자1][객체][][][크기새로증가][][][]... 속도가 느리다.
 - 정적 배열 : 1000번지[1]1004번지[2]1008번지[3]  속도가 빠르다.

**배열은 왜 필요한가? : 변수를 많이 만들어야 될 경우 많은 이름들을 만들어야되는데 배열을 사용하면 하나의 이름으로 사용할 수 있다.
main배열 예 : main(String[] args)   혹은 main(String args[]) 으로 사용할 수 있는데
**main(String[] args)로 사용하는 이유가 String[] 스트링 배열인지 한눈에 확인 할 수 있기 때문이다.

int[] i = new int[크기]; // i : int형 배열을 담을 수 있는 type. i는 int형이 아니다. 반드시 크기를 할당해야 쓸 수 있다.

- new : 참조생성연산자
i.length : 배열의 크기를 알려준다. 위의 i.length == 5
일반화를 시키면 index의 크기는 0 =< index =< length-1
 
int[] i = new int[3]; // 하면 int[] type의 기본값인 0으로 배열 안에 자동으로 채워진다. i[0]=10;하면 i[0]만 10, 나머진 0으로 채워진다.
배열 참조형의 기본값은 null으로 채워진다.

new연산자의 의미
int[]i = new int[3]; // 하면 heap영역에 4*3 byte, 총 12byte공간의 메모리가 생긴다.
예)  FFEE:003C의 물리적 주소가 있다면 이 주소의 참조값은 Array타입@해쉬코드16진수 형식으로 생긴다.
1. 배열 객체를 메모리에 생성한다.
2.물리 주소에 대한 참조(reference)연산이 일어난다.
3. i에 참조값을 리턴한다.
기본형은 값을 값으로 받지만 참조형은 참조값을 값으로 갖는다.

char[] charAaary=new char[5]; 하고 System.out.println(charArray);하면 String형태로 바뀐다. 실제로 쳐보면 참조값이 보인다. 잘 모르겠음.
char[]는 String 형태이다.

http://unicode.org/ 가면 전세계에 알려진 문자는 모두 나옴.

배열은 메모리에 연속적으로 잡힌다.
예) 연속적 : [][][][][][] 형태로 주소가 동일 간격으로 떨어져서 붙어있다.

int table[3][4];
table.length : 3
table[0].length : 4

System.out.println(안에 나오는 + : 문자열 접합 연산자

switch (식) : 식에는 정수나 char 타입의 값이 들어간다.

switch에 break문을 사용하지 않으면 아래것들이 모두 실행되니 주의할것.(break를 사용해서 의도된 프로그래밍을 하자)

do - while   은 조건식이 true일 동안 do를 무조건 한번 실행. do - while(); <-반드시 세미콜론;를 쓸 것.

for(초기화식;조건식;업데이트식)
for문의 실행순서
1. 초기식
2. 조건식
3. 실행
4. 증감식
5. 조건식
6. 실행
int cnt= 0;
for ( ; cnt < 10; ){
System.out.println(cnt);
cnt++;
} 이런 형식으로도 선언을 미리하고 조건도 블럭안에 두어서 사용할 수 있다.
for 위에 int cnt하게되면 cnt를 for문 밖에서도 쓸 수있는것이장점.

for(int i = 0; i < a.length ; i++) 형식으로 사용하면 매번 a.length를 계산해야 되므로 프로세스가 더 느려진다. 메모리를 더 잡더라도 int temp = a.length 한 다음에 for(int i = 0; i < temp; i++) 형식으로 하는게 속도면에서 좋은 코드가 된다.
반복문 안에서 연산을 수행하는것은 주의를 해야된다(없도록하는게 좋다. 자바에선 배열 length가 변하지 않기 때문). 5만번이면 시간이 많이 달라지게 된다.

향상된 for반복문(java 1.5이상부터 지원)
for(변수타입 변수이름:배열이름) 반복수행
-변수타입 : 배열항목과 동일한 타입
-변수이름:프로그래머가 나름대로 정할 수 있음.
예) for (int num : arr) System.out.println(num);
arr의 길이만큼 자동으로 반복함.
단점 : 낮은 버젼에서는 컴파일이 안되서 하위버전과 호환성이 떨어진다.

break문 : while,do,for,switch문 안에서 빠져나가는 기능, 가장 가까운 반복문을 빠져나간다. if문 안에서 break를 사용해도 if를빠져나가는게 아니고 가까운 while,do,for,switch문을 빠져나간다.

loop:    <- for문에 붙여진 라벨, lable break는 절대 쓰지말것. goto문 처럼 흐름에 안좋은 코드이다. 100page참고

for문 안에서의 continue : continue아래있는 for문 블럭을 실행하지않고 다음번 for문을 실행함. 101page참고
continue는 brake; 처럼 반복문 안에서만 사용가능(for,while,switch,do)

method는 함수처럼 return값이 있고 파라미터를 받는다.
method는 접근제한자(지정자)를 받는다. 종류 : public, protected, deafult, private, static
method 에서 반환형을 return 값을 준다.없으면 void 값을 리턴한다. 반환형은 출력데이터가 된다.
형식 : [접근제한자] [static] 반환형 메소드이름([파라미터리스트]) {      return 리턴값;   } // [  ] 안은 생략가능하다는 의미
method에서 파라미터리스트에는 변수타입 변수이름, .... , ....등 여러개가 들어갈 수 있다. 입력데이터가 된다.
method의 호출은 stack영역에서 이뤄진다.(stack:LIFO형식)

a('a',100); 처럼 함수를 만들어서 값을 넘겨주는데 넘겨주는쪽을 아규먼트Argument라고 한다.
static void a(char ch, int i){  } 처럼 값을 받는 쪽에선 파라미터Parameter라고 한다.
Argument랑 Parameter랑 동일한 말로 쓰기도 한다.

숫자 파라미터(parameter)를 넘겨줄 때 int형으로 넘겨주는데 그 이유는 가장 빠르기 때문이다. 32bit pc가 이유.. int형이 32비트 기본형이다.

return할 때 기본형은 리턴형 지정하는 선언부분 type과 return타입이 맞아야된다. 참조형은 다르다.

if와 switch는 switch가 빠르다.

main메소드의 파라미터, argument String사용하는 방법 110page참조
main은 반드시 String으로 받아야된다. int형으로 받을 수 없게 되어있다.

10.0 / 0.0 계산하면 양의 방향으로 무한대가 나온다. ( +Infinity 값)

cmd에서 입력할때 * 는 입력이 안되므로 "*" 로 입력하면 *로 입력된다.
cmd에서 입력할때 안녕 홍 길동 의 홍길동 이름부분을 공백없이 묶어서 2글자로 하고싶으면 안녕 "홍 길동" 하면된다
cmd에서 입력할때 안녕 "홍 길동"으로 표현하고 싶으면 안녕 "\"홍 길동"\" 으로 입력하면된다. \" 가 따옴표 표시이다.

Exception(예외) Error(에러)
Error : 프로그래머가 프로그래밍 적으로 손 댈수 없는 상황.
Exception : 프로그래머가 오류를 제어할 수 있는 상황, 프로그래머가 처리해 줘야 될 오류들.
우주에 있는 먼지 하나라도 오류가 날 가능성이 있으면 예외처리(exception)을해주는 것이 좋다.
RuntimeException : 프로그램을 실행하다가 발생하는 예외
Compile Error : 코드를 잘못짜서 실행을 할 수 없는 상황
Out Of Memory : 메모리가 부족함. Error의 종류임.
Exception을 잘 제어할 수록 프로그램을 견고하게 만들게 된다.
Exception의 최상위 클래스에는 Throwable 클래스가 있다.
JavaDoc에서 최상위클래스 Throwable을 검색하면 Error과 Exception을 확인할 수 있다.
try , catch, finally 를 이용하여 exception을 처리해 줄 수 있다.
 try{예외 발생 가능한 코드}
 catch(예외타입 변수명){예외 처리 코드}// catch는 여러개를 만들 수 있다.
 finally{예외가 생기거나 말거나 반드시수행해야 될 실행 코드들}

예)DB를 사용할때 열면 반드시 닫아줘야되는데 finally에 닫는 코드를 넣어준다.

catch를 사용하여 예외가 발생되었을 때 처리하는 부분을 정의해준다. 반드시 쓸것.
e.printStackTrace(); 하면 오류메세지를 출력한다.
System.out.println(e.getMessage()); 하면 오류나는 스택의 자리를 숫자로 알려준다.