Java Day8 - 클래스, 상속, 배열 실습

ClassArray 실습

package Basic_Java;

// 학생 학번과 성적
// 학번 배열
// 성적 배열
// 배열 인덱스 이용해서 학번과 성적 연결

import java.util.Arrays;
import java.util.Random;

class Student{
    // 속성
    int hakbun;
    int score;
}

public class ClassArray {
    public static void main(String[] args) {
        Random rand = new Random();
        // 객체 배열(기본형 타입만 배열이 될 수 있는 것은 아님)
        // 학생 객체 5개를 담을 수 있는 배열
        Student [] studentArray = new Student[5];

        // 배열에 객체는 들어있지 않음
        // 객체를 담을 수 있는 메모리 공간만 확보
        System.out.println(Arrays.toString(studentArray));

        // 첫번째 학생 == 배열의 0번 인덱스
        studentArray[0] = new Student();
        System.out.println(Arrays.toString(studentArray));
        // 첫번째 학생은 배열의 0번 인덱스 통해 접근 가능
        System.out.println("학번: "+studentArray[0].hakbun+", 성적: "+studentArray[0].score);

        // 5명의 학생 정보를 담을 수 있도록 객체를 배열에 선언
        // 반복문으로 만들 수 있음
        for(int i = 1; i<studentArray.length;i++){
            studentArray[i] = new Student();
        }
        System.out.println(Arrays.toString(studentArray));

        // 학번 입력(1001~1005)
        int hakbun = 1001;
        // 학생들의 성적을 랜덤으로 받아오기
        for(Student student: studentArray){
            int score = rand.nextInt(100)+1;
            student.hakbun = hakbun;
            student.score = score;
            hakbun++;
        }

        // 학생들의 학번과 성적 출력
        for(Student student: studentArray){
            System.out.println("학번: "+student.hakbun+", 성적: "+student.score);
        }

        // 학생 성적의 총점과 평균 구하기
        int total = 0;
        for(Student student: studentArray){
            total += student.score;
        }

        System.out.println("학생들의 총점은: "+total+", 평균은: "+(float)(total/ studentArray.length));

    }
}

• 학번과 성적을 입력받는 메서드 추가

package Basic_Java;

// 학생 학번과 성적
// 학번 배열
// 성적 배열
// 배열 인덱스 이용해서 학번과 성적 연결

import java.util.Arrays;
import java.util.Random;

class Student{
    // 속성
    private int hakbun;
    private int score;

    // 학번과 성적을 입력받는 메서드 정의
    void setData(int hakbun, int score){
        this.hakbun = hakbun;
        this.score = score;
    }

    // 속성을 출력할 수 있는 메서드 정의
    void printData() {
        System.out.println("학번: "+this.hakbun+", 성적: "+this.score);
    }
}

public class ClassArray {
    public static void main(String[] args) {
        Random rand = new Random();
        // 객체 배열(기본형 타입만 배열이 될 수 있는 것은 아님)
        // 학생 객체 5개를 담을 수 있는 배열
        Student [] studentArray = new Student[5];

        // 배열에 객체는 들어있지 않음
        // 객체를 담을 수 있는 메모리 공간만 확보
        System.out.println(Arrays.toString(studentArray));

        // 5명의 학생 정보를 담을 수 있도록 객체를 배열에 선언
        // 반복문으로 만들 수 있음
        for(int i = 0; i<studentArray.length;i++){
            studentArray[i] = new Student();
        }
        System.out.println(Arrays.toString(studentArray));

        // 만들어진 메서드를 통해서 학번과 점수 채우기
        // 학번은 1001 ~ 1005(순차적 증가)
        // 점수는 랜덤으로 받기

        int hakbun = 1001;
        for(Student student: studentArray){
            int score = rand.nextInt(100)+1;
            student.setData(hakbun, score);
            hakbun++;
        }

        // 출력하려면 메서드 필요
        for(Student student: studentArray){
            student.printData();
        }


    }
}

• has-a

import java.util.*;

// has-a
// 과목별 점수
// 서브젝트 객체 1개는 과목 1개에 대한 정보(과목 이름과 점수)
class Subject {
    String name;
    int score;
}

class Student {

    String name;

    // 여러 과목에 대한 점수를 배열로 유지
    Subject[] subjectArray;

