생성자(Constructor)

생성자는 두가지 역할을 한다 

1. 인스턴스를 만든다 

2. 인스턴스의 속성(인스턴스변수)들을 초기화 시켜준다 

 

// 기본 생성자
// 생성자를 따로 정의하지 않았을 경우에는 기본 생성자를 사용하면은 된다  
Person p1 = new Person();


// 생성자 정의 

public class Person {
	String name; 
    int age; 
    
    // parameter를 2개받는 생성자를 작성
    public Person(String pName, int pAge){      
    	name = pName; 
        age = pAge;     
    } 
}

// 생성자 정의 전 

public static void main(String[] args) {
	Person p1 = new Person(); 
    p1.setName("yunajoe"); 
    p1.setAge(27);    
}

// 생성자 정의 후  
public static void main(String[] args){
	Person p1 = new Person("yunajoe", 27); 

}

생성자 오버로딩

// parameter를 두개 받는 생성자 
public Person(String pName, int pAge) {
	name = pName;
    age = pAge; 

}

// parameter를 한개 받는 생성자 
public Person(String pName){
	name = pName; 
	age = 100;


// 2개의 생성자를 이용하여 만들어보기 
public static void main(String[] args) {
	Person p1 = new Person("yunajoe", 30); // parameter를 두개를 받는 생성자 사용 
    Person p2 = new Person("여나당"); // parameter를 한개 받는 생성자 사용

    System.out.println(p1.name);
    System.out.println(p1.age);
    System.out.println(p2.name);
    System.out.println(p2.age);
}

 

실습

 

// Person 


Person의 생성자 2개를 만들 것입니다.

(1) 파라미터로 '이름'을 뜻하는 String형 값 pName과 '나이'를 뜻하는 int형 값 pAge를 받고
초기값을 설정합니다. 인스턴스 변수 cashAmount은 0으로 시작합니다. 
단, pAge가 음수면 인스턴스 변수 age는 12로 설정

    public Person(String pName, int pAge){
        name = pName;
        cashAmount = 0;
        if (pAge < 0){
            age = 12;
        }else{
            age = pAge;
        }
    }    


(2) 파라미터로 '이름'을 뜻하는 String형 값 pName, '나이'를 뜻하는 int형 값 pAge, 
그리고 '보유 현금'을 뜻하는 int형 값 pCashAmount를 받고 초기값을 설정합니다
(1)번과 마찬가지로 pAge가 음수인 경우에는 age를 12로 설정합니다.
pCashAmount가 음수면 인스턴스 변수 cashAmount를 0으로 설정

    public Person(String pName, int pAge, int pCashAmount){
            name = pName;
            if (pAge<0){
                age = 12;
            }else{
                age = pAge;
            }

            if(pCashAmount <0){
                cashAmount = 0;
            }else{
                cashAmount = pCashAmount;
            }
        }
        
// BankAccount

(1) 파라미터로 '잔액'을 뜻하는 int형 값 pBalance를 받습니다.
파라미터로 받은 잔액은 음수가 될 수 없습니다. 
음수 입력이 있을 경우 0으로 설정

    public BankAccount(int pBalance){
    if(pBalance <0 ){
        balance = 0;
    }else{
        balance = pBalance;
        }
    }


(2) 파라미터로 '소유자'를 뜻하는 Person형 값 pOwner를 받습니다. 
pOwner를 인스턴스 변수 owner에 지정해주고, 잔액은 0으로 시작

public BankAccount(Person pOwner){
        owner = pOwner;
        balance = 0;
    } 

(3) 파라미터로 '잔액'을 뜻하는 int형 값 pBalance와 '소유자'를 뜻하는 
Person형 값 pOwner를 받습니다. 마찬가지로 balance와 owner를 설정해주고,
파라미터로 받은 잔액이 음수인 경우에는 balance를 0으로 설정

    public BankAccount(int pBalance, Person pOwner){
        owner = pOwner;
        if(pBalance < 0){
            balance = 0;
        }else{
            balance = pBalance;
        }

    }
    
    
 // 테스트 
 
1. Person의 1번 생성자를 사용해서 인스턴스 p1을 만듭니다. 
생성 후 보유 현금은 30000으로 재설정해줍니다.
Person p1 = new Person("yuna", 30);
p1.setCashAmount(3000);


2. Person의 2번 생성자를 사용해서 인스턴스 p2를 만듭니다.
보유 현금 초기값은 100000으로 설정해줍니다.
Person p2 = new Person("yuna2", 30, 100000);
 


3. BankAccount의 2번 생성자를 사용해서 인스턴스 a1을 만듭니다. 
파라미터로 p1을 넘겨줘서 p1과 a1을 연결해줍니다. 
생성 후 잔액을 100000으로 재설정해줍니다.
BankAcount a1 = new BankAccount(p1);
a1.setbalance = 100000;
p1.setAccount(a1);


4. BankAccount의 3번 생성자를 사용해서 인스턴스 a2을 만듭니다.
파라미터로 p2을 넘겨줘서 p2과 a2을 연결해줍니다. 잔액 초기값은 500000입니다.
BankAccount a2 = new BankAccount(500000,p2);
p2.setAccount(a2);

 

실습

public class Person{
    // 인스턴스 변수명 지정하기
    private String name;
    private int age;
    private int cashAmount;
    // BankAccount 클래스를 자료형으로 받고 account라는 변수로 만듬
    private BankAccount account;

    // 생성자 정의하기 - 1
    public Person(String pName, int pAge){
        name = pName;
        cashAmount = 0;
        if (pAge<0) {
            age = 12;
        }else{
            age= pAge;
        }
    }
    // 생성자 정의하기 - 2
    public Person(String pName, int pAge, int pCashAmount){
        name = pName;
        if(pAge<0){
            age = 12;
        }else{
            age = pAge;
        }

        if(pCashAmount<0){
            cashAmount = 0;
        }else{
            cashAmount = pCashAmount;
        }
    }

    // set, get 메서드
    public void setName(String pName){
        name = pName;
    }
    public String getName(){
        return name;
    }

    public void setAge(int pAge){
        age = pAge;
    }
    public int getAge(){
        return age;
    }
    public void setCashAmount(int pCashAmount){
        cashAmount = pCashAmount;
    }
    public int getCashAmount(){
        return cashAmount;
    }

    public void setAccount(BankAccount pAccount){
        account = pAccount;
    }

    public BankAccount getAccount(){
        return account;
    }

    // 메서드1
    public boolean transfer(Person to, int amount){

        return account.transfer(to.getAccount(), amount);
    }

    // 메서드2
    public boolean transfer(BankAccount to, int amount){
        return account.transfer(to, amount);
    }  


}

public class BankAccount {
    // 인스턴스 변수명
    private int balance;
    private Person owner;

    // 생성자 생성

    public BankAccount(int pBalance){
        if (pBalance < 0){
            balance = 0;
        }else{
            balance = pBalance;
        }
    }

    public BankAccount(Person pOwner){
        owner = pOwner;
        balance = 0;
    }

    public BankAccount(int pBalance, Person pOwner){
        owner = pOwner;
        if (pBalance < 0) {
            balance = 0;
        } else {
            balance = pBalance;
        }
    }
    // get, set 메서드
    public void setBalance(int pBalance){
        balance = pBalance;
    }
    public int getBalance(){
        return balance;
    }

    public void setOwner(Person pOwner){
        owner = pOwner;
    }
    public Person setOwner(){
        return owner;
    }
    // 메서드
    boolean deposit(int amount){
        if(amount<0 || owner.getCashAmount()< amount){
            System.out.println("입금 실패입니다. 잔고: " + balance + "원, 현금: " + owner.getCashAmount() + "원");
            return false;
        }
        balance += amount;
        owner.setCashAmount(owner.getCashAmount()-amount);

        System.out.println(amount + "원 입금하였습니다 잔고: " + balance + "원, 현금: " + owner.getCashAmount() + "원");
        return true;
    }

    boolean withdraw(int amount){
        if(amount < 0 || amount >balance){
            System.out.println("출금 실패입니다 잔고: " + balance + "원, 현금: " + owner.getCashAmount() + "원");
            return false;
        }
        balance -= amount;
        owner.setCashAmount(owner.getCashAmount() + amount);
        System.out.println(amount + "원 출금하였습니다 잔고: " + balance + "원, 현금: " + owner.getCashAmount() + "원");
        return true;
    }

    //
    public boolean transfer(Person to, int amount){
        return transfer(to.getAccount(), amount);
    }

    public boolean transfer(BankAccount to, int amount){
        if(amount < 0 || amount > balance){
            System.out.println("false - from: " + owner.getName() + ", to: " + to.owner.getName() + ", amount: " + amount + ", balance: " + balance);
            return false;
        }else{
            balance -= amount;
            to.balance += amount;
            System.out.println("true - from: " + owner.getName() + ", to: " + to.owner.getName() + ", amount: " + amount + ", balance: " + balance);
            return true;
        }
    }








}

public class BankDriver {
    public static void main(String[] args) {
        // 사람  1
        Person p1 = new Person("yuna1", 30);
        p1.setCashAmount(30000);

        // 은행 계좌 1
        BankAccount acc1 = new BankAccount(p1);
        acc1.setBalance(100000);
        p1.setAccount(acc1);

        // 사람 2
        Person p2 = new Person("yuna2", 30, 100000);

        // 은행 계좌 2
        BankAccount acc2 = new BankAccount(500000, p2);
        p2.setAccount(acc2);

        // 계좌 이체 테스트
        acc2.transfer(acc1,200000); // BankAccount 클래스에 있는 transfer 메서드 에서 transfer(BankAccount to, int amount)사용 
        acc1.transfer(p2, 150000); // BankAccount 클래스에 있는 transfer 메서드 에서 transfer(Person to, int amount)사용 
        p2.transfer(acc1, 270000); // Person 클래스에 있는 transfer(BankAccount to, int amount)사용
        p1.transfer(p2,130000); //  Person클래스에 있는 transfer(Person to, int amount)
    }
}