Java Review(3)

지환·2023년 9월 25일
0

JAVA

목록 보기
11/39
post-thumbnail

9.25

  • 학습목표 : 리턴타입과 메소드 선언 및 사용
package com.HomeWork;

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;
	}
}
public class Bmain {
	public static void main(String[] args) {
		B a = new B();
		int hap = a.hap1();
		System.out.println(hap);
		hap = a.hap1(50, 60, 70);
		System.out.println(hap);
	}

}

(2) tot 중심으로 다시 보기 중요한 부분은 this를 사용해서 값을 넣고 그것을 반환했다는 점


package com.HomeWork;

class A
{// 첫번쨰 학생 점수를 담을 변수 선언한다.
// 전변은 유지된다. 
	int n1 = 70;
	int n2 = 80;
	int n3 = 90;
	int tot = 0;
	void hap1() { // 처리하기 부른다 - > 리턴타입 int, 또는 전변을 굳이 지변으로 처리
		int tot = n1 + n2 + n3;
		this.tot = tot; // ->0-> 240으로 change
		//tot는 지변이라서 다른 외부의 클레스에서는 사용이 불가하다.
		//해당 부분은 필자가 생각했을 때 return과 같은 역할이다. 단, 전역변수로 선언이 되어 있어야 한다.
	}
}

public class Amain {

	public static void main(String[] args) {
		A a = new A();
		System.out.println(a.n1);
		a.hap1();
		System.out.println(a.tot);

	}

}

/*
1. 세 학생의 점수를 입력 받아서 -> 변수 3개가 필요하다. -> 전변으로 할까[지변으로 할까]
2. 타입은 어떻게 구성할까?-> 초기화 생략가능 / 하나의 클래스를 대표하는 값이다. 
3. 
*/

-----------------------------
70
240

메소드 오버로딩

[해당 부분 복습]

  • 메소드 오버로딩은 반드시 파라미터의 개수가 다르거나 타입이 달라야한다.
  • 리턴타입이 있고 없고는 메소드 오버로딩에 영향이 없다.:
package com.HomeWork;

public class Frame1 {

	void initDisplay()
	{
		
	}
	
	void initDisplay(int width, int height)
	{
		
	}
	
	void initDisplay(Double width, Double height)
	{
		
	}
	
	void initDjsplay(int width, int height, int isView)
	{
		
	}
	public static void main(String[] args) {

	}

}

(2)

package com.HomeWork;

// 자바에서는 같은 이름의 메소드를 중복 선언할 수 있다.
// 이것을 가능하게 하는 건 메소드 오버로딩과 메소드 오버라이딩이 있다. 
// 그 이유는 컨벤션이 있기 때문이다.

/*
 * 메소드 오버로딩은 반드시 파라미터의 개수가 다르거나 타입이 달라야한다.
 * 리턴타입이 있고 없고는 메소드 오버로딩에 영향이 없다.
 */
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;
	}

	
}
public class Bmain {
	public static void main(String[] args) {
		B a = new B();
		int hap = a.hap1();
		System.out.println(hap);
		hap = a.hap1(50, 60, 70);
		System.out.println(hap);
	}

}

--------------------------

240
180

(3) 클래스가 3개일 경우

package com.HomeWork;

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);
	}

}

참조변수 + 추가분

package com.HomeWork;

public class Z {

	int i = 1;
	void m1()
	{
		Z z = new Z();
		System.out.println(z.i);
		z.m2(z);
		System.out.println(z);
		
		
	}
	// 여기에서 6번에 생성된 주소번지를 굳이 사용하고 싶다 어떡하지?
	void m2(Z z)
	{
		System.out.println(z.i);
		System.out.println(z);
	}
	public static void main(String[] args) {

		Z i = new Z();
		i.m1();
		i.m2(i);
		/*
		 * println(i.m1())이 안되는 이유는 return / 반환하는 부분이 없다는 것이다.
		 */
	}

}

2) Test Case2

package com.HomeWork;

public class Z {