    // 생성자
    // 리턴 타입이 없습니다. 
    // 클래스의 이름과 동일
    // 메서드 오버로딩(생성자 오버로딩)
    Student() {}

    Student(String name) {
        this.name = name;
        this.subjectArray = new Subject[3];
    }
}

public class ClassArray {
    public static void main(String [] args) {

        // 학생 3명의 정보를 담을 수 있는 배열을 생성
        Student [] studentArray = new Student[3];

        // 학생 정보를 담을 수 있는 객체 3개를 생성해서 배열에 담아보도록 합니다. 
        // 학생 1명당 객체 1
        // 생성자의 활용
        // 학생 객체가 생성될 때 이름을 초기화 할 수 있도록 해봅시다. 
//        for( int i = 0; i < studentArray.length; i++) {
//            studentArray[i] = new Student();
//        }
        studentArray[0] = new Student("장동건");
        studentArray[1] = new Student("원빈");
        studentArray[2] = new Student("이정재");

        System.out.println(Arrays.toString(studentArray));        

        for( Student stu: studentArray) {
            System.out.printf("학생: %s\n", stu.name);
        }

         // 점수추가
        // 김준면 학생에 국어: 90 영어: 85 수학: 70 추가하기
        // 일단, 김준면 학생의 객체를 꺼내와야 함
        Student jun = null;
        for(Student stu:studentArray) {
            if(stu.name.equals("김준면")){
                jun = stu;
                break;
            }
        }

        for(int i = 0; i< jun.subjectArray.length;i++){
            jun.subjectArray[i] = new Subject();
        }

        jun.subjectArray[0].name = "국어";
        jun.subjectArray[0].score = 90;

        jun.subjectArray[1].name = "영어";
        jun.subjectArray[1].score = 85;

        jun.subjectArray[2].name = "수학";
        jun.subjectArray[2].score = 70;

        for(Subject sub: jun.subjectArray){
            System.out.println("과목:"+sub.name+", 성적:"+sub.score);
        }
    }
}

Class_Vs_Instance

사람, 나이

package Basic_Java;

import java.util.Scanner;

// 사람을 모델로 해서 클래스 정의
// Person 클래스 정의
class Person{

    private int age; // 나이속성 private으로 정의

    // 나이 속성을 초기화하는 생성자 정의
    // 생성자의 매개변수는 initialAge
    // 생성자는 어디에서나 접근할 수 있도록 정의
    public Person(int initialAge) {
        this.age = initialAge;
    }

    // 나이를 체크하는 메서드 정의
    // 매개변수와 돌려주는 값이 없는 메서드 정의
    // 어디에서나 접근할 수 있도록 정의
    public void amIOld(){
        if(this.age<10){
            System.out.println("어리군요");
        }
        else if(this.age>=10 && this.age<20){
            System.out.println("10대군요");
        }
        else if(this.age >= 20){
            System.out.println("성인이시군요");
        }
    }

    // 나이 속성을 하나씩 증가시켜주는 메서드 yearPasses 정의
    // 돌려주는 값은 없고, 매개변수를 갖지 않음
    // 어디에서나 접근 가능하도록 정의
    // 나이 속성을 1 증가시키기
    public void yearPasses(){
        this.age++;
    }

}

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

        int T = sc.nextInt();
        for(int i = 0; i< T; i++){ // 입력된 t만큼 반복
            int age = sc.nextInt(); // 나이 입력받기
            Person p = new Person(age);
            p.amIOld(); // 현재 나이 출력
            for(int j = 0; j<3;j++){ //3년이 지난 후
                p.yearPasses();
            }
            p.amIOld(); //3년 후의 나이
            System.out.println();
        }

    }
}

동물, 새

package Basic_Java;

import java.util.Scanner;

// 상속

class Bird extends Animal{
    void fly() {
        System.out.println("나는 날고 있다.");
    }
}

// 이 코드가 동작할 수 있게 적당한 Animal 클래스 정의
public class ClassVsInstance {
    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.walk();
        bird.flt();

    }
}

[Output]
나는 걷고 있다.
나는 날고 있다.

package Basic_Java;

import java.util.Scanner;

// 상속

