- [Java 기본]다차원배열, 클래스

출처 : http://cafe.naver.com/litave/358

ho0107.java

//===========================================================================//
  본 내용은 2002년 제가 Java 강의를 수강하며 정리 했던 내용을
    기본으로 하여 정리하였습니다.
  - 마침 java 기초를 전파할 기회가 생겨 핑계김에 정리해 가려 합니다.
  작성자 : litwave
//---------------------------------------------------------------------------//

<목차>
1. Java 다차원 배열
2. 클래스

//---------------------------------------------------------------------------//
[Java 기본]메소드, Java 1차원 배열 관련 과제 참고

5번 과제:
석차 구하기
         tot              rank    tot를 모든 값과 비교하여 자신 보다 큰값이 있으면 1을 증가 시킨다.
tot[0]   231     rank[0]   1       + 1 + 1 + 1  = 4
   [1]   251           [1]   1       + 1 = 2
   [2]   123           [2]   1       + 1 + 1 + 1 + 1 = 5
   [3]   471           [3]   1       + 1 + 1 = 3
   [4]   631           [4]   1       = 1
a) 우선 rank 배열을 모두 1로 초기화 시킨다.
b) 구현
   for(int i=0; i<5; i++) {
     for(int j=0; j<5; j++) {
       if(tot[i] < tot[j]) {
         rank[i]++;
       }
     }
   }


//---------------------------------------------------------------------------//
** 자바 배열 **

1. 다차원 배열
  1) 선언 : 
    a) 자료형[][] 배열명;
    b) 자료형[] 배열명[];
    c) 자료형 배열명[][];

  2) 초기화 :
    a) 배열명 = new 자료형[개수1][개수2];
    b) 배열명 = {{...}, {...}, {...}, ..};
    c) 배열명 = new 자료형[개수1][개수2]{{...},{...}...};
    d) 배열명 = new 자료형[개수][];          // <- 매우 중요

  1.1 배열의 특징
    a) 배열은 무조건.. 4바이트 이다.
    b) char[] ch, ch1[][], d[];   // ch는 1차원배열, ch1 은 3차원 배열, d는 2차원 배열
    c) 자바는 항상 1차원 배열 밖에 기억할 수 가 없다.
    d) 자바 배열의 실제 Data 공간은 마지막 공간이다.
       나머지는 전부 reference type 공간이다.  // 모든 배열에 저장 된다.

    예)
      char[][] ch = new char[3][2];
                                             ^여기만 데이타를 저장할수 있는 공간이고..
                    ^-------------^ 여기는 레퍼런스 타입이다.
      // 참고 : 여기서 ch.length 는 3이다.


  1.2 동적 배열
    1) 선언
      배열명 = new 자료형[개수][];
      - 몇행 무한열이 되어서... 자바가 동적으로 메모리를 사용할 수 있음을 의미 한다.
      - 가장 첫번째 자리는 무조건 정해야 하고 나머지는 선택 사항이다.

      예) int[][][][][] i = new int[2][][][];    // 가능..
          int[][][][][] i = new int[2][][4][];   // 사용할 수 없다.

  2) 무한적으로 사용시의 이점.
      Char[][] ch = new char[3][];
    a) 메모리 구성 형태

      할당 바이트 수     4         4       4                                 4
      메모리 내용       null      null    null                            10억
                             ch[0]   ch[1]   ch[2]                         ch
      메모리 주소       ^10억 번지

      - ch는 위와 같이 ch[0]의 주소인 10억 번지를 값으로 가지게 된다.
      - 위와 같이 무한열이면 null값이 저장된다.
      - null 값인 상태로 사용하려 하면 NullPointerException 에러를 발생한다.

   b) 0번째 공간에 3개의 공간을 만들고 싶다면  => ch[0] = new char[3];
      1번째 공간에 4개의 공간을 만들고 싶다면  => ch[1] = new char[4];
      2번째 공간에 2개의 공간을 만들고 싶다면  => ch[2] = new char[2];

   c) ch[0] = new char[3];
       로 하면

      할당 바이트 수     4        4         4                 2                2           2                              4
      메모리 내용       20억    null      null                                                                          10억
                            ch[0]   ch[1]   ch[2]  ...  ch[0][0]  ch[0][1]  ch[0][2]                        ch
      메모리 주소      ^10억 번지                      ^20억 번지
       과 같이 할당 된다.

   - ch는 ch배열의 처음인 ch[0]의 주소(10억)을 주소로 가지며, 
     ch[0]은 다시 ch[0][0]의 주소인 20억 번지를 값으로 가진다.


  3) 1차원 배열에서 3차원 배열까지 변경해 가능 과정
     Ex0107_01
   - 배열에서 신경 써야 할것은 가장 첫번째 사람의 데이터를 어떻게 입력 받을 것인가를 생각하는 것이다.