	int i = 1;
	void m1()
	{
		Z z = new Z();
		System.out.println(z.i);
		System.out.println(z);
		m2(z);
		
		
	}
	// 여기에서 6번에 생성된 주소번지를 굳이 사용하고 싶다 어떡하지?
	void m2(Z z)
	{
		System.out.println(z);
	}
	public static void main(String[] args) {

		Z i = new Z();
		i.m1();
		i.m2(i);
		/*
		 * println(i.m1())이 안되는 이유는 return / 반환하는 부분이 없다는 것이다.
		 */
	}

}

3) 값을 대입하는 경우 

package com.HomeWork;

public class Z {

	int i = 1;
	void m1()
	{
		Z z = new Z();
		Z c = new Z();
		System.out.println(z.i);
		System.out.println(z);
		c = m2(z); //c는 z의 주소번지와 값을 가지고 있다.
		System.out.println(c);
		
		
	}
	// 여기에서 6번에 생성된 주소번지를 굳이 사용하고 싶다 어떡하지?
	Z m2(Z z)
	{
		System.out.println(z);
		return z;
	}
	public static void main(String[] args) {
		
		Z i = new Z();
		i.m1();
		i.m2(i);
		/*
		 * println(i.m1())이 안되는 이유는 return / 반환하는 부분이 없다는 것이다.
		 */
	}

}


필자는 처음에 

	void m2(Z z)
	{
		System.out.println(z);
		
	}
 이 부분에서 --> void이면 리턴 할 수 없기 때문에, m1에서 대입하여 사용이 불가능하다. 타입이 있어야 반환 값이 존재하고 값을 넣을 수 있다.

Scanner Test Case

  • 학습목표 : 전역변수에 인스턴스화가 가능하다. + 값을 입력받아 사용한다.
package com.HomeWork;

import java.util.Scanner;

/*
 * getFirst 메소드를 선언해서 사용자로 부터 숫자를 입력받는 메소드를 구현해보시오.
 * 
 *  */

class E
{
	Scanner sc = new Scanner(System.in);
	
	public int getFirst()
	{
		int num=0;
		num = sc.nextInt();
		return num; // 전변으로 해야 될까? || 지변으로 해야 될까??
	}
	
	}

public class Emain {
	

	public static void main(String[] args) {
		
		E e = new E();
		int first = e.getFirst();
		System.out.println(first);
		

	}

}


/* 0 ~ 9사이의 임의의 숫자를 채번하고 
 * 
 */

----------------------------------------------
20
20

2)Test Case-2

package com.ABCDEFG;

import java.util.Scanner;

/*
 * getFirst 메소드를 선언해서 사용자로 부터 숫자를 입력받는 메소드를 구현해보시오.
 * 
 * Key Point -> 스캐너를 전역변수로 인스턴스화를 한다. [같은 주소번지를 갖는다는점을 잊지말자]
 *  */

class E
{
	Scanner sc = new Scanner(System.in);
	
	public int getFirst()
	{
		int num=0;
		num = sc.nextInt();
		return num; // 전변으로 해야 될까? || 지변으로 해야 될까??
	}
	public int getHap() // 두 수의 합
	{
		int x, y = 0;
		x = sc.nextInt();
		y = sc.nextInt();
		int hap = 0;
		hap = x + y;
		return hap;
	}
	
	public Double getDivide()
	{
		double x, y = 0;
		x = sc.nextDouble();
		y = sc.nextDouble();
		double Divide = 0;
		Divide = sc.nextDouble();
		Divide = x * y / Divide;
		
		return Divide;
	}
	}

public class Emain {
	

	public static void main(String[] args) {
		
		E e = new E();
		int first = e.getFirst();
		System.out.println(first);
		// 두수의 합을 입력받아 사용한다. 
		int hap = e.getHap();
		System.out.println(hap);
		
		double Divide = e.getDivide();
		System.out.println(Divide);

	}

}


/* 0 ~ 9사이의 임의의 숫자를 채번하고 
 * 
 */