class Animal{
    Animal() {

    }
    void walk() {
        System.out.println("나는 걷고 있다.");
    }
}

class Bird extends Animal{
    void fly() {
        System.out.println("나는 날고 있다.");
    }
}

// 이 코드가 동작할 수 있게 적당한 Animal 클래스 정의
public class ClassVsInstance02 {
    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.walk();
        bird.fly();

    }
}

은행관리 프로그램

package Basic_Java;

// 은행을 모델로 클래스 설계
// 은행 -> 고객
// 고객 -> 계좌번호, 통장 잔액
// 고객: 여러 개의 계좌 소유 가능
// 인출, 입금, 송금, ...

// 은행을 모델로 클래스 설계
// 유저 클래스(사용자 id, 개설된 계좌의 수, 계좌번호)
// 계좌 클래스(계좌번호, 잔액)

import java.util.Random;

class User {
    String userId;
    String accountNumber;
    int balance;

    // 고객 정보 출력
    // 현재 고객의 계좌번호와 잔액 출력하는 메서드 정의
    void printAccouuntInfo() {
        System.out.println("계좌번호: "+this.accountNumber+", 잔액: "+this.balance);
    }
}

public class ClassVsInstance03 {
    public static void main(String[] args) {
        // 가입
        // User 클래스에 대한 객체 생성
        User user01 = new User(); // 은행의 첫 번째 고객

        // 두 번째 고객 추가
        User user02 = new User();

        // 1. 계좌번호 생성 및 부여
        Random rand = new Random();
        String account = String.format("%04d-%04d-%04d-%04d",
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1);

        user01.accountNumber = account;
        user01.printAccouuntInfo();

        account = String.format("%04d-%04d-%04d-%04d",
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1);

        user02.accountNumber = account;
        user02.printAccouuntInfo();


    }
}

• 고객이 추가될 때마다 계좌번호를 부여하기 귀찮다
• 자동으로 계좌번호 부여될 수 있도록 생성자를 추가

package Basic_Java;

// 은행을 모델로 클래스 설계
// 은행 -> 고객
// 고객 -> 계좌번호, 통장 잔액
// 고객: 여러 개의 계좌 소유 가능
// 인출, 입금, 송금, ...

// 은행을 모델로 클래스 설계
// 유저 클래스(사용자 id, 개설된 계좌의 수, 계좌번호)
// 계좌 클래스(계좌번호, 잔액)

import java.util.Random;

class User {
    String userId;
    String accountNumber;
    int balance;

    // 생성자 추가
    User() {
        this.accountNumber = create_AccountNum();
        this.balance = 0;
    }

    // 생성자 오버로딩(이름은 같고, 매개변수는 다르게)
    User(int amount){
        this.accountNumber = create_AccountNum();
        this.balance = amount;
    }

    private String create_AccountNum(){
        Random rand = new Random();
        String account = String.format("%04d-%04d-%04d-%04d",
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1);
        return account;
    }

    // 고객 정보 출력
    // 현재 고객의 계좌번호와 잔액 출력하는 메서드 정의
    void printAccouuntInfo() {
        System.out.println("계좌번호: "+this.accountNumber+", 잔액: "+this.balance);
    }

}

public class ClassVsInstance03 {
    public static void main(String[] args) {

        // 가입할 때, 입금액이 있는 경우를 위한 생성자 추가(오버로딩)
        // 입금액 없으면 0, 있으면 입금액 전달받아서 초기화


        // 가입
        // User 클래스에 대한 객체 생성
        User user01 = new User(); // 은행의 첫 번째 고객

        // 두 번째 고객 추가
        User user02 = new User();

        // 생성자 추가해서 고객 객체 생성 때마다 자동으로 부여되도록 수정

        User user03 = new User(10000);
        User user04 = new User();

        // 1. 계좌번호 생성 및 부여
        user01.printAccouuntInfo();
        user02.printAccouuntInfo();
        user03.printAccouuntInfo();
        user04.printAccouuntInfo();
    }
}

• 고객이 늘어날 수록, 변수도 증가한다 -> 코드의 복잡성

package Basic_Java;

import java.util.Random;

class User {
    String userId;
    String accountNumber;
    int balance;

    // 생성자 추가
    User() {
        this.accountNumber = create_AccountNum();
        this.balance = 0;
    }

