21.09.13 - 웹 개발 입문 24일차

Q. 편의점 POS 구현
우리 편의점에서는 다음 상품(Product)을 판매합니다
- 상품명 : 아카시아 , 상품분류 : 껌 , 판매가격 : 500원 , 재고 : 40개
- 상품명 : 전주비빔 , 상품분류 : 삼각김밥 , 판매가격 : 1200원 , 재고 : 5개
- 상품명 : 제육도시락 , 상품분류 : 도시락 , 판매가격 : 4000원 , 재고 : 3개
- 상품명 : 육개장큰사발 , 상품분류 : 라면 , 판매가격 : 1500원 , 재고 : 25개
- 상품명 : 판타롱스타킹 , 상품분류 : 양말 , 판매가격 : 1000원 , 재고 : 20개

상품명을 입력하면 해당하는 상품이 "판매 가능"한지 파악해서 재고를 감소시킵니다.
판매된 상품 수량만큼 오늘자 매출이 누적계산되어야 합니다.
상품명에 "종료"라고 입력하면 프로그램이 종료되면서 남아있는 상품목록과 일 매출액이 화면에 출력되어야 합니다.

<예시>
판매할 상품명 : 참치마요
-> 존재하지 않는 상품입니다.
판매할 상품명 : 육개장큰사발
-> [육개장큰사발] 판매 완료되었습니다.
판매할 상품명 : 육개장큰사발
-> [육개장큰사발] 재고가 부족하여 판매할 수 없습니다.
판매할 상품명 : 종료
-> 프로그램을 종료합니다.
일 매출액 : ???원
<상품리스트>
- 상품명 : 아카시아 , 상품분류 : 껌 , 판매가격 : 500원 , 재고 : 40개
- 상품명 : 전주비빔 , 상품분류 : 삼각김밥 , 판매가격 : 1200원 , 재고 : 5개
- 상품명 : 제육도시락 , 상품분류 : 도시락 , 판매가격 : 4000원 , 재고 : 3개
- 상품명 : 육개장큰사발 , 상품분류 : 라면 , 판매가격 : 1500원 , 재고 : 25개
- 상품명 : 판타롱스타킹 , 상품분류 : 양말 , 판매가격 : 1000원 , 재고 : 20개

 

package api.collection;

import java.util.Objects;

public class Product {
	// 멤버 변수 : 상품이름, 상품분류, 판매가격, 상품재고
	private String name;
	private String type;
	private int price;
	private int stock;

	// 멤버 메소드 : setter , getter , 판매 , 판매가능여부 확인
	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;
	}

	public int getPrice() {
		return price;
	}

	public void setPrice(int price) {
		if (price < 0) {
			return;
		}
		this.price = price;
	}

	public int getStock() {
		return stock;
	}

	public void setStock(int stock) {
		if (stock < 0) {
			return;
		}
		this.stock = stock;
	}

	// 생성자 : 상품이름 + 상품분류 ( + 판매가격 ) ( + 상품재고 )
	public Product(String name, String type) {
		this(name, type, 0, 0);
	}

	public Product(String name, String type, int price) {
		this(name, type, price, 0);
	}

	public Product(String name, String type, int price, int stock) {
		this.setName(name);
		this.setType(type);
		this.setPrice(price);
		this.setStock(stock);
	}

	@Override
	public String toString() {
		return "Product [name=" + name + ", type=" + type + ", price=" + price + ", stock=" + stock + "]";
	}

	// 재고 감소(판매) 기능
	public boolean sell() {
		if (this.isSellable()) {
			this.stock--;
			return true;
		} else {
			return false;
		}
	}

	public boolean isSellable() {
//		if(this.stock > 0) {
//			return true;
//		}
//		else {
//			return false;
//		}
		return this.stock > 0;
	}

	public Product(String name) {
		super();
		this.name = name;
	}

	@Override
	public int hashCode() {
		return Objects.hash(name);
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Product other = (Product) obj;
		return Objects.equals(name, other.name);
	}

	// 매출액을 클래스레벨에서 관리(탈객체)
	private static long total = 0L;

	public static long getTotal() {
		return total;
	}

	public static void addTotal(int price) {
		total += price;
	}
}

 

