반응형
챕터1
# 02. 생활 속에서 객체 찾아 클래스로 구현해 보기
## 객체를 찾아 봅시다
- 온라인 쇼핑몰에 회원 로그인을 하고 여러 판매자가 판매하고 있는 제품 중 하나를 골라 주문을 한다
- 아침에 회사에 가는 길에 별다방 커피숍에 들려 아이스 카페라떼를 주문했다
- 성적확인을 위해 학사 관리 시스템에 로그인 하여 수강 한 과목들의 성적을 확인했다
- 학생 클래스
```
public class Student {
int studentNumber;
String studentName;
int majorCode;
String majorName;
int grade;
}
```
- 주문 클래스
```
public class Order {
int orderId;
String buyerId;
String sellerId;
int productId;
String orderDate;
}
```
- 회원 클래스
```
public class UserInfo {
String userId;
String userPassWord;
String userName;
String userAddress;
int phoneNumber;
}
```
챕터2
## 08. 다음 설명에 해당되는 객체를 구현하고 해당 정보를 출력해 보세요
1. 키가 180 이고 몸무게가 78 킬로인 남성이 있습니다. 이름은 Tomas 이고 나이는 37세입니다.
2. 음식점에 배달 주문이 들어왔습니다.
주문 접수 번호 : 202011020003
주문 핸드폰 번호 : 01023450001
주문 집 주소 : 서울시 강남구 역삼동 111-333
주문 날짜 : 20201102
주문 시간 : 130258
주문 가격 : 35000
메뉴 번호 : 0003
package ch08;
public class Person {
public String name;
public int age;
public int height;
public int weight;
public String gender;
public void showPersonInfo() {
System.out.println("키가 " + height + "이고, 몸무게가 " + weight + "킬로인 "+ gender + "이 있습니다.");
System.out.println("이름은 " + name + "이고, 나이는 " + age + "세입니다" );
}
}
package ch08;
public class PersonTest {
public static void main(String[] args) {
Person personT = new Person();
personT.name = "Tomas";
personT.age = 37;
personT.height = 180;
personT.weight = 78;
personT.gender = "남성";
personT.showPersonInfo();
}
}
package ch08;
public class Order {
// Date 나 Calendar 객체를 사용할 줄 알면 시간이나 날짜 대한 값은 해당 객체를 사용하면 됩니다.
// 여기서 숫자에 해당되는 자료형을 String으로 표현한건 0으로 시작될 가능성이 있는 숫자에 해당합니다.
public String orderNumber;
public String customerPhone;
public String customerAddress;
public String orderDate;
public String orderTime;
public int price;
public String menuId;
public void showOrderDetail() {
System.out.println("주문 접수 번호: " + orderNumber);
System.out.println("주문 핸드폰 번호: " + customerPhone);
System.out.println("주문 집 주소: " + customerAddress);
System.out.println("주문 날짜: " + orderDate);
System.out.println("주문 시간: " + orderTime);
System.out.println("주문 가격: " + price);
System.out.println("메뉴 번호: " + menuId);
}
}
package ch08;
public class OrderTest {
public static void main(String[] args) {
Order myOrder = new Order();
myOrder.orderNumber = "202011020003";
myOrder.customerPhone = "01023450001";
myOrder.customerAddress = "서울시 강남구 역삼동 111-333";
myOrder.orderDate = "20201102";
myOrder.orderTime = "130258";
myOrder.price = 35000;
myOrder.menuId = "0003";
myOrder.showOrderDetail();
}
}
# 09. 참조 자료형 변수
## 참조 자료형
- 변수의 자료형
- 클래스형으로 변수를 선언
- 기본 자료형은 사용하는 메모리의 크기가 정해져 있지만, 참조 자료형은 클래스에 따라 다름
- 참조 자료형을 사용 할때는 해당 변수에 대해 생성하여야 함 <br>
(String 클래스는 예외적으로 생성하지 않고 사용할 수 있음)
## 참조 자료형 정의하여 사용하기
- 학생이 수강한 과목들에 대한 성적을 산출하기 위한 경우 학생 클래스 속성에 과목이 모두 있으면 불합리
- 학생(Student)과 과목(Subject)에 대한 클래스를 분리하여 사용하고 Subject 클래스를 활용하여 수강한 과목들의 변수의 타입으로 선언
- 선언된 Subject 변수는 생성된 인스턴스가 아니므로, Student의 생성자에서 생성하여 사용
Student.java
```
package ch09;
public class Student {
int studentID;
String studentName;
Subject korea;
Subject math;
public Student(int id, String name) {
studentID = id;
studentName = name;
korea = new Subject();
math = new Subject();
}
public void setKoreaSubject(String name, int score) {
korea.subjectName = name;
korea.score = score;
}
public void setMathSubject(String name, int score) {
math.subjectName = name;
math.score = score;
}
public void showStudentSocre() {
int total = korea.score + math.score;
System.out.println(studentName + " 학생의 총점은 " + total + "점 입니다." );
}
}
```
Subject.java
```
package ch09;
public class Subject {
String subjectName;
int score;
int subjectID;
}
```
StudentTest.java
```
package ch09;
public class StudentTest {
public static void main(String[] args) {
Student studentLee = new Student(100, "Lee");
studentLee.setKoreaSubject("국어", 100);
studentLee.setMathSubject("수학", 95);
Student studentKim = new Student(101, "Kim");
studentKim.setKoreaSubject("국어", 80);
studentKim.setMathSubject("수학", 99);
studentLee.showStudentSocre();
studentKim.showStudentSocre();
}
}
```
# 14. 버스 타고 학교 가는 학생의 과정을 객체 지향 프로그래밍으로 구현해보기
## 버스와 지하철을 타는 예제 프로그래밍
James와 Tomas는 각각 버스와 지하철을 타고 학교에 갑니다.
James는 5000원을 가지고 있었고, 100번 버스를 타면서 1000원을 지불합니다.
Tomas는 10000원을 가지고 있었고, 초록색 지하철을 타면서 1200원을 지불합니다.
두 학생이 버스와 지하철을 타는 상황을 구현해 봅시다.
Student.java
```
public class Student {
String studentName;
int grade;
int money;
public Student(String studentName, int money) {
this.studentName = studentName;
this.money = money;
}
public void takeBus(Bus bus) {
bus.take(1000);
this.money -= 1000;
}
public void takeSubway(Subway subway) {
subway.take(1200);
this.money -= 1200;
}
public void showInfo() {
System.out.println(studentName +"님의 남은 돈은 " + money + "원 입니다");
}
}
```
Bus.java
```
public class Bus {
int busNumber;
int passengerCount;
int money;
public Bus(int busNumber) {
this.busNumber = busNumber;
}
public void take(int money) { //승차
this.money += money;
passengerCount++;
}
public void showBusInfo() {
System.out.println(busNumber + "번 버스의 승객은 " + passengerCount + "명 이고, 수입은 " + money + "원 입니다");
}
}
```
Subway.java
```
public class Subway {
int lineNumber;
int passengerCount;
int money;
public Subway(int lineNumber) {
this.lineNumber = lineNumber;
}
public void take(int money) {
this.money += money;
passengerCount++;
}
public void showSubwayInfo() {
System.out.println(lineNumber + "번 지하철의 승객은 " + passengerCount + "명 이고, 수입은 " + money + "원 입니다");
}
}
```
TakeTransTest.java
```
public class TakeTransTest {
public static void main(String[] args) {
Student studentJ = new Student("James", 5000);
Student studentT = new Student("Tomas", 10000);
Bus bus100 = new Bus(100);
Subway subwayGreen = new Subway(2);
studentJ.takeBus(bus100);
studentT.takeSubway(subwayGreen);
studentJ.showInfo();
studentT.showInfo();
bus100.showBusInfo();
subwayGreen.showSubwayInfo();
}
}
# 19. 복습해봅시다 (static과 싱클톤 패턴)
## 설명에 따른 객체를 구현하여 테스트 코드가 실행되도록 구현하기
자동차 공장이 있습니다. 자동차 공장은 유일한 객체이고, 이 공장에서 생산되는 자동차는 제작될 때마다 고유의 번호가 부여됩니다.
자동차 번호가 10001부터 시작되어 자동차가 생산될 때마다 10002, 10003 이렇게 번호가 붙도록 자동차 공장 클래스, 자동차 클래스를 구현하세요
다음 CarFactoryTest.java 테스트 코드가 수행 되도록 합니다.
package ch19;
public class Car {
private static int serialNum = 10000;
private int carNum;
public Car() {
serialNum++;
carNum = serialNum;
}
public int getCarNum() {
return carNum;
}
public void setCarNum(int carNum) {
this.carNum = carNum;
}
}
package ch19;
public class CarFactory {
private static CarFactory instance = new CarFactory();
private CarFactory() {}
public static CarFactory getInstance() {
if(instance == null) {
instance = new CarFactory();
}
return instance;
}
public Car createCar() {
Car car = new Car();
return car;
}
}
CarFactoryTest.java
```
public class CarFactoryTest {
public static void main(String[] args) {
CarFactory factory = CarFactory.getInstance();
Car mySonata = factory.createCar();
Car yourSonata = factory.createCar();
System.out.println(mySonata.getCarNum()); //10001 출력
System.out.println(yourSonata.getCarNum()); //10002 출력
}
}
```
챕터2
# 24. ArrayList를 활용한 간단한 성적 산출 프로그램
## 예제 시나리오
1001학번 Lee와 1002학번 Kim, 두 학생이 있습니다.
Lee 학생은 국어와 수학 2과목을 수강했고, Kim 학생은 국어, 수학, 영어 3 과목을 수강하였습니다.
Lee 학생은 국어 100점, 수학 50점입니다.
Kim 학생은 국어 70점, 수학 85점, 영어 100점입니다.
Student와 Subject 클래스를 만들고 ArrayList를 활용하여 두 학생의 과목 성적과 총점을 출력하세요
## Student 클래스
```
import java.util.ArrayList;
public class Student {
int studentID;
String studentName;
ArrayList<Subject> subjectList;
public Student(int studentID, String studentName){
this.studentID = studentID;
this.studentName = studentName;
subjectList = new ArrayList<Subject>();
}
public void addSubject(String name, int score){
Subject subject = new Subject();
subject.setName(name);
subject.setScorePoint(score);
subjectList.add(subject);
}
public void showStudentInfo()
{
int total = 0;
for(Subject s : subjectList){
total += s.getScorePoint();
System.out.println("학생 " + studentName + "의 " + s.getName() + " 과목 성적은 " +
s.getScorePoint() + "입니다.");
}
System.out.println("학생 " + studentName + "의 총점은 " + total + " 입니다.");
}
}
```
## Subject 클래스
```
public class Subject {
private String name;
private int scorePoint;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScorePoint() {
return scorePoint;
}
public void setScorePoint(int scorePoint) {
this.scorePoint = scorePoint;
}
}
```
## 실행하기
```
public class StudentTest {
public static void main(String[] args) {
Student studentLee = new Student(1001, "Lee");
studentLee.addSubject("국어", 100);
studentLee.addSubject("수학", 50);
Student studentKim = new Student(1002, "Kim");
studentKim.addSubject("국어", 70);
studentKim.addSubject("수학", 85);
studentKim.addSubject("영어", 100);
studentLee.showStudentInfo();
System.out.println("======================================");
studentKim.showStudentInfo();
}
}
챕터3
# 02. 상속을 활용한 멤버십 클래스 구현하기
## 멤버십 시나리오
회사에서 고객 정보를 활용한 맞춤 서비스를 하기 위해 일반고객(Customer)과
이보다 충성도가 높은 우수고객(VIPCustomer)에 따른 서비스를 제공하고자 함
물품을 구매 할때 적용되는 할인율과 적립되는 보너스 포인트의 비율이 다름
여러 멤버십에 대한 각각 다양한 서비스를 제공할 수 있음
멤버십에 대한 구현을 클래스 상속을 활용하여 구현해보기
## 일반 고객(Customer) 클래스 구현
- 고객의 속성 : 고객 아이디, 고객 이름, 고객 등급, 보너스 포인트, 보너스 포인트 적립비율
- 일반 고객의 경우 물품 구매시 1%의 보너스 포인트 적립
## 우수 고객(VIPCustomer) 구현
매출에 더 많은 기여를 하는 단골 고객
제품을 살때 10%를 할인해 줌
보너스 포인트는 제품 가격의 5%를 적립해 줌
담당 전문 상담원이 배정됨
- Customer 클래스에 추가해서 구현하는 것은 좋지 않음
- VIPCustomer 클래스를 따로 구현
- 이미 Customer에 구현된 내용이 중복되므로 Customer를 확장하여 구현함(상속)
## protected 접근 제어자
- 상위 클래스에 선언된 private 멤버 변수는 하위 클래스에서 접근 할 수 없음
- 외부 클래스는 접근 할 수 없지만, 하위 클래스는 접근 할 수 있도록 protected 접근 제어자를 사용```
package ch01;
public class Customer {
private int customerID;
private String customerName;
private String customerGrade;
int bonusPoint;
double bonusRatio;
public Customer() {
customerGrade = "SILVER";
bonusRatio = 0.01;
}
public int calcPrice(int price) {
bonusPoint += price * bonusRatio;
return price;
}
public String showCustomerInfo() {
return customerName + "님의 등급은 " + customerGrade +
"이며, 보너스 포인트는" + bonusPoint + "입니다";
}
}
```
```
public class VIPCustomer extends Customer{
private int agentID;
double salesRatio;
public VIPCustomer() {
customerGrade = "VIP"; //오류 발생
bonusRatio = 0.05;
salesRatio = 0.1;
}
public int getAgentID() {
return agentID;
}
}
```
Customer.java
```
protected int customerID;
protected String customerName;
protected String customerGrade;
//getter, setter 구현
...
public int getCustomerID() {
return customerID;
}
public void setCustomerID(int customerID) {
this.customerID = customerID;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
public String getCustomerGrade() {
return customerGrade;
}
public void setCustomerGrade(String customerGrade) {
this.customerGrade = customerGrade;
}
```
## Customer와 VIPCustomer 테스트하기
```
public class CustomerTest {
public static void main(String[] args) {
Customer customerLee = new Customer();
customerLee.setCustomerName("이순신");
customerLee.setCustomerID(10010);
customerLee.bonusPoint = 1000;
System.out.println(customerLee.showCustomerInfo());
VIPCustomer customerKim = new VIPCustomer();
customerKim.setCustomerName("김유신");
customerKim.setCustomerID(10020);
customerKim.bonusPoint = 10000;
System.out.println(customerKim.showCustomerInfo());
}
}
```
## 다음 강의
[03. 상속에서 클래스 생성 과정과 형 변환](https://gitlab.com/easyspubjava/javacoursework/-/blob/master/Chapter3/3-03/README.md)
# 09. 추상 클래스(abstract class) 구현하기
Computer.java
```
public abstract class Computer {
abstract void display();
abstract void typing();
public void turnOn() {
System.out.println("전원을 켭니다.");
}
public void turnOff() {
System.out.println("전원을 끕니다.");
}
}
```
DeskTop.java
```
public class DeskTop extends Computer{
@Override
void display() {
System.out.println("DeskTop display");
}
@Override
void typing() {
System.out.println("DeskTop typing");
}
@Override
public void turnOff() {
System.out.println("Desktop turnoff");
}
}
```
NoteBook.java
```
public abstract class NoteBook extends Computer{
@Override
public void typing() {
System.out.println("NoteBook typing");
}
}
```
MyNoteBook.java
```
public class MyNoteBook extends NoteBook{
@Override
void display() {
System.out.println("MyNoteBook display");
}
}
```
ComputerTest.java
```
public class ComputerTest {
public static void main(String[] args) {
Computer computer = new DeskTop();
computer.display();
computer.turnOff();
NoteBook myNote = new MyNoteBook();
}
}
```
# 10. 추상 클래스의 응용 - 템플릿 메서드 패턴
Car.java
```
public abstract class Car {
public abstract void drive();
public abstract void stop();
public void startCar() {
System.out.println("시동을 켭니다.");
}
public void turnOff() {
System.out.println("시동을 끕니다.");
}
final public void run() {
startCar();
drive();
stop();
turnOff();
}
}
```
ManualCar.java
```
public class ManualCar extends Car{
@Override
public void drive() {
System.out.println("사람이 운전합니다.");
System.out.println("사람이 핸들을 조작합니다.");
}
@Override
public void stop() {
System.out.println("브레이크를 밟아서 정지합니다.");
}
}
```
AICar.java
```
public class AICar extends Car{
@Override
public void drive() {
System.out.println("자율 주행합니다.");
System.out.println("자동차가 스스로 방향을 바꿉니다.");
}
@Override
public void stop() {
System.out.println("스스로 멈춥니다.");
}
}
```
CarTest.java
```
public class CarTest {
public static void main(String[] args) {
Car aiCar = new AICar();
aiCar.run();
System.out.println("=================");
Car manualCar = new ManualCar();
manualCar.run();
}
}
```
## 15. 클래스 상속과 인터페이스 구현 함께 쓰기
- 책이 순서대로 대여가 되는 도서관 구현
- 책을 보관하는 자료 구조가 Shelf에 구현됨 (ArrayList)
- Queue 인터페이스를 구현함
- Shelf 클래스를 상속 받고 Queue를 구현한다.
Shelf.java
```
public class Shelf {
protected ArrayList<String> shelf;
public Shelf() {
shelf = new ArrayList<String>();
}
public ArrayList<String> getShelf(){
return shelf;
}
public int getCount() {
return shelf.size();
}
}
```
Queue.java
```
public interface Queue {
void enQueue(String title);
String deQueue();
int getSize();
}
```
BookShelf.java
```
public class BookShelf extends Shelf implements Queue{
@Override
public void enQueue(String title) {
shelf.add(title);
}
@Override
public String deQueue() {
return shelf.remove(0);
}
@Override
public int getSize() {
return getCount();
}
}
```
BookShelfTest.java
```
public class BookShelfTest {
public static void main(String[] args) {
Queue bookQueue = new BookShelf();
bookQueue.enQueue("태백산맥1");
bookQueue.enQueue("태백산맥2");
bookQueue.enQueue("태백산맥3");
System.out.println(bookQueue.deQueue());
System.out.println(bookQueue.deQueue());
System.out.println(bookQueue.deQueue());
}
}
```
# 16. 복습해보세요
## 추상 클래스와 템플릿 메서드
Player가 있고 Player는 GameLevel 속성을 가집니다. 각 GameLevel 단계 마다 run(), jump(), turn() 세 가지 기능이 업그레이드 됩니다.
초보자 레벨 : 천천히 달립니다. run() 만 가능
중급자 레벨 : 빠르게 달리고, 점프할 수 있습니다. run(), jump() 가능
고급자 레벨 : 엄청 빠르게 달리고, 높게 점프하고, 턴할 수 있습니다. run(), jump(), turn() 가능
Player는 한번에 하나의 레벨 상태만을 가질 수 있습니다.
Player가 play() 중에 레벨에 있는 go(int count) 라는 메서드를 호출하면 run() 하고 count 횟수 만큼 jump() 하고 turn() 합니다. 다음 클래스 다이어그램을 참고하여 각 레벨에서 go() 가 호출 될때 다음과 같이 출력 되도록 하세요
## 인터페이스를 활용한 정책 프로그래밍
고객 센터에 전화 상담을 하는 상담원들이 있습니다. 일단 고객에게서 전화가 오면 대기열에 저장되고 각 상담원에게 배분이 됩니다.
배분이 되는 정책은 크게 세 가지가 있습니다.
1. 모든 상담원이 동일한 상담 건수를 처리하도록 상담원 순서대로 배분합니다.
2. 쉬고 있거나 상담원에게 할당된 통화 수가 가장 적은 상담원에게 배분합니다.
3. 고객의 등급에 따라 등급이 높은 고객은 업무능력이 우수한 상담원에게 배분합니다.
세 가지 정책은 필요에 따라 바뀌어 운영될 수 있습니다. 다음 클래스 다이어그램을 참고하여 각 배분 규칙이 적용되도록 구현해 보세요
테스트 프로그램은 다음과 같습니다. 문자를 입력 받아 입력되는 문자에 따라 배분 규칙을 수행하도록 합니다.
```
public class SchedulerTest {
public static void main(String[] args) throws IOException {
System.out.println("전화 상담원 할당 방식을 선택하세요");
System.out.println("R : 한명씩 차례대로");
System.out.println("L : 대기가 적은 상담원 우선");
System.out.println("P : 우선순위가 높은 고객우선 숙련도 높은 상담원");
int ch = System.in.read();
Scheduler scheduler = null;
if ( ch == 'R' || ch =='r') {
scheduler = new RoundRobin();
}
else if ( ch == 'L' || ch =='l') {
scheduler = new LeastJob();
}
else if ( ch == 'P' || ch =='p') {
scheduler = new PriorityAllocation();
}
else {
System.out.println("지원되지 않는 기능입니다.");
return;
}
scheduler.getNextCall();
scheduler.sendCallToAgent();
}
}
```
챕터4
# 04. Class 클래스 사용하기
## Class 클래스
- 자바의 모든 클래스와 인터페이스는 컴파일 후 class 파일이 생성됨
- Class 클래스는 컴파일 된 class 파일을 로드하여 객체를 동적 로드하고, 정보를 가져오는 메서드가 제공됨
- Class.forName("클래스 이름") 메서드로 클래스를 동적으로 로드 함
```
Class c = Class.forName("java.lang.String");
```
- 클래스 이름으로 직접 Class 클래스 가져오기
```
Class c = String.class;
```
- 생성된 인스턴스에서 Class 클래스 가져오기
```
String s = new String();
Class c = s.getClass(); //Object 메서드
```
## 동적 로딩
- 컴파일 시에 데이터 타입이 binding 되는 것이 아닌, 실행(runtime) 중에 데이터 타입을 binding 하는 방법
- 프로그래밍 시에는 문자열 변수로 처리했다가 런타임시에 원하는 클래스를 로딩하여 binding 할 수 있다는 장점
- 컴파일 시에 타입이 정해지지 않으므로 동적 로딩시 오류가 발생하면 프로그램의 심각한 장애가 발생가능
## Class의 newInstance()메서드로 인스턴스 생성
- new 키워드를 사용하지 않고 클래스 정보를 활용하여 인스턴스를 생성할 수 있음
## 클래스 정보 알아보기
- reflection 프로그래밍 : Class 클래스를 사용하여 클래스의 정보(생성자, 변수, 메서드)등을 알 수 있고 인스턴스를 생성하고,
메서드를 호출하는 방식의 프로그래밍
- 로컬 메모리에 객체 없는 경우, 원격 프로그래밍, 객체의 타입을 알 수 없는 경우에 사용
- java.lang.reflect 패키지에 있는 클래스를 활용하여 프로그래밍
- 일반적으로 자료형을 알고 있는 경우엔 사용하지 않음
StringTest.java
```
public class StringTest {
public static void main(String[] args) throws ClassNotFoundException {
Class c3 = Class.forName("java.lang.String");
Constructor<String>[] cons = c3.getConstructors();
for(Constructor con: cons) {
System.out.println(con);
}
System.out.println();
Method[] methods = c3.getMethods();
for(Method method : methods) {
System.out.println(method);
}
}
}
```
Person.java
```
public class Person {
private String name;
private int age;
public Person() {};
public Person(String name) {
this.name = name;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return name;
}
}
```
ClassTest.java
```
public class ClassTest {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException,
ClassNotFoundException, NoSuchMethodException, SecurityException {
Person person = new Person("James");
System.out.println(person);
Class c1 = Class.forName("ch04.Person");
Person person1 = (Person)c1.newInstance();
System.out.println(person1);
Class[] parameterTypes = {String.class};
Constructor cons = c1.getConstructor(parameterTypes);
Object[] initargs = {"김유신"};
Person personLee = (Person)cons.newInstance(initargs);
System.out.println(personLee);
}
}
```
챕터6
# 04. 객체지향 프로그래밍 vs. 람다식 구현
## 객체 지향 프로그래밍과 람다식 비교
- 문자열 두 개를 연결하여 출력하는 예제를 두 가지 방식으로 구현해 보자
- 인터페이스 선언
```
public interface StringConcat {
public void makeString(String s1, String s2);
}
```
- 객체 지향 프로그래밍으로 구현하기
인터페이스를 구현한 클래스 만들기
```
public class StringConCatImpl implements StringConcat{
@Override
public void makeString(String s1, String s2) {
System.out.println( s1 + "," + s2 );
}
}
```
클래스를 생성하고 메서드 호출하기
```
public class TestStringConcat {
public static void main(String[] args) {
String s1 = "Hello";
String s2 = "World";
StringConCatImpl concat1 = new StringConCatImpl();
concat1.makeString(s1, s2);
}
}
```
- 람다식으로 구현하기
```
StringConcat concat2 = (s, v)->System.out.println(s + "," + v ); //System.out.println(i);
concat2.makeString(s1, s2);
```
## 익명 객체를 생성하는 람다식
- 자바에서는 객체 없이 메서드가 호출 될 수 없음
- 람다식을 구현하면 익명 내부 클래스가 만들어지고, 이를 통해 익명 객체가 생성됨
```
StringConcat concat3 = new StringConcat() {
@Override
public void makeString(String s1, String s2) {
System.out.println( s1 + "," + s2 );
}
};
concat3.makeString(s1, s2);
```
- 익명 내부 클래스에서와 마찬가지로 람다식 내부에서 에서도 외부에 있는 지역 변수의 값을 변경하면 오류가 발생함
## 함수를 변수처럼 사용하는 람다식
변수는...
특정 자료형으로 변수를 선언 한 후 값을 대입함 int a = 10;
매개 변수로 전달하여 사용함 int add(int x, int y)
메서드의 반환 값으로 반환 하기 return num;
- 인터페이스형 변수에 람다식 대입하기
함수형 인터페이스
```
interface PrintString{
void showString(String str);
}
```
```
PrintString lambdaStr = s->System.out.println(s); //람다식을 변수에 대입
lambdaStr.showString("hello lambda_1");
```
- 매개변수로 전달하는 람다식
```
showMyString(lambdaStr);
public static void showMyString(PrintString p) {
p.showString("hello lambda_2");
}
```
- 반환 값으로 쓰이는 람다식
```
public static PrintString returnString() { //반환 값으로 사용
return s->System.out.println(s + "world");
}
PrintString reStr = returnString();
reStr.showString("hello ");
```
# 05. 스트림(Stream)
## 스트림 이란?
- 자료의 대상과 관계없이 동일한 연산을 수행
배열, 컬렉션을 대상으로 연산을 수행 함
일관성 있는 연산으로 자료의 처리를 쉽고 간단하게 함
자료 처리에 대한 추상화가 구현되었다고 함
- 한번 생성하고 사용한 스트림은 재사용 할 수 없음
자료에 대한 스트림을 생성하여 연산을 수행하면 스트림은 소모됨
다른 연산을 수행하기 위해서는 스트림을 다시 생성해야 함
- 스트림 연산은 기존 자료를 변경하지 않음
자료에 대한 스트림을 생성하면 스트림이 사용하는 메모리 공간은 별도로 생성되므로 연산이 수행되도 기존 자료에 대한 변경은 발생하지 않음
- 스트림 연산은 중간 연산과 최종 연산으로 구분 됨
스트림에 대해 중간 연산은 여러 개의 연산이 적용될 수 있지만 최종 연산은 마지막에 한 번만 적용됨
최종연산이 호출되어야 중간 연산에 대한 수행이 이루어 지고 그 결과가 만들어짐
따라서 중간 연산에 대한 결과를 연산 중에 알수 없음
이를 '지연 연산'이라 함
## 스트림 생성하고 사용하기
- 정수 배열에 스트림 생성하여 연산을 수행 하는 예
```
public class IntArrayTest {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
int sumVal = Arrays.stream(arr).sum();
long count = Arrays.stream(arr).count();
System.out.println(sumVal);
System.out.println(count);
}
}
```
## 중간 연산과 최종 연산
- 중간 연산의 예 - filter(), map(), sorted() 등
조건에 맞는 요소를 추출(filter)하거나 요소를 변환 함(map)
- 최종 연산이 호출될 때 중간 연산이 수행되고 결과가 생성 됨
- 문자열 리스트에서 문자열의 길이가 5 이상인 요소만 출력하기
```
sList.stream().filter(s->s.length() >= 5).forEach(s->System.out.println(s));
```
filter()는 중간 연산이고, forEach()는 최종 연산임
- 고객 클래스 배열에서 고객 이름만 가져오기
```
customerList.stream().map(c->c.getName()).forEach(s->System.out.println(s));
```
map()은 중간 연산이고, forEach()는 최종 연산임
- 중간 연산과 최종 연산에 대한 구현은 람다식을 활용함
- 최종 연산의 예 - forEach(), count(), sum() 등
스트림이 관리하는 자료를 하나씩 소모해가며 연산이 수행 됨
최종 연산 후에 스트림은 더 이상 다른 연산을 적용할 수 없음
forEach() : 요소를 하나씩 꺼내 옴
count() : 요소의 개수
sum() : 요소들의 합
## ArrayList 객체에 스트림 생성하고 사용하기
- ArrayList에 문자열 자료(이름)을 넣고 이에 대한 여러 연산을 수행해보기
```
public class ArrayListStreamTest {
public static void main(String[] args) {
List<String> sList = new ArrayList<String>();
sList.add("Tomas");
sList.add("Edward");
sList.add("Jack");
Stream<String> stream = sList.stream();
stream.forEach(s->System.out.print(s + " "));
System.out.println();
sList.stream().sorted().forEach(s->System.out.print(s+ " "));
sList.stream().map(s->s.length()).forEach(n->System.out.println(n));
sList.stream().filter(s->s.length() >= 5).forEach(s->System.out.println(s));
}
}
```
- 새로운 연산을 수행하기 위해서는 기존의 스트림은 재사용할 수 없고 stream()메서드를 호출하여 스트림을 다시 생성해야 함
- 정수 자료에 대한 여러 가지 연산 예
```
public class IntArrayStreamTest {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
Arrays.stream(arr).forEach(n->System.out.print(n + "\t"));
System.out.println();
int sum = Arrays.stream(arr).sum();
System.out.println("sum: " + sum);
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
int sum2 = list.stream().mapToInt(n->n.intValue()).sum();
System.out.println(sum2);
}
}
```# 06. 연산 수행에 대한 구현을 할 수 있는 reduce()연산
## reduce() 연산
- 정의된 연산이 아닌 프로그래머가 직접 구현한 연산을 적용
```
T reduce(T identify, BinaryOperator<T> accumulator)
```
- 최종 연산으로 스트림의 요소를 소모하며 연산을 수행
- 배열의 모든 요소의 합을 구하는 reduce() 연산 구현 예
```
Arrays.stream(arr).reduce(0, (a,b)->a+b));
```
- reduce() 메서드의 두 번째 요소로 전달되는 람다식에 따라 다양한 기능을 수행 할 수 있음
- 람다식을 직접 구현하거나 람다식이 긴 경우 BinaryOperator를 구현한 클래스를 사용 함
## BinaryOperator를 구현하여 배열에 여러 문자열이 있을 때 길이가 가장 긴 문자열 찾기 예
```
class CompareString implements BinaryOperator<String>{
@Override
public String apply(String s1, String s2) {
if (s1.getBytes().length >= s2.getBytes().length) return s1;
else return s2;
}
}
public class ReduceTest {
public static void main(String[] args) {
String[] greetings = {"안녕하세요~~~", "hello", "Good morning", "반갑습니다^^"};
System.out.println(Arrays.stream(greetings).reduce("", (s1, s2)->
{if (s1.getBytes().length >= s2.getBytes().length)
return s1;
else return s2;}));
String str = Arrays.stream(greetings).reduce(new CompareString()).get(); //BinaryOperator를 구현한 클래스 이용
System.out.println(str);
}
}
```
# 07. 스트림을 활용하여 패키지 여행 비용 계산하기
## 문제 정의
여행사에 패키지 여행 상품이 있습니다. 여행 비용은 15세 이상은 100만원, 그 미만은 50만원 입니다.
고객 세 명이 패키지 여행을 떠난다고 했을 때 비용 계산과 고객 명단 검색등에 대한 연산을 스트림을 활용하여 구현해 봅니다.
고객에 대한 클래스를 만들고 ArrayList로 고객을 관리 합니다.
고객 정보는 다음과 같습니다.
CustomerLee
이름 : 이순신
나이 : 40
비용 : 100
CustomerKim
이름 : 김유신
나이 : 20
비용 : 100
CustomerHong
이름 : 홍길동
나이 :13
비용 : 50
## 스트림을 활용한 연산 수행
1. 고객의 명단을 출력합니다.
2. 여행의 총 비용을 계산합니다.
3. 고객 중 20세 이상인 사람의 이름을 정렬하여 출력합니다.
```
public class TravelCustomer {
private String name; //이름
private int age; //나이
private int price; //가격
public TravelCustomer(String name, int age, int price) {
this.name = name;
this.age = age;
this.price = price;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public int getPrice() {
return price;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setPrice(int price) {
this.price = price;
}
public String toString() {
return "name: " + name + "age: " + age + "price: " + price;
}
}
```
```
public class TravelTest {
public static void main(String[] args) {
TravelCustomer customerLee = new TravelCustomer("이순신", 40, 100);
TravelCustomer customerKim = new TravelCustomer("김유신", 20, 100);
TravelCustomer customerHong = new TravelCustomer("홍길동", 13, 50);
List<TravelCustomer> customerList = new ArrayList<>();
customerList.add(customerLee);
customerList.add(customerKim);
customerList.add(customerHong);
System.out.println("== 고객 명단 추가된 순서대로 출력 ==");
customerList.stream().map(c->c.getName()).forEach(s->System.out.println(s));
int total = customerList.stream().mapToInt(c->c.getPrice()).sum();
System.out.println("총 여행 비용은 :" + total + "입니다");
System.out.println("== 20세 이상 고객 명단 정렬하여 출력 ==");
customerList.stream().filter(c->c.getAge() >= 20).map(c->c.getName()).sorted().forEach(s->System.out.println(s));
}
}
```
# 10. 사용자 정의 예외 클래스와 그 활용
## 사용자 정의 예외 클래스 구현하기
- 자바에서 제공되는 예외 클래스외에 프로그래머가 직접 만들어야 하는 예외가 있을 수 있음
- 기존 예외 클래스중 가장 유사한 예외 클래스에서 상속 받아 사용자 정의 예외 클래스를 만든다.
- 기본적으로 Exception 클래스를 상속해서 만들 수 있음
## 패스워드에 대한 예외 처리 하기
- 패스워드를 입력할 때 다음과 같은 경우 오류처리를 합니다.
비밀번호는 null일 수 없습니다.
비밀번호의 길이는 5이상입니다.
비밀번호는 문자로만 이루어져서는 안됩니다.(하나이상의 숫자나 특수문자를 포함)
```
public class PasswordException extends IllegalArgumentException{
public PasswordException(String message) {
super(message);
}
}
```
```
public class PasswordTest {
private String password;
public String getPassword(){
return password;
}
public void setPassword(String password) throws PasswordException{
if(password == null){
throw new PasswordException("비밀번호는 null 일 수 없습니다");
}
else if( password.length() < 5){
throw new PasswordException("비밀번호는 5자 이상이어야 합니다.");
}
else if (password.matches("[a-zA-Z]+")){
throw new PasswordException("비밀번호는 숫자나 특수문자를 포함해야 합니다.");
}
this.password = password;
}
public static void main(String[] args) {
PasswordTest test = new PasswordTest();
String password = null;
try {
test.setPassword(password);
System.out.println("오류 없음1");
} catch (PasswordException e) {
System.out.println(e.getMessage());
}
password = "abcd";
try {
test.setPassword(password);
System.out.println("오류 없음2");
} catch (PasswordException e) {
System.out.println(e.getMessage());
}
password = "abcde";
try {
test.setPassword(password);
System.out.println("오류 없음3");
} catch (PasswordException e) {
System.out.println(e.getMessage());
}
password = "abcde#1";
try {
test.setPassword(password);
System.out.println("오류 없음4");
} catch (PasswordException e) {
System.out.println(e.getMessage());
}
}
}
```
챕터7
# 7. 인터페이스를 활용한 학점 산출 프로그램 만들기
## 문제 정의
- Good School 학교가 있습니다. 이 학교에는 5명의 학생들이 수업을 듣습니다. 과목은 국어와 수학이 있고, 각 학생은 두 과목을 모두 수강합니다.
전공은 컴퓨터공학과 국어국문학 두 가지가 있습니다. 컴퓨터공학과 학생은 수학이 필수과목이고, 국어국문학과 학생은 국어가 필수 과목입니다.
각 학생별로 한 개의 전공을 선택합니다.
이번 학기 각 학생의 성적은 다음과 같습니다.
| 이름 | 학번 | 전공 | 필수 과목 | 국어 점수 | 수학 점수 |
| ------ | ------ | ------ | ------ | ------ | ------ |
| 강감찬 | 211213 | 국어국문학과 | 국어 | 95 | 56 |
| 김유신 | 212330 | 컴퓨터공학과 | 수학 | 95 | 98 |
| 신사임당 | 201518 | 국어국문학과 | 국어 | 100 | 88 |
| 이순신 | 202360 | 국어국문학과 | 국어 | 89 | 95 |
| 홍길동 | 201290 | 컴퓨터공학과 | 수학 | 83 | 56 |
- 학점을 부여하는 방벅은 여러 가지가 있습니다. 단순히 A,B,C,D,F를 부여하는 방법, A+, B-처럼 +/-를 사용하는 방법, Pass/Fail 만을 부여하는 방법등이 있습니다.
여기 각 학생에게 학점을 부여하는 데 사용하는 정책은 두 가지입니다. 일반 과목이라면 A ~ F로, 필수 과목이라면 S ~ F 로 분류합니다. 점수에 따른 학점 부여기준은
다음과 같습니다
- 필수 과목 학점 기준
| S | A | B | C | D | F |
| ------ | ------ | ------ | ------ | ------ | ------ |
| 95~100점 | 90~94점 | 80~89점 | 70~79점 | 60~69점 | 60점 미만 |
- 일반 과목 학점 기준
| A | B | C | D | F |
| ------ | ------ | ------ | ------ | ------ |
| 90~100점 | 80~89점 | 70~79점 | 55~69점 | 55점 미만 |
만약 똑같이 95점을 받은 경우, 필수 과목이라면 S를 받지만, 일반 과목은 A를 받습니다. 또한 56점을 받으면 필수 과목은 F이지만, 일반 과목은 D를 받습니다.
- 프로그램 구현 과제
위와 같이 주어진 성적과 각 과목에 대한 학점 정책에 따라 아래와 같이 학점 결과가 나올 수 있도록 구현합니다.
학점의 정책이 추가되는 경우와 과목이 추가되는 경우를 고려하여 객체를 설계하고 학점 정책에 대해서는 인터페이스를 선언하고 각 정책이 해당 인터페이스를 구현하도록 합니다.
국어 과목 결과
수학 과목 결과
## 클래스 정의 하고 관계도 그리기
Student.java
```
public class Student {
private int studentId; //학번
private String studentName; //이름
private Subject majorSubject; //중점 과목
//학생의 성적 리스트
//addSubjectSocre() 메서드가 호출되면 리스트에 추가 됨
private ArrayList<Score> scoreList = new ArrayList<Score>();
public Student( int studentId, String studentName, Subject majorSubject){
this.studentId = studentId;
this.studentName = studentName;
this.majorSubject = majorSubject;
}
public void addSubjectScore(Score score){
scoreList.add(score);
}
public int getStudentId() {
return studentId;
}
public void setStudentId(int studentId) {
this.studentId = studentId;
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
}
public Subject getMajorSubject() {
return majorSubject;
}
public void setMajorSubject(Subject majorSubject) {
this.majorSubject = majorSubject;
}
public ArrayList<Score> getScoreList(){
return scoreList;
}
public void setScoreList(ArrayList<Score> scoreList) {
this.scoreList = scoreList;
}
}
```
Subject.java
```
public class Subject {
private String subjectName; //과목 이름
private int subjectId; // 과목 고유번호
private int gradeType; // 과목 평가 방법 기본은 A,B 방식
//수강 신청한 학생 리스트
//register() 메서드를 호출하면 리스트에 추가 됨
private ArrayList<Student> studentList = new ArrayList<Student>();
public Subject(String subjectName, int subjectId){
this.subjectName = subjectName;
this.subjectId = subjectId;
this.gradeType = Define.AB_TYPE; //기본적으로 A, B 타입
}
public String getSubjectName() {
return subjectName;
}
public void setSubjectName(String subjectName) {
this.subjectName = subjectName;
}
public int getSubjectId() {
return subjectId;
}
public void setSubjectId(int subjectId) {
this.subjectId = subjectId;
}
public ArrayList<Student> getStudentList() {
return studentList;
}
public void setStudentList(ArrayList<Student> studentList) {
this.studentList = studentList;
}
public int getGradeType() {
return gradeType;
}
public void setGradeType(int gradeType) {
this.gradeType = gradeType;
}
public void register(Student student){ //수강신청
studentList.add(student);
}
}
```
Score.java
```
public class Score {
int studentId; //학번
Subject subject; //과목
int point; //점수
public Score( int studentId, Subject subject, int point){
this.studentId = studentId;
this.subject = subject;
this.point = point;
}
public int getStudentId() {
return studentId;
}
public void setStudentId(int studentId) {
this.studentId = studentId;
}
public Subject getSubject() {
return subject;
}
public void setSubject(Subject subject) {
this.subject = subject;
}
public int getPoint() {
return point;
}
public void setPoint(int point) {
this.point = point;
}
public String toString(){
return "학번:" + studentId + "," + subject.getSubjectName() + ":" + point;
}
}
```
Define.java
```
public class Define {
public static final int KOREAN = 1001; //국어
public static final int MATH = 2001; //수학
public static final int AB_TYPE = 0; // A, B, C
public static final int SAB_TYPE = 1; // S, A, B, c
public static final int PF_TYPE = 2; // P, F
}
```
## 학점 평가 정책 설계하고 구현하기
- 인터페이스 정의하기
점수에 따른 학점의 정책은 여러가지가 있을 수 있습니다. 인터페이스를 먼저 선언하고, 각 정책 클래스가 이를 구현하도록 합니다
GradeEvaluation.java
```
public interface GradeEvaluation {
public String getGrade(int point);
}
```
일반 과목 학점에 대한 클래스 구현
BasicEvaluation.java
```
public class BasicEvaluation implements GradeEvaluation{
@Override
public String getGrade(int point) {
String grade;
if(point >=90 && point <=100)
grade = "A";
else if(point >=80 && point <=89)
grade = "B";
else if(point >=70 && point <=79)
grade = "C";
else if(point >=55 && point <=69)
grade = "D";
else
grade = "F";
return grade;
}
}
```
필수 과목 학점에 대한 클래스 구현
MajorEvaluation.java
```
public class MajorEvaluation implements GradeEvaluation{
@Override
public String getGrade(int point) {
String grade;
if(point >=95 && point <=100)
grade = "S";
else if(point >=90 && point <=94)
grade = new String("A");
else if(point >=80 && point <=89)
grade = "B";
else if(point >=70 && point <=79)
grade = "C";
else if(point >=60 && point <=69)
grade = "D";
else
grade = "F";
return grade;
}
}
```
## 리포트 클래스
- 학점 평가에 대한 클래스들을 인스턴스화 하고 이에 대한 배열을 만들어 각 과목에 점수를 산정할 때 필수 과목인지 일반 과목인지에 따라 각 정책 클래스가 학점을 평가할 수 있도록 구현 합니다.
- 전반적인 리포트의 생성은 header부분, 본문 부분, tail 부분으로 구성합니다.
- StringBuffer 클래스를 이용하여 모든 리포트의 내용을 만들고 난후 toString()을 호출 하여 String 클래스로 반환합니다.
GenerateGradeReport.java
```
public class GenerateGradeReport {
School school = School.getInstance();
public static final String TITLE = " 수강생 학점 \t\t\n";
public static final String HEADER = " 이름 | 학번 |중점과목| 점수 \n";
public static final String LINE = "-------------------------------------\n";
private StringBuffer buffer = new StringBuffer();
public String getReport(){
ArrayList<Subject> subjectList = school.getSubjectList(); // 모든 과목에 대한 학점 산출
for( Subject subject : subjectList) {
makeHeader(subject);
makeBody(subject);
makeFooter();
}
return buffer.toString(); // String 으로 반환
}
public void makeHeader(Subject subject){
buffer.append(GenerateGradeReport.LINE);
buffer.append("\t" + subject.getSubjectName());
buffer.append(GenerateGradeReport.TITLE );
buffer.append(GenerateGradeReport.HEADER );
buffer.append(GenerateGradeReport.LINE);
}
public void makeBody(Subject subject){
ArrayList<Student> studentList = subject.getStudentList(); // 각 과목의 학생들
for(int i=0; i<studentList.size(); i++){
Student student = studentList.get(i);
buffer.append(student.getStudentName());
buffer.append(" | ");
buffer.append(student.getStudentId());
buffer.append(" | ");
buffer.append(student.getMajorSubject().getSubjectName() + "\t");
buffer.append(" | ");
getScoreGrade(student, subject.getSubjectId()); //학생별 해당과목 학점 계산
buffer.append("\n");
buffer.append(LINE);
}
}
public void getScoreGrade(Student student, int subjectId){
ArrayList<Score> scoreList = student.getScoreList();
int majorId = student.getMajorSubject().getSubjectId();
GradeEvaluation[] gradeEvaluation = {new BasicEvaluation(), new MajorEvaluation()}; //학점 평가 클래스들
for(int i=0; i<scoreList.size(); i++){ // 학생이 가진 점수들
Score score = scoreList.get(i);
if(score.getSubject().getSubjectId() == subjectId) { // 현재 학점을 산출할 과목
String grade;
if(score.getSubject().getSubjectId() == majorId) // 중점 과목인 경우
grade = gradeEvaluation[Define.SAB_TYPE].getGrade(score.getPoint()); //중점 과목 학점 평가 방법
else
grade = gradeEvaluation[Define.AB_TYPE].getGrade(score.getPoint()); // 중점 과목이 아닌 경우
buffer.append(score.getPoint());
buffer.append(":");
buffer.append(grade);
buffer.append(" | ");
}
}
}
public void makeFooter(){
buffer.append("\n");
}
}
```
## 프로그램 테스트 하기
- 주어진 테이터에 기반하여 Student, Subject, Score 객체를 직접 만들어 각 과목에 따른 학점의 결과가 잘 출력되는지 확인 합니다.
- 모든 학생과 과목을 관리하는 School 맥체를 만듭니다.
School.java
```
public class School {
private static School instance = new School();
private static String SCHOOL_NAME = "Good School";
private ArrayList<Student> studentList = new ArrayList<Student>();
private ArrayList<Subject> subjectList = new ArrayList<Subject>();
private School(){}
public static School getInstance(){
if(instance == null)
instance = new School();
return instance;
}
public ArrayList<Student> getStudentList(){
return studentList;
}
public void addStudent(Student student){
studentList.add(student);
}
public void addSubject(Subject subject) {
subjectList.add(subject);
}
public ArrayList<Subject> getSubjectList() {
return subjectList;
}
public void setSubjectList(ArrayList<Subject> subjectList) {
this.subjectList = subjectList;
}
}
```
TestMain.java
```
public class TestMain {
School goodSchool = School.getInstance();
Subject korean;
Subject math;
GenerateGradeReport gradeReport = new GenerateGradeReport();
public static void main(String[] args) {
TestMain test = new TestMain();
test.creatSubject();
test.createStudent();
String report = test.gradeReport.getReport(); //성적 결과 생성
System.out.println(report); // 출력
}
//테스트 과목 생성
public void creatSubject(){
korean = new Subject("국어", Define.KOREAN);
math = new Subject("수학", Define.MATH);
goodSchool.addSubject(korean);
goodSchool.addSubject(math);
}
//테스트 학생 생성
public void createStudent(){
Student student1 = new Student(211213, "강감찬", korean );
Student student2 = new Student(212330, "김유신", math );
Student student3 = new Student(201518, "신사임당", korean );
Student student4 = new Student(202360, "이순신", korean );
Student student5 = new Student(201290, "홍길동", math );
goodSchool.addStudent(student1);
goodSchool.addStudent(student2);
goodSchool.addStudent(student3);
goodSchool.addStudent(student4);
goodSchool.addStudent(student5);
korean.register(student1);
korean.register(student2);
korean.register(student3);
korean.register(student4);
korean.register(student5);
math.register(student1);
math.register(student2);
math.register(student3);
math.register(student4);
math.register(student5);
addScoreForStudent(student1, korean, 95);
addScoreForStudent(student1, math, 56);
addScoreForStudent(student2, korean, 95);
addScoreForStudent(student2, math, 95);
addScoreForStudent(student3, korean, 100);
addScoreForStudent(student3, math, 88);
addScoreForStudent(student4, korean, 89);
addScoreForStudent(student4, math, 95);
addScoreForStudent(student5, korean, 85);
addScoreForStudent(student5, math, 56);
}
//과목별 성적 입력
public void addScoreForStudent(Student student, Subject subject, int point){
Score score = new Score(student.getStudentId(), subject, point);
student.addSubjectScore(score);
}
}
```
## 프로그램 업그레이드 하기
- 과목과 학점 정책이 추가되는 경우
방송댄스 과목이 새로 개설되고 이 과목의 학점 평가 정책은 pass/fail 로 정해졌다고 합니다. 70점 이상인 경우는 pass, 미만인 경우는 fail입니다.
전체 5명 학생중 3명만이 이 과목을 수강신청 했습니다. 추가된 요구사항이 잘 반영되도록 구현하세요
- 상수값 추가하기
Define.java
```
public class Define {
public static final int KOREAN = 1001; //국어
public static final int MATH = 2001; //수학
public static final int DANCE = 3001; //방송댄스
public static final int AB_TYPE = 0; // A, B, C
public static final int SAB_TYPE = 1; // S, A, B, c
public static final int PF_TYPE = 2; // P, F
}
```
- GradeEvaluation 인터페이스를 구현한 Pass/Fail BasicEvaluation
PassFailEvaluation
```
public class PassFailEvaluation implements GradeEvaluation{
@Override
public String getGrade(int point) {
if (point >= 70)
return "P";
else
return "F";
}
}
```
- 리포트 클래스 추가할 부분
학점 평가 정책 인스턴스 배열에 새로 추가한 정책에 대한 인스턴스를 추가합니다.
또한 Subject에 대한 학점 정책이 PF_TYPE인 경우만 해당 클래스가 적용되도록 합니다.
GenerateGradeReport
```
...
public void getScoreGrade(Student student, Subject subject){
ArrayList<Score> scoreList = student.getScoreList();
int majorId = student.getMajorSubject().getSubjectId();
GradeEvaluation[] gradeEvaluation = {new BasicEvaluation(), new MajorEvaluation(), new PassFailEvaluation()}; //학점 평가 클래스들
for(int i=0; i<scoreList.size(); i++){ // 학생이 가진 점수들
Score score = scoreList.get(i);
if(score.getSubject().getSubjectId() == subject.getSubjectId()) { // 현재 학점을 산출할 과목
String grade;
if(subject.getGradeType() == Define.PF_TYPE) {
grade = gradeEvaluation[Define.PF_TYPE].getGrade(score.getPoint());
}
else {
if(score.getSubject().getSubjectId() == majorId) // 중점 과목인 경우
grade = gradeEvaluation[Define.SAB_TYPE].getGrade(score.getPoint());//중점 과목 학점 평가 방법
else
grade = gradeEvaluation[Define.AB_TYPE].getGrade(score.getPoint()); // 중점 과목이 아닌 경우
}
buffer.append(score.getPoint());
buffer.append(":");
buffer.append(grade);
buffer.append(" | ");
}
}
}
```
- 테스트 클래스에 문제의 셋을 추가하여 학점을 출력해 봅니다.
TestMain.java
```
public class TestMain {
School goodSchool = School.getInstance();
Subject korean;
Subject math;
Subject dance;
GenerateGradeReport gradeReport = new GenerateGradeReport();
public static void main(String[] args) {
TestMain test = new TestMain();
test.creatSubject();
test.createStudent();
String report = test.gradeReport.getReport(); //성적 결과 생성
System.out.println(report); // 출력
}
//테스트 과목 생성
public void creatSubject(){
korean = new Subject("국어", Define.KOREAN);
math = new Subject("수학", Define.MATH);
dance = new Subject("방송댄스", Define.DANCE);
dance.setGradeType(Define.PF_TYPE);
goodSchool.addSubject(korean);
goodSchool.addSubject(math);
goodSchool.addSubject(dance);
}
//테스트 학생 생성
public void createStudent(){
Student student1 = new Student(211213, "강감찬", korean );
Student student2 = new Student(212330, "김유신", math );
Student student3 = new Student(201518, "신사임당", korean );
Student student4 = new Student(202360, "이순신", korean );
Student student5 = new Student(201290, "홍길동", math );
goodSchool.addStudent(student1);
goodSchool.addStudent(student2);
goodSchool.addStudent(student3);
goodSchool.addStudent(student4);
goodSchool.addStudent(student5);
korean.register(student1);
korean.register(student2);
korean.register(student3);
korean.register(student4);
korean.register(student5);
math.register(student1);
math.register(student2);
math.register(student3);
math.register(student4);
math.register(student5);
//세 명만 등록
dance.register(student1);
dance.register(student2);
dance.register(student3);
addScoreForStudent(student1, korean, 95);
addScoreForStudent(student1, math, 56);
addScoreForStudent(student2, korean, 95);
addScoreForStudent(student2, math, 95);
addScoreForStudent(student3, korean, 100);
addScoreForStudent(student3, math, 88);
addScoreForStudent(student4, korean, 89);
addScoreForStudent(student4, math, 95);
addScoreForStudent(student5, korean, 85);
addScoreForStudent(student5, math, 56);
addScoreForStudent(student1, dance, 95);
addScoreForStudent(student2, dance, 85);
addScoreForStudent(student3, dance, 55);
}
//과목별 성적 입력
public void addScoreForStudent(Student student, Subject subject, int point){
Score score = new Score(student.getStudentId(), subject, point);
student.addSubjectScore(score);
}
}
```
반응형
'Server Programming > BackEnd Project' 카테고리의 다른 글
| 14일차 - TIL (0) | 2022.12.26 |
|---|---|
| 13일차 - TIL (0) | 2022.12.25 |
| 12일차 - 자바 (3) 연산자 (+ Short-circuit) (0) | 2022.12.23 |
| 12일차 - TIL (0) | 2022.12.23 |
| 11일차 - TIL (0) | 2022.12.22 |
