맑은소금

자바의 기본 입.출력
 우선 System 이라는 클래스부터 알아보자
 (http://xrath.com/javase/ko/6/docs/ko/api/index.html)
 System클래스의 필드는 모두 3가지 임을 알수있다.
 in, err, out
 이것은 System. 뒤에 오는 멤버가 3가지라는 것을 말하고
 다시 이것은 PrintStream이란 클래스와 연결되어 있는걸 볼수있다.
 PrintStream이란 클래스는 java.io 패키지 안에 있는 클래스로
 이것을 실행시켜주려면 import java.io.*을 해줘야 한다.

import java.io.*;
public class Exec_01 {
 public static void main(String[] args) throws IOException{
  System.err.println("에러 출력 스트림...");
  int x = System.in.read();
  System.out.println("x = " + x);
  System.out.println("기본 출력 스트림...");
 }
}
=> 입력을 받으려면 예외처리를 해줘야 하는데...
   예외처리로 java.io패키지를 반드시 import 시켜주고
   사용하고자 하는 곳에 throws IOException을 넣어준다.

 
- 기본출력
  - System.out.write(출력대상);
   
public class Exec_02 {
 public static void main(String[] ar) {
  System.out.write(65);
 }
}

=> 아무것도 출력되지 않음을 알수있다.(결과는 종료되었는데도,...)
   jvm은 메모리나 버퍼에 자료를 담고 있다가 어느정도 자료가 쌓이면
   자료를 화면에 출력을 해 주는데 메모리상에 자료를 화면에 내 보내는
   것을 flush()를 해줘야 한다.
   항상 쌍으로 이뤄져야 화면에 나타나게 되는데 나중에 배울
   화일처리나, 통신에서 중요하게 다루게 된다.

public class Exec_02 {
 public static void main(String[] args) {
  System.out.write(65);
  System.out.flush();  
 }
}

  - System.out.write(배열, 초기위치, 길이);

public class Exec_02 {
 public static void main(String[] args) {
  System.out.write(65);
  System.out.flush();
  System.out.println();
  byte[] by = new byte[]{'J', 'A', 'V', 'A'};
  System.out.write(by, 0, 4);
  System.out.println();
 }
}
=> 위의 write()에서는 flush를 해줘야 하는데 아래 배열을 넣은 write에서는
   flush를 안해도 된다.
   이것을 auto flush라고 한다.

  - System.out.print(출력대상);
    콘솔에 출력을 해라
  - System.out.println(출력대상);
    콘솔에 출력을 하고 한줄 내려라
  - System.out.printf("서식",출력대상); - 1.5버젼부터 사용 가능
    자바 1.5버전부터 PrintStream클래스에 printf라는 메소드를 도입했다.
    다음은 그 형식과 설명이다.(c에서 따온 방식이다)
    %c - char 문자 1개를 출력하는 서식
    %숫자c - char문자 1개를 해당 숫자의 자리수만큼 확보한 상태에서 출력하는 서식
             (음수이면 좌측정렬, 양수이면 우측정렬)
    %d(%o, %x) - byte,short,int,long형의 데이터를 10진(16,8진)수로 출력하는 서식
    %숫자d(%숫자o,%숫자x) - byte,short,int,long형의 데이터를 10진(16,8진)수로
                            해당하는 숫자의 자리수만큼 확보한 상태로 출력하는 서식
                            (음수이면 좌측정렬, 양수이면 우측정렬)
    %0숫자d(%0숫자o,%0숫자x) - 확보한 자리가 공백이면 0값을 공백에 채우게 하는 서식
                              (음수이면 런타임 에러가 발생)
    %f(%g, %e) - float,double형의 데이터를 실수(근사,지수)로 출력하는 서식
    %숫자f(%숫자g,%숫자e) - 숫자는 소수점이하 1자리를 나타낼수 있다.
                            예 %10.2f는 10자리중 2자리는 소수점이하로 나타내라는 뜻
    %0숫자f(%0숫자e,%0숫자e)
    %s - 문자열(String) 데이터를 출력하는 서식
    %숫자s   

public class Exec_03 {
 public static void main(String[] args) {
  int a = 100;
  char b = 'A';
  float c = 12.346f;
  String d = "김병철";
  
  System.out.printf("a = %d 입니다.\n", a);
  System.out.printf("b = %c = %d \n", b, (int)b);
  System.out.printf("c = %6.2f \n", c);
  System.out.printf("d = %s 입니다.", d);
 }
}
    
  자바에서는 + 연산자를 문자열의 나열시 사용할수 있게 해 놓았다.
  String s1 = "자바"; String s2 = "김병철"
  System.out.println(s1 +"아이티윌" + "강사" +s2);  =>자바아이티윌강사김병철
  문자열에서만 + 가 나열이지 그냥 변수에서는 아니다.
  int a = 1; int b = 2;
  System.out.println(a+b); => 3
  하지만, 아래에서는 결과값이 다르다.
  System.out.println(""+a+b); => 12
  문자열은 그 어떤것과 연산이 되어도 문자열이 되어버리는 무서운 성질을 가지고 있다.
  System.out.println(""+a+b*2); => 14
  System.out.println(""+a+b-1); => error
     
입.출력 예외 처리
 - 항상 안정성을 두고 작업을 하게끔 구성이 되어 있다
   예기치 않은 사항이 발생했을때 이렇게 처리해라 라고 미리 정의하는것을 예외처리라 함
 - 자바에서 입.출력을 처리함에 있어 예외 처리를 하게끔 요구되어 있다.
   그렇지 않을 경우, 컴파일조차도 되지 않도록 설계되어 있다.
   앞서 배운 print,println,printf는 자체적을 예외처리가 되어 있어서 생략이 가능한
   것이고 나머지는 반드시 예외 처리를 해 주어야 한다.
 - 반드시 java.io 패키지를 import 시켜줘야 한다.
 - 입.출력과 관련된 내용이 사용되는 메서드 뒤에 IOException을 throws 시킨다

import java.io.*;
public class Exec_04{
  public static void main(String[] args) throws IOEception {
    byte[] = bb = {'J','A','V','A'};
    System.out.write(bb);
  }
}
=> 메소드와 구문의 시작 사이에 throws IOEception를 입력해준다.
   메소드에 대해 간단히 배울텐데 메소드에서 사용을 하면
   메소드에서도 throws IOEception를 입력해줘야 한다.
  
import java.io.*;
public class Exec_05 {
  public static void aaa() throws IOException {
  }
  public static void main(String[] ar) throws IOException {
    aaa();//aaa()매소드를 사용하면 여기도 throws IOException를 해줘야 한다
  }
}

 
기본 입력
한글자 입력
  - System.in.read();
    java.io 패키지의 InputStream클래스이며, 이 클래스내의 모든것을 사용 가능
    아스키코드값으로 입력을 받는다.
    int aa = System.in.read();
    System.out.println("입력하신 것은 ="+aa);
    A를 입력하면 65가 나오게 된다.
    만약 입력한 그대로 나오게 하려면
    char aa = (char)Sytem.in.read(); 이렇게 해줘야 한다.
    숫자일 경우에는
    int aa = System.in.read() - 48; 또는 int aa = System.in.read() - '0'을 해준다

@@ 한개의 문자를 받아 화면에 아스키코드값을 나타내기

import java.io.*;
public class Exec_06 {
  public static void main(String[] args) throws IOException {
    System.out.print("아무키나 누르세요");
    int a = System.in.read();
    System.out.println(char(a)+"키의 아스키값은 = "+a);
  }
}

@@ 두개의 문자를 받는 프로그램 코딩후 아래 설명후 수정

  두개이상을 입력받고자 한다면
  int aa = System.in.read();
  System.in.read();
  System.in.read();
  이렇게 해줘야 한다. 이유는 자바에서는 enter키도
  하나의 입력으로 생각하기 때문이다.
  또한 enter는 \r 과 \n 두개를 가지고 있으므로
  입력문 2개를 만들어서 처리해 줘야 한다.
 
문자열입력받기
- BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
역시 외어야 하며, 문자열 입력받을 메소드 안에 넣어준다.
 
import java.io.*;
public class Exec_07{
  public static void main(String[] args) throws IOEception {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    String name = "";
    System.out.print("이름을 입력하세요");
    name = in.readLine();
    System.out.println("당신의 이름은 " + name + " 입니다");
  }
}

문자열을 받은 데이타를 자료형을 변환하고 한다면
일반 자료형으로는 불가능 하므로 우리가 알고있는 함수 wrapper클래스를 이용하자

 문자열로 받은 데이타를 boolean형으로 변환하는 방법
import java.io.*;
public class Exec_08{
  public static void main(String[] args) throws IOEception {
    BufferedReader in = BufferedReader(new InputStreamReader(System.in));
    System.out.print("boolean 자료를 입력하세요");
    String imsi = in.readLine();
    boolean bool = Boolean.valueOf(imsi).booleanValue();  //<=암기하세요
    System.out.println("입력하신 boolean형 자료의 값은 "+ bool + "입니다");
  } 
}

 문자열로 받은 데이타를 int형으로 변환하는 방법
 (boolean형만 제외하고 다 이방법으로 한다)
import java.io.*;
public class Exec_09{
  public static void main(String[] args) throws IOEception {
    BufferedReader in = BufferedReader(new InputStreamReader(System.in));
    System.out.print("나이를 입력하세요");
    String imsi = in.readLine();
    int aa = Interger.parseInt(imsi); //숫자가 아닌 다른 문자라면 오류발생
    //또는 int aa=Interger.parseInt(in.readLine()); 위 두줄대신 이렇게도 함
    System.out.println("당신의 나이는 "+aa+"입니다");
  }
}

연산자 우선순위
연산자란 어떤 대상체에 대해 계산을 수행하도록 하는 특수한 문자 기호의 총칭이다.
그래서 어떤 연산자가 먼저 실행하는지, 그 연산자가 어떠한 일을 하는지 알아야 한다.

일반적인 실행순서는 왼쪽에서 오른쪽, 위에서 아래이지만, 예외적인 상황 중 하나가
연산자가 사용되었을 때 이다.

boolean bool = 4 + 5 > 2 - 1 * 7 && (12 & 3 * 2) > 7 || -2 != 2;

결과는 true의 값이 저장된다.

이유는??
우선 ()안을 먼저 계산 하는데 & 와 * 중 * 를 먼저 계산해야 하므로
(12&6) 00001100 & 00000110 = 00000100 이므로 닶은 4
4+5>2-1*7&&4>7||-2!=2;
산술연산을 해준다. *와 /가 +나 -보다 우선순위가 높으므로
9>-5&&4>7||-2!=2;
관계연산자를 계산해 준다.
9>-5 true, 4>7 false, -2!=2 true 따라서
true && false || true;
false || true;
true;

연산자의 우선순위는 다음과 같다.
최우선연산자 > 단항연산자 > 산술연산자 > 쉬프트연산자 > 관계연산자 > 비트연산자
> 논리연산자 > 삼항연산자 > 배정대입연산자 > 증감후위연산자 > 순차연산자

최우선연산자 - “.”, “[]”, “()”
. : 참조연산자 - 클래스의 멤버를 사용하기위해 사용됨
[] : 배열참조연산자? - 배열위 위치번째를 나타낼때 사용됨
() : 괄호연산자 - 특정연산자를 묶어 먼저 처리할수 있게 만들어 주는 연산자

public class Exec_01 {
 public static void main(String[] args) {
  System.out.println("Test");
  int x = 5 + 3 * 2;
  int y = (5 + 3) * 2;
  System.out.println("x = " + x);
  System.out.println("y = " + y);
 }
}

단항연산자 - "!" , "~" , "+/-" , "++/--" , "(cast 자료형)" , "instanceof"
! : 논리부정 - 내용의 반대되는 값을 표현, boolean자료형에서만 사용가능

public class Exec_02 {
 public static void main(String[] ar) {
  boolean bool = false;
  System.out.println("a = " + bool);
  System.out.println("b = " + !bool);
  boolean bool1 = 5 > 3;
  System.out.println("c = " + bool1);
  System.out.println("d = " + !(5 > 3));
  //System.out.println("e = " + !5);
 }
}

~ : 비트부정 - 비트단위로 부정을 한후, 2진수 0은 1로, 1은 0으로 바꾸는 작업
    boolean, 실수형자료형에서는 사용 불가
    byte,short,char,int 형은 ~연산후 int형이나 long형에 결과값을 담을수 있고
    long형은 ~연산후 long형에만 담을수 있다.

public class Exec_03 {
 public static void main(String[] args) {
  System.out.println("a = " + ~(~(4)));
  int x = +4;
  int y = -4;
  int z = -4 * -3;
  System.out.println("z = " + z);
 }
}

+/- : 부호연산자

++/-- : 특정필드의 값을 하나 증감시키는 연산자
        앞쪽에 적히는 경우가 우선순위 2순위인 단항연산이고
        뒤에 붙으면 우선순위 11위인인 증감 연산 후위형에 속한다.
        int a=5; int k = 4 + ++a * 3; k=22, a=6(연산전 계산)
        int a=5l int k = 4 + a++ * 3; k=19, a=6(연산후 계산)

public class Exec_04 {
 public static void main(String[] args) {
  int x = 10;
  int y = ++x;
  System.out.println("x = " + x);
  System.out.println("y = " + y);
 }
}

public class Exec_05 {
 public static void main(String[] ar) {
  int x = 10;
  int y = x++;
  System.out.println("x = " + x);
  System.out.println("y = " + y);
 }
}

(cast 자료형) - ex : int i = 1; byte by = (int) i; 단항연산자라고 알아두자

instanceof
객체의 타입을 비교 하는 연산자로서 우변의 객체와 좌변의 객체의 타입을 비교
우변과 좌변의 객체의 타입이 서로 같다면 true 그렇지 않다면 false를 반환

public class Exec_06 {
 public static void main(String[] args) {
  Exec_06 ex = new Exec_06();
  boolean bool = ex instanceof Object;
  System.out.println("bool = " + bool);
 }
}

산술연산자 - +, -, *, /, %
byte, short, char, int형의 자료형의 연산은 int 형의 자료형으로 나타나며
long, float, double형의 자료형은 큰 자료형의 결과로 나타난다
(long<float<double)
float형과 double형의 연산은 혼용하여 사용하지 않는것이 좋다.

public class Exec_07 {
 public static void main(String[] args) {
                float f = 1.2f;
                double d = 1.2;
                double d1 = d - f;
                System.out.println(d1);
        }
}

나눗셈과 나머지 구하는 문제
public class Exec_08 {
 public static void main(String[] args) {
  int x = 10;
  int y = 3;
  System.out.println("몫 = " + x / y);
  System.out.println("나머지 = " + x % y);
 }
}

시프트연산자“<<“ ,“>>”,“>>>”

 - 자바프로그램에서 사용하는 기본 메모리는 32비트인데,
   때때로 메모리 절약을 위해 int형 하나의 데이터에 16비트씩 2개의
   데이터를 함께 사용하는 경우나, 8비트씩 4개의 데이터를 함께
   사용하는 경우, 필요한 데이터의 결과값만 꺼내려구 할때 사용

대상필드의 값을 2진비트로 바꾼 후 특정 비트 수 만큼 이동시켜 원하는
부분의 비트데이터를 얻어내는 연산자
boolean형, float형, double형에서는 사용할수 없다
a<<b : left shift 연산자
a의 값을 2진비트로 바꾼후 왼쪽으로 b비트수만큼 이동시키고 빈자리는
0으로 채우는 연산자
예) 2<<3
2을 32비트로 분해한다음 왼쪽으로 3bit 이동시켜라
0000 0000 0000 0000 0000 0000 0000 0010
000 0000 0000 0000 0000 0000 0000 0001 0???
앞의 000 은 버리고 뒤의 ???는 000 으로 채운다
결과는
0000 0000 0000 0000 0000 0000 0001 0000 이 된다