    // 생성자 오버로딩(이름은 같고, 매개변수는 다르게)
    User(int amount){
        this.accountNumber = create_AccountNum();
        this.balance = amount;
    }

    private String create_AccountNum(){
        Random rand = new Random();
        String account = String.format("%04d-%04d-%04d-%04d",
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1);
        return account;
    }

    // 고객 정보 출력
    // 현재 고객의 계좌번호와 잔액 출력하는 메서드 정의
    void printAccouuntInfo() {
        System.out.println("계좌번호: "+this.accountNumber+", 잔액: "+this.balance);
    }

}

public class ClassVsInstance03 {
    public static void main(String[] args) {

        // 배열을 사용해보자
        // 고객 객체 저장할 수 있는 메모리 공간
        User[] userList = new User[4];

        //userList의 생성과 출력 동시에 실행
        for(int i = 0; i<userList.length;i++){
            userList[i] = new User();
            userList[i].printAccouuntInfo();
        }

    }
}

• 입/출금 기능 추가

package Basic_Java;

import java.util.Random;

//class Account{
//    int accountNum = 0;
//    int money = 0;
//}

class User {
    String userId;
    String accountNumber;
    int balance;

    // 생성자 추가
    User() {
        this.accountNumber = create_AccountNum();
        this.balance = 0;
    }

    // 생성자 오버로딩(이름은 같고, 매개변수는 다르게)
    User(int amount){
        this.accountNumber = create_AccountNum();
        this.balance = amount;
    }

    private String create_AccountNum(){
        Random rand = new Random();
        String account = String.format("%04d-%04d-%04d-%04d",
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1);
        return account;
    }

    // 고객 정보 출력
    // 현재 고객의 계좌번호와 잔액 출력하는 메서드 정의
    void printAccouuntInfo() {
        System.out.println("계좌번호: "+this.accountNumber+", 잔액: "+this.balance);
    }

    // 입/출금 기능 추가
    void deposit(int amount) {
        this.balance += amount;
    }

    void withdraw(int amount){
        if(this.balance < amount){
            System.out.println("잔액이 부족합니다");
        }
        else{
            this.balance -= amount;
        }
    }
}

public class ClassVsInstance03 {
    public static void main(String[] args) {
        Random rand = new Random();
        // 배열을 사용해보자
        // 고객 객체 저장할 수 있는 메모리 공간
        User[] userList = new User[4];

        for(int i = 0; i<userList.length;i++){
            userList[i] = new User(rand.nextInt(999999)+1);
            userList[i].printAccouuntInfo();
        }

        // 첫 번째 고객의 입금
        userList[0].deposit(10000);
        userList[0].printAccouuntInfo();

        // 두 번째 고객 출금
        userList[1].withdraw(10000);
        userList[1].printAccouuntInfo();
    }
}

• User의 기능 향상시키기 -> 신용대출
  • 확장된 User -> 메서드 오버라이딩
  • User의 기본 기능은 그대로 상속받아서 사용

package Basic_Java;

import java.util.Random;

//class Account{
//    int accountNum = 0;
//    int money = 0;
//}

class User {
    String userId;
    String accountNumber;
    int balance;

    // 생성자 추가
    User() {
        this.accountNumber = create_AccountNum();
        this.balance = 0;
    }

    // 생성자 오버로딩(이름은 같고, 매개변수는 다르게)
    User(int amount){
        this.accountNumber = create_AccountNum();
        this.balance = amount;
    }

    private String create_AccountNum(){
        Random rand = new Random();
        String account = String.format("%04d-%04d-%04d-%04d",
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1);
        return account;
    }

    // 고객 정보 출력
    // 현재 고객의 계좌번호와 잔액 출력하는 메서드 정의
    void printAccouuntInfo() {
        System.out.println("계좌번호: "+this.accountNumber+", 잔액: "+this.balance);
    }

    // 입/출금 기능 추가
    void deposit(int amount) {
        this.balance += amount;
    }

    void withdraw(int amount){
        if(this.balance < amount){
            System.out.println("잔액이 부족합니다");
        }
        else{
            this.balance -= amount;
        }
    }
}

// User의 기능을 확장 => 신용 대출
class UserEx extends User{
    // 잔액이 부족해도 출금이 가능하도록

