(6)-23.09.25[JAVA]

🙋 세 학생의 점수 입력받기

• 문제를 보는 순간 뭘 고민해야 할까?
  - 변수 3개가 필요하네 / 타입은 뭘로 할까? / 전변으로 할까? 아님 지변으로 해도 되나? / main 메소드가 필요한 클래스인가?

<예제1>
package com.step21;
class A {
	// 첫 번째 학생 점수를 담을 변수 선언
	int n1 = 70;
	int n2 = 80; 
	int n3 = 90;
	void hap1() { // 리턴타입 void
		int tot = n1+n2+n3;
	}
}	

public class Amain {

	public static void main(String[] args) {
		A a = new A(); // 전역변수는 유지된다
		System.out.println(a.n1); 
		System.out.println(a.tot); 
        // tot는 지변이라서 다른 외부 클래스에서 재사용 불가
        // (재사용성이 떨어지는 코드)
	}
}
출력: 70
      0

• 전역변수: 하나의 클래스를 대표하는 값(초기화 생략 가능)
  - 인스턴스변수.변수명으로 호출이 가능한 것은 전변 뿐임
• 왜 class A 전역변수로 선언했을까?
  - 해당 학생에 대한 점수이니까(점수가 변하지 않으니까)
• 만약 A a = new A(); 다음 단계에서 a = null;하면 다시 초기화(디폴트값: 모른다/결정되지 않았다).
• a = new A();로 재생성을 할 경우 미묘한 문제 발생
  왜? 원본이 아닌 복사본이 한 개 더 만들어졌으니까
  → 이전에 참조한 클래스는 날아간 것(candidate)
• 리턴타입 void 관련해서 연습하자
  ex. int 또는 전변을 굳이 지변(파라미터자리)으로 처리하기
  

<예제1-2>
package com.step21;
class A {
	int n1 = 70;
	int n2 = 80; 
	int n3 = 90;
	int tot = 0;
	void hap1() { 
		int tot = n1+n2+n3;
		// 원시형 타입은 한 번에 한 가지 값만 담김 - 여러 번 하면 덮어쓰기 되는 것
		this.tot = tot; // 전변에 대한 재정의(0->240)
	}
}	

public class Amain {

	public static void main(String[] args) {
		A a = new A();
		System.out.println(a.n1);
		a.hap1(); 
        // 이게 호출이 되어야 this.tot = tot;가 실행 기회를 가짐
		System.out.println(a.tot);
	}
}
출력: 70
     240

<예제2-오버로딩>
package com.step21;

class B{
	int n1 = 70;
	int n2 = 80;
	int n3 = 90;
	int hap1() {
		int hap = n1 + n2 + n3;
		return hap;
	}
	int hap1(int n1, int n2, int n3) {
		int hap = n1 + n2 + n3;
		return hap; // 180 // 50 + 60 + 70
	}
}
public class Bmain {
	public static void main(String[] args) {
		B a = new B();
		int hap = a.hap1(); // 전변의 값이 더해지니까
		System.out.println(hap); // 240 출력
        // 전변의 값: 다른 클래스에서도 동일한 값을 출력할 수 있다
		hap = a.hap1(50, 60, 70); 
        // 위에서 이미 int 선언을 해줬기 때문에 중복 생략
		System.out.println(hap); // 180 출력
        // 합의 값을 돌려받았기 때문
		System.out.println();
	}
}
출력: 240
      180

• 자바에서는 같은 이름의 메소드를 중복 선언할 수 있다
  - 이것을 가능하게 하는 건 메소드 오버로딩과 메소드 오버라이딩 컨벤션이 있기 때문 ex. 예제2 - int hap1()
• 메소드 오버로딩은 반드시 파라미터의 개수가 다르거나 타입이 달라야 한다.
• 리턴타입이 있고 없고는 메소드 오버로딩에 영향이 없다

🙋‍ Q. int hap = a.hap1(); / a.hap(); 호출에 어떤 차이?
→ a.hap()은 초기 호출 / 대입연산자로 호출한 것은 호출 데이터를 이용해 재생성을 할 때

<예제3-오버로딩>
package com.step21;

import javax.swing.JFrame;
// 이름은 같지만 서로 다른 메소드이다. - 결론
public class Frame1 {
	JFrame jf = new JFrame(); 
	void initDisplay() {
		jf.setSize(500, 400); // 상수를 사용해서 별로임
		jf.setVisible(true); // true도 상수
        //이럴 때 파라미터 이용해서 상수 자리를 다르게 가져갈 수 있다
	}
	void initDisplay(int width, int height) { 
    // 메소드의 파라미터 자리는 호출될 때 결정
    // 하나는 변수로 처리가 되지만, 나머지는 상수로 처리함. 
    // (불리언이 없으니까 디폴트로 처리되니까)
		jf.setSize(width, height);
		jf.setVisible(true); 
	}
	void initDisplayint (int width, int height, boolean isView) {
		jf.setSize(width, height);
		jf.setVisible(isView); 
	}