package api.collection;

import java.text.DecimalFormat;
import java.text.Format;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Test12_11 {
	public static void main(String[] args) {
		//저장소 생성
		List<Product> productList = new ArrayList<>();

		//데이터 추가
		productList.add(new Product("아카시아", "껌", 500, 40));
		productList.add(new Product("전주비빔", "삼각김밥", 1200, 5));
		productList.add(new Product("제육도시락", "도시락", 4000, 3));
		productList.add(new Product("육개장큰사발", "라면", 1500, 25));
		productList.add(new Product("판타롱스타킹", "양말", 1000, 20));

		Scanner sc = new Scanner(System.in);

		while(true) {
			System.out.print("상품 이름 : ");
			String name = sc.nextLine();

			if(name.equals("종료")) {
				break;
			}

			Product temp = new Product(name);
			int index = productList.indexOf(temp);

			if(index >= 0) {//상품이 존재하는 경우
				Product find = productList.get(index);
				if(find.sell()) {//상품이 판매되었다면
					System.out.println("["+find.getName()+"] 판매 완료");
					Product.addTotal(find.getPrice());
				}
				else {//판매되지 않았다면
					System.out.println("재고 부족");
				}
			}
			else {//상품이 존재하지 않는 경우
				System.out.println("해당 상품은 존재하지 않습니다");
			}
		}

		sc.close();

		//데이터 출력
		Format f = new DecimalFormat("#,###");
		System.out.println("<일일 정산>");
		System.out.println("일 매출액 : "+f.format(Product.getTotal())+"원");
		for(Product p : productList) {
			System.out.println(p);
		}
	}
}

 

상품 이름 : 아카시아
20
[아카시아] 판매 완료
상품 이름 : 해당 상품은 존재하지 않습니다
상품 이름 : 아카시아
[아카시아] 판매 완료
상품 이름 : 아카시아
[아카시아] 판매 완료
상품 이름 : 제육도시락
[제육도시락] 판매 완료
상품 이름 : 육개장큰사발
[육개장큰사발] 판매 완료
상품 이름 : 종료
<일일 정산>
일 매출액 : 7,000원
Product [name=아카시아, type=껌, price=500, stock=37]
Product [name=전주비빔, type=삼각김밥, price=1200, stock=5]
Product [name=제육도시락, type=도시락, price=4000, stock=2]
Product [name=육개장큰사발, type=라면, price=1500, stock=24]
Product [name=판타롱스타킹, type=양말, price=1000, stock=20]

 

 

 

 

Collection - Set 기본설명

 

 

Set
중복을 허용하지 않는 저장소
순서가 정해져 있는 저장소
TreeSet, HashSet
(ex) 전화번호부

package api.collection2;

import java.util.Set;
import java.util.TreeSet;

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

		Set<String> set = new TreeSet<>();

		// 추가 : add()
		set.add("차은우");
		set.add("아이유");
		set.add("아이유");
		set.add("김을동");
		set.add("공유");
		set.add("한지민");

		// 출력
		System.out.println(set);

		// 개수확인
		System.out.println(set.size());

		// 검색
		System.out.println(set.contains("아이유"));

		// 삭제
		set.remove("공유");
		System.out.println(set);
	}
}

[공유, 김을동, 아이유, 차은우, 한지민]
5
true
[김을동, 아이유, 차은우, 한지민]

 

 

 

TreeSet의 저장 구조상 Tree의 형태를 취하기 때문에 작은값이 왼쪽, 큰 값이 오른쪽으로 저장됨
절대로 index를 가질 수 없으므로 index관련 명령이 없다.
indexOf(), get() 과 같은 명령이 없다

package api.collection2;

import java.util.HashSet;
import java.util.Set;

