DTO
package student.dto;
// DTO(Data Transfer Object) : 값 전달용 객체
// -> 객체를 이용해서 여러 값을 묶어
// 한번에 전달하는 용도
public class StudentDTO {
private String studentNumber; // 학번
private String name; // 이름
private char gender; // 성별
private int html;
private int css;
private int js;
private int java;
// 기본 생성자 X
// - 생성자가 하나도 없을 경우
// -> 컴파일러가 기본 생성자 추가
// - 생성자가 하나 이상 존재할 경우
// -> 컴파일러가 기본 생성자 추가 안함!!
// 매개 변수 생성자
// -> 컴파일러가 기본 생성자를 만들지 않기 때문에
// 필요하면 기본 생성자를 필수 작성!!!!
public StudentDTO(String studentNumber, String name, char gender) {
this.studentNumber = studentNumber;
this.name = name;
this.gender = gender; // 왜 이렇게 했는지 나중에 물어보기
}
// 점수 담는 용도로 격체 생성할때 사용하는 생성자
public StudentDTO(int html, int css, int js, int java) {
super();
this.html = html;
this.css = css;
this.js = js;
this.java = java;
}
public String getStudentNumber() {
return studentNumber;
}
public void setStudentNumber(String studentNumber) {
this.studentNumber = studentNumber;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public int getHtml() {
return html;
}
public void setHtml(int html) {
this.html = html;
}
public int getCss() {
return css;
}
public void setCss(int css) {
this.css = css;
}
public int getJs() {
return js;
}
public void setJs(int js) {
this.js = js;
}
public int getJava() {
return java;
}
public void setJava(int java) {
this.java = java;
}
public String toString() {
// 학번 / 성별 / 이름
// HTML : 100 / CSS : 50 / JS : 70 / Java : 100
return String.format( "%s / %c / %s\n"
+ "HTML : %d / CSS : %d / JS : %d / Java %d",
studentNumber, gender, name,
html, css, js, java);
}
}
Run
package student.run;
import student.view.StudentView;
// 실행용 클래스
public class StudentRun {
public static void main(String[] args) {
// StudentView 객체 생성
StudentView view = new StudentView();
view.mainMenu();
}
}
Service
package student.service;
import java.util.Random;
import student.dto.StudentDTO;
// 기능(비즈니스 로직) 제공용 클래스
public class StudentService {
// StudentDTO 객체를 참조하는
// StudentDTO 참조 변수 5개 묶음 배열 생성
// 인덱스 : 0 ~ 4
// 각 인덱스 요소 : 초기 값 null
private StudentDTO[] students = new StudentDTO[5];
/* 기본 생성자 - 생성자는 클래스명과 이름이 같아야함!!!!*/
public StudentService() {
// 학생 객체 배열(students)에 샘플 학생 3명 추가
// students[0] : (StudentDTO) 자료형 참조 변수
students[0] = new StudentDTO("24001", "짱구" , '남');
students[1] = new StudentDTO("24002", "유리" , '여');
students[2] = new StudentDTO("24003", "맹구" , '남');
// student[3] / [4] == null
// 0 ~ 100 사이 난수 발생
// 1) Math.floor(Math.random() * 101 ) == 0 ~ 100
// 2) Random random = new Random();
// random.nextInt(101); == 0 ~ 100
Random random = new Random();
for( StudentDTO std : students) { // 향상된 for 문
// 현재 접근한 요소가 참조하는 객체가 없다면
// 반복을 종료
if(std == null) break;
// random.nextInt(101) : 0 이상 101미만 정수형 난수
std.setHtml( random.nextInt(101) );
std.setCss( random.nextInt(101) );
std.setJs( random.nextInt(101) );
std.setJava( random.nextInt(101) );
}
}
/**
* 학생 객체 배열 students 중 비어있는 인덱스에
* 전달 받은 학생 객체(std) 추가
* @param std : 입력 받은 값을 저장한 학생 객체 주소
* @return true : 추가 성공 / false : 추가 실패
* - 실패 조건 : students 배열에 꽉 차있는데 추가 학생이 전달된 경우
*/
public boolean addStudent(StudentDTO std) { // 향상된 for문
// 0번 인덱스 부터
// 순서대로 비어있는(null) 요소를 찾아
// 전달 받은 std를 대입
for(int i = 0 ; i <students.length ; i++) { // 향상된 for문
if(students[i] == null) { // i 번째 요소가 비어있는 경우
students[i] = std;
return true;
}
}
// 비어있는(null)인 요소가 없을 경우 false 반환
return false;
}
/**
* students 객체 배열에 저장된 주소를 얻어가게 하는 메서드
* @return students 객체 배열에 저장된 주소
*/
public StudentDTO[] getStudents() {
return students;
}
/**
* 학생 1명 정보 조회 (index 검색)
* @param index
* @return 조회된 학생 객체 주소 || null
*/
public StudentDTO selectIndex(int index) {
// 전달 받은 index 범위가 students의 인덱스 범위 밖엔 경우
if(index < 0 || index >= students.length) {
return null;
}
return students[index];
}
/**
* 전달 받은 이름과 이름이 일치하는 학생 객체를 반환
* @param targetName
* @return null 또는 일치하는 학생 객체(주소 값)
*/
public StudentDTO selectName(String targetName) {
// 향상된 for문
for(StudentDTO std : students) {
// 저장된 학생이 없을 경우
// -> 뒤에도 없을것!! -> 그냥 여기서 검색 종료
if(std == null) return null;
// == : 기본 자료형 비교
// A.equals(B) : 참조형(객체) 비교
if(std.getName().equals(targetName) ) {
return std;
}
}
return null;
}
/**
* 전달 받은 index가 students 범위 내인지
* + 정상 범위라면 해당 index가 학생 객체를 참조하는지 확인
* @param index
* @return 1또는 2또는 3(정상)
*/
public int checkIndex(int index) {
// 입력 받은 index가 정상인지 판별
// 1 == 범위 초과
// 2 == 학생 없음
// 3 == 정상
// index 가 0보다 작으면 잘못된거니 하나라도 잘못됬으니 무조건 틀림
if(index < 0 || index >= students.length) return 1;
if(students[index] == null) return 2;
return 3;
}
/**
* 전달 받은 index 번째 학생의 점수 수정
* @param index
* @param scores
*/
public void updateScores(int index, StudentDTO other) {
// 객체 배열 : 객체 참조형 변수를 묶음으로 다룸
// students[index] 번째에 저장된 주소 얕은 복사
StudentDTO s = students[index];
s.setHtml( other.getHtml ());
s.setCss( other.getCss ());
s.setJs( other.getJs ());
s.setJava( other.getJava ());
return; // 안써도 컴파일러가 자동으로 추가
}
/**
* 평균 최대/최소 구하기
* @return
* 최고점 : 짱구(85.4)
* 최저점 : 맹구(61.5)
*/
public String selectMaxMin() {
double maxAvg = 0.0;
double minAvg = 0.0;
String maxName = null;
String minName = null;
// 최고/최저 판별
for(StudentDTO std : students) {
if(std == null)break; // 학생이 없으면 반복 멈춤
int sum = std.getHtml() + std.getCss()
+ std.getJs() + std.getJava();
double avg = sum / 4.0;
// for문 첫 반복일 때
if(maxAvg == 0.0) {
maxAvg = avg;
maxName = std.getName();
minAvg = avg;
minName = std.getName();
continue;
}
if(avg > maxAvg) { // 기존 최대값 보다 현재 평균이 클때
maxAvg = avg;
maxName = std.getName();
}
if(avg < minAvg) { // 기존 최소값 보다 현재 평균이 작을때
minAvg = avg;
minName = std.getName();
}
}
String result = String.format("최고점 : %s(%.1f)\n최저점 : %s(%.1f)\n",
maxName, maxAvg, minName, minAvg);
return result;
}
}
View
package student.view;
import java.util.Scanner;
import student.dto.StudentDTO;
import student.service.StudentService;
// 콘솔창에 보여지는 용도
// == 클라이언트의 입력/출력을 담당하는 클래스
public class StudentView {
// 필드
private Scanner sc = new Scanner(System.in);
private StudentService service = new StudentService();
/**
* 메인 메뉴 출력
*/
public void mainMenu() {
int input = 0; // 입력받은 메뉴 번호를 저장할 변수
do {
System.out.println("\n----- 학생 관리 프로그램 -----");
System.out.println("1. 학생 추가");
System.out.println("2. 학생 전체 조회");
System.out.println("3. 학생 1명 정보 조회(인덱스)");
System.out.println("4. 학생 이름으로 조회"); // 동명이인 X 동명이인이 없다고 가정하고 ㄱㄱ
System.out.println("5. 학생 정보 수정(인덱스)");
System.out.println("6. 학생 1명 점수 조회(점수, 합계, 평균)");
System.out.println("7. 평균 최고점, 최저점 학생");
System.out.println("0. 종료");
Systehttp://m.out.print("메뉴 선택 >> ");
input = sc.nextInt();
sc.nextLine(); // 입력 버퍼에 남아있는 엔터 제거
System.out.println(); // 줄바꿈
switch(input) {
case 1: addStudent(); break;
case 2: allStudent(); break;
case 3: selectIndex(); break;
case 4: selectName(); break;
case 5: updateIndex(); break;
case 6: selectScore(); break;
case 7: selectMaxMin();break;
case 0: System.out.println("*** 프로그램 종료 ***"); break;
default: System.out.println("*** 메뉴 번호 잘못 입력 ***");
}
} while(input !=0);
}
/**
* 학생 추가 화면
*
* 학번, 이름, 성별을 입력받아
* Student 객체로 만들어서
* StudentService로 전달!
* -> 추가 성공시 true / 실패시 false 반환받아
* 결과 출력
*/
private void addStudent() {
System.out.println("\n----- 학생 추가 -----\n");
Systehttp://m.out.print("학번 : ");
String studentNumber = sc.nextLine();
Systehttp://m.out.print("이름 : ");
String name = sc.nextLine();
System.out.println("성별(남/여) : ");
char gender = sc.next().charAt(0);
// 학생 객체를 생성하여 입력 받은 데이터를 저장(세팅)
StudentDTO std = new StudentDTO(studentNumber, name, gender);
// studentService 객체의 addStudent() 호출 후
// 결과 반환 받기
boolean result = service.addStudent(std);
if(result) {
System.out.println(name + " 학생이 추가 되었습니다");
} else {
System.out.println("더 이상 학생을 추가할 수 없습니다");
}
}
/**
* studentService에 있는 students 객체 배열을 얻어와
* 모든 학생 정보를 출력
*/
private void allStudent() {
System.out.println("\n----- 학생 전체 조회 -----\n");
// studentService에 있는 students 객체 배열을 얻어오기
StudentDTO[] students = service.getStudents();
// 향상된 for 문
for( StudentDTO std : students ) {
// null인 경우 == 저장된 학생이 없을 때
// -> NullpointerException 방지
// (참조변수가 null을 저장하고 있는데 사용하려고 할 때)
if(std == null) return;
System.out.println(std.toString());
System.out.println("------------------------------------");
}
}
/**
* 인덱스를 입력 받아 service에 전달 하여
* 해당 인덱스의 학생 객체 하나(StudentDTO)를 반환받아 출력
*/
private void selectIndex() {
System.out.println("\n----- 학생 1명 조회(index) -----\n");
Systehttp://m.out.print("조회할 인덱스 입력 : ");
int index = sc.nextInt();
// service 메서드 호출 후 학생 1명 정보 반환 받기
// -> null 또는 학생 객체 주소
StudentDTO std = service.selectIndex(index);
if(std == null) {
System.out.println("*** 해당 인덱스에 학생 객체가 존재하지 않습니다 ***");
return;
}
System.out.println(index + "번째 학생 정보");
System.out.println( std.toString() );
}
/**
* 이름을 입력받아 service의 student 배열에서
* 같은 이름을 가진 학생 객체를 얻어와 출력
* -> 이름 검색
*/
private void selectName() {
System.out.println("\n----- 이름으로 조회 -----n");
System.out.println("검색할 학생 이름 : ");
String targetName = sc.nextLine();
// 입력 받은 이름(targetName)을 서비스로 전달하여
// 일치하는 이름을 가진 학생 객체(주소 값) 반환 받기
// -> null 또는 학생 객체(주소 값)
StudentDTO std = service.selectName(targetName);
if(std == null) {
System.out.println("*** 같은 이름의 학생이 존재하지 않습니다 ***");
return;
}
System.out.println(std.toString());
}
/**
* 인덱스 번호를 입력받아 일치하는 학생의
* html, css, js, java 점수를 수정
*
* 단, 입력된 인덱스가 0 미만 students
* 배열 마지막 인덱스 초과한 경우
* "인덱스 범위가 올바르지 않습니다." (1)
*
* 정상 범위 인덱스이지만 학생이 존재하지 않는 경우
* "해당 인덱스에 학생 정보가 존재하지 않습니다" 출력 (2)
*
* 정상(3)
*/
private void updateIndex() {
System.out.println("\n----- 학생 점수 수정 -----\n");
Systehttp://m.out.print("수정할 학생의 인덱스 번호 입력 : ");
int index = sc.nextInt();
// 입력 받은 index가 정상인지 팔별
// 1 == 범위 초과
// 2 == 학생 없음
// 3 == 정상
int check = service.checkIndex(index);
if(check == 1) {
System.out.println("인덱스 범위가 올바르지 않습니다");
return;
}
if(check == 2) {
System.out.println("해당 인덱스에 학생 정보가 존재하지 않습니다");
return;
}
/* 학생이 존재하는 경우 */
// HTML, CSS, JS, Java 순서로 점수 입력 : 100 40 60 70
Systehttp://m.out.print("HTML, CSS, JS, Java 순서로 점수 입력 : ");
int html = sc.nextInt();
int css = sc.nextInt();
int js = sc.nextInt();
int java = sc.nextInt();
// 점수만 담는 용도의 StudentDTO 객체 생성
StudentDTO scores = new StudentDTO(html, css, js, java);
// 점수 수정 서비스 메서트 호출
// -> 절대로 실패할 일이 없기 때문에 반환값 없음
service.updateScores(index, scores);
System.out.println("*** 점수 수정 완료***");
}
/**
* 입력 반은 index번째 학생의 점수, 합계, 평균 출력
*
* 단, 정상 index인지 확인
*
* ex)인덱스 입력 : 0
* ----------------------------------------------------------------------
* 이름 : 짱구
* HTML(80) CSS(70) JS(50) Java(90)
* 합계 : 290
* 평균 : 72.5
* ----------------------------------------------------------------------
*/
private void selectScore() {
System.out.println("\n----- 학생 점수 조회 -----\n");
Systehttp://m.out.print("인덱스 입력 : ");
int index = sc.nextInt();
int check = service.checkIndex(index);
if(check == 1) {
System.out.println("인덱스 범위가 올바르지 않습니다");
return;
}
if(check == 2) {
System.out.println("해당 인덱스에 학생 정보가 존재하지 않습니다");
return;
}
// 인덱스 번째 학생 조회
StudentDTO std = service.selectIndex(index);
System.out.println("------------------------------------");
System.out.println("이름 : " + std.getName());
Systehttp://m.out.printf("HTML(%d) CSS(%d) JS(%d) Java(%d) \n",
std.getHtml(), std.getCss(), std.getJs(), std.getJava());
// 합계
int sum = std.getHtml() + std.getCss() + std.getJs() + std.getJava();
// 평균
double avg = sum / 4.0;
System.out.println("합계 : " + sum);
System.out.println("평균 : " + avg);
System.out.println("------------------------------------");
}
/**
* 평균 최고점, 최저점 조회하기
*
* service.selectMaxMin(); 반환되는 문자열 모양
* 최고점 : 짱구(85.4)
* 최저점 : 맹구(61.5)
*/
private void selectMaxMin() {
System.out.println("\n---- 평균 최고/최저점 조회 ----\n");
String result = service.selectMaxMin();
System.out.println(result);
}
//// private void testMaxMin() {
//
//
// // 테스트 코드
// int[] arr = {50, 30, 10, 70, 40};
//
// int max = 0; // 최대값을 저장할 변수
// int min = 0; // 최소값을 저장할 변수
//
// for(int i = 0; i<arr.length; i++) {
//
// if(i == 0) { // 맨 처음
// max = arr[i];
// min = arr[i];
// continue; // 다음반복으로 넘어간다, return은 현재꺼 종료하고 다시 돌아간다
// }
//
// // 최대 값 비교
// if(arr[i] > max) max= arr[i]; // max에 새 최대값 대입
//
// // 최소 값 비교
// if(arr[i] < min) min= arr[i]; // min에 새 최대값 대입
//
// }
// System.out.println("max : " + max);// 70
// System.out.println("min : " + min);// 10
// }
}