JAVA study 12

예제) Vending Mechine 자판기 시스템 만들기

package ex1_vending;

public class Can {

	private String canName;
	private int price;
	public String getCanName() {
		return canName;
	}
	public void setCanName(String canName) {
		this.canName = canName;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	
	
	
}

--

package ex1_vending;

public class Vending {
	
	private Can[] can = new Can[5];
	private int money;
	
	//자판기에 들어갈 음료의 종류를 결정하는 메서드
	public void init() {
		
		for(int i = 0; i < can.length; i++) {
			can[i] = new Can();
		}
		
		can[0].setCanName("coke");
		can[0].setPrice(1000);

		can[1].setCanName("cider");
		can[1].setPrice(1100);

		can[1].setCanName("hotsix");
		can[1].setPrice(1200);
		
		can[3].setCanName("coffee");
		can[3].setPrice(1300);

		can[4].setCanName("banana");
		can[4].setPrice(1400);
						
	}//init()
	
	//사용자가 투입한 금액의 범위에 있는 음료의 목록만 보여주는 메서드
	public void showCans(int money) {
		this.money = money; //자판기안으로 금액 들어옴
		
		for(int i = 0 ; i < can.length; i++) {
			if(can[i].getPrice() <= money) { 
				System.out.printf("%s - %d원\n", can[i].getCanName(), can[i].getPrice());
			}
		}
	}

	public void outCan (String name) {
		
		for(int i = 0; i < can.length; i++) {
			if(can[i].getCanName().equals(name)) {
				System.out.println(name + "를 선택하셨네요.");
				System.out.println("잔액 : " + (money - can[i].getPrice()));
			}
		}
	}
	
	
	//선택한 음료를 제공하고 잔액을 돌려주는 메서드
	
}

--

package ex1_vending;

import java.util.Scanner;

public class VendingMain {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		Vending v = new Vending();
		v.init();//음료수 정보 초기화
		
		System.out.print("insert coin : ");
		int money = sc.nextInt();
		
		v.showCans(money);
		System.out.print("음료를 골라 : ");
		String sel = sc.next();
		
		v.outCan(sel);
		
	}
}

 

2. Overload 오버로드

package ex2_overload;

public class OverloadTest {

	// 메서드의 오버로딩 : 메서드의 '중복정의'라고 하며, 하나의 클래스에서
	// 같은 이름을 가진 메서드가 여러개 정의되는 것을 말한다.

	// 오버로딩의 규칙
	// 1) 인자의 갯수가 다른경우
	// 2) 인자의 갯수는 같으나 타입이 다른경우 (인자의 이름이 다른경우는 안됨)
	// 3) 인자의 갯수가 같고, 타입까지 같지만, 순서가 다른 경우

	public void getResult() {
		System.out.println("인자가 없는 메서드");
	}

	public void getResult(int n) {
		System.out.println("정수를 인자로 받는 메서드");
	}

	public void getResult(char n) {
		System.out.println("문자를 인자로 받는 메서드");
	}

	public void getResult(String s) {
		System.out.println("문자열을 인자로 받는 메서드");
	}

	public void getResult(int n, String s) {
		System.out.println("정수, 문자을 인자로 받는 메서드");
	}

	public void getResult(String s, int n) {
		System.out.println("문자열, 정수를 인자로 받는 메서드");
	}

}

--

package ex2_overload;

public class OverloadMain {
	public static void main(String[] args) {

		OverloadTest ot = new OverloadTest();
		ot.getResult();
		ot.getResult(10);
		ot.getResult('A');
		ot.getResult("ABC");
		ot.getResult(10, "ABC");
		ot.getResult("ABC", 10);

	}// main

}

 

예제)빵만들기

package ex3_overload;

public class Bread {

	public void makeBread() {//메서드 1
		System.out.println("빵을 만들었습니다.");
	}

	public void makeBread(int n) {//메서드 2
		for(int i = 0; i <= n; i++) {
			System.out.println("빵을 만들었습니다.");
		}
		System.out.printf("요청하신 %d개의 빵을 만들었습니다.\n", n);
	}
	
	public void makeBread(int n, String s) {//메서드 3
		for(int i = 0; i <= n; i++) {
			System.out.printf("%s빵을 만들었습니다.\n", s);
		}
		System.out.printf("요청하신 %d개의 %s빵을 만들었습니다.\n",n,s);
	}
	
}

--

package ex3_overload;

public class BreadMain {

