클래스

클래스 실습

예시 1. 어제 작성했던 은행 클래스의 기능을 추가하여 진행해보자.

BankManager

Scanner sc = new Scanner(System.in);
	
// 널널하게 BankInfo 객체 100개짜리 배열 선언 
private BankInfo[] bankList = new BankInfo[100];
	
private BankInfo account;
	
// 고객 번호를 자동으로 지정해 줄 변수 
private int count = 0;
	
// 메뉴 보여줄 메소드 
public void showMenu() {
	System.out.println("=========================================================================");
	System.out.println("| 1. 계좌생성 | 2. 입금 | 3. 출금 | 4. 계좌이체 | 5. 잔액 | 6. 고객리스트 | 7. 종료 |");
	System.out.println("=========================================================================");
	System.out.print("메뉴 선택 : ");
}

// 메뉴 숫자 입력받을 때 사용할 메소드 
public int inputNum() {
	int input = sc.nextInt();	
	return input;
}
	
// 계좌 생성 메소드 
public void createAccount() {		
	// 현재 계좌를 최대한으로 담을 수 있는 배열 크기가 100이므로
	if (count < 100) {
		account = new BankInfo();
			
		System.out.print("이름 입력 : ");
		String clientName = sc.next();
		account.setClientName(clientName);
		
		System.out.print("계좌번호 입력 : ");
		String accountNum = sc.next();
		account.setAccountNum(accountNum);

		System.out.print("초기 잔고 입력 : ");
		int balance = sc.nextInt();
		account.setBalance(balance);

		// 고객 번호 부여 
		account.setClientNum(count);
			
		// 고객 계좌정보 배열에 고객 정보 대입  
		bankList[count] = account;
		
		// 고객 번호 1만큼 증가 
		++count;
			
		System.out.println("계좌가 생성되었습니다.");
	}
}
	
// 고객 리스트 출력 메소드
public void clientList() {

	// 고객 배열을 순환하며,
	for (int i = 0; i < bankList.length; i++) {
			
		// 고객 배열의 요소 (고객 정보) 가 있다면 (!= null)
		if (bankList[i] != null) {
			System.out.print("고객 번호 : " + bankList[i].getClientNum());
			System.out.print("| 고객 이름 : " + bankList[i].getClientName());
			System.out.print("| 계좌 번호 : " + bankList[i].getAccountNum());
			System.out.println("| 현재 잔액 : " + bankList[i].getBalance());
		}
 	}
}
	
// 잔액 조회 기능 메소드
public void balanceCheck() {
	System.out.println("잔액 확인 메뉴입니다.");
	System.out.print("계좌번호 입력 : ");
		
	// 검색할 계좌번호를 받아온다 
	String accountNum = sc.next();
		
	// 받아온 계좌번호를 인덱스 검색 기능 메소드에 넘기고 index를 받아온다.
	int index = searchIndex(accountNum);
		
	// 만약 해당하는 계좌 번호가 존재한다면, 
	if (index > -1) {
			
		// 해당하는 계좌의 잔액을 출력해준다. 
	System.out.println("현재 잔액 : " + bankList[index].getBalance());
		
	// 찾는 계좌가 존재하지 않는다면, 
	} else {
		
		// 계좌를 찾을 수 없다는 멘트를 출력. 
		System.out.println("계좌를 찾을 수 없습니다.");
	}
}

// 인덱스 검색 기능 메소드 
public int searchIndex(String accountNum) {
	
	// 계좌를 찾지 못했을 경우, 이 값 그대로 반환  
	int index = -1;
	
	for (int i = 0; i < bankList.length; i++) {
			
		// 고객 정보가 존재한다면
		if (bankList[i] != null) {
				
			// 매개 변수로 받은 계좌번호 (검색할 번호)가 존재한다면, (배열 내 고객정보 요소와 일치한다면)
			if (accountNum.equals(bankList[i].getAccountNum())) {
					
				// 해당 요소의 위치를 index에 저장
				index = i;
				break;
			}
		}
	}
		
	// index값 반환 
	return index;
}
	