	public static void main(String[] args) {
		Frame1 f = new Frame1();
		~~f.initDisplay(500, 400);~~ 
		f.initDisplay(500, 400, false); 
        // 값에 의한 호출(호출될 때 지역변수가 초기화 됨)
	}

}
 이거 왜 오류나지?

• 상수를 사용하면 기능 구현이 어렵다(ex. 앱으로 음악을 듣는 중에 전화가 들어오는 상황)

<예제4>
package com.step21;

class C {
	int n1 = 70;
	int n2 = 80;
	int n3 = 90;
}
class C1{
	int hap1() { 
		C c = new C(); 
        // 데이터를 쥐고 있는 클래스를 지변으로 인스턴스화 하였다
		int hap = c.n1 + c.n2 + c.n3;
		return hap;
	}
	int hap1(C c) {
		int hap = c.n1 + c.n2 + c.n3;
		return hap;
	}	
}
public class Cmain {
	public static void main(String[] args) {
		C c = new C();
		C1 a = new C1();
		int hap = a.hap1();
		System.out.println(hap);
		c.n1 = 50;
		c.n2 = 60;
		c.n3 = 50;
		hap = a.hap1(c);
		System.out.println(hap);
	}
}

• class C: 데이터를 관리하는 클래스로 선언
• class C1: C클래스에서 전달 받은 데이터를 가지고 총합을 구하는 메소드 선언
  → 그런데 같은 이름의 메소드를 2개 정의함(메소드오버로딩: 파라미터의 개수나 타입이 다르다)
• int hap1(): hap1 메소드 안에서 데이터를 갖는 C클래스를 인스턴스화 함(main없음/변수만 3개)
  → 학생수가 10명이라면 인스턴스화를 10번 반복해야한다(그래서 for문, while문 반복문 공부 필요함)
  

<예제5-for문으로 처리>
package com.step21;

public class Student {
	int html = 0;
	int css = 0;
	int java = 0;
	public static void main(String[] args) {
		int i; // 3. 그래서 선언을 밖에다 해줌
		~~for(int i=0;i<3;i=i+1)~~ { // 1. for문 안에서 선언
		for(i=0;i<3;i=i+1) { // 0->1->2->3
			Student s = new Student();
			System.out.println(s);
			System.out.println(i);
		} // end of for
		~~System.out.println(i);~~
        // 2. for문 안에서 선언된 변수는 밖에서 사용 불가
	}
}

• for(1-초기화;2-조건식;3-증감연산자)
• for문에서 조건식이 true면 for문 안에 실행문이 차례대로 실행됨

<예제6>
package com.step21;

public class Student {
	int html 	= 0;
	int css 	= 0;
	int java 	= 0;
	public static void main(String[] args) {
		Student s = new Student();
		s.html = 70;
		s.css = 80;
		s.java = 90;
		System.out.println(s);
		s = new Student();
		s.html = 60;
		s.css = 70;
		s.java = 80;		
		System.out.println(s);
		s = new Student();
		s.html = 50;
		s.css = 60;
		s.java = 70;		
		System.out.println(s);
	}
}
출력: com.step21.Student@3d012ddd
     com.step21.Student@626b2d4a
     com.step21.Student@5e91993f

• 같은 타입의 클래스를 인스턴스화 할 때마다 서로 다른 전역변수의 값을 관리할 수 있다
  

<예제7>
package com.step21;

public class Z {
	int i = 1;
	void m1() {
		Z z = new Z();
		System.out.println(z); 
        // 여기서 출력되는 주소번지와 13번의 주소번지가 같다
		System.out.println(z.i); // 출력: 1
		m2(z);
	}
	void m2(Z z) {
		// 여기에서 6번에 생성된 주소번지를 굳이 사용하고 싶다면?
		// 파라미터 자리에 참조형 타입의 변수를 넘기면 원본을 재사용할 수 있다-결론
		System.out.println(z); 
	}
	public static void main(String[] args) {
		Z z = new Z();
		z.m1();
	}
}

<예제8-Scanner>
package com.step21;

import java.util.Scanner;
// JVM은 java.lang 폴더 안에 있는 클래스만 알고 있다
// 나머지 폴더에 있는 클래스는 반드시 import문 추가해야 함
class E {
	// 인스턴스화를 할 때도 메소드와 동일하게 파라미터 개수나 타입을 맞춰야 함
	Scanner sc = new Scanner(System.in); 
	// 인스턴스화도 전역에서 하는 것과 지역에서 하는 것을 나누어 연습할 필요가 있다
	// getFirst메소드를 선언해서 사용자로부터 숫자를 입력받는
	// 메소드를 구현해 보시오
	public int getFirst() {
		int num = 0;
		// 전역변수의 자리에서 sc를 생성하였으므로 
        // getFirst 메소드 안에서도 sc변수를 사용할 수 있다
		num = sc.nextInt(); // 사용자가 결정하는(입력하는) 값
		return num; // 전변으로 할까? 아님 지변으로 해야할까?
	}
}
public class Emain {