3) 배열을 통한 사용자로부터 입력

  • 내가 봐야 될 부분은 Ball[] 배열을 '선언'은 했지만, 초기화를 하지 않아서 해당 값을 받을 수 있는 Ball Class를 만들었다.
package com.ABCDEFG;

import java.util.Scanner;

/*
 * getFirst 메소드를 선언해서 사용자로 부터 숫자를 입력받는 메소드를 구현해보시오.
 * 
 * Key Point -> 스캐너를 전역변수로 인스턴스화를 한다. [같은 주소번지를 갖는다는점을 잊지말자]
 *  */

class Ball {
    private int value;

    public Ball(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

class E
{
	Scanner sc = new Scanner(System.in);
	Ball[] balls = new Ball[200];
	
	public int getFirst()
	{
		int num=0;
		num = sc.nextInt();
		return num; // 전변으로 해야 될까? || 지변으로 해야 될까??
	}
	public int getHap() // 두 수의 합
	{
		int x, y = 0;
		x = sc.nextInt();
		y = sc.nextInt();
		int hap = 0;
		hap = x + y;
		return hap;
	}
	
	public Double getDivide()
	{
		double x, y = 0;
		x = sc.nextDouble();
		y = sc.nextDouble();
		double Divide = 0;
		Divide = sc.nextDouble();
		Divide = x * y / Divide;
		
		return Divide;
	}
	
	public Ball[] getBall()
	{
		for(int i = 0; i < 200; i++)
		{
			int userInput = sc.nextInt();
			balls[i] = new Ball(userInput);
		}
		return balls;
	}
	
	}

public class Emain {
	

	public static void main(String[] args) {
		
		E e = new E();
		int first = e.getFirst();
		System.out.println(first);
		// 두수의 합을 입력받아 사용한다. 
		int hap = e.getHap();
		System.out.println(hap);
		
		double Divide = e.getDivide();
		System.out.println(Divide);
		
		// getBall() 메서드를 호출하여 Ball 배열을 받아옴
        Ball[] ballArray = e.getBall();

        for (int i = 0; i < ballArray.length; i++) {
            System.out.println(ballArray[i].getValue());
		
	}

}

----------------------------------------------------
[input]
10
20
30
---------------------------------------------------
10
20
30

4)간단한 게임

package com.Scan;

import java.util.Random;

public class RandomGame {
	int dap = -1; 

	public void newGame()
	{
		Random r = new Random();
		dap = r.nextInt(10); 
	}

	public String account(int User) 
	{
		String hint = null;
		if(dap == User)
		{
			hint = "정답입니다.";
		}
		else if(dap > User) 
		{
			hint = "높여라";
		}
		else if(dap < User) 
		{
			hint = "낮춰라";
		}
		return hint;
	}
	/**********************************************************************************
	 *  판정을 내려주는 메소드 구현하기
	 *  @Param user - 사용자가 숫자를 맞추기 위해서 입력하는 값을 담는 변수다. - 입력할 때마다 바귄다./지역변수
	 *  @return - String 타입 : 힌트를 반환하는 변수 (예시: 높여라 / 낮춰라 / 정답이다.)
	 **********************************************************************************/
	
	public void messagePrint(int User)
	{
		System.out.println(account(User)); 
	}
	
	
	public static void main(String[] args) {
		RandomGame rg = new RandomGame();
		rg.account(5);
		


	}

}


/* 0-9사이의 임의의 숫자를 채번하고
 * 사용자로부터 숫자를 입력 받아서 
 * 입력받은 숫자가 더 작으면 힌트를 높여라 라고 출력하고 
 * 더 크면 나줘라 라고 힌트를 주어서 5번까지만 기회를 제공해서 그 숫자를 맞추는 게임을 작성해 보세요.
 * 
 * 새 게임을 선택했을 때는 0~9 사이에 새로운 숫자를 채번해야 한다.
 * 채번한 숫자는 dap라는 변수에 저장해둔다.
 * 그리고 전역변수로 하는 것이 좋다.
 * 왜냐하면 그 게임을 하는 그 사람이 사용하는 동안에는 오직 하나의 객체만 사용하게 되니깐.
 */
  • 주석
package com.step3;

import java.util.Random;

public class RandomGame {
	//선언부
	//새로 채번된 숫자를 담는다 - 정답이다
	int dap = -1;//-1은 end of file 찾아도 없다
	//사용자가 입력하는 숫자는 절대로 전변으로 하지 않는다. - 매번 입력할 때 마다 바뀌어야 하니까....
	//게임을 하는데 필요한 메소드
	//새게임을 누를 때 마다 호출되는 메소드 이다.
	//여기서 채번되는 숫자가 정답이므로 노출하지 않는다. - 그래서 나는 전변으로 선언하였다.
	public void newGame() {
		Random r = new Random();
		//리턴 타입이 없어도 전변이면 어떠한 메소드에서도 재정의가 가능하다.
		dap = r.nextInt(10);//정답이 결정되었다. - 답이 수시로 변경되면 안된다. -  유지되어야 한다. - 종료될때까지....
	}
	//판정을 내려주는 메소드를 선언해 보자. - 왜냐면
	/************************************************************************************
	 * 판정을 내려주는 메소드 구현하기
	 * @param user - 사용자가 숫자를 맞추기 위해서 입력하는 값을 담는 변수이다. - 입력할 때마다 바뀐다. -지변
	 * @return - String - 힌트를 반환한다(예시: 높여라, 낮춰라, 정답입니다. 축하합니다.)
	 ************************************************************************************/
	public String account(int 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(user));//24-> 5를 쥐고 간다.-> 높여라 출력
	}
	public static void main(String[] args) {
		RandomGame rg = new RandomGame();
		//rg.account(5);
		rg.messagePrint(5);
	}

}
/*
0~9사이의 임의의 숫자를 채번하고 
사용자로 부터 숫자를 입력받아서 
입력받은 숫자가 더 작으면 힌트를 높여라 라고 출력하고
더 크면 낮춰라 라고 힌트를 주어서 
5번까지만 기회를 제공해서 그 숫자를 맞추는 게임을 작성해 보시오.

새게임을 선택했을 때는 0~9사이에 새로운 숫자를 채번해야 합니다.
채번한 숫자는 dap이라는 변수에 저장해 둡시다.
그리고 전역변수로 하는 것이 좋겠습니다.
왜냐면 그 게임을 하는 그 사람이 사용하는 동안에는 오직 하나의 객체만 사용하게 될 테니까요......

*/