적용 공식 : 원본데이타 *2^이동변수

a>>b : right shift 연산자
a의 값을 2진비트로 바꾼후 오른쪽으로 b비트수만큼 이동시키고 빈자리는
원본 데이타의 값이 양수이면 0을, 음수이면 1을 채우는 연산자

적용 공식 : 원본데이타 / 2^이동변수

“>>>”unsigned right shift 연산자
>> 연산자와 기본원리는 똑같으나, 원본데이타가 음수일 경우에도 앞의 빈
비트를 0으로 채운다는 사실이 다르다. 자바에만 있는 기술이다.
원본데이터에 관계없이 결과는 무조건 양수로만 나타나게 된다.
-8>>3
1111 1111 1111 1111 1111 1111 1111 1000
???1 1111 1111 1111 1111 1111 1111 1111
여기서 원본데이터가 양수이면 0을 음수이면 1을 채운다
1111 1111 1111 1111 1111 1111 1111 1111
결과는 -1이된다.
-8>>>3
1111 1111 1111 1111 1111 1111 1111 1000
???1 1111 1111 1111 1111 1111 1111 1111
원본데이터에 상관없이 무조건 0을 채운다
0001 1111 1111 1111 1111 1111 1111 1111
결과는 536870911

public class Exec_09 {
 public static void main(String[] args) {
  int i = 1 << 3;
  int j = 8 >> 3;
                int k = -8 >> 3;
                int l = -8 >>> 3;
                System.out.println(" 1 << 3 = " + i);
  System.out.println(" 8 >> 3 = " + j);
                System.out.println("-8 >> 3 = " + k);
  System.out.println("-8>>> 3 = " + l);  
 }
}

