[Java] Solution to puzzles 🔥

🧩 클래스 다이어그램에 따라 코드 작성하기

Q1 split()과 parsing을 사용하여 String 문자열을 배열로 만든 후, 합과 평균 계산하기

💁‍ 주어진 String 데이터를 “,”로 나누어 5개의 실수 데이터들을 꺼내어 합과 평균을 구하세요. 단, String 문자열의 모든 실수 데이터를 배열로 만들어 계산합니다.

◼ StringTest Class

String str = "1.22, 4.12, 5.93, 8.71, 9.34";
		
double data[] = new double[5];
double sum = 0;
double avg = 0;
		
// str에서 데이터를 분리
String[] st = str.split(",");
		
int i = 0;
// for-each문 사용
for(String s : st) {
	data[i] = Double.parseDouble(s);
	sum += data[i++];
	avg = sum/(st.length);
}
System.out.printf("합계 : %.3f\n", sum); // 반올림하여 셋째자리까지 나타내기 위해 printf와 %f 사용
System.out.println("평균 : " + avg);

💬 Overall Comment

* Java 문제를 오랜만에 풀어봐서 그런지 처음에 어떤 메소드를 활용해야할지 주저했으나 
클래스 다이어그램을 여러 번 읽으니 감이 잡혔다. 평소에 배열 부분이 약해서 배열 예제를 
많이 풀어봐야하는데 오랜만에 split(), parsing, 배열을 사용하니 학습이 되새김되는 느낌이었다.

---

Q2 GregorianCalendar 클래스와 SimpleDateFormat 을 사용하여 생일, 현재, 나이 구하기

💁‍ GregorianCalendar 클래스를 사용하여, 현재 년도와 비교한 나이를 계산하고 생일의 요일을 출력하세요. 출력시 SimpleDateFormat을 사용하여 출력하세요.

◼ DataTest Class

Calendar gre = new GregorianCalendar(); 
		
/* 현재 */
/* 아래의 생일에서 날짜를 set할 예정이므로, 현재를 먼저 작성하여 값 추출 */
long tDay = gre.getTimeInMillis(); // 출력한 시간(현재)
		
// 만 나이를 구하기 위해 현재의 년, 월, 일 추출
int tYear = gre.get(Calendar.YEAR);
int tMonth = gre.get(Calendar.MONTH) + 1;
int tDate = gre.get(Calendar.DATE);
		
/* 생일 */
int bYear = 1987;
int bMonth = 5-1; // month는 0부터 시작하므로, '원하는 월 - 1'
int bDate = 27;
		
gre.set(bYear, bMonth, bDate);
long bDay = gre.getTimeInMillis(); // set한 시간(생일)
int dayOfWeek = gre.get(Calendar.DAY_OF_WEEK); // set한 요일(생일)
		
String day = "";
switch(dayOfWeek) {
case 1 : day = "일"; break;
case 2 : day = "월"; break;
case 3 : day = "화"; break;
case 4 : day = "수"; break;
case 5 : day = "목"; break;
case 6 : day = "금"; break;
case 7 : day = "토"; break;
}
		
/* 출력 */
SimpleDateFormat sdf = new SimpleDateFormat("yyyy년 MM월 dd일 "); // 원하는 포맷으로 문자열 설정
String birthday = sdf.format(bDay);
String today = sdf.format(tDay);
		
System.out.println("생일 : " + birthday + day + "요일");
System.out.println("현재 : " + today);
		
/* 만 나이 */
int age = tYear - bYear;
if(bMonth*100 + bDate > tMonth*100 + tDate)
	age--;
System.out.println("나이 : 만 " + age + " 세");

💬 Overall Comment

