반응형
개념정리
* 메서드를 통해 스태틱 변수와 클래스를 이해하기
Static 변수를 통해서 메서드 간의 변수를 공유할 수 있다.
다른 패키지 간의 변수를 공유할 때는 public 변수를 활용해야한다.
* 이때 import는 클래스를 로딩하거나 컴파일 하는 것이 아니라 바꿔주는 역할을 하는 것이다.
getter 메서드를 사용하는 이유 : 같은 클래스 내에서만 접근이 가능하게한다.
이유는 다른 클래스에서 해당 변수를 바꿀 수가 있기 때문이다. 따라서 결과값을 private로
다른 클래스에서의 진입을 차단시키고 getter 로만 접근이 가능하게 해서 해결해줄 수 있다.
instance 변수를 각 레퍼런스에 담아주기 위해서 객체를 생성한다.
Static 변수를 만들 것인가.
instance 변수를 만들 것인가.
결정하는 기준. 필드를 1개만 만들 것인가,
상황에 따라서 개별적으로 관리하기 위해 여러개를 만들 것인가. 의 여부이다.
// 두개의 계산 결과를 저장할 수 있는 result 변수를 준비한다.
Calculator c1 = new Calculator();
Calculator c2 = new Calculator();
// input = Prompt.inputInt("계산 할 첫 숫자를 입력해주세요 : ");
c1.init(2);
c1.multiple(3);
c1.plus(7);
c1.minus(2);
c1.divide(2);
System.out.println("c1 출력"+c1.getResult());
package bitcamp.util;
public class Calculator {
private int result;
private static int result2;
public static int getResult2() {
return getResult2;
}
public int getResult() {
//Calculator this = 외부에서 넘겨준 주소
return this.result;
}
public class Calculator {
private int result;
private static int result2;
public static int getResult2() {
return getResult2;
}
public int getResult() {
//Calculator this = 외부에서 넘겨준 주소
return this.result;
}
this는 instance 메소드에서 자동으로 컴파일된다.
static 메소드는 필드가 하나이기때문에 this 가 없다.
위의 예시를 보면 c1 이라는 레퍼런스를 생성하고 필드에 result가 담겨있다.
private를 통해서 result 값에는 외부에서 접근할 수 없게하고 클래스 내부에서만 연산이 가능하게한다.
그리고 getResult라는 메소드를 통해서만 연산 결과만을 출력할 수 있게 한다.
여기서 static 변수를 사용하지 않는 이유는 Calculator 가 각 연산에서 사용된 레퍼런스를 고유의 값이 아닌
여러개의 필드를 갖게 하기 위함이다. 때문에 필드가 여러개이면 static 변수를 사용하지 않고 instance 메소드를 사용해야한다. 이것은 자동으로 this 라는 명령을 통해서 외부에서 넘겨온 주소를 받아서 결과를 출력해줄 수 있다.
new 를 통해서 레퍼런스를 생성하게 되면 메소드를 가져오는 것이 아니라
인스턴스 변수만을 가져오게 된다. 때문에
Calculator c = new Calculator();
는 인스턴스 변수만을 생성한다. 그래서 Heap 에 저장된다.
JVM Stack에는 로컬 변수가 저장된다. 즉, 메서드가 호출되면 해당 메서드에서 사용되는 로컬 변수들이
JVM 스택에 할당되고, 메서드가 종료되면 해당 로컬 변수들도 스택에서 제거된다.
c.plis(100);
Plus 는 method (operator) 라고 불린다. 즉 plus는 c의 operator 이다.
c와 (100)은 피연산자이다.
GRASP 패턴 : Information Expert(정보를 갖고 있는 클래스가 그 정보를 다룬다.)
실습
#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);
}
}#12. 클래스를 유지보수하기 쉽게 별도 소스 파일로 분리:
Score 클래스를 별도의 소스 파일로 분리. App 클래스와 Score 클래스가 서로 다른 파일에 위치.
#13. 클래스를 유지보수하기 쉽게 패키지로 분류:
Score 클래스를 bitcamp.test.step14.vo 패키지로 분류. 패키지를 도입하여 클래스를 논리적으로 그룹화
#14. 외부 접근 차단과 값 꺼내기:
Score 클래스의 sum과 aver 필드를 private으로 접근 제한자를 변경. 필드에 직접 접근할 수 없게 됩니다.
값을 꺼내기 위해 getter 메서드를 정의.
#15. 프로그래밍의 일관성을 위해 다른 필드에 대해서도 getter를 만들고 사용:
Score 클래스의 name 필드에 대해서도 getter를 정의.
일관성을 유지하기 위해 모든 필드에 대해 getter를 만들고 사용.
#16. 필드의 직접 접근을 막고 setter를 정의하는 이유:
Score 클래스의 필드에 대해 setter를 정의하여 값을 변경할 때 유효성을 검사.
무효한 값을 저장하는 것을 방지하기 위해 setter를 사용.
#17. 필드의 직접 접근을 막고 인스턴스 변수에 무효한 값이 저장되지 않게 하기 위해:
Score 클래스의 kor, eng, math 필드에 대해 private 접근 제한자를 적용.
값을 설정하는 setter 메서드를 통해 유효성을 검사하고 저장.
// 12) 클래스를 유지보수 하기 쉽게 별도 소스 파일로 분리
app.java
// 12) 클래스를 유지보수 하기 쉽게 별도 소스 파일로 분리
public class App {
public static void main(String[] args) {
final int MAX_SIZE = 10;
Score[] scores = new Score[MAX_SIZE];
int length = 0;
scores[length++] = new Score("홍길동", 100, 100, 100);
scores[length++] = new Score("임꺽정", 90, 90, 90);
scores[length++] = new Score("유관순", 80, 80, 80);
for (int i = 0; i < length; i++) {
printScore(scores[i]);
}
}
static void printScore(Score s) {
System.out.printf("%s: 합계=%d, 평균=%.1f\n",
s.name, s.sum, s.aver);
}
}socre.java
package bitcamp.test.step12;
class Score {
String name;
int kor;
int eng;
int math;
int sum;
float aver;
Score(String name, int kor, int eng, int math) {
this.name = name;
this.kor = kor;
this.eng = eng;
this.math = math;
this.compute();
}
void compute() {
this.sum = this.kor + this.eng + this.math;
this.aver = this.sum / 3f;
}
}// 13) 클래스를 유지보수 하기 쉽게 패키지로 분류: import, public
app.java
// 13) 클래스를 유지보수 하기 쉽게 패키지로 분류: import, public
public class App {
public static void main(String[] args) {
final int MAX_SIZE = 10;
Score[] scores = new Score[MAX_SIZE];
int length = 0;
scores[length++] = new Score("홍길동", 100, 100, 100);
scores[length++] = new Score("임꺽정", 90, 90, 90);
scores[length++] = new Score("유관순", 80, 80, 80);
for (int i = 0; i < length; i++) {
printScore(scores[i]);
}
}
static void printScore(Score s) {
System.out.printf("%s: 합계=%d, 평균=%.1f\n",
s.name, s.sum, s.aver);
}
}score.java
package bitcamp.test.step14.vo;
public class Score {
public String name;
int kor;
int eng;
int math;
public int sum;
public float aver;
public Score(String name, int kor, int eng, int math) {
this.name = name;
this.kor = kor;
this.eng = eng;
this.math = math;
this.compute();
}
void compute() {
this.sum = this.kor + this.eng + this.math;
this.aver = this.sum / 3f;
}
}// 14) 외부접근 차단과 값 꺼내기 : private, getter
// 14) 외부접근 차단과 값 꺼내기 : private, getter
public class App {
public static void main(String[] args) {
final int MAX_SIZE = 10;
Score[] scores = new Score[MAX_SIZE];
int length = 0;
scores[length++] = new Score("홍길동", 100, 100, 100);
scores[length++] = new Score("임꺽정", 90, 90, 90);
scores[length++] = new Score("유관순", 80, 80, 80);
// 변수에 직접 접근 => 국영수 합계를 임의로 조작 가능 !
scores[0].sum = 20000;
for (int i = 0; i < length; i++) {
printScore(scores[i]);
}
}
static void printScore(Score s) {
System.out.printf("%s: 합계=%d, 평균=%.1f\n",
s.name, s.getSum(), s.getAver());
}
}score.java
package bitcamp.test.step14.vo;
public class Score {
public String name;
int kor;
int eng;
int math;
private int sum;
private float aver;
public Score(String name, int kor, int eng, int math) {
this.name = name;
this.kor = kor;
this.eng = eng;
this.math = math;
this.compute();
}
void compute() {
this.sum = this.kor + this.eng + this.math;
this.aver = this.sum / 3f;
}
// getter : private 으로 접근이 막힌 변수의 값을 리턴해주는 메서드
public int getSum() {
return this.sum;
}
// getter : private 으로 접근이 막힌 변수의 값을 리턴해주는 메서드
public float getAver() {
return this.aver;
}
}// 15) 프로그래밍의 일관성을 위해 보통 다른 필드에 대해서도 getter를 만들고 사용한다.
// 15) 프로그래밍의 일관성을 위해 보통 다른 필드에 대해서도 getter를 만들고 사용한다.
public class App {
public static void main(String[] args) {
final int MAX_SIZE = 10;
Score[] scores = new Score[MAX_SIZE];
int length = 0;
scores[length++] = new Score("홍길동", 100, 100, 100);
scores[length++] = new Score("임꺽정", 90, 90, 90);
scores[length++] = new Score("유관순", 80, 80, 80);
// 변수에 직접 접근 => 국영수 합계를 임의로 조작 가능 !
for (int i = 0; i < length; i++) {
printScore(scores[i]);
}
}
static void printScore(Score s) {
System.out.printf("%s: 합계=%d, 평균=%.1f\n",
s.getName(), s.getSum(), s.getAver());
}
}score.java
package bitcamp.test.step15.vo;
public class Score {
//일관성을 위해 private 처리
private String name;
int kor;
int eng;
int math;
private int sum;
private float aver;
public Score(String name, int kor, int eng, int math) {
this.name = name;
this.kor = kor;
this.eng = eng;
this.math = math;
this.compute();
}
void compute() {
this.sum = this.kor + this.eng + this.math;
this.aver = this.sum / 3f;
}
// getter : private 으로 접근이 막힌 변수의 값을 리턴해주는 메서드
public int getSum() {
return this.sum;
}
// getter : private 으로 접근이 막힌 변수의 값을 리턴해주는 메서드
public float getAver() {
return this.aver;
}
public String getName() {
return this.name;
}
}// 16) 필드의 직접 접근을 막고 setter를 정의하는 이유
// 16) 필드의 직접 접근을 막고 setter를 정의하는 이유
public class App {
public static void main(String[] args) {
final int MAX_SIZE = 10;
Score[] scores = new Score[MAX_SIZE];
int length = 0;
scores[length++] = new Score("홍길동", 100, 100, 100);
scores[length++] = new Score("임꺽정", 90, 90, 90);
scores[length++] = new Score("유관순", 80, 80, 80);
// 합계와 평균 계산이 끝난 후에 국어 점수를 변경한다면
// => 국영수 점수와 합계, 평균 점수가 일치하지 않는 문제가 발생한다.
// 데이터의 결함이 발생한다.
// 국영수 점수를 변경한 후에 compute() 를 호출하면 되지 않을까 ?
// 만약 개발자가 compute() 호출하는 것을 잊어버린다면 아무 소용이 없다.,
// 만약 유효하지 않은 국영수 점수를 입력한다면? 이건 막을 방법이 없다.
scores[0].kor = 7000; // 이렇게 무효한 점수를 입력하는 것을 막을 수 없다.
// scores[0].compute(); //호출하지 않으면 아무 소용이 없다
for (int i = 0; i < length; i++) {
printScore(scores[i]);
}
}
static void printScore(Score s) {
System.out.printf("%s: 국어=%d, 영어=%d, 수학=%d, 합계=%d, 평균=%.1f\n",
s.getName(), s.kor, s.eng, s.math, s.getSum(), s.getAver());
}
}score.java
package bitcamp.test.step16.vo;
public class Score {
//일관성을 위해 private 처리
private String name;
public int kor;
public int eng;
public int math;
private int sum;
private float aver;
public Score(String name, int kor, int eng, int math) {
this.name = name;
this.kor = kor;
this.eng = eng;
this.math = math;
this.compute();
}
public void compute() {
this.sum = this.kor + this.eng + this.math;
this.aver = this.sum / 3f;
}
// getter : private 으로 접근이 막힌 변수의 값을 리턴해주는 메서드
public int getSum() {
return this.sum;
}
// getter : private 으로 접근이 막힌 변수의 값을 리턴해주는 메서드
public float getAver() {
return this.aver;
}
public String getName() {
return this.name;
}
}// 17) 필드의 직접 접근을 막고 인스턴스 변수에 무효한 값이 저장되지 않게 하기 위해
// => getter 정의하기 : 값을 꺼낼 때 사용
// => setter 정의하기 : 값을 변경할 때 사용. 단 유효한 값을 저장하도록 통제한다.
// 17) 필드의 직접 접근을 막고 인스턴스 변수에 무효한 값이 저장되지 않게 하기 위해
// => getter 정의하기 : 값을 꺼낼 때 사용
// => setter 정의하기 : 값을 변경할 때 사용. 단 유효한 값을 저장하도록 통제한다.
public class App {
public static void main(String[] args) {
final int MAX_SIZE = 10;
Score[] scores = new Score[MAX_SIZE];
int length = 0;
scores[length++] = new Score("홍길동", 100, 100, 100);
scores[length++] = new Score("임꺽정", 90, 90, 90);
scores[length++] = new Score("유관순", 80, 80, 80);
// scores[0].kor = 7000; // 접근 불가 !
scores[0].setKor(70); // setter 를 통해서는 값 변경가능. 단 유효값만 가능
// scores[0].compute(); // 호출하는 것을 잊어버릴 수 있기 때문에 setter에서 호출
for (int i = 0; i < length; i++) {
printScore(scores[i]);
}
}
static void printScore(Score s) {
System.out.printf("%s: 국어=%d, 영어=%d, 수학=%d, 합계=%d, 평균=%.1f\n",
s.getName(), s.getKor(), s.getEng(), s.getMath(), s.getSum(), s.getAver());
}
}score.java
package bitcamp.test.step17.vo;
public class Score {
//일관성을 위해 private 처리
private String name;
// 직접 접근을 허용했을 때, 무효한 값을 저장할 수 있기 때문에
// private 으로 접근을 막았다.
private int kor;
private int eng;
private int math;
private int sum;
private float aver;
public Score(String name, int kor, int eng, int math) {
this.name = name;
this.setKor(kor);
this.setEng(eng);
this.setMath(math);
this.compute();
}
public void compute() {
this.sum = this.kor + this.eng + this.math;
this.aver = this.sum / 3f;
}
// getter : private 으로 접근이 막힌 변수의 값을 리턴해주는 메서드
public int getSum() {
return this.sum;
}
// getter : private 으로 접근이 막힌 변수의 값을 리턴해주는 메서드
public float getAver() {
return this.aver;
}
public String getName() {
return this.name;
}
public int getKor() {
return this.kor;
}
public void setKor(int kor) {
if (kor < 0 | kor > 100) {
return;
}
this.kor = kor;
this.compute();
}
public int getEng() {
return this.eng;
}
public void setEng(int eng) {
if (eng < 0 | eng > 100) {
return;
}
this.eng = eng;
this.compute();
}
public int getMath() {
return this.math;
}
public void setMath(int math) {
if (math < 0 | math > 100) {
return;
}
this.math = math;
this.compute();
}
}
반응형