	public static void main(String[] args) {
		
	/*
	 * 빵을 만들었습니다 <-- 메서드 1 호출
	 * ------------
	 * 빵을 만들었습니다
	 * 빵을 만들었습니다
	 * 요청하신 2개의 빵을 만들었습니다. <-- 메서드 2 호출
	 * ------------
	 * 크림빵을 만들었습니다
	 * 크림빵을 만들었습니다
	 * 요청하신 2개의 크림빵을 만들었습니다. <메서드 3 호출
	 */
	
	Bread b = new Bread();
	b.makeBread();
	b.makeBread(2);
	b.makeBread(2,"크림");
	
	}
}

 

3. Constructor 생성자

생성자 : 객체 생성시 메모리 할당 및 멤버의 초기화를 위해 사용하는 영역

생성자를 사용하면 호출이 필요한 사항에 대해 빠짐 없이 사용할 수 있도록 도와준다

생성자는 객체가 생성될때 new로 딱 한번만 호출 할 수 있다. (보안성이 높은 setter 같은 느낌)

생성자를 선택하면 따로 객체를 생성하는 것보다 속도가 더 빠르다

반환형(return)이 없으며 클래스와 반드시 동일한 이름을 가진다

package ex4_constructor;

public class Poke {

	// 생성자 : 객체생성시 메모리 할당 및 멤버의 초기화를 위해 사용하는 영역
	// 객체가 생성될때 딱 한번만 호출 할 수 있다
	// 반환형(return)이 없으며 클래스와 반드시 동일한 이름을 가진다

	private String general = "포켓몬 1세대";
	private String name;
	private String type;

	// 생성자 방식: public + 반환형없이 이름 ( 생성할 속성 ){}
	public Poke(String name, String type) {// 생성자
		general = "1세대";
		this.name = name;// name은 main에서 주는 값을 받을께
		this.type = type;// type은 main에서 주는 값을 받을께
		System.out.println("나는 Pok의 생성자야");
	}

	public String getGeneral() {
		return general;
	}

	public void setGeneral(String general) {
		this.general = general;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

}

--

package ex4_constructor;

public class PokeMain {
	public static void main(String[] args) {
		
		Poke p1 = new Poke("피카츄", "전기");
	
		System.out.println(p1.getGeneral());
		System.out.println(p1.getName());
		System.out.println(p1.getType());
		
		
		
	}//main
}

 

생성자 + 오버로드 계속(펜)

package ex5_constructor;

public class Pen {

	private int length;
	private String color;
	private int price;
	
	public Pen() {
		length = 15;
		color = "black";
		price = 500;
	}
	//생성자의 오버로드
	public Pen(String color, int price) {
		length = 15;
		this.color = color;
		this.price = price;
	}
	
	public void myPen() {
		System.out.println("길이 : " + length + "cm");
		System.out.println("색상 : " + color);
		System.out.println("가격 : " + price + "원");
		System.out.println("-----------------------");
	}
}

--

package ex5_constructor;

public class PenMain {
	public static void main(String[] args) {
		
		Pen p1 = new Pen();
		p1.myPen();
		
		Pen p2 = new Pen("gold", 20000); //생성자 오버로드를 통해 따로 입력 가능
		p2.myPen();
		
		
	}//main
}

 

예제) Vending Mechine 자판기 시스템 생성자로 만들기

package ex6_constructor;

public class Can {

	private String canName;
	private int price;

	public String getCanName() {
		return canName;
	}
	public int getPrice() {
		return price;
	}

	public Can(String canName, int price) {
		this.canName = canName;
		this.price = price;
	}

}

--

package ex6_constructor;

public class Vending {

	private Can[] can = new Can[5];
	private int money;

	// 자판기에 들어갈 음료의 종류를 결정하는 메서드

	public Vending() {//Vending자체를 생성자로 사용하면서 음료정보 초기화가 필요 없음
		// 음료정보, 깜박하면 안되는 정보를 꼭 입력하게 만듬(음료이름, 가격)
		can[0] = new Can("coke", 1000);
		can[1] = new Can("cider", 1100);
		can[2] = new Can("hotsix", 1200);
		can[3] = new Can("coffe", 1300);
		can[4] = new Can("banana", 1400);
	}

	// 사용자가 투입한 금액의 범위에 있는 음료의 목록만 보여주는 메서드
	public void showCans(int money) {
		this.money = money; // 자판기안으로 금액 들어옴

		for (int i = 0; i < can.length; i++) {
			if (can[i].getPrice() <= money) {
				System.out.printf("%s - %d원\n", can[i].getCanName(), can[i].getPrice());
			}
		}
	}

