자바 3주차 정리. 1부 배열, 클래스, 객체, GRASP패턴, 생성자 도입

#1. 낱개의 변수 사용: 변수를 개별적으로 선언하여 학생의 이름, 국어 점수, 영어 점수, 수학 점수 등을 저장.
이후 합계와 평균을 계산하여 출력.

#2. 낱개의 변수 재사용: 여러 학생의 정보를 처리하기 위해 변수를 재사용. 
하나의 변수를 사용하여 여러 학생의 정보를 처리하고 출력.

#3.배열 사용: 배열을 사용하여 여러 학생의 정보를 저장하고 처리.
학생의 이름, 국어 점수, 영어 점수, 수학 점수 등을 배열로 선언하여 관리.

#4. 클래스 타입을 이용하여 데이터 정의 (중첩 클래스; 로컬 클래스): 
클래스를 사용하여 학생의 정보를 구조화. Score라는 중첩 클래스를 정의.
학생의 이름, 국어 점수, 영어 점수, 수학 점수 등을 멤버 변수로 갖고 있는
객체를 생성.

#5. 출력 기능을 별도의 메서드로 분리 + (중첩 클래스; 스태틱 클래스): 
출력 기능을 별도의 메서드로 분리하여 중복을 제거.
중첩 클래스로 정의된 printScore 메서드를 이용하여 학생의 정보를 출력.

#6. 합계 및 평균을 계산: Score 클래스에 compute 메서드를 추가하여 합계와 평균을 계산.

#7. GRASP 패턴: Information Expert(정보를 갖고 있는 클래스가 그 정보를 다룬다): 
Score 클래스가 학생의 정보를 갖고 있고, 합계와 평균을 계산하는 등의 정보를 다루는 역할을 수행.

#8. 인스턴스 메서드 도입: 
Score 클래스에 compute 메서드를 인스턴스 메서드로 변경하여 객체에 대해 합계와 평균을 계산.

#9. (디자인 패턴; 팩토리 메서드): 객체 생성이 번거롭고 복잡한 경우 메서드로 분리하는 것이 낫다. 
createScore 메서드를 도입하여 객체 생성을 간소화.

#10. GRASP 패턴: Information Expert: createScore 메서드를 Score 클래스로 이동하여
객체 생성과 관련된 정보를 다룸.

#11. 생성자 도입: Score 클래스에 생성자를 도입하여 객체 생성 시 초기화 작업을 수행.

 

// 1) 낱개의 변수사용

package bitcamp.test.step1;
import bitcamp.util.Prompt;

// 1) 낱개의 변수사용
public class App {

  public static void main(String[] args) {
    String name;
    int kor;
    int eng;
    int math;
    int sum;
    float aver;

    name = "홍길동";
    kor = 100;
    eng = 100;
    math = 100;

    sum = kor + eng + math;
    aver = sum / 3f;

    System.out.printf("%s: 합계=%d, 평균=%f\n",name, sum, aver);
  }
  

}

---

// 2) 낱개의 변수 재사용

package bitcamp.test.step2;
import bitcamp.util.Prompt;

// 1) 낱개의 변수사용
// 2) 낱개의 변수 재사용
public class App {

  public static void main(String[] args) {
    String name;
    int kor;
    int eng;
    int math;
    int sum;
    float aver;

    name = "홍길동";
    kor = 100;
    eng = 100;
    math = 100;

    sum = kor + eng + math;
    aver = sum / 3f;

    System.out.printf("%s: 합계=%d, 평균=%f\n",name, sum, aver);

    name = "임꺽정";
    kor = 100;
    eng = 100;
    math = 100;

    sum = kor + eng + math;
    aver = sum / 3f;

    System.out.printf("%s: 합계=%d, 평균=%f\n",name, sum, aver);

    name = "유관순";
    kor = 100;
    eng = 100;
    math = 100;

    sum = kor + eng + math;
    aver = sum / 3f;

    System.out.printf("%s: 합계=%d, 평균=%f\n",name, sum, aver);
  }
  

}

---

// 3) 배열 사용

package bitcamp.test.step3;
import bitcamp.util.Prompt;

// 1) 낱개의 변수사용
// 2) 낱개의 변수 재사용
// 3) 배열 사용
public class App {