* GregorianCalendar와 SimpleDateFormat을 활용하여 풀어내려하니 꽤 생각을 많이 해야하는 
  부분이 있었다. 많이 사용해보지 못 한 클래스들이라 정리해둔 것을 꼼꼼히 찾아가며 해야했다. 
  아직 머릿속에 정말 무수한 메소드들이 정리되지 않아서 애를 꽤 먹었지만 잘 정리된 코드가 
  완성되니 귀한 재산이 생긴 느낌이고 매우 뿌듯했다.

---

Q3 예외처리를 활용한 1부터 입력 받은 수까지의 합 출력하기

💁‍ 2부터 5까지의 정수형 데이터만을 키보드로 입력 받아 1부터 입력 받은 수까지의 합을 출력하세요. 단, 입력 받은 수가 2부터 5까지의 범위를 벗어나면 “입력 값에 오류가 있습니다.”라고 출력하고 프로그램을 종료합니다.

◼ Calculator Class

public class Calculator {

	public double getSum(int data) throws InvalidException {
		
		int sum = 0;
		
		if(data > 1 && data < 6) {
			for(int i = 0; i <= data; i++) {
				sum += i;
			}
		} else {
			throw new InvalidException("입력 값에 오류가 있습니다.");
		} 
		return sum;	
	} 
}

◼ ExceptionTest Class

public class ExceptionTest {

	public static void main(String[] args) {
		
		Calculator c = new Calculator();
		
		Scanner sc = new Scanner(System.in);

		try {
			System.out.println("< 1부터 입력 받은 수까지의 합 출력하기 >");
			System.out.println("---------------------------------");			
			System.out.print("2부터 5까지의 정수 중 하나를 입력해주세요 : ");
			int num = sc.nextInt();
			System.out.println("결과값 : " + c.getSum(num));

		} catch (InvalidException e) {
			e.printStackTrace(); 
		}
	}
}

◼ InvalidException Class

public class InvalidException extends Exception {

	public InvalidException(String message) {
		super(message);
	}
}

💬 Overall Comment

* 항상 완벽히 기억하지 못 하는 부분들은 언젠가 문제로 다가와서 나의 뒷통수를 콩- 치는 것 
  같다. 예외처리의 흐름을 이해하고 기억했다고 생각했으나 이해만 했던 내 자신 반성해야한다. 
  결국 또 정리해둔 예외처리 포스트를 찾아보며 코드를 완성할 수 있었다. 아직은 기억보다 
  기록에 의존해야하는 새싹단계이지만 이런 문제를 풀어보며 계속 기억을 곱씹어준다면 훗날 
  찾아보지않고 문제를 풀 수 있는 날이 올 것이라 믿는다 :)

---

Q4 상속을 활용하여 오버라이딩된 메소드 구현하기

💁‍ Abstract 클래스에서 상속받은 두 개의 클래스를 구현하여 아래 5번 항목의 실행 결과가 나오도록 프로그램을 작성하세요.

◼ Plane Abstract Class

public abstract class Plane {
	
	/* 필드 */
	private String planeName;
	private int fuelSize;
	
	/* 생성자 */
	public Plane() {}

	public Plane(String planeName, int fuelSize) {
		super();
		this.planeName = planeName;
		this.fuelSize = fuelSize;
	}
	
	/* getter & setter */
	public String getPlaneName() {
		return planeName;
	}

	public void setPlaneName(String planeName) {
		this.planeName = planeName;
	}

	public int getFuelSize() {
		return fuelSize;
	}

	public void setFuelSize(int fuelSize) {
		this.fuelSize = fuelSize;
	}
	
	/* 메소드 */
	public void refuel(int fuel) { // 주유
		fuelSize += fuel;
	}
	
	public abstract void flight(int distance); // 운항


	public void print() { // 출력용
		System.out.println(planeName + "\t\t" + fuelSize);
	}
}

◼ Airplane Class

public class Airplane extends Plane {

	public Airplane() {}
	
	public Airplane(String planeName, int fuelSize) {
		super(planeName, fuelSize);
	}
	
	@Override
	public void flight(int distance) {
		setFuelSize(getFuelSize() - (distance * 3)); 
	}
}

