JAVA Study

자바 프로그램은 .java의 확장자를 갖는다.
반드시 1개 이상의 클래스를 갖는다.
public 클래스이므로 파일명과 클래스명이 같아야 한다.

하나의 파일에 여러개의 클래스를 가질수 있지만, public은 1개만 온다.
애매한 경우 main() 메소드를 갖는 클래스에 온다.(주로 main에 온다.)
main이 없으면 아무 class나 지정
(? public class는 파일에 꼭 1개 있어야 하나?)

class A{
}
class B{
}
public class C{
    public static void main(String[] args){
    }
}
------------------

주석 ------>
package --->
import ---->
class ----->

class의 멤버
--+- 멤버필드(member field => 전역변수) = 멤버변수(member variable)
  |          = 인스턴스변수(instance variable) = 프로퍼티(property)
  +- 메소드(method)
 
+- 멤버필드 : 클래스의 멤버로 사용하는 전역변수  
+- 지역변수 : 메소드내에 선언되어 사용하는 변수(자동변수)

public class test{
    int x = 1; --> 멤버변수(멤버필드)
    public void test_member(){
        int x = 5; --> 지역변수
    }   
}

// --> 1줄 주석
/*         */ //--> 여러줄 주석

/*
자바 식별자(identifer)
클래스명, 메소드명, 멤버필드명, 지역변수명
- 길이제한 없고, 첫글자는 영문자, _, $로 시작
- 대소문자 구분(주의)
- 첫글자로 $ 사용 자제(컴파일러에게 자바 식별자명을 생성하라는 의미로 사용됨)
- 자바는 unicode로 이루어져서 한글사용도 가능하나, 식별자에서만 사용제한함.

1.class명 작성 규칙
  - 첫글자만 대문자 사용, 단어 구별시 첫글자만 대문자 사용
2.메소드명, 멤버필드명, 지역변수명 작성 규칙
  - 첫글자도 소문자 사용, 단어 구별시 첫글자만 대문자 사용(클래스명과 동일)

키워드(keyword, 예약어)
- 모두 소문자로 구성
- abstract  ,boolean    ,break     ,byte         ,case
  catch     ,char       ,class     ,const        ,continue
  default   ,do         ,double    ,else         ,extends
  final     ,finally    ,float     ,for          ,goto
  if        ,implements ,import    ,instanceof   ,int       
  interface ,long       ,native    ,new          ,package
  private   ,protected  ,public    ,return       ,short
  static    ,super      ,switch    ,synchronized ,this
  throw     ,throws     ,transient ,try          ,void
  volatile  ,while
 
+-지역변수는 사용전에 초기화해야 한다.
+-멤버필드는 자동으로 초기화된다.
  - byte, short, int, long, float, double, char => 0
  - boolean => false
  - String (레퍼런스 타입) => null
  - 접근제어자가 붙는다.(다른 클래스에서 참조할수 있으므로)

public class TestVariable{
    private int age; --> 데이터타입이 int이므로 자동적으로 0값을 가짐.
    public int getAge(){
        return age;
    }
}
 
main() 메소드에서 객체의 레퍼런스 없이 멤버 필드의 값에 접근하려면
                  해당 멤버 필드가 Static변수이어야 한다.
       static으로 선언된 메소드에서는
       static으로 선언된 멤버 필드나 메소드에만 접근할 수 있기 때문이다.

public class GlobalVariableTest {
    static boolean x;
   
 public static void main(String[] args) {
        boolean y = true;
       
        System.out.println("x = " + x);
        System.out.println("y = " + y);
 }
} 

* 데이터 타입 : 변수 선언시 필요,   
  +- 변수가 저장하는 값의 형태를 결정
  +- 메소드의 리턴 타입에 기술되어 메소드의 수행 결과값의 형태를 결정. 
 
+- 기본 데이터 타입(primitive data type)
|   => byte, short, int, long, float, double, char, boolean
|
+- 레퍼런스 데이터 타입(reference data type)

* 정수 -+- byte (1byte, 0)  -128 ~ +127     
        +- short(2byte, 0)  -32,768 ~ +32,767
        +- int  (4byte, 0)  -2,147,243,648 ~ +2,147,243,647 (2억)
        +- long (8byte, 0)  -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807 (9백경)
  실수 -+- float  (4byte, 0)  -3.40292347E+38 ~ +3.40292347E+38
        +- double (8byte, 0)  -1.79769313486231570E+308 ~ +1.79769313486231570E+308          
  문자 -+- char (2byte, 0)  '\u0000' ~ '\uFFFF'  
  불   -+- boolean (1bit, false)  true or false

* 기본 실수데이터 타입은 double.
  2.5가 저장된 실수 데이터타입은 double로 인식되므로,
  2.5f처럼 f를 붙여야 float 타입으로 인식된다.

* 정수는 소숫점이하 버림.
* 형변환 사용 => (변경할 데이터타입)변수명
* 자동 형변환(프로그램에 의해서) => 프로모션(promotion)

int var = 5;
float result = var / 2;
System.out.println("5 / 2 = " + result); => 5 / 2 = 2.0
=> (계산 따로, 출력 따로) 정수 / 정수 계산후 실수로 표시됨. 

* 문자 데이터 타입 => char(문자 데이터는 1개의 문자를 의미, char은 1개의 문자만 저장)
  - 여러개의 문자 저장 => char 타입의 배열, String 타입
  - 16bit 유니코드 채택, 유니코드는 문자 1개당 2byte(16bit) 필요.
  - int로 형변환 가능, 해당문자의 유니코드 반환.
  - 문자 데이터값을 변수에 직접 대입할때는 ' ' 로 감싼다. ( char var = 'a'; )
  
* boolean타입은 true, false 값 저장, C언어의 bit 타입과 같이 1bit의 크기임.
  다른 데이터 타입으로 형변환 불가
 
*                    기본 데이터 타입-------레퍼런스 데이터 타입 
- 기억장소         : 실제 데이터 값 저장    객체가 있는 곳의 주소 저장
- 메모리 할당 시점 : 변수 선언 즉시         new 키워드로 객체를 생성할때
                                            (기본값은 null)
                                           
- 생성된 객체 접근 : C언어는 포인터로 접근하는 대신,
                     자바는  객체의 레퍼런스로 접근

* 레퍼런스 데이터 타입 => 클래스 타입인 객체타입만 있음
                         (기본 데이터 타입이외의 모든 타입은 객체 타입만 있음.)

public class Test{
    int x = 20;
    ToolSystem ts1;
   
    ts1 = new ToolSystem(); => 클래스의 객체 주소가 들어간다.
          ** 객체는 한번만 생성하면 여러곳에서 사용할 수있다.(객체지향 프로그램 목적) **
      
* 문자열 변수 저장은 String 클래스 사용(문자열변수는 레퍼런스 타입의 변수이다.)
  String var; => 기본 데이터 타입과 동일하게 선언.
- 선언과 사용(값 변경)은 기본 데이터와 같으나, 내부적으로는 객체가 처리되는 방식으로 처리.
  문자열 변경시 가리키는 문자열이 변경된다.
  + 사용해서 두개의 문자열을 결합한다.
- String var = "test"; => new 키워드 없는 객체 생성. anonymous(무명) String 객체
- anonymous 객체는 이런 내용만 관리하는 저장소에서 관리되어 문자열은 한번 생성되면
  변화되지 않고 JVM내에 저장된다. => 같은 문자열은 단한번만 만들어진다.
String str1 = "TEST"; --> TEST 문자열 생성
String str2 = "TEST"; --> TEST 문자열 재생성 없음.(위에서 생성된 TEST 문자열(객체)의 주소 넘겨줌)
       str1[200] --+--> 200[TEST]   
       str2[200] --+
str1, str2는 같은 주소의 문자열을 가리킨다.

* 연산자 규칙 정리할것.
  7 / 2 => 7을 2로 나눈 몫(3)
  7 % 2 => 7을 2로 나눈 나머지(1)
 
* 연산자                연산자 설명                               연산순서
- ()                    ():괄호 연산자, 우선순위를 바꿀때 사용    왼쪽->오른쪽
- ++,--,+,-,~,!,(cast)  ++:1증가 연산자, --:1감소 연산자          오른쪽->왼쪽(*) 
                        +,-:부호, ~:보수, !:Not연산자       
                        (cast):캐스트연산자 예) (float)7
- *,/,%                 *:곱하기,/:나누기,%:나머지                왼쪽->오른쪽                 
- +,-                   +:더하기,-:빼기                           왼쪽->오른쪽
- <<,>>,>>>             <<:왼쪽 시프트 연산자                     왼쪽->오른쪽
                        >>:오른쪽 시프트 연산자
                        >>>:부호 없는 오른쪽 시프트 연산자
- <,>,<=,>=,instanceof  <:작다,>:크다,<=:작거나 같다              왼쪽->오른쪽        
                        >=:크거나 같다,instanceof:상속관계
- ==,!=                 ==:같다,!=:같지 않다                      왼쪽->오른쪽
- &                     &:비트 연산자 AND 연산자                  왼쪽->오른쪽
- ^                     ^:비트 연산자 Exclusive OR 연산자(XOR)    왼쪽->오른쪽  
- !                     !:비트 연산자 OR 연산자                   왼쪽->오른쪽
- &&                    &&:AND 연산자                             왼쪽->오른쪽
- !!                    !!:OR 연산자                              왼쪽->오른쪽
- ? :                   ? : 조건연산자, 조건? 참: 거짓            오른쪽->왼쪽(*)
- =,+=,-=,*=,/=,%=      =:대입연산자                              왼쪽->오른쪽 
                        +=:값을 더한후 결과 값을 대입하는 연산자
                        -=:값을 뺀후 결과 값을 대입하는 연산자
                        *=:값을 곱한후 결과 값을 대입하는 연산자
                        /=:값을 나눈후 결과 값을 대입하는 연산자
                        %=:나머지를 구한후 값을 대입하는 연산자

* 대입 연산자는 '같다'는 의미가 아니라 assign(대입)하라는 의미이다.
  변수(왼편) = (오른편)상수, 수식, 변수 
* a += 5; a와 5를 더해서 a에 넣으라는 의미, a = a+5;와 같은 결과값(연산자 2회 사용)  
          연산자 1회 사용으로 더 빠르다.
* 증감연산자(++,--)
- C언어처럼 1증가 1감소 연산자 제공.
- 전증가(++a),전감소(--a) : 변수에 1을 증가(감소)후에 변수의 새로운값이 수식에 사용된다.
  후증가(a++),후감소(a--) : 수식에 사용된후에 변수에 1을 증가(감소)하고, 다음 라인에서 사용된다.
a=5;
b=++a; => b=(++a)와 같다. ++a가 먼저 실행후 b에 대입된다.
c=a++; => (c=a)++ 즉, c에 대입후 a++가 실행되서 다음 라인에서 적용가능하다.
++a; a++; 처럼 단독으로 사용되면 다음 라인에서 증가된 a가 적용되는것은 똑같다.

** 후증가(a++), 후감소(a--)를 사용해라. **

* 변수값을 1증가하는 3가지 방법(수행속도 순서)
  a++; (권장)  >  a += 1;  >  a = a + 1;
 
* 논리 연산자(&&, ||, !)
- && (AND), || (OR), !(NOT)
- 숏서킷로직(short circuit logic) : 처음항의 결과가 전체결과를 결정하면 나머지항 무검사
  && 모든항이 true일때 true이므로, 처음항이 false이면 false
  || 하나항만 true면 true이므로, 처음항이 true면 true

* 비트연산자(&,|,^)
- 비트 단위로 연산수행, 숏 서킷 로직(short circuit logic) 수행 않함.
- 단순히 참(true), 거짓(false)을 비교할때는 논리연산자의 &&, || 연산자와 같은 의미로 쓰임.
  &  (AND)  주어진 조건식이 모두 true일때만 결과 값이 true
  |  (OR)   주어진 조건식중 하나 이상 true일때 결과 값이 true
  ^  (XOR, Excusive OR)  주어진 조건식 두개의 결과 값이 다를 때만 true

int x = 0; int y = 0;
if ((5 < 1) && (x++ > y))
    y++;
System.out.println("x = " + x + ", y = " + y); => x=0, y=0

if ((5 < 1) & (x++ > y)) // 실행이 된다(x=1로 증가)
 y++;
System.out.println("x = " + x + ", y = " + y); => x=1, y=0
 
* 시프트 연산자(<<, >>, >>>)
- << : 왼쪽으로 이동, 곱하기 2 효과, 빈칸은 0으로 채움.
- >> : 오른쪽으로 이동, 나누기 2효과, 빈칸은 부호로 채움.
       부호가 +이면 0으로, 부호가 -이면 1로 채움.   
- >>> : 오른쪽으로 이동, 나누기 2효과, 빈칸은 무조건 0으로 채움.

* instanceof : 객체의 상속관계 여부를 boolean으로 표시, 상속관계가 있으면 true로

* @SuppressWarnings("unused") => 에러를 잠재움(새로운 뭐지 ??????).
public class BitOperatorTest {
 @SuppressWarnings("unused")  
 public static void main(String[] args) {
 
*****< 매우 중요 >*********************************************************************** 
* +-- == 연산자 -----+-- 기본테이터 타입 : 두 변수의 값이 같은가 비교
  |                  +-- 레퍼런스 타입   : 두 레퍼런스 변수가 같은 객체를 가리키고 있는가
  +-- equals()연산자 +-- 기본테이터 타입 : ?????? 이런 경우는 없나??????
                     +-- 레퍼런스 타입   : 두 객체가 참조하는 번지의 내용이 같은가 비교
1) ==연산자를 기본 데이터 타입에 사용한 경우 [=> 같은 값을 가지고 있을때만 true 리턴]
  int x = 20; int y = 20;
  x => [20]   y => [20]
  -----> x==y 는 x와 y 값이 같은가를 비교,  x와 y의 값이 20으로 같다. true 값을 리턴.
2) ==연산자를 레퍼런스 타입에 사용한 경우 [=> 같은 객체를 가리키고 있을때만 true 리턴]
  Test t1 = new Test();  Test t2 = new Test();
  t1 => [200]  200 => [Test 클래스의 객체]      
  t2 => [300]  300 => [Test 클래스의 객체]
  -----> t1==t2 는 t1과 t2가 같은 객체를 가리키고 있는가를 비교.
         t1이 가리키는 객체는 200번지, t2가 가리키는 객체는 300번지에 있기 때문에
         둘은 서로 다른 객체임. false를 리턴
3) equals()연산자를 레퍼런스 타입에 사용한 경우
  String t1 = new String("hi");
  String t2 = new String("hi");
  t1 => [200]  200 => [String 클래스의 객체 "hi"]      
  t2 => [300]  300 => [String 클래스의 객체 "hi"]
  -----> t1.equals(t2) 는 t1과 t2가 가리키는 객체의 내용이 같은가를 비교.
         t1이 가리키는 객체는 200번지, t2가 가리키는 객체는 300번지이지만
         두 객체의 내용은 "hi"로 둘다 같다. true 리턴
 
+------------------------------------------------------------------------+
|1.변수에 값을 입력하는 방법
|  1) 변수에 값을 직접 입력하기 => x=5;
|  2) 매개변수 리스트를 사용해서 변수에 값 입력하기
|     => main() 메소드의 매개변수 리스트(argument list)를 사용하는 방법
|  3) 입력 대화 상자를 사용하여 변수에 값 입력하기
|     => JOptionPane 클래스의 showInputDialog()메소드를 사용하는 방법
+------------------------------------------------------------------------+
|2.결과값을 화면에 출력하는 방법
|  1) 표준 출력인 System.out.println()을 사용하는 방법
|  2) 메시지 상자를 사용하여 결과를 출력하는 방법
+------------------------------------------------------------------------+ 

1) 변수에 값을 직접 입력하기----------------------------------------------
+-- 바뀌지 않는 변수값(상수)나 변수에 초깃값을 지정할때 사용
|   => 1) 변수에 값을 직접 입력하기
+-- 새로운 값을 입력받는 경우
    => 2) 매개변수리스트 사용, 3)입력 대화 상자 사용

* 상수 : 프로그램 수행동안 절대로 바뀌지 않는 값, 상수형 변수에 넣어서 사용.
* 상수 선언(상수형 변수 선언) : final 키워드 사용, 멤버 필드의 위치에 선언.
  - 값을 반드시 초기화하고, 절댓값을 변경 할수 없다(변경시 에러 발생)      
  - 상수명은 모두 대문자 표기(변수명과 구별)

public class VariableAssignTest {
           +----+ main()메소드에서 상수에 접근하기 위해 선언할때 static 사용
    public static final int VARI = 20; // 상수선언은 멤버필드 위치에서.
                  +---+ 상수선언 키워드
 public static void main(String[] args) {
        System.out.println("VARI = " + VARI);}
 
2) 매개변수 리스트를 사용해서 변수에 값 입력하기------------------------------
+--public int process(int x, int y){}       : 단일변수 타입(int x, int y)
+--public static void main(String[] args){} : 배열타입     (String[] args)
   - main(String[] args), main(String args[]) 둘다 가능  
   - java 클래스명 입력값_1 입력값_2 입력값_3 => args[0]    args[1]    args[2]
                                                 [입력값_1] [입력값_2] [입력값_3]  
* 문자열은 문자열 결합 연산만 있다.
- args[0] + args[1]; => "60" + "70" 으로 "6070"이 된다.
* 파싱 : 문자열의 문자형 숫자 값을 순수한 숫자나 연산이 가능한 숫자로 만드는것
- 숫자값으로 파싱할때는 래퍼클래스(Wrapper clsaa) 사용
- int타입으로 변환(가장 많이 사용)
  => Integer.parseInt(문자형 숫자)  
     +-(1)-+ +-(2)--+    (1)Integer : 래퍼클래스 (2)parseInt() : int 타입으로 파싱하는 메소드

***************************************************************************
*  DOS모드에서 실행시 package에 등록되어 있으면,                          *
*  package 상위에 가서 실행해야 한다.                                     *
***************************************************************************
   
- eclipse의 [Run]-[Run configurations...]에서
  [Arguments]탭의 [Program arguments]항목에 값을 입력해야 하는 번거로움 발생.    
   
3) 입력 대화 상자를 사용하여 변수에 값 입력하기
     => JOptionPane 클래스의 showInputDialog()메소드를 사용하는 방법

import javax.swing.JOptionPane;  --> [1] javax.swing.JOptionPane 을 import
public class InputDialogTest {
 public static void main(String[] args) {
        int val;
        val  = Integer.parseInt(JOptionPane.showInputDialog("점수 입력")); --> [2]
            [2-1] JOptionPane.showInputDialog("내용") 메소드로 입력받음.
            [2-2] Integer.parseint로 문자형 상수를 int 타입으로 변경.
        
        System.out.println("점수 = " + val);
 
1) 표준 출력인 System.out.println()을 사용하는 방법
2) 메시지 상자를 사용하여 결과를 출력하는 방법
   => JOptionPane 클래스의 showMessageDialog(null, "내용"); 
import javax.swing.JOptionPane;    --> [1] javax.swing.JOptionPane 을 import
public class MessageDialogTest {
 public static void main(String[] args) {
        int var1;
        var1 = Integer.parseInt(JOptionPane.showInputDialog("첫번째값 입력")); --> [2]
            [2-1] JOptionPane.showInputDialog("내용") 메소드로 입력받음.
            [2-2] Integer.parseint로 문자형 상수를 int 타입으로 변경.
        JOptionPane.showMessageDialog(null, "첫번째값 = " + var1);  --> [3]
            [3] JOptionPane.showMessageDialog("내용") 메소드로 출력
            
- 첫번째 매개변수 = null, 두번째 매개변수 = 메시지상자 표시 내용(String 타입만 가능)
- 문자열 + 숫자를 결합해서 문자열인 String 타입으로 만든다.

* 의사코드(pseudocode)
- 알고리즘을 개발하는데 사용하는 일종의 작위적인 언어이다.
- 프로그램으로 변환했을때 실행되는 부분만 표현
- 예) count : 인원수를 누적하는 변수(인원수 카운트 변수)
      count의 값이 10보다 작거나 같으면 count의 값을 1 증가한다. <- 의사코드
     
* 제어문 2가지 형태
+-- 조건 비교 분기문(조건을 비교해서 그에 따라 코드가 분기됨)
|   1)if문, 2)switch문
+-- 조건 비교 반복문(조건을 비교해서 그에 따라 여러번 같은 코드를 반복함)
|   1)for문, 2)while문, 3)do~while문
+-- 조건에 따라 반복문(루프:loop)을 탈출할때 사용하는 구문)
    1)break문, 2)continue문

1) if문
- if(조건){if문 블록, 코드 기술}
- 조건 -+--리턴타입이 boolean타입인 메소드
        +--결과값이 boolean 타입이 되는 논리연산자, 관계연산자 등이 수식으로 사용된다.   
- 3가지 형태 : if문(단순if문), if~else문, 블록 if문

1_1)if문(단순if문 : '조건'의 결과값이 true인 경우 if 블록안의 내용 실행)
if(조건) { --> true 또는 false를 가짐.
    문장;  --> '조건'의 결과 값이 true인 경우 '문장;' 수행
}
* Integer class는 'java.lang' 패키지에 있으므로 import 하지 않는다.
- 'java.lang' 패키지는 암묵적으로 자동 import 된다.
***************************************************************************
*  클래스의 메소드에 접근하는 방법
*  반드시 해당 클래스의 객체를 생성하고 객체의 레퍼런스로 메소드에 접근한다.
*  예외) 접근하려는 메소드가 static메소드이면
*        객체를 생성하지 않고 '클래스명.메소드명'으로 접근 가능하다.
***************************************************************************

* showInputDialog();, showMessageDialog();, parseInt() 는 static 메소드이다.
- API 참조할것

1_2)if~else문
if(조건){  --> true 또는 false를 가짐.
    문장1; --> '조건'의 결과값이 true인 경우 '문장1' 수행
} else {
    문장2; --> '조건'의 결과값이 false인 경우 '문장2' 수행
}

1_3)블록 if문
if(조건1){  --> true 또는 false를 가짐.
    문장1;  --> '조건1'의 결과값이 true인 경우 '문장1' 수행
} else if(조건2) {
    문장2;  --> '조건2'의 결과값이 true인 경우 '문장2' 수행
} else { 
    문장3;  --> '조건1','조건2'를 모두 만족하지 못한 경우 '문장3' 수행
}
- if문의 수는 '결과의 수 - 1'로 결과가 3개이면 if의 갯수는 2개가 된다.   
   
2) switch문
switch(표현식){
  case 케이스1: --+--> 케이스1의 경우 실행
       문장1;     |
       break;   --+
  case 케이스2: --+--> 케이스2의 경우 실행
       문장2;     |
       break;   --+
  default:      --+--> 그 외의 경우 실행
       문장3;     |
       break;}  --+
- 표현식(expression)은 리턴 타입이나 결과값이 정수타입만 가능.(정수 long제외)
  : int, short, char(문자형, int 타입으로 형변환 가능), byte 

3) for문
조건 비교 반복문의 4가지 조건(a.for문, b.while문, c.do~while문)
- 반복 횟수 카운트 변수의 선언 및 초기값 할당, 조건, 반복 수행할 문장, 반복 횟수 카운트
  a.for문
    for(반복 횟수 카운트 변수의 선언 및 초기값 할당; 조건; 반복 횟수 카운트){
        반복 수행할 문장;
    }
  b.while문
    반복 횟수 카운트 변수의 선언 및 초기값 할당;
    while(조건){
        반복 수행할 문장;
        반복 횟수 카운트;
    }
  c.do~while문
    반복 횟수 카운트 변수의 선언 및 초기값 할당;
    do{
        반복 수행할 문장;
        반복 횟수 카운트;
    }while(조건);      
-for문은 일정한 문장을 반복 수행할 횟수가 결정된 경우에 주로 사용
-배열문이 나오면 대부분 for문으로 배열의 반복을 제어한다.
* for(초기값;조건;반복횟수카운트){ 반복 수행할 문장; }
- 초기값 : 반복횟수 제어 카운트변수 선언, 초기값 할당, 단한번만 실행
- 조건 : 반복 범위 탈출 조건, 문장 수행전 만족여부 확인
- 반복 횟수 카운트 : 증감 연산자(++, --)를 사용
- 초기값 -> 조건 -> 반복 수행되는 문장 -> 반복 횟수 카운트 순서

* 중첩for문

* while문
- 반복 횟수를 알수 없는 경우사용(for문과 쓰임새가 같다.)
- 반복횟수를 알수 없는 경우에는 for문 보다 선호한다.

* import java.text.DecimalFormat;
- 평균의 소수점 이하 자릿수를 맞출때 사용
- 객체 생성 : DecimalFormat digits = new DecimalFormat("0.00");
- 사용 : digits.format(average);

* JOptionPane.showMessageDialog(null,"평균 : 100","평균구하기",JOptionPane.INFORMATE_MESSAGE);
- 인수1 : Parents 컴포넌트의 레퍼펀스를 기술(현재 없으므로 null)
- 인수2 : 메시지 상자에 표시할 내용을 기술
- 인수3 : 메시지 상자의 제목표시줄(title bar)에 표시할 내요을 기술
- 인수4 : 메시지의 종류를 기술(5가지)
  ERROR_MESSAGE, INFORMATION_, WARNING_, QUESTION_, PLAIN_)

* while문은 무한루프를 작성할때 선호되는 제어문이다.
- 무한 루프( while(true){} )를 탈출할 때는 루프 탈출조건에 break; 문은 사용.

* do~while문
- 조건이 맞지 않더라도 반드시 한번은 do~while 블록내의 문장을 수행하게 된다.

* break문과 continue문 ( 제어를 바꾼다. )
+-- break문 : 반복문을 빠져나올때 사용. 제어의 흐름을 바꿀때(반복문을 완전히 벗어날때) 사용.
+-- continue문 : 반복문을 조건이 만족된 경우 빠져나왔다가 다시 반복문의 나머지를 수행

* break구문 사용예 if(str.equals("end"))  break;
  - 구문으로 빠져나온다. 
  - String 구문중에 \n은 줄바꿈의 의미이다.
  - String도 레퍼런스 객체이므로, equals를 쓰면, 객체의 내용이 같은지 확인하게 된다.

* continue구문 사용예
  반복문 블럭{
      if(조건)  ---> 반복문 탈출조건
          continue;  ---> 조건 만족시 반복문을 빠져나왔다가
  }                       다시 반복문의 나머지 부분을 수행.
  for(int i=0; i<10; i++){
      if(i==7) continue;
  } 
--------------------------------------------------------------------
* 배열:같은 이름과 같은 데이터타입을 갖는 연속적인 기억장소의 집합이다.
- 배열명은 배열의 저장위치를 가리키는 레퍼런스 변수 역활을 한다.
- 배열명 c : c라는 이름으로 저장된 배열의 기억장소 시작번지를 가지고 있다.
* 배열선언과 메모리할당
  int[] c;  --------> 배열c 선언.(=> int c[]; 도 입력가능)      
  c = new int[5]; --> 배열c 메모리할당.(=> int[] c = new int[5]; 도 입력가능) 
  - 배열을 사용하기 위해서는 메모리에 할당해야 하고, new 키워드를 사용한다.
  - int 타입이 4바이트이므로 c는 4*5=20바이트가 할당되고, 데이터 타입의 기본값으로 초기화된다.
  - 숫자타입 : 0, boolean타입 : false, 레퍼런스타입 : null
* 2차원 배열 : int a[][] = new int[2][2];  
* 배열은 for문은 사용한다.
- int[] c; ---> 배열선언 
  int d[]; ---> 배열선언
  c = new int[5]; ---> 배열의 메모리 할당
  c[3] = 5;       ---> 배열의 사용. c[3]의 위치에 5를 넣음.
  d = c;          ---> c배열의 시작주소를 d배열에 넘겨준다.
                       결론적으로 c배열과 d배열은 같은 배열을 가리킨다.
  System.out.println(d[3]);  ---> c[3]과 d[3]은 같은 배열의 위치를 가리키므로 5가 출력된다.
 
* 바둑판이 아닌 열의 갯수를 동적으로 생성가능하다.
        char stars[][];
        stars = new char[3][];
       
        for (int i=0; i < stars.length; i++){  ---> 배열의 크기선언(유동적으로)
         stars[i] = new char[i+1];          ---> 열의 크기는 행번호(i)+1 이다.
         for (int j=0; j < stars[i].length; j++){
          stars[i][j] = '*';  // '*'와 "*"는 다르다.
         }
        }       
       
        for (int i=0; i < stars.length; i++){  ---> 배열의 메모리 할당
         for(int j=0; j<stars[i].length; j++){
          result += stars[i][j];
         }
            result += "\n";
        }
결과값       
*
**
***

* '*'와 "*"는 다르다. 뭐지??????
* 2차원배열에서 배열명.length  ----------> 행의수 획득
                배열명(행번호).legnth  --> 열의수 획득
* 2차원배열에서 열의 크기 선언은 stars[i] = new char[i+1]; 이다.
                                 +------+ 행의 크기는 선언되어 있다.
* 배열의 초기화 리스트
- 배열을 선언할때 값을 바로 할당하는 것(배열의 선언, 기억장소 할당, 배열의 원소에 값 할당)                                
- int c[] = {1, 2, 3};                                                                
            +-------+ 배열의 초기화 리스트

**( class : 매우 중요 )***************************************************************           
* 클래스에서 작업의 처리는 메소드가 한다.
* main() 메소드는 특수 메소드라 재사용 및 재정의도 할수 없다.

* 메소드 관련
* 클래스 만들때 유의 사항
- 클래스의 실행과 관련이 있는 main()메소드는 클래스의 실행만 담당시키도록 작성하고,
  그 클래스 고유의 작업들은 각각 개별적인 메소드로 작성하는 것이 좋다.
- 또한 재사용을 목적으로 하는 클래스들은 main()메소드 없이
  그 클래스에서 필요한 작업을 하는 메소드들만 가지고 있게 한다.
- main()메소드는 클래스를 실행(기동)시키는 일만 하기 때문에
  다른 클래스에서 사용되어지는 클래스들은 main() 메소드를 가질 필요가 없다.
  왜냐하면 다른 클래스들에서 사용되어질 클래스들은 필요한곳에서 실행기키면
  되기 때문이다. 이런 클래스들은 클래스의 실행보다는
  작업을 잘 정의한 메소드들의 작성에 전념해야 한다.
 
+-- 메소드선언 : 메소드가 하는 작업을 정의해 놓은것
+-- 메소드호출 : 필요한 곳에서 메소드를 사용하는 것
* 접근제어자 리턴타입 메소드명(매개변수목록){} => public void process(int x){}
접근제어자 리턴타입 메소드명(매개변수목록){ --+--> 매개변수 유무에 따라 매개변수목록이 없기도 함. 
    문장;                                     |
    return문; --> 리턴타입에 따라 없기도 함.  +--> 메소드의 바디도 메소드의 형태에 따라 없기도 함.
}                                      -------+
****************************************************************************************
*+-- 메소드 접근 제어자(method access modifier): public, protected, private 타입 사용 
*|  메소드 선언시 사용 키워드 : abstract, static, final, native, synchronized 
*|  - native : 자바클래스에서 C/C++ 구현시 사용
*|  - synchronized : 쓰레드의 동기화와 관련
****************************************************************************************
 +-- 메소드 리턴 타입(method return type): 
    +-- 메소드 실행결과 리턴(반환)하지 않는 경우: 
    |   - 리턴 타입에 void옴. 반환 없음므로 return;문 없다.(있으면 에러난다.)
    |   접근제어자, 리턴타입, 메소드명
    |   public      void      shutDown(){ ---> 리턴타입이 void이므로, 메소드가 없다.
    |       key = false;   
    |   }
    |
    +-- 메소드 실행결과 리턴(반환)하는 경우:
        - 리턴 타입에 void 제외.(기본 데이터 타입, 레퍼런스 타입(배열타입 포함))
          메소드 수행결과로 리턴 타입에 기술된 타입이며, return;문이 있다.(없으면 에러난다.)
        접근제어자, 리턴타입, 메소드명, 매개변수
        public      int       checkIt(  int check){
           check++;
           return check; ---> 리턴타입이 int이므로, 이 위치에 return문이 같은 int타입의 값을 리턴한다.
        }

* 메소드 호출
- 호출하는 메소드 안에서 호출하고 싶은 메소드명을 써주면 된다.
  +--public void execute(){ --> execute() 메소드 선언
  |      int check = 5;
  |      int x = checkIt(check); --> check 변수의 값(5)으로 매개변수에 값(5)을 넘기고 checkIt을 호출.
  |                                  checkIt의 check는 6을 리턴 -> x에는 6이 대입된다. 
  |      riseOn();          --> riseOn() 메소드 호출
  |  }
  |
  +--public int checkIt(int check){  --> checkIt() 메소드 선언(check = 5)
         check++;      --> 5++   
         return check; --> check = 6
     }

* 클래스 다이어그램
- 클래스의 구조를 한눈에 알아보기 위해 UML(Unified Modeling Language) 다이어그램중
  클래스 다이어그램(class diagram)을 사용해서 클래스의 구조를 파악
    +-- 하나의 클래스 구조를 표현하는 것 (여기서 사용할 구조)
    +-- 클래스간의 관계를 표현한는 것
  * 형식:
  [클래스영역] ---> class일때는 클래스명을 쓰고, interface일때는 '<interface>'를 입력하고 인터페이스명을 쓴다.    
  [멤버필드영역] --> 접근제어자 표시를 붙여 '멤버 필드명:멤버 필드 타입'의 형태로 쓴다.
  [메소드영역] ---> 접근제어자 표시를 붙여 '매소드명(매개변수타입):리턴타입'의 형태로 쓴다.
  * 접근제어자 표시
  - public => '+', private => '-', Protected => '#', default => 무표시
    +-- abstract 키워드 사용(추상클래스나 추상메소드)한 경우 => 기울임꼴(italic:이탤릭체)
    +-- static 키워드 사용 메소드나 멤버필드 => 밑줄(underline:언더라인)
   
* static 메소드 : 객체의 생성 없이 메소드를 호출해서 사용할 수 있다.
public class StaticMethodCallTest {
    static String result = "";
   
    public static void sumMethod(int a){
     a++;
     result += "sumMethod()의 a = " + a + "\n";
    }
 
    public static String nameMethod(){
     String name = "";
     name = JOptionPane.showInputDialog("이름을 입력하세요.");
     return name;
    } 
 
 public static void main(String[] args) { --> 프로그램의 실행을 담당, 자동 실행되는 시작 메소드이다.
        int a = 10;
        result += " main()의 a = " + a + "\n";
        StaticMethodCallTest.sumMethod(a);
                +--> 클래스의 시작 메소드로 클래스를 실행하는 것은 이 메소드를 실행하는 것이다.
                     sumMethod() 메소드가 static 메소드이기 때문에 클래스명.메소드명으로 호출 가능
        result += "입력하신 이름은 :" + nameMethod() + "\n";
                +--> nameMethod()도 static메소드이다. 메소드에 레퍼런스나 클래스명을 붙이지 않고 호출할 수 있는것은
                     호출하는 메소드인 main() 메소드가 static이기 때문이다.
                     static 메소드끼리는 그냥 호출할 수 있다.  
        JOptionPane.showMessageDialog(null, result);      
    * 메소드명 앞에 static이 붙은 메소드는 static이 붙은 메소드만을 직접 호출할 수 있다.
      static이 붙지 않은 메소드를 호출하려면 객체를 생성하여 객체의 레퍼런스명으로 접근해서 호출해야 한다.
          
* icon 설명(eclipse)
- Help > Help Contents > (contents)Java development user guide > Reference > Wizards and Dialogs > Icons

* static 메소드는 특수 메소드로 꼭 필요할때만 사용
- static이 붙은 메소드가 존재하는 클래스는 다른 클래스에 상속할 때 주의
  (static이 붙은 메소드는 상속 받는 쪽에서 재정의 할 수 없다)
* static이 붙은 메소드에서 static이 붙지 않은 메소드를 호출하려면 해당 클래스의 객체를 생성해서
  '객체의 레퍼런스명.메소드명'으로 호출한다.
  static메소드인 main()메소드에서 static이 붙지 않는 일반적인 메소드를 호출할때 이방법 사용.
  - public static void main(String[] args) {
     NonStaticMethodCallTest nsmct = new NonStaticMethodCallTest(); --> 객체(인스턴스) nsmct 생성
         --> 객체(인스턴스)인 nsmct는 인스턴스이면서 동시에 인스턴스를 가리키는 레퍼런스로 사용된다.
     nsmct.printMethod();  --> nsmct는 객체의 레퍼런스이고, printMethod()는 호출한 메소드이다.
  - static메소드에서 non-static메소드를 호출하려면 객체를 생성해서 '객체의 레퍼런스.메소드()'로 호출한다.