  public static void main(String[] args) {
    String[] name = new String[10];
    int[] kor = new int[10];
    int[] eng = new int[10];
    int[] math = new int[10];
    int[] sum = new int[10];
    float[] aver = new float[10];
    int length = 0;

    name[length] = "홍길동";
    kor[length] = 100;
    eng[length] = 100;
    math[length] = 100;

    sum[length] = kor[length] + eng[length] + math[length];
    aver[length] = sum[length] / 3f;
    length ++;
    

    name[length] = "임꺽정";
    kor[length] = 100;
    eng[length] = 100;
    math[length] = 100;

    sum[length] = kor[length] + eng[length] + math[length];
    aver[length] = sum[length] / 3f;
    length ++;



    name[length] = "유관순";
    kor[length] = 100;
    eng[length] = 100;
    math[length] = 100;

    sum[length] = kor[length] + eng[length] + math[length];
    aver[length] = sum[length] / 3f;
    length ++;

    for (int i=0; i < length; i++) {
    System.out.printf("%s: 합계=%d, 평균=%f\n",name[length], sum[length], aver[length]);
    }


    }
  }

---

// 4) 클래스 타입을 이용하여 데이터 정의 (중첩클래스; 로컬클래스)

 

package bitcamp.test.step4;
import bitcamp.util.Prompt;

// 1) 낱개의 변수사용
// 2) 낱개의 변수 재사용
// 3) 배열 사용
// 4) 클래스 타입을 이용하여 데이터 정의 (중첩클래스; 로컬클래스)

public class App {

  public static void main(String[] args) {
    class Score {
      String name;
      int kor;
      int eng;
      int math;
      int sum;
      float aver;
    }

    // String[] name = new String[10];
    // int[] kor = new int[10];
    // int[] eng = new int[10];
    // int[] math = new int[10];
    // int[] sum = new int[10];
    // float[] aver = new float[10];

    final int MAX_SIZE = 10;
    Score[] scores = new Score[MAX_SIZE];
    int length = 0;

    //
    Score s = new Score();
    s.name = "홍길동";
    s.kor = 100;
    s.eng = 100;
    s.math = 100;

    s.sum = s.kor + s.eng + s.math;
    s.aver = s.sum / 3f;
    scores[length++] = s;

    s = new Score();
    s.name = "임꺽정";
    s.kor = 90;
    s.eng = 90;
    s.math = 90;

    s.sum = s.kor + s.eng + s.math;
    s.aver = s.sum / 3f;
    scores[length++] = s;
    
    s = new Score();
    s.name = "유관순";
    s.kor = 80;
    s.eng = 80;
    s.math = 80;

    s.sum = s.kor + s.eng + s.math;
    s.aver = s.sum / 3f;
    scores[length++] = s;

    for (int i=0; i < length; i++) {
    s = scores[i];
    System.out.printf("%s: 합계=%d, 평균=%f\n",s.name, s.sum, s.aver);
    }


    }
  }

---

// 5) 출력 기능을 별도의 메서드로 분리 + (중첩클래스; 스태틱클래스)

package bitcamp.test.step5;
import bitcamp.util.Prompt;

// 1) 낱개의 변수사용
// 2) 낱개의 변수 재사용
// 3) 배열 사용
// 4) 클래스 타입을 이용하여 데이터 정의 (중첩클래스; 로컬클래스)
// 5) 출력 기능을 별도의 메서드로 분리 + (중첩클래스; 스태틱클래스)

public class App {
  static class Score {
    String name;
    int kor;
    int eng;
    int math;
    int sum;
    float aver;
  }
  
  public static void main(String[] args) {

    // String[] name = new String[10];
    // int[] kor = new int[10];
    // int[] eng = new int[10];
    // int[] math = new int[10];
    // int[] sum = new int[10];
    // float[] aver = new float[10];

    final int MAX_SIZE = 10;
    Score[] scores = new Score[MAX_SIZE];
    int length = 0;
    
    
    //
    Score s = new Score();
    s.name = "홍길동";
    s.kor = 100;
    s.eng = 100;
    s.math = 100;

    s.sum = s.kor + s.eng + s.math;
    s.aver = s.sum / 3f;
    scores[length++] = s;
    
    s = new Score();
    s.name = "임꺽정";
    s.kor = 90;
    s.eng = 90;
    s.math = 90;

    s.sum = s.kor + s.eng + s.math;
    s.aver = s.sum / 3f;
    scores[length++] = s;
    
    s = new Score();
    s.name = "유관순";
    s.kor = 80;
    s.eng = 80;
    s.math = 80;

    s.sum = s.kor + s.eng + s.math;
    s.aver = s.sum / 3f;
    scores[length++] = s;

    for (int i = 0; i < length; i++) {
      printScore(scores[i]);
    }

  }