// 입금 기능 메소드 
public void deposit() {
	System.out.println("입금 메뉴입니다.");
	System.out.print("계좌번호 입력 : ");
		
	// 계좌번호를 받아오고 
	String accountNum = sc.next();
		
	// 계좌번호가 있는지 검색 
	int index = searchIndex(accountNum);
		
	// 해당하는 계좌정보가 존재한다면 
	if (index > -1) {
		System.out.print("입금할 금액 : ");
			
		// 입금할 금액을 입력받고, 해당 계좌의 현재 잔액을 불러온다.
		int deposit = sc.nextInt();
		int balance = bankList[index].getBalance();
			
		// 그리고 현재 잔액에 입금액을 더해준 다음,
		int result = balance + deposit;
			
		// 해당하는 계좌에 합한 금액을 입금한다.
		bankList[index].setBalance(result);
			
		// 입금 완료 메시지 출력
		System.out.println("입금이 완료되었습니다.");
		System.out.println("현재 잔액 : " + bankList[index].getBalance());
		
	// 계좌를 찾지 못한 경우 
	} else {
		System.out.println("계좌를 찾지 못했습니다.");
	}
}
	
	
// 출금 기능 메소드
public void withdraw() {
	System.out.println("출금 메뉴입니다.");
	System.out.print("계좌번호 입력 : ");
		
	// 계좌 번호 받아오고 
	String accountNum = sc.next();
		
	// 계좌 있는지 검색 
	int index = searchIndex(accountNum);
		
	// 계좌가 존재하는 경우 
	if (index > -1) {
			
		int balance = bankList[index].getBalance();
			
		// 해당하는 계좌의 현재 잔액을 먼저 보여준다.
		System.out.println("현재 잔액 : " + balance);
		System.out.print("출금할 금액 : ");
			
		// 출금할 금액을 입력받는다.
		int withdraw = sc.nextInt();
			
		// 출금할 금액이 현재 잔고와 같거나 적은 금액이라면 (출금 가능)
		if (balance >= withdraw) {
				
			// 최종계좌잔고 = 기존 잔고 - 출금액;
			int result = balance - withdraw;
				
			// 최종계좌잔고를 입력해준다.
			bankList[index].setBalance(result);
				
			// 출금 후 잔액을 보여준다.
			System.out.println("출금 후 잔액 : " + bankList[index].getBalance());
			} else {
				System.out.println("찾는 계좌가 없습니다.");
			}
		}
	}
	
// 계좌이체 기능 메소드 
public void transfer() {
	/*
	 * src -> dest 계좌 각각 입력받고, (출금할 -> 입금할)
	 * 출금액이 잔액보다 많은지 아닌지 체크 꼭 하고.
	 */
		
	System.out.println("계좌이체 메뉴입니다.");
	System.out.print("출금할 계좌 입력 : ");
		
	// 출금할 계좌 입력 
	String srcAccountNum = sc.next();
		
	// 출금할 계좌의 index 받아오고 
	int srcIndex = searchIndex(srcAccountNum);
		
	// 혹시 없는 계좌를 골랐으면 
	if (srcIndex == -1) {
		System.out.println("출금 계좌를 찾을 수 없습니다.");
			
		// 그대로 종료.
		return;
	}
		
	System.out.print("이체할 금액 : ");
		
	// 이체할 금액 입력받기 
	int transfer = sc.nextInt();
		
	// 이체할 금액이 출금 계좌의 잔고보다 많으면 
	if (transfer > bankList[srcIndex].getBalance()) {
		System.out.println("이체할 금액이 잔액보다 많습니다.");
			
		// 그대로 종료.
		return;
	}
		
	// 입금할 계좌 입력 
	System.out.print("입금할 계좌번호 : ");
	String destAccountNum = sc.next();
		
	// 입금할 계좌의 index 받아오고
	int destIndex = searchIndex(destAccountNum);
		
	// 입금할 계좌가 없으면
	if (destIndex == -1) {
		System.out.println("입금 계좌를 찾을 수 없습니다.");
			
		// 그대로 종료
		return;
	}
		
	// 이제 위에서 모든 검사가 끝났으니 실제로 이체를 해 줄수 있는 상황
		
	// 출금할 계좌의 잔액을 불러와서 - 출금 금액을 뺀 값을 = 출금 계좌의 잔액으로 설정 
	bankList[srcIndex].setBalance(bankList[srcIndex].getBalance() - transfer);
		
	// 입금 계좌의 잔액에 + 이체 금액을 더해서 = 입금 계좌의 잔액으로 설정 
	bankList[destIndex].setBalance(bankList[destIndex].getBalance() + transfer);
		
	System.out.println("이체가 완료되었습니다.");
}

BankMain

BankManager bankMgr = new BankManager();
boolean run = true;
		