◼ Cargoplane Class

public class Cargoplane extends Plane {

	public Cargoplane() {}
	
	public Cargoplane(String planeName, int fuelSize) {
		super(planeName, fuelSize);
	}
	
	@Override
	public void flight(int distance) {
		setFuelSize(getFuelSize() - (distance * 5)); 
	}
}

◼ PlaneTest Class

public class PlaneTest {

	public static void main(String[] args) {
		
		/* Airplane & Cargoplane 객체 생성 및 인자전달 */
		Plane air = new Airplane("L747", 1000);
		Plane cargo = new Cargoplane("C40", 1000);
		
		/* 객체 정보 출력 */
		System.out.println("Plane\t\tfuelSize");
		System.out.println("--------------------------");
		air.print();
		cargo.print();
		
		/* 100 운항 */
		air.flight(100);
		cargo.flight(100);
		
		System.out.println("100 운항");
		System.out.println("Plane\t\tfuelSize");
		System.out.println("--------------------------");
		air.print();
		cargo.print();
		
		/* 200 주유 */
		air.refuel(200);
		cargo.refuel(200);
		
		System.out.println("200 주유");
		System.out.println("Plane\t\tfuelSize");
		System.out.println("--------------------------");
		air.print();
		cargo.print();
	}
}

💬 Overall Comment

* 내가 좋아하는 파트인 '상속'파트. 하지만 이 문제 또한 호락호락하지않았다. 
  아마도 클래스 다이어그램으로 문제를 접해서인지 몰라도 일단 문제를 올바르게 파악하는데 
  시간이 꽤 소요되었다. 인자를 매개변수로 넘겨주어 각각 서브클래스의 메소드가 호출되게끔 
  해야하는 문항이었다. 이해하는데에 더 오래 걸린 듯하나 만족스러운 코드가 완성된 것 같아 뿌듯하다.

---

Q5 상속과 인터페이스를 활용한 메소드 구현하기

💁‍ Abstract 클래스에서 상속받고 Interface를 구현한 두 개의 클래스를 구현하여 항목 5번의 실행결과가 나오도록 프로그램을 작성하세요.

◼ Bonus Interface

public interface Bonus {

	public void incentive(int pay);
}

◼ Employee Abstract Class

public abstract class Employee {
	
	/* 필드 */
	private String name;
	private int number;
	private String department; // 부서
	protected int salary; // private int salary로 어떻게 풀죠..
	
	/* 생성자 */
	public Employee() {}

	public Employee(String name, int number, String department, int salary) {
		super();
		this.name = name;
		this.number = number;
		this.department = department;
		this.salary = salary;
	}

	/* getter & setter */
	public String getName() {
		return name;
	}

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

	public int getNumber() {
		return number;
	}

	public void setNumber(int number) {
		this.number = number;
	}

	public String getDepartment() {
		return department;
	}

	public void setDepartment(String department) {
		this.department = department;
	}

	public int getSalary() {
		return salary;
	}

	public void setSalary(int salary) {
		this.salary = salary;
	}
	
	/* 메소드 */
	public double tax() { // 세금
		
		return salary * 0.0;
	}
}

◼ Sales Class

public class Sales extends Employee implements Bonus {

	public Sales() {}
	
	public Sales(String name, int number, String department, int salary) {
		super(name, number, department, salary);
	}

	public double tax() { // 세금
		
		return salary * 0.13;
	}
	
	@Override
	public void incentive(int pay) { // 인센티브 지급
		salary += (int) (pay * 1.2);
	}
}

◼ Secretary Class

public class Secretary extends Employee implements Bonus {

	public Secretary() {}
	
	public Secretary(String name, int number, String department, int salary) {
		super(name, number, department, salary);
	}

	public double tax() { // 세금
		
		return salary * 0.1;
	} 
	