  static void printScore(Score s) {
    System.out.printf("%s: 합계=%d, 평균=%f\n",s.name, s.sum, s.aver);
    }


    }

---

// 6) 합계 및 평균을 계산

package bitcamp.test.step6;
import bitcamp.util.Prompt;

// 1) 낱개의 변수사용
// 2) 낱개의 변수 재사용
// 3) 배열 사용
// 4) 클래스 타입을 이용하여 데이터 정의 (중첩클래스; 로컬클래스)
// 5) 출력 기능을 별도의 메서드로 분리 + (중첩클래스; 스태틱클래스)
// 6) 합계 및 평균을 계산

public class App {
  static class Score {
    String name;
    int kor;
    int eng;
    int math;
    int sum;
    float aver;
  }
  
  public static void main(String[] args) {

    // String[] name = new String[10];
    // int[] kor = new int[10];
    // int[] eng = new int[10];
    // int[] math = new int[10];
    // int[] sum = new int[10];
    // float[] aver = new float[10];

    final int MAX_SIZE = 10;
    Score[] scores = new Score[MAX_SIZE];
    int length = 0;
    
    
    //
    Score s = new Score();
    s.name = "홍길동";
    s.kor = 100;
    s.eng = 100;
    s.math = 100;
    compute(s);
    scores[length++] = s;
    
    s = new Score();
    s.name = "임꺽정";
    s.kor = 90;
    s.eng = 90;
    s.math = 90;
    compute(s);
    scores[length++] = s;
    
    s = new Score();
    s.name = "유관순";
    s.kor = 80;
    s.eng = 80;
    s.math = 80;
    compute(s);
    scores[length++] = s;

    for (int i = 0; i < length; i++) {
      printScore(scores[i]);
    }

  }

  static void compute(Score s) {
    s.sum = s.kor + s.eng + s.math;
    s.aver = s.sum / 3f;
  }


  static void printScore(Score s) {
    System.out.printf("%s: 합계=%d, 평균=%f\n",s.name, s.sum, s.aver);
    }


    }

---

// 7) GRASP 패턴 : Information Expert(정보를 갖고 있는 클래스가 그 정보를 다룬다.)

package bitcamp.test.step7;
import bitcamp.util.Prompt;

// 1) 낱개의 변수사용
// 2) 낱개의 변수 재사용
// 3) 배열 사용
// 4) 클래스 타입을 이용하여 데이터 정의 (중첩클래스; 로컬클래스)
// 5) 출력 기능을 별도의 메서드로 분리 + (중첩클래스; 스태틱클래스)
// 6) 합계 및 평균을 계산
// 7) GRASP 패턴 : Information Expert(정보를 갖고 있는 클래스가 그 정보를 다룬다.)

public class App {
  static class Score {
    String name;
    int kor;
    int eng;
    int math;
    int sum;
    float aver;

    static void compute(Score s) {
      s.sum = s.kor + s.eng + s.math;
      s.aver = s.sum / 3f;
    }
  }
  
  public static void main(String[] args) {

    // String[] name = new String[10];
    // int[] kor = new int[10];
    // int[] eng = new int[10];
    // int[] math = new int[10];
    // int[] sum = new int[10];
    // float[] aver = new float[10];

    final int MAX_SIZE = 10;
    Score[] scores = new Score[MAX_SIZE];
    int length = 0;
    
    
    //
    Score s = new Score();
    s.name = "홍길동";
    s.kor = 100;
    s.eng = 100;
    s.math = 100;
    Score.compute(s);
    scores[length++] = s;
    
    s = new Score();
    s.name = "임꺽정";
    s.kor = 90;
    s.eng = 90;
    s.math = 90;
    Score.compute(s);
    scores[length++] = s;
    
    s = new Score();
    s.name = "유관순";
    s.kor = 80;
    s.eng = 80;
    s.math = 80;
    Score.compute(s);
    scores[length++] = s;

    for (int i = 0; i < length; i++) {
      printScore(scores[i]);
    }

  }