while (run) {
	bankMgr.showMenu();
	int menuSel = bankMgr.inputNum();
			
	switch (menuSel) {
	case 1:
		// 계좌 생성
		bankMgr.createAccount();
		break;
	case 2:
		// 입금 기능 
		bankMgr.deposit();
		break;
	case 3:
		// 출금 기능
		bankMgr.withdraw();
		break;
	case 4:
		// 계좌이체 기능
		bankMgr.transfer();
		break;
	case 5:
		// 잔액 확인
		bankMgr.balanceCheck();
		break;
	case 6:
		// 고객 리스트 확인
		bankMgr.clientList();
		break;
	case 7:
		run = false;
		break;
		default:
			System.out.println("잘못된 선택입니다.");
	}
}
		
System.out.println("종료되었습니다.");

예시 2. 회원 가입 및 관리 프로그램을 만들어보자. 요구사항은 아래와 같다.

1. 회원이 가질 멤버변수는 다음과 같다.
   1.1. int
회원 번호
   --
   1.2. String
아이디
비밀번호
회원 이름
회원 이메일

2. 매니저 클래스에서는 다음과 같은 기능을 갖는다.
   2.1. 회원 가입
   2.2. 회원 정보
   2.3. 정보 수정
   2.4. 회원 목록
   2.5. 종료

3. 정보 수정 메뉴에서는 다음과 같은 기능을 갖는다.
   3.1. 이름 변경
   3.2. 이메일 변경
   3.3. 정보수정 종료

Member

private int memberNum;		// 회원 번호 
private String id;			// 아이디 
private String password;	// 비밀번호 
private String name;		// 회원 이름 
private String email;		// 회원 이메일 
	
public void setMemberNum(int memberNum) {
	this.memberNum = memberNum;
}
	
public int getMemberNum() {
	return this.memberNum;
}
	
public String getId() {
	return id;
}
	
public void setId(String id) {
	this.id = id;
}
	
public String getPassword() {
	return password;
}
	
public void setPassword(String password) {
	this.password = password;
}
	
public String getName() {
	return name;
}
	
public void setName(String name) {
	this.name = name;
}
	
public String getEmail() {
	return email;
}
	
public void setEmail(String email) {
	this.email = email;
}

MemberManager

// 입력받을 스캐너 선언 
Scanner sc = new Scanner(System.in);
	
// 회원 배열 선언 (100개) 
Member[] memList = new Member[100];
Member mem;
	
// 회원 번호 부여할 변수  
int memberNum = 0;
	
// 기본 메뉴 출력 메소드
public void showMenu() {
	System.out.println("=========================================================");
	System.out.println("| 1. 회원가입 | 2. 회원정보 | 3. 정보수정 | 4. 회원목록 | 5. 종료 |");
	System.out.println("=========================================================");
	
	System.out.print("메뉴 선택 : ");
}
	
// 메뉴 숫자 입력받을 메소드
public int inputNum() {
	int input = sc.nextInt();
	return input;
}
	
// 회원가입 메소드
public void signIn() {
	mem = new Member();
	
	// 회원 번호는 일단 회원번호 변수 +1로 해준다. (변수는 배열에 쓰일거라 0~99)
	mem.setMemberNum(memberNum + 1);
		
	System.out.println("회원 가입 메뉴입니다.");
		
	// 같은 아이디가 있다는 가정 하에 시작 
	boolean hasSameId = true;
		
	while (hasSameId) {
			
		// id를 입력받고 회원 객체에 저장 
		System.out.print("아이디 입력 : ");
		String id = sc.next();
			
		// 아이디 중복 검사하여, 중복 검출 시 재입력받도록 
		for (int i = 0; i < memList.length; i++) {
				
			// 해당 객체 배열이 비어있지 않을 때 (회원 정보가 존재할 때)
			if (memList[i] != null) {
					
				// 해당 회원의 id와 새로 생성하려는 회원의 id가 같으면 (중복) 
				if (memList[i].getId().equals(id)) {
						
					// 중복된 id임을 표시하고 재입력받도록 한다.
					System.out.println("중복된 아이디입니다.");
					break;
				}
			// 모든 회원 정보를 조사한 후 중복된 경우가 없이 회원 정보가 빈 공간에 도달할 경우 
			} else {
					
				// 중복된 아이디가 없음을 알리고 
				System.out.println("중복되지 않은 아이디입니다.");
				hasSameId = false;
					
				// 비로소 아이디를 저장해 준 후 종료.
				mem.setId(id);
				break;
			}
		}	
	}
		
	// 비밀번호 입력받고 저장 
	System.out.print("비밀번호 입력 : ");
	String password = sc.next();
	mem.setPassword(password);
		
	// 이름 입력받고 저장 
	System.out.print("이름 입력 : ");
	String name = sc.next();
	mem.setName(name);
		
	// 이메일 입력받고 저장 
	System.out.print("이메일 입력 : ");
	String email = sc.next();
	mem.setEmail(email);
		
	// 각 정보가 다 저장된 회원 객체를, 회원 객체 배열에 저장.
	memList[memberNum] = mem;
		
	// 회원 번호를 1만큼 증가.
	memberNum++;
		
	System.out.println("회원 가입이 완료되었습니다.");
}
	