public class Test03 {
	public static void main(String[] args) {
    
		Set<Integer> set = new HashSet<>();

		// 5 → 7 → 13 → 21 → 45 → 93 → 65
		set.add(5);
		set.add(7);
		set.add(13);
		set.add(21);
		set.add(45);
		set.add(93);
		set.add(65);

		System.out.println(set);
		System.out.println(set.size());

//		System.out.println(set.get(0));//될 수가 없다
	}
}

[1, 3, 4, 5, 6, 7, 9]
7

 

 

Q. 로또 문제를 List처럼 풀이

package api.collection2;

import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

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

		Set<Integer> lotto = new TreeSet<>();

		Random r = new Random();
		for (int i = 0; i < 6; i++) {
			int number = r.nextInt(45) + 1;
			if (!lotto.contains(number)) {
				lotto.add(number);
			} else {
				i--;
			}
		}

		System.out.println(lotto);

	}
}

[7, 15, 22, 25, 38, 43]

 

 

Set 전체추출

Set의 전체 추출 및 출력?
List에서는 index를 이용한 반복이 가능했었으나 Set은 index가 없다.
1. Iterator 이용
2. Foreach 이용

package api.collection2;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

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

		Set<String> languages = new TreeSet<>();

		languages.add("Java");
		languages.add("Python");
		languages.add("Javascript");
		languages.add("C++");
		languages.add("Go");

		System.out.println(languages);

//		System.out.println(languages.get(0));
//		System.out.println(languages.get(1));
//		System.out.println(languages.get(2));
//		System.out.println(languages.get(3));
//		System.out.println(languages.get(4));

//		1. 이터레이터(Iterator)를 사용하여 추출하는 방법
		Iterator<String> iter = languages.iterator();// Set<String> ----> Iterator<String> 이동

		while (iter.hasNext()) {
			String name = iter.next();
			System.out.println("name = " + name);
		}

//		2. 확장 for문(foreach)를 이용하여 추출하는 방법
		for (String name : languages) {
			System.out.println("name = " + name);
		}
	}
}

[C++, Go, Java, Javascript, Python]
name = C++
name = Go
name = Java
name = Javascript
name = Python
name = C++
name = Go
name = Java
name = Javascript
name = Python

 

 

 

Set 객체저장

 

 Car를 저장할 수 있는 저장소 생성

package api.collection2;

import java.util.Objects;

public class Car implements Comparable<Car> {
	private String name;
	private String type;
	private int price;

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

	public int getPrice() {
		return price;
	}

	public void setPrice(int price) {
		this.price = price;
	}

	public Car(String name, String type, int price) {
		super();
		this.name = name;
		this.type = type;
		this.price = price;
	}

	@Override
	public String toString() {
		return "Car [name=" + name + ", type=" + type + ", price=" + price + "]";
	}

	@Override
	public int hashCode() {
		return Objects.hash(name);
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Car other = (Car) obj;
		return Objects.equals(name, other.name);
	}

	public Car(String name) {
		this(name, null, 0);
	}

	@Override
	public int compareTo(Car o) {
		return this.getName().compareTo(o.getName());
	}

}

Comparable을 상속한 클래스는 TreeSet을 그냥 이용할 수 있다.

package api.collection2;

import java.util.Set;
import java.util.TreeSet;

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

		Set<Car> items = new TreeSet<>();

		items.add(new Car("소나타", "중형", 15000000));
		items.add(new Car("소나타", "중형", 15000000));
		items.add(new Car("소나타", "중형", 15000000));
		items.add(new Car("아반떼", "중형", 12000000));
		items.add(new Car("레이", "소형", 9000000));

//		출력
		for(Car car : items) {
			System.out.println(car);
		}
	}
}

 

 

 

Collection - 집합연산

집합연산?
서로 다른 두 집합 간의 연산
= 합집합, 교집합, 차집합