//---------------------------------------------------------------------------//

과제. 1.

  java Ho0107_01 국어 영어 수학 ... 3      //3 : 학급수(임의의 정수)
  프로그램 시작..

출력 :

** 성적 처리 P/G **
1번째 학급 이름 = 참새반    // 참새반 입력
1번째 학급 인원수 = 5       // 5 입력
2번째 학급 이름 = 노루반
2번째 학급 인원수 = 7
3번째 학급 이름 = 고래반
3번째 학급 인원수 = 3



* 각반이 배정되었습니다.

참새반 1번째 사람 성적 입력
이름 = aaa                 // aaa 입력
국어 = 100                 // 100 입력
영어 = 90
수학 = 80

참새반 2번째 사람 성적 입력
.
.
.

고래반 3번째 사람 성적 입력
이름 = kkk
국어 = 50
영어 = 70
수학 = 60


o 전체 성적표

반이름 이름 국어 영어 수학 총점 평균 학점 반석차 전교석차

참새   aaa   100   90  80   270  90   ..    1        2

참새    .

참새    .

.       .

.       .

.       .

고래   kkk    50   70  60    .    .      .    .       .

//---------------------------------------------------------------------------//

2. Class
  1) class 가 나타난 배경 : OOP
    oop의 삼대 특징 :
      캡슐화  - 추상화        // 현재는 두개로 분리 됨
              - 은닉화
      상속성
      다형성

  2) 실무적인 의미에서의 클래스에 대해서(자료 사용의 발전.. )
    //필요한 데이터 선언  ==>  동일한 자료들을 묶어서  ==>  다양한 데이터 타입을          ==>  + 행위(포함시키고 싶다.)
    //                                   배열로 사용                         하나의 데이터 형으로 사용
    int tot;
    int kor;                                                                          
    int eng;                     ==>  int[] sub                     ==> struct A {                           ==>  class A {
    int math;                                                                       String ...;                                 자료형
                                                                                       float  ...;                                  행위
    String name;                                                             };                                                행위
    float avg;                                                                                                                 }
    char hak;

    클래스의 궁극적 목적 : 특정한 하나의 생산물을 만들기 위한 목적으로 만들어짐
      - 한가지 목적을 달성하기 위한 단체, 묶음, 모임.
      - 보다 코딩을 줄이고 효율적으로 사용할 수 있다.


  1.1 클래스의 포함 멤버들
    1) Field       = 멤버 변수
    2) Method      = 멤버 함수
    3) Constructor = 생성자


  1.2 클래스의 구성 형태
    - [] 부분은 생략 가능 한것 표시
    1.2.1 일반 class 형식 :
      접근자  [지정어]  class  클래스명  [extends  상위클래스]  [implements  상위인터페이스1, 상위 인터페이스2...] {   }

      1) 접근자 : 접근자는 모두 동일(0106에서 설명)
        public
        private
        package     // 하나의 폴더는 동일한 package로 인식 된다.
        protected

      2) 지정어 :
        a) abstract : 로 선언 되면 추상클래스 가 된다.(new 를 이용한 직접적인 객체 생성이 불가능하다.)
        b) static   : 정적 중첩(inner) 클래스에서 많이 사용한다.
        c) final    : 더이상 상속을 주지 않는 최종 클래스로 사용할때 사용한다.
            - final 로 선언하면.. 상속을 할 수 없다.

      3) extends    : 클래스가 클래스를 상속해주거나 인터페이스(클래스의 일종)가 인터페이스에게 상속해줄 때 사용할 수 있는 예약어
            - 클래스는 단일 상속만 할수 있지만, 인터페이스는 다중 상속이 가능하다.

      4) implements : 인터페이스가 클래스에게 상속을 줄 때 사용할 수 있다.
            - 클래스는 인터페이스에게 상속을 줄 수 없다.
            - extends 와 implements 두개 동시에 상속 받을 때는 extends 를 먼저 쓴다.

      5) 자바의 모든 클래스는 Object 라는 클래스를 자동 상속 받는다.  <=== 아주 중요.
            - 그래서 따로 명시할 필요가 없다.

      6) 클래스의 마지막에 ;를 붙이지 않는다.


    1.2.2 Field 형식 : (클래스의 내부에 들어 가는 것)
      접근자  [지정어]  자료형(클래스형)  변수명(객체)   [= 초기값];

      1) 지정어 :
        a) static : 그 필드는 공유 변수의 개념으로 사용된다.
        b) final : 정적(상수) 변수로 사용된다. (= C++의 Const 와 동일)

      2) 초기값을 바로 선언이 가능하다.(생성자에서 값을 주는 C++과 다름)

    1.2.3 Constructor 형식 :
      접근자  클래스명(매개변수들) [throws  예외클래스1, 예외클래스2,...] {   }

      - Method 와 같이 생각해도 되지만 리턴값과 지정어를 적을 수 없다.
      - 생성자의 이름은 클래스의 이름과 완벽히 동일해야 한다.
      - 예외 처리를 뒤 쪽에서 할 수 있다.
      - 조금 특이한 Method라고 생각해도 된다.
      - 생성자는 일반적으로 public 타입이 된다.

      a) 생성자(Constructor) 앞에는 private 을 거의 사용하지 않는다.
           - protected도 잘 사용하지 않음.

  1.3 클래스의 포함 멤버들이 사용되는 형태
    1) 클래스를 사용하는 방법(사용자 정의 데이타를 만드는 방법)
        class AA {
          int a;
          float b;
          char  c;
        }

        public Class B {
          public static void main(String [] args) {
            AA i= new AA();            // 사용자정의 자료형도 reference 이다. 4바이트
                                       // reference 변수들을 초기화 할때. new를 사용한다.
                                       // 마지막에는 생성자를 넣어 주면 된다.
            i.b = 1.2;                 // 의 형태로 멤버 변수 사용 가능
          }
        }


    할당메모리          4    4    2                                               4
                          ----------------------------------------------
    메모리내용       |   |1.2f|   |                                           |10억|
                          ----------------------------------------------
                            a    b   c                                                 i
    메모리주소      ^ 10번지



  1.4 클래스 생성자(Constructor)에 대해서
    1) 객체발생시 Field 의 값을 초기화 시킨다.
    2) 객체의 발생 시 Computer 에게 객체 발생을 알리고 클래스명@hashcode 6자리의 고유값 보존
    3) 클래스 이름과 동일한 Method 로 지정어와 결과형 리턴형을 가지지 않는다.
    4) 객체 생성시 반드시 하나의 생성자만 호출된다.
    5) Overloading 가능하다. 
       - 매개변수의 개수 다르거나 매개변수의 자료형 틀린경우

    6) 생성자가 존재하지 않을 경우에만 Default 생성자가 존재하는 것으로 간주한다.
      - Default 생성자가 생성되면 내용부는 아무것도 존재하지 않게 된다.
    7) this()와 super()를 이용해서 자신의 클래스와 상위 상속관계 클래스의 생성자를 한번에 호출할 수 있다.
      - this()를 이용하면 자기자신의 생성자를 또 한번 호출 할 수 있다.
      - this() Method는 생성자의 시작블럭 바로 다음에 단 한번만 적을 수 있다.
        예)
          class A {
                int a, b, c, d, e, f, g, h;
                A () {
                  a = 10;  b = 20;
                  c = 30;  d = 40;
                  e = 50;  f = 60;
                  g = 70;  h = 80;
                }
            }

          e 의 값만.. 50으로 바꾸고 싶다.

          A(int x) {
            this();
            e = x;
          }

          A(int x, int y) {
            this(x);
            f = y;
          }

          A ap = new A();
          A bp = new A(500);
          A cp = new A(500, 1000);

    8) Member에 한하여 this 예약어 사용이 가능하다.(super 도)
        (단, static 멤버는 this 예약어가 없다.)
    9) 상속되지 않는다.



    1.4.1 설명
      생성자란 : 객체를 발생시키는 놈
      객체란 : new 생성자 한 놈을 담아두는 순간을 객체라고 한다.

        A ap = new A();
        ap를 객체 또는 인스턴스라고 한다.


    1.4.2 클래스명@hashcode라는 고유한 값을 돌려줌
      System.out.println(ap);  // 를 실행 하면
      A@....         //객체가 갖는 고유한 번호를 찍는다.



    1.4.2 자기 자신의 Field 를 사용할 때는 this.su1 식으로 this 를 붙여 준다. this는 생략도 가능한 예약어 이다.
     - 매개 변수를 Field 이름과 동일 한 이름을 사용할 경우 this 를 붙여 주어야 한다.