// 회원정보 메소드 
public void showMemberInfo() {
	System.out.println("회원 정보 메뉴입니다.");
		
	// 찾으려는 회원이 존재하는지 searchMember를 통해 검색 
	int index = this.searchMember();
		
	// 찾으려는 회원이 존재하면 
	if (index != -1) {
		System.out.println("아이디 : " + memList[index].getId() +
					" 비밀번호 : " + memList[index].getPassword() +
					" 이름 : " + memList[index].getName() +
					" 이메일 : " + memList[index].getEmail());	
	}
		
}
	
	
// 정보수정 메소드
public void changeMemberInfo() {
	System.out.println("정보수정 메뉴입니다.");
		
	// 해당 회원이 존재하는지 확인
	int index = this.searchMember();
		
	// 회원이 존재하면 
	if (index != -1) {
		boolean run = true;
			
		while (run) {
			System.out.println("=========================================");
			System.out.println("| 1. 이름변경 | 2. 이메일변경 | 3. 정보수정종료 |");
			System.out.println("=========================================");
				
			int menuSel = this.inputNum();
				
			switch (menuSel) {
			case 1:
				System.out.print("변경할 이름 입력 : ");
				String name = sc.next();
					memList[index].setName(name);
				System.out.println("이름 변경 완료");
				break;
			case 2:
				System.out.print("변경할 이메일 입력 : ");
				String email = sc.next();
					memList[index].setName(email);
				System.out.println("이메일 변경 완료");
				break;
			case 3:
				run = false;
				break;
				default:
					System.out.println("잘못된 입력입니다.");
			}
		}
	}
		
	System.out.println("정보수정 종료.");
}
	
// 회원목록 메소드
public void showMemberList() {
		
	for (int i = 0; i < memList.length; i++) {
			
		// 회원 배열의 해당 요소(회원 정보)가 존재하는 경우
		if (memList[i] != null) {
			System.out.println("아이디 : " + memList[i].getId() +
									" 이름 : " + memList[i].getName() +
									" 이메일 : " + memList[i].getEmail());
		}
	}
}
	
// 아이디, 비밀번호 기반으로 회원 확인 후 index 반환하는 메소드 
public int searchMember() {
	System.out.println("[계정 확인]");
		
	System.out.print("아이디 : ");
	String id = sc.next();
		
	System.out.print("비밀번호 : ");
	String pw = sc.next();
		
	int index = -1;
		
	for (int i = 0; i < memList.length; i++) {
			
		// 해당 요소(회원 정보)가 존재하고, 입력한 아이디값과 저장된 아이디가 동일하면 
		if (memList[i].getId().equals(id) && memList[i] != null) {
				
			// 비밀번호를 대조해봐서 비밀번호 같으면, 
			if (memList[i].getPassword().equals(pw)) {
					
				// 해당 회원의 index를 저장
				index = i;
				
			// 비밀번호가 틀린 경우 
			} else {
				System.out.println("아이디/비밀번호 불일치");
			}
				
			break;
		}
	}
		
	return index;
}

MemberMain

MemberManager memMgr = new MemberManager();
boolean run = true;
		
while (run) {
	memMgr.showMenu();
	int menuSel = memMgr.inputNum();
			
	switch (menuSel) {
	case 1:
		memMgr.signIn();
		break;
	case 2:
		memMgr.showMemberInfo();
		break;
	case 3:
		memMgr.changeMemberInfo();
		break;
	case 4:
		memMgr.showMemberList();
		break;
	case 5:
		run = false;
		break;
		default:
			System.out.println("잘못 입력하셨습니다.");
	}
}