	@Override
	public void incentive(int pay) { // 인센티브 지급
		salary += (int) (pay * 0.8);
	}
}

◼ Company Class

public class Company {

	public static void main(String[] args) {
		
		/* 객체 생성 및 배열에 넣기 */
		Employee[] employees = new Employee[2];
		employees[0] = new Secretary("Hilery", 1, "secretary", 800);
		employees[1] = new Sales("Clinten", 2, "sales     ", 1200);
		
		/* 기본 정보 출력 */
		System.out.println("name\t department\tsalary");
		System.out.println("-------------------------------");
		
		for(int i = 0; i < employees.length; i++)
			System.out.println(employees[i].getName() +"\t "+ employees[i].getDepartment() +"\t"+ employees[i].getSalary());

		
		/* 인센티브 100 지급 후 다시 객체의 salary에 넣기 */
		((Secretary)employees[0]).incentive(100);
		((Sales)employees[1]).incentive(100);		
		
		System.out.println();
		System.out.println("인센티브 100 지급");
		System.out.println("name\t department\tsalary\t   tax");
		System.out.println("---------------------------------------");
		
		for(int i = 0; i < employees.length; i++)
			System.out.println(employees[i].getName() +"\t "+ employees[i].getDepartment() +"\t"+ employees[i].getSalary() +"\t "+ employees[i].tax());
	}
}

💬 Overall Comment

* 나의 아픈 손가락인 '배열'이 포함된 상속 파트 문항이었다. 그래도 문제를 계속 풀다보니 
  이해력도 늘어나 곧잘 풀 수 있었다. 하지만 한 가지 애로사항이 있었는데, 각 서브클래스의 
  필드에 salary를 선언하는 것과 아예 수퍼클래스에서 salary를 private가 아닌 protected로 
  설정하는 것. 둘 중에 한 가지를 고려해야만 했다. 그렇지 않고서 서브 클래스들에서 salary를 
  가지고 세금과 인센티브를 계산할 수 없었다. 나는 결국 private가 아닌 protected로 
  변경하는 방안을 선택했는데, 내일 선생님의 해설 코드가 올라오면 꼭 참고하도록 해야겠다. 

---

Q6 ArrayList를 활용한 랜덤 숫자 정렬하여 출력하기

💁‍ java.util.ArrayList 에 값들을 저장하고, 내림차순 정렬된 결과를 출력되게 하세요.

◼ Descending Class

public class Descending implements Comparator<Integer> {

	@Override
	public int compare(Integer o1, Integer o2) {
		int result = 0;
		
		if(o1 > o2) {
			result = -1;
            // 내림차순을 위해 순서를 바꿔야 하는 경우 양수 반환
            
		} else if(o1 < o2) {
			result = 1;
            // 이미 내림차순으로 정렬 되어 있는 경우 음수 반환
            
		} else {
			result = 0;
            // 두 값이 같은 경우 0을 반환
		}
		return result;
	}
}

◼ ListTest Class

public class ListTest {

	public static void main(String[] args) {
		
		List<Integer> list = new ArrayList<>();
		Random random = new Random();
		
		// 명시한 사용 데이터를 list에 기록
		for(int i = 0; i < 10; i++) {
			int randomNum = random.nextInt(100) + 1;
			if(!list.contains(randomNum)) // 중복값 제거
			list.add(randomNum);
		}
		
		// display 메소드 호출
		ListTest dis = new ListTest();
		System.out.print("정렬 전 : ");
		dis.display(list);
		
		// list의 데이터를 내림차순 정렬
		Collections.sort(list, new Descending()); 
		
		// display 메소드 호출
		System.out.print("정렬 후 : ");
		dis.display(list);
	}
	
	public void display(List list) {

		System.out.println(list);
	}
}

💬 Overall Comment