package api.collection2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

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

		// List<Integer> a = new ArrayList<>();
		List<Integer> a = Arrays.asList(10, 20, 30);// 10, 20, 30이 들어있는 크기 고정 List 생성(불변)
		List<Integer> b = Arrays.asList(20, 30, 40, 50);// 20, 30, 40, 50이 들어있는 불변 List

		System.out.println(a);
		System.out.println(b);

		List<Integer> c = new ArrayList<>();
//		c.addAll(a);
//		c.addAll(b);
		for (int n : a) {
			if (!c.contains(n)) {
				c.add(n);
			}
		}
		for (int n : b) {
			if (!c.contains(n)) {
				c.add(n);
			}
		}
		System.out.println(c);
	}
}

 

ex . 예제

package api.collection2;

import java.util.Arrays;
import java.util.Set;
import java.util.TreeSet;

public class Test08 {
	public static void main(String[] args) {
		Set<Integer> a = new TreeSet<>(Arrays.asList(10, 20, 30));
		Set<Integer> b = new TreeSet<>(Arrays.asList(20, 30, 40, 50));

		System.out.println(a);
		System.out.println(b);

		Set<Integer> c = new TreeSet<>();
		c.addAll(a);
		c.addAll(b);
		System.out.println(c);
	}
}

[10, 20, 30]
[20, 30, 40, 50]
[10, 20, 30, 40, 50]

 

 

Q. 하니와 둘리는 올해 다음과 같은 영화를 봤습니다.
- 하니 : 소울, 미나리, 자산어보, 서복, 비와 당신의 이야기
- 둘리 : 소울, 내일의 기억, 비와 당신의 이야기, 크루엘라, 발신제한
1. 하니와 둘리 모두 본 영화를 출력하세요
2. 하니만 보고 둘리는 보지 않은 영화를 출력하세요
3. 둘리만 보고 하니는 보지 않은 영화를 출력하세요
4. 하니와 둘리 중 한 명이라도 본 영화를 출력하세요
참고 : 집합연산의 명령은 다음과 같습니다.
- 합집합 : addAll()
- 교집합 : retainAll()
- 차집합 : removeAll()

package api.collection2;

import java.util.Arrays;
import java.util.Set;
import java.util.TreeSet;

public class Test09 {
	public static void main(String[] args) {
		Set<String> hani = new TreeSet<>(Arrays.asList("소울", "미나리", "자산어보", "서복", "비와 당신의 이야기"));
		Set<String> duli = new TreeSet<>(Arrays.asList("소울", "내일의 기억", "비와 당신의 이야기", "크루엘라", "발신제한"));

//		1. 교집합(하니 ∩ 둘리)
		Set<String> intersect = new TreeSet<>();
		intersect.addAll(hani);
		intersect.retainAll(duli);

//		System.out.println(union);
		System.out.println("1. 하니와 둘리 모두 본 영화");
		for (String movie : intersect) {
			System.out.println("--> " + movie);
		}

//		2. 차집합(하니 - 둘리)
		Set<String> haniOnly = new TreeSet<>();
		haniOnly.addAll(hani);
		haniOnly.removeAll(duli);

//		System.out.println(haniOnly);
		System.out.println("2. 하니만 본 영화");
		for (String movie : haniOnly) {
			System.out.println("--> " + movie);
		}

//		3. 차집합(둘리 - 하니)
		Set<String> duliOnly = new TreeSet<>(duli);
		duliOnly.removeAll(hani);
//		System.out.println(duliOnly);
		System.out.println("3. 둘리만 본 영화");
		for (String movie : duliOnly) {
			System.out.println("--> " + movie);
		}

//		4. 합집합(하니 ∪ 둘리)
		Set<String> union = new TreeSet<>();
		union.addAll(hani);
		union.addAll(duli);

//		System.out.println(union);
		System.out.println("4. 하니와 둘리 중 한명이라도 본 영화는 총 " + union.size() + "개 입니다");
		for (String movie : union) {
			System.out.println("--> " + movie);
		}

	}
}