관계연산자
비교관계 : “>”, “<“, “>=“, “<=“
항등관계 : “==“, “!=“
비교관계연산자는 다 아는 경우이고,
항등관계 연산자는 피 연산자들이 서로 같은지 다른지를 판단하는 것
== 는 비교하는 두개의 피연산자가 같은면 true, 틀리면 false
!= 는 비교하는 두개의 피연산자가 같으면 false, 틀리면 true 반환

- !=는 관계연산자 이지만, =!는 뒤의 연산자를 부정한후 대입하라는 뜻

public class Exec_10 {
 public static void main(String[] args) {
  boolean bool = 5 < 3; // false
  boolean bool1 = 10 != 10; // false
  System.out.println("bool = " + bool);
  System.out.println("bool1 = " + bool1);
  
  boolean a = bool != bool1;
  boolean b = bool =! bool1;
  System.out.println("a = " + a);
  System.out.println("b = " + b);
 }
}

비트연산자 - “&”, “|”, “^”
& - and연산자, 대조되는 비트가 모두 1일때 결과값을 1로 주는 연산자
| - or연산자, 대조되는 비트 한쪽이라도 1이면 결과값은 1로주는 연산자
^ - exclusive or연산자, 대조되는 비트가 틀리면 1을 주는 연산자

public class Exec_11 {
 public static void main(String[] ar) {
  int a = 4;
  int b = 7;
  System.out.println("& = " + (a & b));//0100 & 1100 = 0100
  System.out.println("| = " + (a | b));//0100 | 1100 = 1100
  System.out.println("^ = " + (a ^ b));//0100 ^ 1100 = 0011
 }
}