/** 앞으로 과제는 메인에서 프로그램을 하지 말것.. **/

//---------------------------------------------------------------------------//
//수업중 예제 소스

// Ex0107_01.java
import java.io.*;
public class Ex0107_01 {
    public static void main(String[] ar) throws IOException {
        if(ar.length != 2) {
            System.out.println("매개변수가 필요합니다.");
            System.out.println("Usage : java Ex0107_01 인원수 학급수");
            System.exit(0);
        }
        int inwon = Integer.parseInt(ar[0]);
        int num = Integer.parseInt(ar[1]);
        
        BufferedReader br = new BufferedReader(
                                new InputStreamReader(System.in));
        String[][] name = new String[num][inwon];
        String[] subname = {"국어", "영어", "수학"};
        int[][][] sub = new int[num][inwon][subname.length + 1];
        float[][] avg = new float[num][inwon];
        for(int k = 0; k < num; k++) {
            for(int j = 0; j < inwon; j++) {
                System.out.print("이름 = ");
                name[k][j] = br.readLine();
                for(int i = 0; i < subname.length - 1; i++) {
                    do {
                        System.out.print(subname[i] + " = ");
                        sub[k][j][i] = Integer.parseInt(br.readLine());
                    } while(sub[k][j][i] < 0 || sub[k][j][i] > 100);
                    sub[k][j][subname.length] += sub[k][j][i];
                }
                avg[k][j] = sub[k][j][subname.length] / (float)(subname.length - 1);
            }
        }
    }
}


// Ex0107_02.java, Ex0107_03.java
public class Ex0107_02 {
    public static void main(String[] ar) {
        Ex0107_03 es = new Ex0107_03();
        System.out.println(es.i);
    }
}

public class Ex0107_03 {
    public  int i = 20;

}


// Ex0107_04.java
import java.io.*;
class Ex0107_04_Sub {
    private BufferedReader br;
    private int su1, su2, tot;
    public Ex0107_04_Sub() {
        br = new BufferedReader(new InputStreamReader(System.in));
        su1 = su2 = tot = 0;
    }
    public void input() throws IOException {
        System.out.print("su1 = ");
        this.su1 = Integer.parseInt(this.br.readLine());
        System.out.print("su2 = ");
        this.su2 = Integer.parseInt(this.br.readLine());
    }
    public void yonsan() {
        this.tot = this.su1 + this.su2;
    }
    public void output() {
        System.out.println(this.su1 + " + " + this.su2 + " = " + this.tot);
    }
}

public class Ex0107_04 {
    public static void main(String[] ar) throws IOException{
        Ex0107_04_Sub es = new Ex0107_04_Sub();   
        es.input();   
        es.yonsan();    
        es.output();
    }

}

//===========================================================================//