    // 메서드 오버라이딩
    // 부모 클래스의 메서드 이름과 동일
    void withdraw(int amount){
        this.balance -= amount;
    }
}

public class ClassVsInstance03 {
    public static void main(String[] args) {
        Random rand = new Random();
        User[] userList = new User[4];

        for(int i = 0; i<userList.length;i++){
            userList[i] = new User(rand.nextInt(999999)+1);
            userList[i].printAccouuntInfo();
        }

        // 첫 번째 고객의 입금
        userList[0].deposit(10000);
        userList[0].printAccouuntInfo();

        // 두 번째 고객 출금
        userList[1].withdraw(10000);
        userList[1].printAccouuntInfo();

        // 확장된 고객 객체 생성
        UserEx user01 = new UserEx();
        user01.printAccouuntInfo();

        // 마이너스 인출
        user01.withdraw(10000);
        user01.printAccouuntInfo();
    }
}

• 신용등급 추가
  • 거래량(입금횟수)에 따라 신용등급에 변화 주기 -> deposit 메서드 오버라이딩

package Basic_Java;

import java.util.Random;

//class Account{
//    int accountNum = 0;
//    int money = 0;
//}

class User {
    String userId;
    String accountNumber;
    int balance;

    // 생성자 추가
    User() {
        this.accountNumber = create_AccountNum();
        this.balance = 0;
    }

    // 생성자 오버로딩(이름은 같고, 매개변수는 다르게)
    User(int amount){
        this.accountNumber = create_AccountNum();
        this.balance = amount;
    }

    private String create_AccountNum(){
        Random rand = new Random();
        String account = String.format("%04d-%04d-%04d-%04d",
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1,
                rand.nextInt(9999)+1);
        return account;
    }

    // 고객 정보 출력
    // 현재 고객의 계좌번호와 잔액 출력하는 메서드 정의
    void printAccountInfo() {
        System.out.println("계좌번호: "+this.accountNumber+", 잔액: "+this.balance);
    }

    // 입/출금 기능 추가
    void deposit(int amount) {
        this.balance += amount;
    }

    void withdraw(int amount){
        if(this.balance < amount){
            System.out.println("잔액이 부족합니다");
        }
        else{
            this.balance -= amount;
        }
    }
}

// User의 기능을 확장 => 신용 대출
class UserEx extends User{
    // 잔액이 부족해도 출금이 가능하도록

    // 신용등급 추가
    int creditLevel = 0;
    int depositCnt = 0;

    // 메서드 오버라이딩
    // 거래량(입금횟수)에 따라 신용등급 -> Level 1씩 증가 -> deposit 오버라이딩
    void deposit(int amount){
        super.deposit(amount);
        // 추가된 기능 정의
        this.depositCnt++;
        if(this.depositCnt % 5 == 0) creditLevel++;
    }

    // 메서드 오버라이딩
    // 부모 클래스의 메서드 이름과 동일
    void withdraw(int amount){
        if(this.balance < amount && this.creditLevel > 10) this.balance -= amount;
        else if(this.balance < amount && this.creditLevel <= 10) System.out.println("잔액이 부족합니다.");
        else balance -= amount;
    }

    // 메서드 오버라이딩
    void printAccountInfo(){
        super.printAccountInfo();
        System.out.printf("신용등급: %d, 입금횟수: %d", this.creditLevel, this.depositCnt);
        System.out.println();
    }
}

public class ClassVsInstance03 {
    public static void main(String[] args) {
        Random rand = new Random();
        User[] userList = new User[4];

        for(int i = 0; i<userList.length;i++){
            userList[i] = new User(rand.nextInt(999999)+1);
            userList[i].printAccountInfo();
        }

        // 첫 번째 고객의 입금
        userList[0].deposit(10000);
        userList[0].printAccountInfo();

        // 두 번째 고객 출금
        userList[1].withdraw(10000);
        userList[1].printAccountInfo();

        // 확장된 고객 객체 생성
        UserEx user01 = new UserEx();
        user01.printAccountInfo();

        int money = 0;
        for(int i = 1; i<12;i++){
            money = rand.nextInt(9999)+1;
            user01.deposit(money);
        }

        // 마이너스 인출
        user01.withdraw(10000);
        user01.printAccountInfo();
    }
}