논리연산자 - “&&”,“||”
“&&”- and연산자, 피연산자를 비교하여 둘다 참이면 true 아니면 false
“||”- or연산자, 피연산자를 비교하여 둘중 하나만 참이면 ture, 아니면 false

public class Exec_12 {
 public static void main(String[] ar) {
  boolean bool = 5 < 3 && 7 > 4; /* false
          false && true */
  boolean bool1 = 10 != 11 || 7 <= 3; /* true
                                  true   ||  false */
  System.out.println("bool = " + bool);
  System.out.println("bool1 = " + bool1); // 여기까지 한번 보여주고
  
                //아래의 경우도 한번 생각해 보자
  int i = 1;
                int j = 3;
                boolean bool2 = ++i > j && i < ++j;
                System.out.println("i = "+i);
                System.out.println("j = "+j);
                System.out.println("bool2 = "+bool2);
/*              j의 값은 변화되지 않았다.
                &&나||연산자는 앞쪽의 피연산자만으로 전체 상황판단이 가능하면
                뒤쪽 피연산자는 실행 자체가 되지 않도록 되어 있다  */

                i = 1;j = 3;
                boolean bool3 = ++i > j & i < ++j;
                System.out.println("i = "+i);
                System.out.println("j = "+j);
                System.out.println("bool3 = "+bool3);
/*  이렇게 &나 |으로 연산을 하면 뒤쪽 연산자도 실행이 되는 것을
                알수있다 */
 }
}
-- 결과값
    bool = false
    bool1 = true

    i = 2
    j = 3
    bool2 = false

    i = 2
    j = 4
    bool3 = false

삼항연산자 :“조건항 ? 항1 : 항2”
 조건항이 참이면 항1번을 시행하고 조건항이 거짓이면 항2번을 실행한다

