맑은소금

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

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

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를 만들때 사용하는 주석처리