	// 선택한 음료를 제공하고 잔액을 돌려주는 메서드
	public void outCan(String name) {

		for (int i = 0; i < can.length; i++) {
			if (can[i].getCanName().equals(name)) {
				System.out.println(name + "를 선택하셨네요.");
				System.out.println("잔액 : " + (money - can[i].getPrice()));
			}
		}
	}


}

--

package ex6_constructor;

import java.util.Scanner;

public class VendingMain {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		Vending v = new Vending();//Vending에서 생성자를 통해 초기화되서 옴


		System.out.print("insert coin : ");
		int money = sc.nextInt();

		v.showCans(money);
		System.out.print("음료를 골라 : ");
		String sel = sc.next();

		v.outCan(sel);

	}// main
}

 

예제) WordGame

package ex7_work;

import java.util.Random;
import java.util.Scanner;

public class WordGame {
	public static void main(String[] args) {

		// PEALP
		// 정답? : ealpp
		// ealpp 오답
		// 정답? : apple
		// apple 정답!

		String[] strArr = { "HOPE", "VIEW", "APPLE", "BANANA" };
		Scanner sc = new Scanner(System.in);

		int randomArr = new Random().nextInt(strArr.length);
		String realWord = strArr[randomArr];
		char[] shuffle = strArr[randomArr].toCharArray(); // 글자를 배열로 나누기
		int rNum = new Random().nextInt(shuffle.length);

		int[] arr = new int[shuffle.length];

		for (int i = 0; i < shuffle.length; i++) {
			arr[i] = new Random().nextInt(shuffle.length);

			for (int j = 0; j < i; j++) {
				if (arr[i] == arr[j]) {
					i--;
				} // if
			} // inner
				// System.out.println(shuffleWord); // 랜덤 확인용
		} // outer
		for (int i = 0; i < arr.length; i++) {
			// System.out.println(arr[i]);
		}

		String str = "";
		for (int i = 0; i < arr.length; i++) {
			str += shuffle[arr[i]];
		}
		System.out.println(str);

		// 정답맞추기
		while (true) {
			System.out.print("정답은? : ");
			String answer = sc.next();

			if (answer.equalsIgnoreCase(realWord)) {
				System.out.println("정답");
				break;
			}
			System.out.println("오답");
		}
	}
}

 

예제) WordGame_tCode

package ex7_work;

import java.util.Random;

public class Scramble {

	private String shake; // 정답을 섞어서 저장할 변수
	private String str; // 랜덤으로 골라진 정답

	public Scramble(String[] strArr) {
		shake = "";
		int idx = new Random().nextInt(strArr.length);
		str = strArr[idx];

	}

	public String getAnswer() {
		return str;
	}

	// 정답을 섞어서 문제로 반환하는 메서드
	public String getScrambled() {

		// 정답문장을 문자 단위로 끊어서 배열에 저장
		int[] inArr = new int[str.length()];

		// 만들어진 inArr배열에 중복되지 않는 난수를 집어넣기
		outer: for (int i = 0; i < inArr.length; i++) {
			inArr[i] = new Random().nextInt(str.length());

			// 중복체크
			for (int j = 0; j < i; j++) {
				if (inArr[i] == inArr[j]) {
					continue outer;
				}
			} // inner
			i++;

		} // outer

		// 정답을 섞어서 shake변수에 저장
		for (int i = 0; i < str.length(); i++) {
			shake += str.charAt(inArr[i]);

		}

		return shake;
	}

}

 

package ex7_work;

import java.util.Scanner;

public class WordGame_tCode {
	public static void main(String[] args) {

		// PEALP
		// 정답? : ealpp
		// ealpp 오답
		// 정답? : apple
		// apple 정답!

		String[] strArr = { "HOPE", "VIEW", "APPLE", "BANANA" };
		Scanner sc = new Scanner(System.in);

		Scramble scramble = new Scramble(strArr);
		String answer = scramble.getAnswer();// 정답단어

		System.out.print("문제 : " + scramble.getScrambled());

		while (true) {

			System.out.print("정답은 뭘까? : ");
			String s = sc.next();

			if (s.equalsIgnoreCase(answer)) {
				System.out.println("정답!");
				break;
			} else {
				System.out.println("오답...");
			}
		} // while

	}
}