import java.io.*;
public class Exec_13 {
 public static void main(String[] args) throws IOException {
  BufferedReader in = new BufferedReader
                               (new InputStreamReader(System.in));
  System.out.print("1.남성 2.여성 = ");
  int x = Integer.parseInt(in.readLine());
  
  String str = x == 1 ? "남성" : "여성";
  
  System.out.println("str = " + str);
 }
}

삼항연산자에서 범하기 쉬운 오류(특히 c언어 배우신분들)
  int a = 10;
  a == 10 ? System.out.println("같다!") : System.out.println("다르다!");
  => not a statement 성립되지 않는 문장입니다.
 
  int a = 10;
  System.out.println(a == 10 ? "같다!" : "다르다!"); 로 고쳐줘야 한다.

  String str = ""; int a = 0;
  a != 0 ? str = "남성" : str = "여성";
  => unexpected type ... 오류가 발생한다.

  String str = ""; int a = 0;
  str = a != 0 ? "남성" : "여성";

  자바는 문장의 형식을 중시한다.

배정대입연산자 : =, *=, /=, %=, +=, -=, <<=, >>=, >>>=
= : 대입연산자, 단순히 오른쪽에 있는 값을 왼쪽으로 옮겨라.
byte a = 5;
배정연산자
  a = a - 5; 라고 하면 5값은 int형이라 오류가 발생한다.(형변환을 해줘야 함)
  이렇때 형변환을 쓰지 않으면서 결과값은 같게 나오게 하는 해결책
  우선적으로 배정되어 있는 다른 연산이 먼저 발생한 후에 대입연산을 해라
   ex) a += b => a = a + b;
   ex) a -= b => a = a - b;
   ex) a *= b => a = a * b;
   ex) a /= b => a = a / b;
   ex) a %= b => a = a % b;
   ex) a <<= b => a = a << b;
   ex) a >>= b => a = a >> b;
   ex) a >>>= b => a = a >>> b;

  byte a = 5;
  a = a - 5; 라고 하면 5값은 int형이라 오류가 발생한다.(형변환을 해줘야 함)
  이렇때 형변환을 쓰지 않으면서 결과값은 같게 나오게 하는 해결책이다.

public class Exec_14 {
 public static void main(String[] args) {
  byte b = 10, a = 20;
  //b = b + 1; <= 오류발생
  b += 1; // b++; ++b;와 같은 경우
  
  byte c = 12;
  byte d = 50;
  //c = c + d; 역시 오류가 발생
  c += d;
  System.out.println("c = " + c);
 }
}

상수와 변수, 자료형
  상수 : 항상 일정한 값을 유지하는 데이터
  변수 : 특정 상황에 따라 변화하는 데이터
  자료형 : 상수나 변수의 유동적인 데이터를 저장할 수 있는 크기를 규정하는 형태

@@ 하나하나 예를 들어주면서 설명하며 특히 정수형중 byte부분은 좀더 상세히 설명

  - 1.논리형 자료형
      1)boolean : 사용바이트 1byte, 입.출력범위 : true/false => 형변환이 안된다
                  예) boolean bool = false;("false",'false'는 안된다)
  public class Exec_01{
    public static void main(String[] args){
      boolean bool = true;
      System.out.println("bool의 값은 "+bool);
    }
  }
  - 2.정수형 자료형
      2)byte : 사용바이트 1byte, 입.출력범위 : -128 ~ 127
               예) byte by = 123;(초기화를 꼭 시켜줘야 한다 - 스택영역에 저장)
               127 + 1 프로그램 하나를 실행시켜 보자.
               이프로그램의 원리를 설명해 주도록 하자(시계를 예로 들면서)
  public class Exec_02{
    public static void main(String[] args){
      byte by = 127;
      by++;
      System.out.println("byte값 127 + 1 = "+by+"입니다");
    }
  }
      3)char : 사용바이트 2byte, 입.출력범위 : 0 ~ 65,536(유일한 unsigned data)
               유니코드를 도입해서 2Byte로 이루어져 있다
               예) char ch = 65('A'의 아스키 코드 값)
                   char ch = 'A'(작은따움표는 ASCII코드 값을 의미한다)
                   char ch = '\u0041';(\u는 유니코드를 의미하는 표시이고
                                       뒤의 4자리는 'A'를 16진수로 표현한 값이다
  public class Exec_03{
    public static void main(String[] args){
      char ch1 = 65;
      char ch2 = 'A';
      char ch3 = '\u0041';
      Sytem.out.println("ch1 = "+ch1+", ch2 = "+ch2+", ch3 = "+ch3+"입니다");
    }
  }
      0 = \0 or NULL => NULL 문자
      8 = \b back space => 백스페이스 문자
      9 = \t tab     => 탭 문자
     10 = \n         => 한줄개행(새로운 라인의 커서를 이동, 바로 아래쪽으로 이동)
     13 = \r         => 현재줄의 가장 첫 번째로 이동 (\r\n으로 사용한다)
     27 = 'esc'      => esc키 아스키 값
  48-57 = '0' ~ '9'  => 숫자 아스키 값
  65-90 = 'A' ~ 'Z'  => 대문자 아스키 값
 97-122 = 'a' ~ 'z'  => 소문자 아스키 값

     4)short : 사용바이트 2byte, 입.출력범위 : -2^15~2^15-1(-32,768 ~ 32,767)
               예) short sh = 12345;
               정수형으로 잘 사용되지 않는다.
 
     5)int : 사용바이트 4byte, 입.출력범위 : -2^31~2^31-1(-2,147,483,648~2,147,483,647)
             예) int i = 100;
             4byte 메모리를 기억, 모든 정수의 기본 자료구조가 int형이다.
             정수 연산시에 발생하는 결과 값은 모두 int형으로 표현
             byte a = 10; byte b = 20; a+b => byte형이라도 + 연산자를 사용하면 int형 30이 된다
     6)long : 사용바이트 8byte
       입.출력범위 : -2^63~2^63-1(-9,223,372,036,854,775,808~9,223,372,036,854,775,807)
       초기화 할때 l이나 L을 붙혀야 한다.
       예) long lo = 123356L;
    
  - 실수형 자료형
     7)float : 사용바이트 4byte, 입.출력범위 : 1.4E-45 ~ 3.402823E38
               예) float f = 12.34f;
               기본 자료형이 아니므로 초기화 할때 반드시 f나 F를 붙혀줘야 한다.

               0으로 나누었을때 무한대의 값을 표기하는 Infinity라는 예약어를 이용
               0을 0으로 나누었을때 수가 아닌 값을 표현하기 위해 NaN이라는 예약어를 이용
 
     8)double : 사용바이트 8byte, 입.출력범위 : 4.9E-324 ~ 1.8E308
               예) double du = 12345.789;
               실수형 기본 자료형으로 8byte범위를 나타낸다

  - 클래스형 자료형
     9) String : 사용바이트 4byte(레퍼런스형), 입.출력범위 : 무한대
                 예) Sting str="김병철"
                 String의 S는 항상 대문자(클래스이므로)
                 클래스의 자료형은 초기화를 해 줄 필요가 없다(동적할당메모리영역에 저장)
                 클래스변수는 무조건 4byte이며, 문자열을 처리할수 있는 자료형처럼
                 사용할 수 있도록 만들어졌다.