* ArrayList와 random을 사용하여 1~100 중 랜덤 숫자 10개를 추출하는 문항이었는데, 
  배열의 형제 ArrayList가 있으니 꼭 집중해서 풀어야했다. 또한 ArrayList에는 다양한 
  메소드가 있으므로 적절히 사용하여 문제를 풀어야 했고, 정렬 메소드를 호출하여 사용해야했다. 
  문제에는 없었으나 중복값도 제거하고싶어 한참 찾아보던 와중 contains()함수를 사용하여 
  List의 중복값을 제거할 수 있는 방법을 찾아내었다! 신이 나서 코드를 열심히 만들어보고 
  수정하니 만족스러운 결과물이 나온 듯 하여 뿌듯했다 :) 

---

Q7 Properties와 .xml파일을 활용하여 데이터를 저장하고 다시 배열에 기록 및 출력하기

💁‍ java.util.Properties 를 사용하여, data.xml 파일에 데이터를 기록 저장한 다음 파일에 기록된 데이터들을 읽어와서 Fruit[] 에 기록하고 Fruit[]의 값들을 화면에 출력 처리하세요.

◼ Fruit Class

public class Fruit {
	private String name;
	private int price;
	private int quantity;
	
/* 기본 생성자, 모든 매개변수가 있는 생성자 */

/* getter & setter */

/* toString */

◼ PropTest Class

public class PropTest {
	
	public static void main(String[] args) {
		Properties p = new Properties();
		
		//명시한 사용 데이터를 prop 에 기록
		p.setProperty("1", "apple,1200,3");
		p.setProperty("2", "banana,2500,2");
		p.setProperty("3", "grape,4500,5");
		p.setProperty("4", "orange,800,10");
		p.setProperty("5", "melon,5000,2");
		
		// fileSave() 메소드를 호출
		new PropTest().fileSave(p);
		// fileOpen() 메소드를 호출
		new PropTest().fileOpen(p);
		
	}