• 생성자

import java.util.*;

// 은행을 모델로 클래스를 설계
// 유저 클래스( 사용자 id, 계좌정보(객체) )
// 계좌 클래스( 계좌번호, 잔액 )

//class Account {
//    
//}

class User {
    String id;

    String accountNumber;
    int balance;

    // 생성자 추가
    // 리턴이 없고, 클래스 이름과 동일
    User() {
        this.accountNumber = createAccountNumber();
        this.balance = 0;
    }

    // 생성자 오버로딩
    // 이름은 같고, 매개변수는 다르고(개수, 타입)
    User( int amount ) {
        this.accountNumber = createAccountNumber();
        this.balance = amount;
    }

    // 클래스 내부에서 초기화 할 때만 사용
    // 부모 - 자식 간에도 상속이 되지 않습니다.
    // private String createAccountNumber() {
    protected String createAccountNumber() {
        Random rand = new Random();
        String account = String.format(
                "%04d-%04d-%04d-%04d", 
                rand.nextInt(9999) + 1,
                rand.nextInt(9999) + 1,
                rand.nextInt(9999) + 1,
                rand.nextInt(9999) + 1 );
        return account;
    }

    // 고객의 정보를 출력
    // 현재 고객의 계좌번호와 잔액을 출력하는 메서드
    void printAccountInfo() {
        System.out.printf("계좌번호: %s, 잔액: %d\n", this.accountNumber, this.balance);
    }

    void deposit( int amount ) {
        this.balance += amount;
    }

    void withdraw( int amount ) {
        if ( this.balance < amount ) {
            System.out.println("잔액이 부족합니다");
        } else {
            this.balance -= amount;
        }
    }
}

// User의 기능을 확장 => 신용대출
// User의 기본 기능 상속

class UserEx extends User {
    // 잔액이 부족해도 출금이 가능하도록

    int creditLevel = 0;
    int depositCnt = 0;

    // 오버라이딩 아닙니다
    UserEx() {
//        this.accountNumber = createAccountNumber();
//        this.balance = 0;
        super();
    }

    // 생성자 오버로딩
    // 이름은 같고, 매개변수는 다르고(개수, 타입)
    UserEx( int amount ) {
//        this.accountNumber = createAccountNumber();
//        this.balance = amount;
        super(amount);
    }

    // 메서드 오버라이딩
    // 입금횟수에 따라서 신용등급을 올려주도록 deposit 오버라이딩 해봅시다
    void deposit(int amount) {
        super.deposit(amount);
        // 추가된 기능
        this.depositCnt ++;
        if (this.depositCnt % 5 == 0) creditLevel++;
    }

    // 메서드 오버라이딩
    // 부모 클래스의 메서드 이름과 동일
    void withdraw(int amount) {
        if (this.balance < amount && this.creditLevel > 10) this.balance -= amount;
        else if(this.balance < amount && this.creditLevel <= 10) System.out.println("잔액이 부족합니다");
        else balance -= amount;

    }

    // 메서드 오버라이딩
    void printAccountInfo() {
        super.printAccountInfo();
        System.out.printf("신용등급: %d, 입금횟수: %d\n", this.creditLevel, this.depositCnt);
    }
}

public class ClassVsInstance {
    public static void main(String[] args) {

        Random ran = new Random();
        User [] userList = new User[5];

        for( int i = 1; i < userList.length; i++) { // 1, 2, 3, 4
            userList[i] = new User( ran.nextInt(999999) );
            userList[i].printAccountInfo();
        }

        // 첫 번째 고객의 입금
        userList[1].deposit(10000);
        userList[1].printAccountInfo();

        // 두 번째 고객의 출금
        userList[2].withdraw(100000000);
        userList[2].printAccountInfo();        

        // 확장된 고객 객체를 생성
        // 생성자는 상속되지 않습니다
        // UserEx는 기본 생성자가 동작
        UserEx user01 = new UserEx(100000);
        user01.printAccountInfo();

        for( int i = 1; i < 102; i++) {
            int money = ran.nextInt(9999) + 1;
            user01.deposit(money);
        }

        // 마이너스 인출
        user01.withdraw(10000000);
        user01.printAccountInfo();
    }
}