Promosion 과 Casting을 이용한 자료형의 변환
 - 형변환이란 위의 자료형들에 저장된 값을 다른 자료형에 집어 넣는 방식을 말한다.
   - 자동형변환(Promosion) : 큰자료형에 작은 자료형을 넣을 경우
                             에러는 발생하지 않으나, 메모리 공간이 낭비된다.
   - 강제형변환(Casting) : 작은 자료형에 큰 자료형의 값을 대입하는 경우
                           반드시 형변환이 이루어져야만 한다. 안하면 에러발생
   - 기준
     1) 자료형들의 공간 범위를 기준으로 한다.
       - short a=10; char b=a; 라고 하면 오류가 발생
         short형은 -32,768~32,767이고 char은 65,535까지 이므로 음수가 되었을 경우를
         생각해서 casting되어야 한다. char b=(char)a;
         예) byte a=12; char b=a;
             byte a=12; short b=a;
             char a=12; short b=a;
     2) 실수형자료형은 정수형자료형보다 큰 자료형이다
       - 실수는 무조건 정수보다 크다(무조건 외우자)

@@ 강제형변환과 자동형변환의 예를 들며 프로그램 작성등으로 설명
 
**초기화 에러
  long a = 12; 이러면 int 12를 long형 a에 저장하는 자동 형변환이 일어난다.
  l,L을 안붙혀서 나타나는 현상   
  float f = 12.5; 이러면 에러가 난다. double 12.5를 float형 f에 넣을때는 강제형변환을 해줘야한다
  f,F를 안붙혀서 나타나는 현상

프롤로그
  언어란 상대방과의 의사소통을 위한 것
  컴퓨터 언어란 컴퓨터와 사람과의 의사 소통
  사람과 사람사이에 통역사가 있듯 컴퓨터와 사람사이에도 통역사가 필요하다
  자바에서는 JDK라는 통역이 있고 우리는 그것을 배우기 위해 이자리에 있다

컴퓨터언어의 발전
  저급언어 : 어셈블리어, 기계어(0과 1로 이루어진 언어)
  고급언어 : 사람이 이해하기 쉬운 언어

  ALGOL60 -> CPL(63) -> BCPL(70) -> B(70) -> C(73) -> C++(85) -> JAVA(95)

자바 언어의 의사 소통 방법
 - 컴파일러(Compiler) : 바이트 코드로의 변환
 - 인터프리터(Interpreter) : 라인 별 실행