	// fileSave() 메소드를 구현
	public void fileSave(Properties p) {
		try {
			p.storeToXML(new FileOutputStream("data.xml"), "test");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	// fileOpen() 메소드를 구현
	public void fileOpen(Properties p) {
		try {
			p.loadFromXML(new FileInputStream("data.xml"));
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		// data.xml파일의 키들만 set으로 묶은 것을 Iterator로 하나씩 접근
		Iterator<Object> it = p.keySet().iterator();
		ArrayList<String> keyList = new ArrayList<>();
		
		while(it.hasNext()) { // 값이 있을 때(true)까지 접근하여 keyList에 하나씩 String으로 담기
			keyList.add((String)it.next());
		}
		
		Collections.sort(keyList); // Collections.sort 메소드를 사용 시, list가 정렬된 뒤 해당 상태가 유지
		
		// Fruit 배열에 담아 정렬된 KeyList에서 값을 하나씩 뽑아내고 split, parsing하여 프린트
		Fruit[] arr = new Fruit[p.size()];
		int idx = 0;
		for(String key : keyList) { // "apple,1200,3"
			String[] s =  p.getProperty(key).split(",");
			arr[idx] = new Fruit(s[0], Integer.parseInt(s[1]), Integer.parseInt(s[2]));
			System.out.println(key + " = " + arr[idx].getName() + ", " + 
			      arr[idx].getPrice() +"원, " + arr[idx].getQuantity()+"개");
			idx++;
		}
	}
}

◼ data.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<entry key="1">apple,1200,3</entry>
<entry key="2">banana,2500,2</entry>
<entry key="3">grape,4500,5</entry>
<entry key="4">orange,800,10</entry>
<entry key="5">melon,5000,2</entry>
</properties>

💬 Overall Comment

* 이 문항은 iterator를 사용하여 List에 접근하는 방식으로 풀어내야했으나, 계속 다른 방향성을 
가지고 접근하다보니 문제가 풀리지 않았었다.
Property 파일에서 읽어오는 과정을 보다 더 학습해야겠다고 다짐하게 된 문항이었다.

---

Q8 Map과 SimpleDateFormat을 활용하여 데이터를 저장하고 다시 배열에 기록 및 출력하기

💁‍ java.util.Map 을 사용하여 상품재고 정보를 저장하고 출력되게 하세요. 출력시 날짜 데이터에 대해서는 SimpleDateFormat 을 사용하여 출력 처리하세요.

◼ AmountNotEnough Class

public class AmountNotEnough extends Exception {
	
	public AmountNotEnough() {}

	public AmountNotEnough(String message) {
		super(message);
	}
}

◼ Inventory Class

public class Inventory {

	/* 필드 */
	private String productName;	// 상품명
	private Date putDate;		// 입고일
	private Date getDate;		// 출고일
	private int putAmount;		// 입고수량
	private int getAmount;		// 출고수량
	private int inventoryAmount;// 재고수량
	
	/* 생성자 */
	public Inventory() {}

	public Inventory(String productName, Date putDate, int putAmount) {
		super();
		this.productName = productName;
		this.putDate = putDate;
		this.putAmount = putAmount;
		this.inventoryAmount = putAmount; // 재고수량 임의로 설정
	}

	/* getter & setter */
	public String getProductName() {
		return productName;
	}

	public void setProductName(String productName) {
		this.productName = productName;
	}

	public Date getPutDate() {
		return putDate;
	}

	public void setPutDate(Date putDate) {
		this.putDate = putDate;
	}

	public Date getGetDate() {
		return getDate;
	}

	public void setGetDate(Date getDate) {
		this.getDate = getDate;
	}

	public int getPutAmount() {
		return putAmount;
	}

	public void setPutAmount(int putAmount) {
		this.putAmount = putAmount;
	}

	public int getGetAmount() {
		return getAmount;
	}

	public void setGetAmount(int getAmount) throws AmountNotEnough {
		this.getAmount = getAmount;
		if(inventoryAmount < getAmount) {
			throw new AmountNotEnough("현재 재고가 부족합니다. 재고수량 확인하시기 바랍니다.");
		}
		inventoryAmount -= getAmount;
	}
	

	public int getInventoryAmount() {
		return inventoryAmount;
	}

	public void setInventoryAmount(int inventoryAmount) {
		this.inventoryAmount = inventoryAmount;
	}

	@Override
	public String toString() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy년 M월 d일");
		String putDate = this.putDate == null ? null + ", " : sdf.format(this.putDate) + " 입고, ";
		String getDate = this.getDate == null ? null + ", ": sdf.format(this.getDate) + " 출고, "; 
		
		return productName + ", " + putDate + putAmount + "개, " 
		+ getDate + getAmount +"개, 재고 " + inventoryAmount + "개";
	}
}

◼ MapTest Class

public class MapTest {

	public static void main(String[] args) {
		
		// Generics 적용된 맵 객체를 선언 및 할당
		Map<String, Inventory> map = new HashMap<String, Inventory>();
		
		// 상품명을 키로 사용하여 저장 처리
		map.put("삼성 갤럭시S7", new Inventory("삼성 갤럭시S7", new GregorianCalendar(2016, 3-1, 15).getTime(), 30));
		map.put("LG G5", new Inventory("LG G5", new GregorianCalendar(2016, 2-1, 25).getTime(), 20));
		map.put("애플 아이패드 Pro", new Inventory("애플 아이패드 Pro", new GregorianCalendar(2016, 1-1, 23).getTime(), 15));
		
		Inventory[] inventory = new Inventory[map.size()];
		int i = 0;
		
		// 맵에 기록된 정보를 연속 출력. EntrySet() 사용
		// 맵에 기록된 정보를 Inventory[] 로 변환한 다음,
		for(Entry<String, Inventory> e : map.entrySet()) {
			System.out.println(e.getValue());
			inventory[i++] = e.getValue();
		}
		
		// 출고 날짜를 오늘 날짜로, 출고 수량은 모두 10개로 지정. 예외처리
		// 변경된 Inventory[] 의 정보를 모두 출력
		System.out.println("출고 수량 10 적용시-------------------------------------");
		for(Inventory iv : inventory) {
			
			try {
				iv.setGetDate(new Date());
				iv.setGetAmount(10);
				System.out.println(iv);
			} catch (AmountNotEnough e) {
				System.out.println(e.getMessage());
			}
			
		}
		
		System.out.println("출고수량 부족시-------------------------------------");
		for(Inventory iv : inventory) {
			
			try {
				iv.setGetDate(new Date());
				iv.setGetAmount(25);
				System.out.println(iv);
			} catch (AmountNotEnough e) {
				System.out.println(e.getMessage());
			}
		}
	}
}

💬 Overall Comment

* Map을 올바르게 활용하는 법을 몰라서 처음에 많이 헤맸으나, 레시피를 참고하여 풀어내고 Map을 사용했을 때의 흐름을 어느정도 파악하게 해준 무항이었다. DTO를 구성할 때 유의해야할 부분이 많아 어려웠다.

---

Q9 BufferedReader와 try-with-resource를 활용하여 입출력처리하기

💁‍ Good 클래스를 작성하고, java.io.BufferedReader 를 사용하여 키보드로 입력 받을 스트림을 생성
하고 각 필드에 기록할 값을 입력 받아 객체 초기화에 사용한다.
가격과 수량을 계산하여 구매가격을 출력한다.

◼ Goods Class

public class Goods {

	private String name;
	private int price;
	private int quantity;
	
	public Goods() {}

	public Goods(String name, int price, int quantity) {
		super();
		this.name = name;
		this.price = price;
		this.quantity = quantity;
	}

	public String getName() {
		return name;
	}

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

	public int getPrice() {
		return price;
	}

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

	public int getQuantity() {
		return quantity;
	}

	public void setQuantity(int quantity) {
		this.quantity = quantity;
	}

	@Override
	public String toString() {
		return name + ", " + price + "원, " + quantity + "개 \n총 구매 가격 : " + (price * quantity) + "원";
	}
}

◼ GoodsTest Class

public class GoodsTest {

	public static void main(String[] args) {
		
//		Goods goods = new Goods();
		
		// 입출력 (try-with-resource문)
		try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in));) {
			System.out.println("다음 항목의 값을 입력하시오.");
			System.out.print("상품명 : ");
			String name = br.readLine();
			System.out.print("가격 : ");
			int price = Integer.parseInt(br.readLine());
			System.out.print("수량 : ");
			int quantity = Integer.parseInt(br.readLine());
			
			System.out.println("입력된 결과는 다음과 같습니다.");
			Goods goods = new Goods(name, price, quantity);
			System.out.println(goods.toString());
		
		} catch (IOException e) {
			e.printStackTrace();
		} 
	}
}