  static void printScore(Score s) {
    System.out.printf("%s: 합계=%d, 평균=%f\n",s.name, s.sum, s.aver);
    }


    }

---

// 8) 인스턴스 메서드 도입

package bitcamp.test.step8;
import bitcamp.util.Prompt;

// 1) 낱개의 변수사용
// 2) 낱개의 변수 재사용
// 3) 배열 사용
// 4) 클래스 타입을 이용하여 데이터 정의 (중첩클래스; 로컬클래스)
// 5) 출력 기능을 별도의 메서드로 분리 + (중첩클래스; 스태틱클래스)
// 6) 합계 및 평균을 계산
// 7) GRASP 패턴 : Information Expert(정보를 갖고 있는 클래스가 그 정보를 다룬다.)
// 8) 인스턴스 메서드 도입

public class App {
  static class Score {
    String name;
    int kor;
    int eng;
    int math;
    int sum;
    float aver;

    void compute() {
      this.sum = this.kor + this.eng + this.math;
      this.aver = this.sum / 3f;
    }
  }
  
  public static void main(String[] args) {

    // String[] name = new String[10];
    // int[] kor = new int[10];
    // int[] eng = new int[10];
    // int[] math = new int[10];
    // int[] sum = new int[10];
    // float[] aver = new float[10];

    final int MAX_SIZE = 10;
    Score[] scores = new Score[MAX_SIZE];
    int length = 0;
    
    
    //
    Score s = new Score();
    s.name = "홍길동";
    s.kor = 100;
    s.eng = 100;
    s.math = 100;
    s.compute();
    scores[length++] = s;
    
    s = new Score();
    s.name = "임꺽정";
    s.kor = 90;
    s.eng = 90;
    s.math = 90;
    s.compute();
    scores[length++] = s;
    
    s = new Score();
    s.name = "유관순";
    s.kor = 80;
    s.eng = 80;
    s.math = 80;
    s.compute();
    scores[length++] = s;

    for (int i = 0; i < length; i++) {
      printScore(scores[i]);
    }

  }


  static void printScore(Score s) {
    System.out.printf("%s: 합계=%d, 평균=%f\n",s.name, s.sum, s.aver);
    }


    }

---

// 9) 객체 생성이 번거롭고 복잡한 경우 메서드로 분리하는 것이 낫다.

(디자인패턴; 팩토리 메서드)

package bitcamp.test.step9;
import bitcamp.util.Prompt;

// 1) 낱개의 변수사용
// 2) 낱개의 변수 재사용
// 3) 배열 사용
// 4) 클래스 타입을 이용하여 데이터 정의 (중첩클래스; 로컬클래스)
// 5) 출력 기능을 별도의 메서드로 분리 + (중첩클래스; 스태틱클래스)
// 6) 합계 및 평균을 계산
// 7) GRASP 패턴 : Information Expert(정보를 갖고 있는 클래스가 그 정보를 다룬다.)
// 8) 인스턴스 메서드 도입
// 9) 객체 생성이 번거롭고 복잡한 경우 메서드로 분리하는 것이 낫다. (디자인패턴; 팩토리 메서드)
public class App {
  static class Score {
    String name;
    int kor;
    int eng;
    int math;
    int sum;
    float aver;

    void compute() {
      this.sum = this.kor + this.eng + this.math;
      this.aver = this.sum / 3f;
    }
  }
  
  public static void main(String[] args) {

    // String[] name = new String[10];
    // int[] kor = new int[10];
    // int[] eng = new int[10];
    // int[] math = new int[10];
    // int[] sum = new int[10];
    // float[] aver = new float[10];

    final int MAX_SIZE = 10;
    Score[] scores = new Score[MAX_SIZE];
    int length = 0;
    
    
    scores[length++] = createScore("홍길동", 100, 100, 100);
    scores[length++] = createScore("임꺽정", 90, 90, 90);
    scores[length++] = createScore("유관순", 80, 80, 80);


    for (int i = 0; i < length; i++) {
      printScore(scores[i]);
    }

  }