자바 언어의 역사
  1991년 1월 15일 : Bill Joy, Andy Bechtolsheim, Wayne Rosing, Mike Sheridan,
    Patrick Naughton 그리고 James Gosling 이렇게 6명이 모여 ‘Stealth Project’라는
    이름으로 회의를 시작
  1991년 6월 : James Gosling이 ‘Oak’라는 이름으로 인터프리터 개발에 착수
  1991년 8월 19일 : 사용자 인터페이스에 대한 아이디어와 그래픽 시스템을 Sun의 창립자인
    Scott McNealy와  Bill Joy에게 소개
  1993년 9월 : Arthur Van Hoff가 ‘Interactive Television’ 프로젝트에 동참
  1994년 4월 25일 : ‘Sun Interactive’ 완성. 이후 내용은 강력하지만 프로그램의 크기는
    작은 운영체제를 목적으로 ‘Liveoak Project’를 시작했다가 다시 웹에서 동작하는 Oak
    개발에 집중
  1994년 9월 16일 : ‘HOT JAVA’의 원형격인 ‘WebRunner’(Mosaik 같은 브라우저)를
    Jonathon Payne과 Naughton이 개발을 시작.
    비슷한 시기에 Arthur Van Hoff는 James Gosling이 C 언어로 구현했던 자바 컴파일러를
    자바 언어를 이용하여 구현
  1995년 5월 23일 : ‘SunWorld 95’에 공식적으로 JAVA와 HOT JAVA가 발표.
    같은 날 Netscape사가 Netscape 브라우저에서 사용할 자바에 대한 라이센스 계약 예정 공표
  1995년 12월 7일 : MS사가 참여하기까지 많은 회사와 라이센스 계약
    (Toshiba, Oracle, Lotus, Intuit, Borland, Macromedia, Spyglass, Silicon Graphics,   
     Mitsubishi, Sybase, Symatec, IBM, Adobe 등)

자바환경 설정
  JRE - 사용자를 위한 실행환경만 제공
  JDK - 실행환경과 반기계어로 변환하는 컴파일러까지 포함 - 우리는 이것을 다운받아야 한다.

JAVA 싸이트
 - http://www.oracle.com/
환경변수 만들기
  시작 -> 설정 -> 제어판 -> 시스템 -> 고급 -> 환경변수
  path를 클릭
  맨앞에 C:\Program Files\Java\jdk1.7.0_09\bin;을 넣어준다
  변수 설정을 해준다
  설정이 끝났으면 java -version과 javac를 실행시켜본다.
 
프로그램의 작성, 컴파일, 실행
파일명.java 라는 파일을 작성하게 된다.
이것을 컴파일해야 하는데 이때 사용하는 명령어가 javac 이다.(바이트 코드로 변환시키는것)
이러면 파일명.class가 나오는데 이것을 실행하는 명령어는 java 이다(jvm내에 설치된 인터프리터)

프로그램 구문분석 및 main()메소드
예) hello java
01   import java.lang.*;  //c언어의 #include와 비슷
02   public class Exec01_01{
03      public static void main(String[] args){
04         System.out.println("Hello Java!!");
05      }
06   }

실행을 시켜 보자

우선 메모장에서 위의 구문을 입력하여 저장한후(.java), 실행(javac Exec01_01.java)을 시켜본다.

01 : import는 알지못하는 클래스의 정의가 들어 있는 곳을 지칭하기 위해 사용하는 것
     import java.lang.*; 은 java라는 폴더안에 lang이라는 폴더, 그 내안에 있는 클래스들 
     을 사용하겠다고 정의하는 것
     그런데 import java.lang.*은 생략한 곳이 많다.
     이유는 java에서는 기본적으로 java.lang 부분을 import 해 놨기 때문이다.
02 : public이라는 예약어를 쓸수 있는 클래스는 하나뿐이다.
     그리고 이 클래스가 파일명이 되는것이다.
     따라서 파일명과 이 클래스의 이름은 대,소문자까지 똑같아야만 한다.
     물론 모든 클래스가 public 이라는 이름을 사용하지 않아도 된다.
03 : public static void main(String[] args)
     시작을 나타나는 메소드 이다.. 반드시 외어야 한다
     자바프로그램은 파일명과 동일한 클래스의 main()메서드에서 시작해서 그메서드의 마지막
     블록에서 끝이난다.
04 : System.out.println("Hello Java!!");
     자바의 라인 끝은 ;이나 {}으로 끝이 난다  
     System.out.println은 출력을 나타내는 메소드 이며 자세한건 입출력을 배울때 한다

자바의 특징
  - 이식성이 높은 언어이다.
  - 외부의 포인터를 제거하고 내부 포인터만 사용한다.
  - 완벽한 객체지향적인 언어이다(하나의 덩어리다)

JVM
  - 자바가상머신(java virtual machine) : 바이트코드를 읽어서 실행할 수 있도록 해주는 도구
    자신의 메모리에 배치시킨다.
    메모리의 구조
    - 스택영역(Runtime Stack) : 자바의 로컬변수를 할당, 해당변수는 그것이 선언된 블럭을
                           벗어나는 순간 메모리가 소멸됨
                           자동으로 초기화 되지 않으므로 초기화 해주어야 한다.
    - 동적할당메모리영역 : 배열로 만들어진 연속된 공간들이나 클래스에 포함된 멤버를 할당하는 영역
                     Garbage 컬렉터에 의해 관리
                     초기화가 디폴트로 되어 있음
    - 상수와 메서드영역 : 프로그램의 시작시 생성, 종료시 소멸됨
                    고정데이터를 가진 상수나 추상화 형식을 지닌 메서드의 경우 해당 내용을
                    기억해 두어야 할 필요성 때문에 만들어진 영역, 실행시 위치값을 가지게 된다
    - Register 영역 : jvm을 실행하면서 필요한 부분의 주소를 기억해 두는 곳
                  각영역에 연결되어 있는 프로세서가 작동할때 여기에 등록된 내용을 기초로 실행
 => 단순한 프로그램이 아닌, 프로그램을 실행시키는 도구 그자체이다.