💬 Overall Comment

* 입출력은 아직 사용하기에 어려운 점이 많았다. 그래도 열심히 정리하여 포스팅해둔 덕분에 
찾아보면서 코드를 완성할 수 있었다. 이 문항에서는 평소에 정말 자주 사용했던 Scanner가 
아닌 BufferReader의 readLine() 메소드로 콘솔창에 입력을 받아 저장했는데 그저 이론으로 
배웠을 때와는 달리 재밌고 이렇게도 사용될 수 있구나 하며 신기했다. 아직 생소한 부분이 
많지만 계속 사용하다보면 Scanner 처럼 자유자재로 사용할 수 있는 날이 오지않을까한다 :)

---

Q10 ArrayList와 .dat파일을 활용하여 리스트에 데이터를 저장하고 출력하기

💁‍ ArrayList 에 3개의 Book 객체를 생성하여 저장하고, books.dat 파일에 객체를 기록 및 저장하세요. books.dat 에 기록된 객체 정보를 읽어서 각각의 정보와 할인된 가격을 출력하세요.

◼ Book Class

public class Book implements Serializable {
	
	private static final long serialVersionUID = 4973296860562099534L;
	private String title;
	private String author;
	private int price;
	private String publisher;
	private double discountRate;
	
	public Book() {}