  static Score createScore(String name, int kor, int eng, int math) {
    Score s = new Score();
    s.name = name;
    s.kor = kor;
    s.eng = eng;
    s.math = math;
    s.compute();
    return s;
  }

  static void printScore(Score s) {
    System.out.printf("%s: 합계=%d, 평균=%f\n",s.name, s.sum, s.aver);
  }


}

---

// 10) GRASP 패턴 : Information Expert

package bitcamp.test.step10;
import bitcamp.util.Prompt;

// 1) 낱개의 변수사용
// 2) 낱개의 변수 재사용
// 3) 배열 사용
// 4) 클래스 타입을 이용하여 데이터 정의 (중첩클래스; 로컬클래스)
// 5) 출력 기능을 별도의 메서드로 분리 + (중첩클래스; 스태틱클래스)
// 6) 합계 및 평균을 계산
// 7) GRASP 패턴 : Information Expert(정보를 갖고 있는 클래스가 그 정보를 다룬다.)
// 8) 인스턴스 메서드 도입
// 9) 객체 생성이 번거롭고 복잡한 경우 메서드로 분리하는 것이 낫다. (디자인패턴; 팩토리 메서드)
// 10) GRASP 패턴 : Information Expert
//       - createScore()를 
public class App {
  static class Score {
    String name;
    int kor;
    int eng;
    int math;
    int sum;
    float aver;

    void compute() {
      this.sum = this.kor + this.eng + this.math;
      this.aver = this.sum / 3f;
    }

    static Score create(String name, int kor, int eng, int math) {
      Score s = new Score();
      s.name = name;
      s.kor = kor;
      s.eng = eng;
      s.math = math;
      s.compute();
      return s;
    }
  }
  
  public static void main(String[] args) {

    final int MAX_SIZE = 10;
    Score[] scores = new Score[MAX_SIZE];
    int length = 0;
    
    
    scores[length++] = Score.create("홍길동", 100, 100, 100);
    scores[length++] = Score.create("임꺽정", 90, 90, 90);
    scores[length++] = Score.create("유관순", 80, 80, 80);


    for (int i = 0; i < length; i++) {
      printScore(scores[i]);
    }

  }

  static void printScore(Score s) {
    System.out.printf("%s: 합계=%d, 평균=%f\n",s.name, s.sum, s.aver);
  }


}

---

// 11) 생성자 도입

package bitcamp.test.step11;
import bitcamp.util.Prompt;

// 1) 낱개의 변수사용
// 2) 낱개의 변수 재사용
// 3) 배열 사용
// 4) 클래스 타입을 이용하여 데이터 정의 (중첩클래스; 로컬클래스)
// 5) 출력 기능을 별도의 메서드로 분리 + (중첩클래스; 스태틱클래스)
// 6) 합계 및 평균을 계산
// 7) GRASP 패턴 : Information Expert(정보를 갖고 있는 클래스가 그 정보를 다룬다.)
// 8) 인스턴스 메서드 도입
// 9) 객체 생성이 번거롭고 복잡한 경우 메서드로 분리하는 것이 낫다. (디자인패턴; 팩토리 메서드)
// 10) GRASP 패턴 : Information Expert
//       - createScore()를 Score 클래스로 이동
// 11) 생성자 도입
public class App {
  static class Score {
    String name;
    int kor;
    int eng;
    int math;
    int sum;
    float aver;

    void compute() {
      this.sum = this.kor + this.eng + this.math;
      this.aver = this.sum / 3f;
    }

    static Score create(String name, int kor, int eng, int math) {
      Score s = new Score();
      s.name = name;
      s.kor = kor;
      s.eng = eng;
      s.math = math;
      s.compute();
      return s;
    }
  }
  
  public static void main(String[] args) {

    final int MAX_SIZE = 10;
    Score[] scores = new Score[MAX_SIZE];
    int length = 0;
    
    
    scores[length++] = Score.create("홍길동", 100, 100, 100);
    scores[length++] = Score.create("임꺽정", 90, 90, 90);
    scores[length++] = Score.create("유관순", 80, 80, 80);


    for (int i = 0; i < length; i++) {
      printScore(scores[i]);
    }

  }

  static void printScore(Score s) {
    System.out.printf("%s: 합계=%d, 평균=%f\n",s.name, s.sum, s.aver);
  }


}