1. 하니와 둘리 모두 본 영화
--> 비와 당신의 이야기
--> 소울
2. 하니만 본 영화
--> 미나리
--> 서복
--> 자산어보
3. 둘리만 본 영화
--> 내일의 기억
--> 발신제한
--> 크루엘라
4. 하니와 둘리 중 한명이라도 본 영화는 총 8개 입니다
--> 내일의 기억
--> 미나리
--> 발신제한
--> 비와 당신의 이야기
--> 서복
--> 소울
--> 자산어보
--> 크루엘라

 

 

 

Collection - Map

Map<K, V>
개별 처리에 특화된 저장소
데이터에 이름을 붙여서 관리하는 형태
 K는 이름의 역할을 수행, V는 데이터의 역할을 수행
K(key, 이름)는 중복이 불가능
V(value, 값)는 중복이 가능

package api.collection3;

import java.util.HashMap;
import java.util.Map;

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

//		ex : 우리반 학생의 시험 점수
//		[1] 이름 : 피카츄 , 점수 : 50
//		[2] 이름 : 라이츄 , 점수 : 70
//		[3] 이름 : 파이리 , 점수 : 70

		Map<String, Integer> record = new HashMap<>();
//		Map<String, Integer> record = new TreeMap<>();

//		추가 : add()는 데이터를 1개 추가하는 명령. 2개는 put()이라는 명령을 사용
		record.put("피카츄", 50);
//		record.put(50, "피카츄");//예외 발생
		record.put("라이츄", 70);
		record.put("파이리", 70);

		System.out.println(record);
//		개수 확인 : size()
		System.out.println(record.size());

//		검색 명령 : contains() 대신 key와 value 검색명령을 따로 둔다. containsKey() , containsValue()
		System.out.println(record.containsKey("피카츄"));
		System.out.println(record.containsValue(70));

//		삭제 명령 : remove()
		record.remove("피카츄");
		System.out.println(record);

		int score = record.get("라이츄");// null이 나올 수 없는 경우
//		Integer score = record.get("라이츄");//null이 나올 수 있는 경우
		System.out.println(score);
	}
}

{라이츄=70, 파이리=70, 피카츄=50}
3
true
true
{라이츄=70, 파이리=70}
70

 

 

Q.다음 데이터를 저장하고 문제를 푸세요
- 이름 : K5 , 가격 : 1200만원
- 이름 : 모닝 , 가격 : 500만원
- 이름 : BMW : 가격 : 4000만원
사용자가 이름을 입력하면 가격이 출력되도록 구현, 단 없으면 존재하지 않는다는 메세지를 출력

package api.collection3;

import java.text.DecimalFormat;
import java.text.Format;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Test02_2 {
	public static void main(String[] args) {
		Format f = new DecimalFormat("#,###");
		Scanner sc = new Scanner(System.in);

		// 저장소 생성
		Map<String, Integer> cars = new HashMap<>();

		// 데이터 추가
		cars.put("K5", 12000000);
		cars.put("모닝", 5000000);
		cars.put("BMW", 40000000);

		// 이름 준비
		String name = sc.next();
		sc.close();
		// 문제점 : 없는 이름이 들어가면 예외 발생
		// [2] Map의 containsKey() 메소드 활용
		if (cars.containsKey(name)) {
			int price = cars.get(name);
			System.out.println(name + "의 가격은 " + f.format(price) + "원 입니다");
		} else {
			System.out.println("존재하지 않는 차량입니다");
		}

	}
}

K5
K5의 가격은 12,000,000원 입니다

 

 

Q. 다음과 같은 데이터를 Map에 저장한 뒤 요구사항에 맞게 문제를 푸세요
- 데이터
- 아이디 : testuser , 비밀번호 : testuser1234
- 아이디 : student , 비밀번호 : student1234
- 아이디 : manager , 비밀번호 : manager1234
- 요구사항
- 사용자에게 아이디와 비밀번호를 입력받는다
- 저장소에 있는 아이디, 비밀번호들과 비교하여 일치하는 항목이 있을 경우 "로그인 성공" 이라고 출력
- 일치하는 항목이 없을 경우 "로그인 실패"라고 출력

 