	public Book(String title, String author, int price, String publisher, double discountRate) {
		super();
		this.title = title;
		this.author = author;
		this.price = price;
		this.publisher = publisher;
		this.discountRate = discountRate;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getAuthor() {
		return author;
	}

	public void setAuthor(String author) {
		this.author = author;
	}

	public int getPrice() {
		return price;
	}

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

	public String getPublisher() {
		return publisher;
	}

	public void setPublisher(String publisher) {
		this.publisher = publisher;
	}

	public double getDiscountRate() {
		return discountRate;
	}

	public void setDiscountRate(double discountRate) {
		this.discountRate = discountRate;
	}

	@Override
	public String toString() {
		return title + ", " + author + ", " + publisher + ", " + price + "원, " 
				+ (int)(Math.round(discountRate*100)) + "% 할인\n할인된 가격 : " + (int)(price-price*discountRate) + "원";
	}
}

◼ BookListTest Class

public class BookListTest {

	public static void main(String[] args) {
		
		BookListTest test10 = new BookListTest();
		ArrayList<Book> list = new ArrayList<Book>();
		
		/* Book 객체를 3개 생성하여 리스트에 넣기 */
		test10.storeList(list);
		
		/* book.dat 파일에 리스트에 저장된 book 객체들을 저장 */
		test10.saveFile(list);
		
		/* books.dat 파일로부터 객체들을 읽어서 리스트에 담기 */
		List<Book> booksList = test10.loadFile();
		
		// 리스트에 저장된 객체 정보 출력
		test10.printList(booksList);
		
	}
	
	/* Book 객체를 3개 생성하여 리스트에 넣기 */
	public void storeList(List<Book> list) {
		
		list.add(new Book("자바의 정석", "남궁성", 30000, "도우출판", 0.15));
		list.add(new Book("열혈강의 자바", "구정은", 29000, "프리렉", 0.2));
		list.add(new Book("객체지향 JAVA8", "금영욱", 30000, "북스홈", 0.1));
		
	}
	
	/* book.dat 파일에 리스트에 저장된 book 객체들을 저장 */
	public void saveFile(List<Book> list) {
		
		try {
			ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src/ncs/test10/book.dat"));
			
			for(int i = 0; i < list.size(); i++) {
				oos.writeObject(list.get(i));
				}
			
			oos.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	/* books.dat 파일로부터 객체들을 읽어서 리스트에 담기 */
	public List<Book> loadFile() {

		List<Book> booksList = new ArrayList<>();
		
		Book[] book = new Book[3];
		
		try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/ncs/test10/book.dat"))) {
			
			for(int i = 0; i < book.length; i++) {
				book[i] = (Book) ois.readObject();

				booksList.add(book[i]);
			}
			
			ois.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}

		return booksList;
	}

	public void printList(List<Book> booksList) {
		
		for(Book book : booksList) {
			System.out.println(book);
		}		
	}
}

💬 Overall Comment

* 정말 애먹었던 문항 중 하나였다. 입출력과 배열, 그리고 ArrayList까지 합세하니 정말 난항 
그 자체였다. 이번에 푼 모든 입출력 문항들 중 내가 막혔던 부분은 동일했다. 파일을 저장하는 
것까지는 성공했으나, 그 파일에서 읽어와 배열이나 리스트에 저장하는 방식에서 계속 막히니 
시간이 필요 이상으로 소요되었고 진전이 되지 않았다. 이 문항으로 정말 많이 배웠으니, 꼭 
기록뿐 아니라 머릿속에도 기억해서 다른 비슷한 문항에서도 유연하게 사용하고싶다 :( 화이팅!