  • 사용자가 입력하는 숫자는 절대로 전변으로 하지 않는다. - 매번 입력할 때 마다 바뀌어야 하니까

  • 여기서 채번되는 숫자가 정답이므로 노출하지 않는다. - 그래서 나는 전변으로 선언하였다.

  • 리턴 타입이 없어도 전변이면 어떠한 메소드에서도 재정의가 가능하다.

  • r.nextInt(10) : 0~9까지 채번한 것을 리턴한다.

생성자를 통해서 newGame을 따로 호출해야한다

package com.Scan;

import java.util.Random;

public class RandomGame {
    int dap = -1;

    public RandomGame() {
        newGame(); // Call newGame in the constructor to initialize dap with a random number.
    }

    public void newGame() {
        Random r = new Random();
        dap = r.nextInt(10);
    }

    public String account(int User) {
        String hint = null;
        if (dap == User) {
            hint = "This is the correct answer.";
        } else if (dap > User) {
            hint = "Raise";
        } else if (dap < User) {
            hint = "Lower";
        }
        return hint;
    }

    public void messagePrint(int User) {
        System.out.println(account(User));
    }

    public static void main(String[] args) {
        RandomGame rg = new RandomGame();
        rg.messagePrint(5); // Use messagePrint instead of account to print the hint.
    }
}

이런식으로

profile
지환
아는만큼보인다.
이전 포스트

자바 프로젝트

다음 포스트

Java -Review(4) 반복문 & 조건문

0개의 댓글