package student;
import java.util.Scanner;
public interface Program {
// 1.학생등록| 2.학생리스트출력| 3.학생검색(학생정보, 수강정보)|
// 4.학생정보수정| 5.학생삭제| 6.수강신청| 7.수강철회| 8.종료
void insertStudent(Scanner scan);
void printStudent();
// 학생을 검색 후 해당 번지를 리턴
int searchStudent(Scanner scan);
void modifyStudent(Scanner scan);
void deleteStudent(Scanner scan);
void registerSubject(Scanner scan);
void deleteSubject(Scanner scan);
}
▣ Student
package student;
public class Student {
/* 한 학생이 가져야하는 정보
* 학번, 이름, 나이, 전화번호, 주소, 수강과목
* 멤버변수 / 생성자 / getter / setter / toString(학생정보출력)
* 수강신청 / 수강철회 / 수강과목 출력
*/
private String stdNum;
private String stdName;
private int stdAge;
private String stdPhone;
private String stdAddress;
private Subject[] subjectList = new Subject[5];
private int cnt; // 배열의 index 역할
// 생성자
public Student() {}
public Student(String stdNum, String stdName, String stdPhone) {
this.stdNum = stdNum;
this.stdName = stdName;
this.stdPhone = stdPhone;
}
public Student(String stdNum, String stdName, int stdAge, String stdPhone, String stdAddress) {
this.stdNum = stdNum;
this.stdName = stdName;
this.stdAge = stdAge;
this.stdPhone = stdPhone;
this.stdAddress = stdAddress;
}
// method
// 학생정보 출력 메서드(toString 이용가능)
public void stdPrint() {
System.out.println("학생명:" + stdName + "(" + stdNum + ") / " + stdPhone);
}
// 수강과목을 출력 메서드 => 배열로 존재 (for)
public void subPrint() {
if(cnt==0) {
System.out.println("수강과목이 없습니다.");
return;
}
for(int i = 0; i < cnt; i ++) {
System.out.println(subjectList[i]); // toString 호출
}
}
// 수강신청 메서드 : subjectList subject 객체를 생성하여 추가
// 수강과목 객체를 매개변수로 받아서 추가
public void insertSubject(Subject sub) {
// 배열이 다 찼다면.. 배열 늘려주기
if(cnt == subjectList.length) {
Subject[] tmp = new Subject[subjectList.length + 5];
// 배열복사
System.arraycopy(subjectList, 0, tmp, 0, cnt);
subjectList = tmp;
}
subjectList[cnt] = sub;
cnt++;
}
// 수강삭제 메서드
// 수강코드 값을 매개변수로 받아서 삭제
public void removeSubject(String subCode) {
// 삭제할 콛의 위치값을 저장하는 변수
int index = -1;
if(subCode == null){
return;
}
// 삭제할 코드의 위치 값 찾기
for(int i = 0; i < cnt; i++) {
if(subjectList[i].getSubCode().equals(subCode)) {
index = i;
break;
}
}
if(index == -1) {
System.out.println("찾는 과목이 없습니다.");
return;
}
// 삭제 : 찾은 위치부터 뒷번지를 앞번지로 옮기는 작업
for(int i = index; i < cnt - 1; i++) {
subjectList[i] = subjectList[i+1];
}
// 끝번지는 null처리
subjectList[cnt - 1] = null;
cnt--;
}
// getter / setter
public String getStdNum() {
return stdNum;
}
public void setStdNum(String stdNum) {
this.stdNum = stdNum;
}
public String getStdName() {
return stdName;
}
public void setStdName(String stdName) {
this.stdName = stdName;
}
public int getStdAge() {
return stdAge;
}
public void setStdAge(int stdAge) {
this.stdAge = stdAge;
}
public String getStdPhone() {
return stdPhone;
}
public void setStdPhone(String stdPhone) {
this.stdPhone = stdPhone;
}
public String getStdAddress() {
return stdAddress;
}
public void setStdAddress(String stdAddress) {
this.stdAddress = stdAddress;
}
public Subject[] getSubjectList() {
return subjectList;
}
public void setSubjectList(Subject[] subjectList) {
this.subjectList = subjectList;
}
public int getCnt() {
return cnt;
}
public void setCnt(int cnt) {
this.cnt = cnt;
}
@Override
public String toString() {
return "Student [stdNum=" + stdNum + ", stdName=" + stdName + ", stdPhone=" + stdPhone + "]";
}
}
▣ StudentController
package student;
import java.util.Scanner;
public class StudentController implements Program {
// 멤버변수 추가 : Student 배열을 멤버변수로 추가
private Student[] studentList = new Student[5];
private int stdCnt = 0;
@Override
public void insertStudent(Scanner scan) {
// 학생 추가 : 1명의 정보를 받아 Student 객체로 생성 후 배열에 추가
System.out.println("학번>");
String stdNum = scan.next();
System.out.println("이름>");
String stdName = scan.next();
System.out.println("전화번호>");
String stdPhone = scan.next();
Student s = new Student(stdNum, stdName, stdPhone);
// 만약 배열이 다차서 저장할 공간이 없을 경우
if(stdCnt == studentList.length) {
Student[] tmp = new Student[studentList.length+5];
System.arraycopy(studentList, 0, tmp, 0, stdCnt);
studentList = tmp;
}
studentList[stdCnt] = s;
stdCnt++;
}
@Override
public void printStudent() {
// 학생 배열 출력
System.out.println("--전체 학생정보--");
for(int i = 0; i < stdCnt; i++) {
// System.out.println(studentList[i]); // toString
studentList[i].stdPrint(); // 메서드 호출
}
}
@Override
// 해당 학번의 index 리턴
public int searchStudent(Scanner scan) {
// 학생검색 - 학번을 기준
// 학번을 입력받아 배열에서 탐색 후 학생정보 + 수강정보 출력
// 없으면 없다고 출력
System.out.println("학번>");
String searchNum = scan.next();
for(int i = 0; i < stdCnt; i++) {
if(searchNum.equals(studentList[i].getStdNum())) {
studentList[i].stdPrint();
studentList[i].subPrint();
return i;
}
}
System.out.println("검색할 학번이 없습니다.");
return -1;
}
@Override
public void modifyStudent(Scanner scan) {
// 학생정보 수정
int index = searchStudent(scan);
if(index != -1) {
System.out.println("이름>");
String name = scan.next();
System.out.println("전화번호>");
String phone = scan.next();
studentList[index].setStdName(name);
studentList[index].setStdPhone(phone);
}
}
@Override
public void deleteStudent(Scanner scan) {
// 학생정보 삭제
int index = searchStudent(scan);
if(index != -1) {
int copyCnt =studentList.length - index - 1;
System.arraycopy(studentList, index+1, studentList, index, copyCnt);
// 마지막 번지 null 처리
studentList[studentList.length-1] = null;
}
}
@Override
public void registerSubject(Scanner scan) {
// 수강과목의 정보를 입력받아 subject 객체를 생성하여 Student 클래스의 개인 추가 메서드 호출
// 누가 어떤 과목을 수강할지를 받아야 함.
// 수강신청 학번을 먼저 검색 후 추가
int index = searchStudent(scan);
System.out.println("------------");
System.out.println("과목코드>");
String subCode = scan.next();
System.out.println("과목이름>");
String subName = scan.next();
// 객체 생성 후 메서드 호출
Subject sub = new Subject(subCode, subName);
studentList[index].insertSubject(sub);
}
@Override
public void deleteSubject(Scanner scan) {
// 삭제할 수강코드를 입력받아 Student 클래스의 강의 삭제 메서드를 호출
int index = searchStudent(scan);
// 수강 과목이 없다면 받지 않기
if(studentList[index].getCnt() != 0) {
System.out.println("------------");
System.out.println("과목코드>");
String subCode = scan.next();
studentList[index].removeSubject(subCode);
System.out.println(subCode + "과목 수강철회를 하였습니다.");
}
}
public Student[] getStudentList() {
return studentList;
}
public void setStudentList(Student[] studentList) {
this.studentList = studentList;
}
}
▣ StudentMain
package student;
import java.util.Scanner;
public class StudentMain {
public static void main(String[] args) {
// 메뉴처리
// 1. 학생등록 | 2. 학생리스트출력 | 3. 학생검색(학생정보, 수강정보)
// 4. 학생정보수정 | 5.학생삭제 |
// 6. 수강신청 | 7. 수강철회 | 8. 종료
/* interface
* 7개의 메뉴의 메서드 정리
* StudentController가 구현
* - Student class 배열처리
* - Student class : 학생정보
* - 학번, 이름, 나이, 전화번호, 주소, 수강과목s(Subject class를 배열로 처리) - 포함관계
* - Subject class : 과목 정보
* - 과목코드, 과목명, 학점, 시수, 교수명, 시간표, 강의장
*/
StudentController sc = new StudentController();
Scanner scan = new Scanner(System.in);
//호출
sc.insertStudent(scan);
int menu = 0;
do {
System.out.println("--menu--");
System.out.println("1. 학생등록 | 2. 학생리스트출력 | 3. 학생검색(학생정보, 수강정보) | 4. 학생정보수정 | 5.학생삭제 |");
System.out.println("6. 수강신청 | 7. 수강철회 | 8. 종료");
menu = scan.nextInt();
switch(menu) {
case 1: sc.insertStudent(scan); break;
case 2: sc.printStudent(); break;
case 3: sc.searchStudent(scan); break;
case 4: sc.modifyStudent(scan); break;
case 5: sc.deleteStudent(scan); break;
case 6: sc.registerSubject(scan); break;
case 7: sc.deleteSubject(scan); break;
case 8: System.out.println("종료!!"); break;
default : System.out.println("없는 메뉴입니다.");
}
}while(menu != 8);
scan.close();
}
}
▣ Subject
package student;
public class Subject {
/* 과목 정보 : 과목코드, 과목명, 학점, 시수, 교수명, 시간표, 강의장
* 멤버변수 / 생성자 / getter / setter / toString(과목정보출력)
*/
private String subCode;
private String subName;
private int subPoint;
private int subTime;
private String subProfessor;
private String subScheduler;
private String subRoom;
// 생성자
public Subject() {};
// 과목코드 / 과목명만 받는 생성자
public Subject(String subCode, String subName) {
this.subCode = subCode;
this.subName = subName;
}
public Subject(String subCode, String subName, int subPoint, int subTime, String subProfessor, String subScheduler,
String subRoom) {
super();
this.subCode = subCode;
this.subName = subName;
this.subPoint = subPoint;
this.subTime = subTime;
this.subProfessor = subProfessor;
this.subScheduler = subScheduler;
this.subRoom = subRoom;
}
public String getSubCode() {
return subCode;
}
public void setSubCode(String subCode) {
this.subCode = subCode;
}
public String getSubName() {
return subName;
}
public void setSubName(String subName) {
this.subName = subName;
}
public int getSubPoint() {
return subPoint;
}
public void setSubPoint(int subPoint) {
this.subPoint = subPoint;
}
public int getSubTime() {
return subTime;
}
public void setSubTime(int subTime) {
this.subTime = subTime;
}
public String getSubProfessor() {
return subProfessor;
}
public void setSubProfessor(String subProfessor) {
this.subProfessor = subProfessor;
}
public String getSubScheduler() {
return subScheduler;
}
public void setSubScheduler(String subScheduler) {
this.subScheduler = subScheduler;
}
public String getSubRoom() {
return subRoom;
}
public void setSubRoom(String subRoom) {
this.subRoom = subRoom;
}
@Override
public String toString() {
return "Subject [subCode=" + subCode + ", subName=" + subName + ", subPoint=" + subPoint + ", subTime="
+ subTime + ", subProfessor=" + subProfessor + ", subScheduler=" + subScheduler + ", subRoom=" + subRoom
+ "]";
}
}
▷ 출력
출력 (1)
2. Lotto
▣ Lotto
package lotto;
import java.util.Arrays;
// Math.random() 같은 효과
import java.util.Random;
public class Lotto {
// 나도 쓰지만 상속 해줘야 함.
protected int numbers[] = new int[6]; // 사용자 번호 + 당첨번호 같이 사용하는 배열
protected int st; // 회차
// 유지보수를 편리하게 하기 위해
protected int random() {
return new Random().nextInt(45)+1;
}
// 1. 랜덤번호 6개를 numbers[]에 채우는 메서드 (중복제거)
protected void randomLotto() {
// 배열초기화
init();
int cnt = 0;
while(cnt < numbers.length) {
int r = random();
if(!isContain(r)) {
numbers[cnt] = r;
cnt++;
}
}
}
// 2. 중복제거 메서드. 중복이 있으면 true / false (범위 체크도 같이)
protected boolean isContain(int num) {
if(num < 0 || num > 45) {
// 오류발생
throw new RuntimeException("숫자의 범위는 1 ~ 45까지 입니다.");
}
for(int tmp : numbers) {
if(tmp == num) {
return true;
}
}
return false;
}
// 3. 배열초기화
protected void init() {
numbers = new int[6]; // 기존 배열 버리고 새배열로 추가
}
// 4. 번호 수동생성
// (수동 생성된 번호(이미 중복제거 확인 후 넘어오는 배열)를 numbers[]에 배열복사)
protected void insertNumbers(int arr[]) {
if(arr.length > numbers.length) { // 7자리는 허용
throw new RuntimeException("배열의 길이가 옳지 않습니다.");
}
// 만약 7자리의 값을 가져오면 마지막 1자리를 버리겠다.
System.arraycopy(arr, 0, numbers, 0, numbers.length);
}
// 5. 번호확인메서드 => toString()
@Override
public String toString() {
return st + "회차 " + Arrays.toString(numbers);
}
public int[] getNumbers() {
return numbers;
}
public void setNumbers(int[] numbers) {
this.numbers = numbers;
}
public int getSt() {
return st;
}
public void setSt(int st) {
this.st = st;
}
}
▣ LottoController
package lotto;
import java.util.Scanner;
public class LottoController{
// 당첨번호는 여러 개 배열로 저장
private LottoExtend lotto[] = new LottoExtend[5];
private int lCount = 0;
// 사용자 번호는 1개
private Lotto user = new Lotto();
private int st = 0; // 회차 값
public void createLotto(Scanner scan) {
// 수동 로또번호 입력
System.out.println("로또번호입력(중복X, 1 ~ 45, 숫자 6개) >");
int tmp[] = new int[6];
for(int i = 0; i < tmp.length; i++) {
tmp[i] = scan.nextInt();
}
if(isDuplicated(tmp)) {
System.out.println("오류발생. 다시 입력하세요");
}else {
user.insertNumbers(tmp);
user.st = this.st+1;
System.out.println(user);
}
}
// 수동으로 입력되는 로또번호의 중복체크, 범위체크
public boolean isDuplicated(int arr[]) {
// 중복확인
for(int i = 0; i < arr.length; i++) {
for(int j=i+1; j<arr.length; j++) {
if(arr[i] == arr[j]) {
return true;
}
}
}
// 범위확인
for(int i = 0; i < arr.length; i++) {
if(arr[i] < 0 || arr[i] > 45) {
return true;
}
}
return false;
}
public void createLottoAuto() {
// 자동 로또번호 입력
user.randomLotto();
user.st = this.st+1;
System.out.println(user);
}
public void insertLotto(Scanner scan) {
// 당첨번호 수동생성
System.out.println("당첨번호입력(중복X, 1 ~ 45, 숫자 7개) >");
int tmp[] = new int[6];
for(int i = 0; i < tmp.length; i++) {
tmp[i] = scan.nextInt();
}
int bonus = scan.nextInt();
if(isDuplicated(tmp)) {
System.out.println("오류발생. 다시 입력하세요");
}else {
LottoExtend tmpLotto = new LottoExtend();
tmpLotto.insertNumbers(tmp, bonus);
this.st++;
tmpLotto.st = st;
lotto[lCount] = tmpLotto;
lCount++;
System.out.println(tmpLotto);
}
}
public void checkLotto() {
// 당첨확인
// 다른 풀이과정
// 사용자 번호와 가장 마지막 당첨번호를 확인하여 등수를 출력
if(user.isContain(0)) { // 모든 값이 다 채워지지 않았거나 하나도 채워지지 않을 경우
System.out.println("체크할 번호가 없습니다.");
return;
}
if(lCount == 0) {
System.out.println("당첨번호가 없습니다.");
return;
}
int cnt = 0;
// 가장 마지막 당첨번호 저장
LottoExtend tmp = lotto[lCount-1];
// 회차 일치여부 확인
if(tmp.getSt() != user.getSt()) {
System.out.println("회차가 맞지 않습니다!!");
return;
}
// for문으로 일치하는 개수 확인
for(int i = 0; i < user.getNumbers().length; i++) {
int num = tmp.getNumbers()[i];
if(user.isContain(num)) {
cnt++;
}
}
int rank = -1;
switch(cnt) {
case 6: rank = 1; break;
case 5: rank = user.isContain(tmp.getBonus()) ? 2 : 3; break;
case 4: rank = 4; break;
case 3: rank = 5; break;
default:
System.out.println("꽝");
}
if(rank != -1) {
System.out.println(rank + "등 당첨");
}
// 내 풀이과정
// int cnt = 0;
//
// for(int i = 0; i < user.numbers.length; i++) {
// for(int userNum : user.numbers) {
// if(userNum == lotto[lCount-1].numbers[i]) {
// cnt++;
// }
// }
// }
//
// System.out.println(lotto[lCount-1].toString());
// switch(cnt) {
// case 6:
// System.out.println("1등");
// break;
// case 5:
// if(checkBonus(user.numbers, lotto[lCount-1].getBonus())) {
// System.out.println("2등");
// break;
// }else {
// System.out.println("3등");
// break;
// }
// case 4:
// System.out.println("4등");
// break;
// case 3:
// System.out.println("5등");
// break;
// default:
// System.out.println("꽝");
// break;
// }
}
// public boolean checkBonus(int arr[], int num) {
// for(int i = 0; i < arr.length; i++) {
// if(arr[i] == num) {
// return true;
// }
// }
// return false;
// }
public void printLotto() {
// 역대 당첨번호 리스트 확인
System.out.println("--당첨번호리스트--");
for(int i =0; i < lCount; i++) {
System.out.println(lotto[i]);
}
}
}
▣ LottoExtend
package lotto;
public class LottoExtend extends Lotto{
// Lotto 클래스를 상속받아서 보너스 처리만 하면 됨.
private int bonus; // 보너스 번호만 있으면 됨.
@Override
protected void randomLotto() {
// 기존 numbers 6자리 배열 채우기는 이미 완성
// 기존 번호에 중복없이 보너스 번호 생성
super.randomLotto();
while(true) {
int r = random();
if(!isContain(r)) {
bonus = r;
break;
}
}
}
@Override
protected void init() {
// 배열 초기화
super.init(); // numbers 배열을 새로만들어 놓은 상태
bonus = 0;
}
@Override
protected void insertNumbers(int[] arr) {
// 가져온 번호가 7자리일 경우...
super.insertNumbers(arr); // 6자리만 넣기
this.bonus = arr[numbers.length-1]; // 6번지 채우기 나머지는 버리기
}
protected void insertNumbers(int[] arr, int bonus) {
// 가져온 번호가 6자리, 보너스를 별도로 가져오는 경우...
super.insertNumbers(arr);
this.bonus = bonus;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return super.toString()+"["+bonus+"]";
}
public int getBonus() {
return bonus;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
}
▣ LottoMain
package lotto;
import java.util.Scanner;
public class LottoMain {
public static void main(String[] args) {
// 로또 프로그램
/* --menu--
* 1. 로또 번호 생성(수동) : 사용자가 직접 번호 입력
* 2. 로또 번호 생성 (자동) : Random
* 3. 당첨번호 입력(수동) : 사용자가 직접 입력
* 4. 당첨확인 : 가장 마지막에 발행한 당첨번호로 확인
* 5. 역대 당첨번호 목록 확인
* 6. 종료
*
* 로또는 상속을 하여 사용
* Lotto class => 사용자의 번호를 저장하는 클래스
* 회차 : 첫 발행부터 자동 증가 1회차
* 회차, 6자리 배열을 넣는 메서드 (중복X), 출력
* 1회차 1 2 3 4 5 6
*
* LottoExtend class => Lotto를 상속 + 보너스번호
* 1회차 1 2 3 4 5 6 [7]
* LottoController => 처리
*/
Scanner scan = new Scanner(System.in);
LottoController lc = new LottoController();
int menu = 0;
do {
System.out.println("--menu--");
System.out.println("1. 로또 번호 생성(수동) | 2. 로또 번호 생성(자동) |");
System.out.println("3. 당첨번호 입력(수동) | 4. 당첨확인 |");
System.out.println("5. 역대 당첨번호 목록 확인 | 6. 종료");
System.out.println("menu >");
menu = scan.nextInt();
switch(menu) {
case 1: lc.createLotto(scan); break;
case 2: lc.createLottoAuto(); break;
case 3: lc.insertLotto(scan); break;
case 4: lc.checkLotto(); break;
case 5: lc.printLotto(); break;
case 6: System.out.println("종료합니다."); break;
default: System.out.println("없는 메뉴입니다.");
}
}while(menu != 6);
scan.close();
}
}