	public static void main(String[] args) {
		// 메소드 호출해 보세요
		E e = new E();
		System.out.println("첫 번째 숫자를 입력하세요.");
		int first = e.getFirst();
		System.out.println("첫 번째 입력 받은 숫자는 "+first+"입니다.");
	} // end of main
} // end of Emain

🙋 스캐너 클래스를 왜 강조할까?

• 사용자와 개발자 사이의 소통은 화면 구현을 통해서 가능하다. 그런데 우리는 아직 html 공부를 하지 않고 있어서 콘솔창을 활용한 소통을 시도할 계획이다.
  → 결국 화면에서 입력받아야 하는 값들이 파라미터 자리를 채워야 한다(사용자가(업무담당자가) 입력한 값을 받아오기)
  

<예제9-Scanner>
package com.step3;

import java.util.Scanner;
// 메뉴 선택하기
public class Scan1 {

	public static void main(String[] args) {
		System.out.println("메뉴를 선택하세요.[새게임:1, 정답확인:2, 종료:3]");
		Scanner sc = new Scanner(System.in);
		// 사용자가 선택한 메뉴 번호를 담을 변수 선언
		int menu = 0;
		// for(변수선언및초기화;조건식-true or false;증감연산자);
		for(int i=0;i<3;i=i+1) {
			System.out.println(i); // 0 출력 
            // 왜 1은 안 나오지? 당신의 선택이 없기 때문에 기다리는 중
			// 3이 되기 전까지는 돌고 있다
			menu = sc.nextInt();
			if(menu == 1) { 
				System.out.println("새 게임을 선택하였습니다.");
			}
			else if(menu ==2) {
				System.out.println("정답보기를 선택하였습니다.");
				
			}
			else if(3 == menu) {
				System.out.println("종료를 선택하였습니다");
			} // end of if
		} // end of for
				System.out.println("for문 탈출 - 여기로....");
	} // end of main
} // end of Scan1

• n-s 차트 참고

<예제10>
package com.step3;

import java.util.Scanner;

public class Scan2 {
	public static void main(String[] args) {
		System.out.println("메뉴를 선택하세요.[새게임:1, 정답확인:2, 종료:3]");
		Scanner sc = new Scanner(System.in);
		int menu = 0;
		for(int i=0;i<3;i=i+1) {
			System.out.println(i); 
			menu = sc.nextInt();
			if(menu == 1) { 
				System.out.println("새 게임을 선택하였습니다.");
			}
			if(menu == 2) { 
            // else가 없으면 아래 조건도 따진다-> 일량이 늘어난다
				System.out.println("정답보기를 선택하였습니다.");
			}
			if(3 == menu) {
				System.out.println("종료를 선택하였습니다");
			} 
		} 
				System.out.println("for문 탈출 - 여기로....");
	} 
} 

• if문 앞에 else를 빼면 첫 번째 조건이 만족했음에도 다음 조건을 일단 따진다. 물론 조건의 결과가 false이니까 실행문은 실행되지 않는다.
  → else if가 아닌 if를 하면 또 비교하는 것(처음 조건을 수렴하면 다음 조건은 굳이 비교할 필요가 없잖아)

<예제11-1>
- 0~9 사이의 임의의 숫자를 랜덤 채번(사용자로부터 숫자 입력받기)
- 입력받은 숫자가 정답보다 더 작으면 '높여라'출력
- 입력받은 숫자가 정답보다 더 크면 '낮춰라'출력
- 5번까지만 기회를 제공해서 그 숫자를 맞추는 게임을 작성해 보시오

package com.step3;

public class RandomGame {
	// 선언부
	// 새로 채번된 숫자를 담는다(정답)
	int dap = -1; // EOF(찾아도 없다)
	1. 사용자가 입력하는 숫자는 절대로 전변으로 하지 않는다
      (매번 입력할 때마다 바뀌어야 하니까-유지되면 안 되니까)
	2. 게임을 하는데 필요한 메소드는?
	   → 새게임을 누를 때마다 호출되는 메소드
	// 여기서 채번되는 숫자가 정답이므로 노출하지 않는다 → 그래서 전변으로 선언
	public void newGame() { 
    // 정답을 보여주면 안 되니까 모르는 상태에서 맞추도록 void	
	}
	/**************************************************
	 * 판정을 내려주는 메소드 구현하기 *
	 * @param user - 사용자가 숫자를 맞추기 위해서 입력하는 값을 담는 변수이다. 
                    (입력할 때마다 바뀐다 - 지변)
	 * @return - String - 힌트를 반환하는 변수
                 (힌트의 예시: 높여라, 낮춰라, 정답입니다. 축하합니다)
	 **************************************************/
	public String account(int user) { 
    // 이 user자리가 매번 화면에 사용자가 입력하고 엔터쳤을 때 결정되는 값
		return "높여라";
	}
	public void messagePrint() {
	}
	public static void main(String[] args) {
	}
}

• 새 게임을 선택했을 때는 0~9 사이에 새로운 숫자를 채번해야 합니다.

• 채번한 숫자는 dap이라는 변수에 저장해 둡시다.

• 그리고 dap은 전역변수로 하는 것이 좋겠습니다. 왜냐면 그 게임을 하는 그 사람이 사용하는 동안에는 오직 하나의 객체만 사용하게 될 테니까요.
  (힌트문은 입력할 때마다 바뀌어야 하기 때문에 그 값은 지변)

• EOF(End Of File): 파일의 끝을 표현하기 위한 상수로 -1 값을 가지는데, 더 이상의 입력이 없을 때(파일의 끝) EOF(-1)를 반환하여 끝을 알린다.

<예제11-2>
package com.step3;

import java.util.Random;

public class RandomGame {
	int dap = -1;
	public void newGame() { 
		Random r = new Random();
		// 좋은 점은? 리턴타입이 없어도 전변이면 어떠한 메소드에서도 재정의가 가능하다
		dap = r.nextInt(10); // 여기서 정답이 결정. // nextInt는 API
		// 답이 수시로 변경되면 안 된다. 유지되어야 한다. 종료될 때까지
	}
	public String account(int user) { 
    // 이 user 자리가 매번 화면에 사용자가 입력하고 엔터쳤을 때 결정되는 값
		System.out.println("dap: " + dap + ", user: " + user);
		String hint = null;
		if(dap == user) {
			hint = "정답입니다.";
		} else if(dap > user) {
			hint = "높여라.";
			
		} else if(dap < user) {
			hint = "낮춰라.";
		}
		return hint;
	}
	public void messagePrint(int user) { 
    // user=5 복사됨 - call by value니까
		System.out.println(account(5)); // 24->5를 쥐고 간다-> '높여라' 출력
	}
	public static void main(String[] args) {
 		RandomGame rg = new RandomGame(); 
		rg.newGame(); 
        // 이 메소드가 호출되어야 0~9 사이의 숫자가 채번된다. 
        // 그래서 채번된 숫자는 dap에 담김
		// messagePrint 호출할 때 파라미터 자리에 5를 넘겨주고 36번에서 account()호출될 때 지역변수에 복사된 user값
		// 즉 5가 파라미터로 넘어간다.
		// 24번에서도 user값은 5가 된다.
		// rg.account(5);
		rg.messagePrint(5);
	}
}
출력: dap: 6, user: 5 
     높여라.

🖱 디버깅
메소드 추적할 때는 F5
순서대로 하나씩 진행 F6

자바 진도 정리

<com.step1>
코딩시작 - 클래스 선언하기 - 변수 선언

<com.step2>
변수 스코프 - 메소드 선언 추가하기 - 인스턴스화 본격적으로 전달

<com.step21> 2주차 시작

• 클래스를 2분할하기(원칙)
• 클래스 쪼개기 → MVC패턴(개발방법론) → Spring 프레임워크
• 전역변수와 지역변수 활용하기(복습)
  (static은 미뤄도 괜찮음-2년차 미만은 제약두는 경우가 많음)
• 메소드의 파라미터와 리턴타입에 대해서 설명할 수 있다(이번 주의 핵심/ 복습 내용)
• 파라미터나 리턴타입 자리에 참조형 타입을 사용하는 것 훈련하기
• 메소드 통해서 객체를 주입(인스턴스화) 받기 → 프레임워크에서 많이 활용됨
• 이 내용을 확장시키면 의존성 주입 → 제어역전(고급기법)
  : 코드의 양은 늘어나더라도 복잡도는 증가되지 않도록 하자 / 이런 컨셉 생각하면서 문제 접근하기
  : 재사용성과 이식성을 높이는 방향으로 코딩을 전개(인스턴스화, 메소드중심 코딩을 전개하기)
• 리턴타입을 결정할 수 있다.
• 파라미터의 타입과 개수까지도 선택할 수 있다