사용자 정의 명칭
  사용자가 정의한 이름이라는 뜻
  폴더의 이름, 클래스의 이름, 메서드의 이름, 그리고 필드의 이름등을 정의할때 사용
  다음과 같은 규칙으로 이루어져 있다.
  - 첫글자는 $,_,영문 대소문자여야 한다.(한글도 가능하지만 권장하지는 않는다)
  - 글자수에는 제한이 없다.
  - 공백 문자는 포함할 수 없다.
  - 특수문자(@,#,%,^,&,!,?)는 사용할수 없다.
  - 숫자는 첫 글자가 아닐경우 사용이 가능하다
  - 예약어는 사용할수 없다.
  권장사항
  - Class : 첫글자는 $,_,대문자를 사용하자
  - Method(함수) : 첫 글자는 $,_,소문자를 사용하자
  - Field(변수) : 일반적으로 전부 대문자인 경우는 static final 필드이고
                  그 외는 첫글자는 대문자, 나머지는 소문자이다
  - 합성어의 첫글자는 대문자로 한다(HelloJava)

주석사용
  프로그램에 영향을 미치지 않으면서 해당부분을 설명해 두어 나중에 그 코딩을 이해하기
  쉽게 만드는 하나의 방법

주석의 종류
  /* ~ */ : c언어에서 따온 주석으로 특정범위를 묶어서 주석 처리
  // : c++에서 따온 주석으로 해당 주석 표시가 있는곳에서부터 그 라인의 끝까지 주석처리
  /** ~ */ : 자바의 document 주석
             나중에 사용자 정의 document API를 만들때 사용하는 주석처리

제가 어제 외우라는 부분 public static void main(String[] args) 이부분은 여러분이 계속 사용하실 것입니다.

외우지 못하시면 앞으로 계속 나올테니 익숙해지세요. 

Hello,Java라고 어제랑 똑같은 값이 나옵니다.

그리고 저처럼 결과가 아래 나올 수도 있고 옆에 뜰 수도 있습니다. 당황하지 마시고 화면을 잘보세요!!

cmd창에서 했을 때는 컴파일을 2번했습니다. 복잡하고 시간이 오래 걸렸습니다.

하지만 eclipse에서 사용했더니 한번으로 줄어 들었습니다. 그리구 여러분이 실수를 한다면  eclipse에서 에러 메세지도 뜰것입니다. 더욱더 쉽게 공부 하실 수 있을 것입니다.

자바를 사용하기 위한 툴로 eclipse,에디터도 있습니다.

하지만 제가 eclipse를 선택한 것은 33개국 나라에서 씁니다. 그리구 더 편해서 사용하게 됬습니다.

궁금하시면 질문 해주세요^^

주의-윈도우7에서는 바로 압축풀기 하지말고 오른쪽클릭하고 여기에 압축풀기로받으면 된다.
바로 압축풀기 하면 에러가 뜰 수 있다!!

 저도 처음에 당황했다. 아 안되 하면서 하지만 당황 하지 마시길. 되게 하는 법을 설명할 것이다.

밑에 그림부터 잘 보시고 따라하세요.

 자바가 깔린곳이다. 어제 PATH를 해주기위해서 위치를 찾았던 곳에서 \javaw.exe를 더추가해줘서 쓰면된다.

-vm도 꼭써준다.그리구 128m,128m을 두 곳다 바꿔줘야한다. 처음에는 256M,256m으로 나와있을 것이다.

따라하시면 아래 그림처럼 설치 파일이 나올 것이다.

성공하면 위처럼 그림이 뜰것이다.

그리구 TIP을 드리겠습니다. 혹시 영어를 못하셔서 머리 아프시다고 하시는분은 네이버에서  eclipse 한글 이라고 치시면 사람들이 올려놓은 한글패치판이 있을 것이다. 다운받으셔서 한글 버전으로 쓰세요 .

되도록 영어로 쓰시기를 권장드립니다. 그리구 못찾으시겠다고 하시면 제가 드리겠습니다. 메일 주소를 써주세요.^^

자바를 쉽게 쓰기 위한 툴 다운로드를 끝내겠습니다. 질문 있으시면 댓글에 써주세요.

자바를 실행해보자.

HelloJava.java 파일로 만들어보자.

--------------------------------------

import java.lang.*;// 생략가능

public class HelloJava{
 public static void main(String[] args){    
  System.out.println("Hello, Java");
 }
}

--------------------------------------

public static void main(String[] args) -이 줄은 앞으로 계속 사용할것이다(외워주자 그러면 편할 것이다.)

 어렵게 생각하지말자.

코딩할때 String[] ar로도 써도된다. 완벽한 문장은 String[] args이다. 둘중에 아무거나 써 줘도 실행 된다는 사실!!

그러나 이부분이 코딩이 틀리면 에러가 뜬다는 사실 주의!!

시작

                                                             dir은 목록을 보여주는 명령어다.

오늘은 여기까지 지금은 완전 기초적인 것만 적었다. 초보적인 입장에서 쉽게 풀어나갈려한다.

천천히 풀어가면서 깊이 들어가겠습니다.

java는 c언어처럼 한번에 컴파일 되지 않고 2단계를 거친다.

JAVA
(컴파일)
바이트코드 =>클래스
-------------------  <==JDK
(인터프린터)
실행파일
-------------  <==JRE
2단계다.

이로써 자바를 사용하기 위한 기본 단계가 다되었다. 이제부터 자바를 시작해봅시다.^^