package api.collection3;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

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

		// 저장소 생성
		Map<String, String> db = new HashMap<>();

		// 데이터 등록
		db.put("testuser", "testuser1234");
		db.put("student", "student1234");
		db.put("manager", "manager1234");

		// 사용자 입력
		Scanner sc = new Scanner(System.in);
		System.out.print("아이디를 입력하세요 : ");
		String id = sc.next();

		System.out.print("비밀번호를 입력하세요 : ");
		String password = sc.next();
		sc.close();

		// boolean isLogin = 아이디 일치 && 비밀번호 일치;
		// boolean isLogin = db.containsKey(id) && db.containsValue(password);//아이디가
		// 존재하고 비밀번호도 존재합니까?
		boolean isLogin = db.containsKey(id) && db.get(id).equals(password);// 아이디가 존재하고 그 아이디에 해당하는 비밀번호와 일치합니까?

		if (isLogin) {
			System.out.println("로그인 성공");
		} else {
			System.out.println("로그인 실패");
		}
	}
}

아이디를 입력하세요 : manager
비밀번호를 입력하세요 : manager1234
로그인 성공

 

- 추가 비트연산 이란?

판정
& 연산은 멍청한 연산 , && 연산은 똑똑한 연산
& 연산은 안봐도 되는 상황을 파악하지 못하고, && 연산은 안봐도 되는 상황을 파악하여 연산 수행
지금 상황이라면 아이디가 존재하지 않으면 비밀번호는 볼 필요가 없다
&& 를 사용하면 아이디가 존재하지 않을 경우 비밀번호 비교를 수행하지 않는다

 

/비트 연산자 : & , | , ^
비트 단위로 숫자를 계산하는 연산
&를 AND 연산
 | 를 OR 연산

^ 를 XOR 연산

package api.collection3;

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

		int flag = 0;
		System.out.println(Integer.toBinaryString(flag));
		// 어떤 이유에서 특정 비트만 1로 설정해야 하는 경우가 발생
		// = 오른쪽에서 4번째 비트만 ON(1) 으로 설정하고 싶은 경우
		flag |= 0b00001000;
		flag |= 0b00010000;
		flag |= 0b01000000;
		System.out.println(Integer.toBinaryString(flag));

		// 어떤 이유에서 특정 비트만 0으로 초기화해야 하는 경우가 발생
		flag &= 0b01000000;
		System.out.println(Integer.toBinaryString(flag));

		// 어떤 이유에서 전체를 초기화해야 하는 경우가 발생
		flag ^= flag;
		System.out.println(Integer.toBinaryString(flag));

		// ex : 비밀번호 암호화(XOR 암호화)
		String password = "khacademy";
		System.out.println(password);

		StringBuffer buffer = new StringBuffer();
		for (int i = 0; i < password.length(); i++) {
			buffer.append((char) (password.charAt(i) ^ 8));
		}

		System.out.println(buffer);// 암호화된 결과

		StringBuffer buffer2 = new StringBuffer();
		for (int i = 0; i < buffer.length(); i++) {
			buffer2.append((char) (buffer.charAt(i) ^ 8));
		}
		System.out.println(buffer2);// 복호화된 결과

	}
}

0
1011000
1000000
0
khacademy
c`ikilmeq
khacademy

 

 

 

- 과제

렌트카 업체용 프로그램
- 관리할 데이터는 차량정보와 대여가능여부 입니다.
- 차량정보는 Car라는 클래스로 관리하며, 차종(name), 승차인원(people), 1일비용(price)정보를 보관
1. 차종 : 스타렉스 , 승차인원 : 11명 , 1일 비용 : 15만원 , 대여상태 : true/false
2. 차종 : 카니발 , 승차인원 : 7명 , 1일 비용 : 17만원 , 대여상태 : true/false
3. 차종 : 그랜저 , 승차인원 : 4명 , 1일 비용 : 20만원 , 대여상태 : true/false
- Map<String, Car> 형태의 저장소를 만들어서 데이터를 관리합니다.
- key에는 "차량이름"을 저장하고, value에는 차량객체를 보관합니다.
- Car 클래스에는 차량 대여상태를 저장할 수 있는 변수가 하나 추가로 필요합니다.
- 대여 가능한 상태면 true , 대여중이면 false로 설정되어야 합니다.
- 주어진 데이터를 등록해둔 뒤 사용자에게 렌트하고싶은 차종을 입력받아 다음과 같이 처리
- 존재하지 않는 차량일 경우 사용자에게 메세지로 출력
- 존재하는 차량일 경우
- 대여 가능한지 파악하여 대여가 가능하면 "대여가 완료되었습니다" 출력 후 객체 상태를 대여중으로 변경
- 대여중이라면 "대여가 불가능합니다" 출력
- "종료"를 입력하면 프로그램을 종료하도록 구현

 

package api.collection3;

public class Car {
	private String name;
	private int people;
	private int price;
	private boolean rental; // 대여 가능한 상태면 true , 대여중이면 false

	public boolean isRental() {
		return rental;
	}

	public void setRental(boolean rental) {
		this.rental = rental;
	}

	public String getName() {
		return name;
	}

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

	public int getPeople() {
		return people;
	}

	public void setPeople(int people) {
		this.people = people;
	}

	public int getPrice() {
		return price;
	}

	public void setPrice(int price) {
		if (price < 0) {
			return;
		}
		this.price = price;
	}

	@Override
	public String toString() {
		return "Car [name=" + name + ", people=" + people + ", price=" + price + ", rental=" + rental + "]";
	}

	public Car(String name, int people, int price) {
		this.setName(name);
		this.setPeople(people);
		this.setPrice(price);
		this.rental = true;
	}

	public Car(String name, int people) {
		this(name, people, 0);
	}

	public void rentEnd() {
		rental = true;
	}

	public void rentStart() {
		rental = false;
	}
}

 

package api.collection3;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

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

		Map<String, Car> rentList = new HashMap<>();

		rentList.put("스타렉스", new Car("스타렉스", 11, 150000));
		rentList.put("카니발", new Car("카니발", 7, 170000));
		rentList.put("그랜저", new Car("그랜저", 4, 200000));

		Scanner sc = new Scanner(System.in);

		while (true) {
			System.out.print("차종을 입력하세요 : ");
			String name = sc.next();
			if (name.equals("종료")) {
				System.out.println("프로그램 종료");
				break;
			}

			if (rentList.containsKey(name)) {
				System.out.println("이 차량을 대여 / 반납 하시겠습니까?.");
				System.out.println("[대여] [반납] [뒤로가기]");
				String menu = sc.next();
				if (menu.equals("대여")) {
					if (rentList.get(name).isRental()) {
						System.out.println("대여가 완료되었습니다.");
						rentList.get(name).rentStart();
					} else {
						System.out.println("대여가 불가능합니다.");
					}
				} else if (menu.equals("반납")) {
					if (!rentList.get(name).isRental()) {
						System.out.println("반납 완료되었습니다.");
						rentList.get(name).rentEnd();
					} else {
						System.out.println("반납이 불가능합니다.");
					}

				} else if (menu.equals("뒤로가기")) {
				} else {
					System.out.println("없는 메뉴입니다.");
				}

			} else {
				System.out.println("존재하지 않는 차량입니다.");
			}

		}
		sc.close();
	}
}

차종을 입력하세요 : 스타렉스
이 차량을 대여 / 반납 하시겠습니까?.
[대여] [반납] [뒤로가기]
반납
반납이 불가능합니다.
차종을 입력하세요 : 스타렉스
이 차량을 대여 / 반납 하시겠습니까?.
[대여] [반납] [뒤로가기]
대여
대여가 완료되었습니다.
차종을 입력하세요 : 카니발
이 차량을 대여 / 반납 하시겠습니까?.
[대여] [반납] [뒤로가기]
반납
반납이 불가능합니다.
차종을 입력하세요 : 종료
프로그램 종료