Java - 메서드를 활용하기.

public class Ex {
 
    public static void main(String[] args) {
        // 파라미터가 2개 이상인 메서드 호출
        // => 메서드 호출 시 전달할 파라미터들을 콤마(,) 로 구분하여 전달
        System.out.println("동생아! 1000원이랑 새우깡 사온거 가지고 가서 쿠쿠다스로 바꿔온나!");
        int money = 1000;
        String snack = "새우깡";
        snack = sister_5(money, snack); // int형, String형 두 가지 데이터를 메서드에 전달
        // => 리턴되는 문자열을 변수 snack 에 저장
        System.out.println("동생이 바꿔다 준 것 : " + snack);
    }
 
    // 파라미터가 2개 이상인 메서드 정의
    // => 전달받는 데이터를 순서대로 저장할 변수 선언(각 변수끼리 콤마로 구분)
    //    (메서드 호출 시 전달하는 데이터 변수명과 파라미터 변수의 이름은 달라도 상관없다!)
    // => 리턴값 있음(문자열)
    public static String sister_5(int sisterMoney, String sisterSnack) {
        System.out.println("동생 : 오빠가 " + sisterSnack + "을 쿠쿠다스로 바꿔오라고 " 
                                                                + sisterMoney + "원을 줬다!");
        sisterMoney -= 800;
        sisterSnack = "쿠쿠다스";
        return sisterSnack;
    }
    
    // => 주의사항!
    //    파라미터는 복수개 지정이 가능하지만, 리턴타입은 1개만 지정이 가능하며
    //    return 문 뒤에 오는 리턴값도 1개만 리턴 가능함
    //    단, String 타입이 리턴될 경우 문자열 결합으로는 리턴 가능함
//    public static String, int sister_6() {} // 리턴타입에 2개 이상의 리턴타입 지정 불가
    
//    public static int sister_6() {
//        return 100, 200; // return 문 뒤에 2개 이상의 값 리턴 불가
//    }
    
    public static String sister_6() {
        return "새우깡" + "쿠쿠다스"; // 문자열 결합으로 복수개 값을 묶어서 리턴은 가능
    }
 
    // -----------------------------------------------------------
    // if문 등의 조건에 따른 return 문 사용 시 주의사항!
    public static String method(int num) {
        // 메서드 종료 시점에서 반드시 String형 데이터 1개 리턴 필수!
        // => return 문은 항상 실행되어야 함!
//        if(num % 2 == 0) { // 짝수일 때 "짝수!" 리턴
//            return "짝수!";
//        } else if(num % 2 == 1) { // 홀수일 때 "홀수!" 리턴
//            return "홀수!";
//        }
        
        // 문제점 : if문 사용 시 모든 조건이 만족하지 않을 때 return 문이 없을 경우
        //          반드시 return 문이 실행되어야 하는 조건이 성립되지 않는다!
        // 해결책1) else 문을 작성하여 나머지 경우에 return 문이 실행되도록 함
//        if(num % 2 == 0) { // 짝수일 때 "짝수!" 리턴
//            return "짝수!";
//        } else if(num % 2 == 1) { // 홀수일 때 "홀수!" 리턴
//            return "홀수!";
//        } else { // 위의 모든 조건을 만족하지 않을 경우 "기타" 리턴
//            return "기타";
//        }
        
        // 해결책2) if문 내에서 return 문을 사용하지 않고 return 값을 생성하기만 하고
        //          if문 종료 후에 통합하여 return 문을 실행하도록 함
        String result = "";
        
        if(num % 2 == 0) { // 짝수일 때 "짝수!" 문자열 저장
            result = "짝수!";
        } else if(num % 2 == 1) { // 홀수일 때 "홀수!" 문자열 저장
            result = "홀수!";
        }
        // 위의 두 가지 조건식을 만족하지 않더라도 널스트링("") 값이 return 됨
        return result;
 
    }
    
 
}
public class Ex2 {
 
    public static void main(String[] args) {
        // Animal 클래스 인스턴스 생성
        // 클래스명 참조변수명 = new 클래스명();
        Animal ani = new Animal();
        
        // Animal 인스턴스의 멤버변수에 데이터 저장 후 출력
        // => 이름 : "멍멍이", 나이 : 3
        // 참조변수명.멤버변수명 형태로 변수에 접근
        ani.name = "멍멍이";
        ani.age = 3;
        System.out.println("이름 : " + ani.name);
        System.out.println("나이 : " + ani.age);
        
        // Animal 인스턴스의 메서드 cry() 호출
        // => 파라미터 없음, 리턴값 없음
        ani.cry();
        
        
        // 또다른 Animal 클래스의 인스턴스 생성(ani2)
        // => 이름: "야옹이", 나이 : 2 초기화 및 출력, cry() 메서드 호출
        Animal ani2 = new Animal();
        ani2.name = "야옹이";
        ani2.age = 2;
        System.out.println("이름 : " + ani2.name);
        System.out.println("나이 : " + ani2.age);
        ani2.cry();
        
        
        System.out.println("---------------------------");
        
        // Person 클래스 인스턴스 생성
        Person p = new Person();
        // 이름 : 철수, 나이 : 20 로 초기화(배고픔(isHungry)은 초기화하지 않음)
        p.name = "철수"; 
        p.age = 20;
        System.out.println("이름 : " + p.name);
        System.out.println("나이 : " + p.age);
        // => 인스턴스 변수는 별도로 초기화하지 않으면 기본값으로 자동으로 초기화 됨
        System.out.println("배고픔 : " + p.isHungry); // 기본값 false 출력됨
        
        // Person 인스턴스의 work() 메서드 호출
        p.work();
        System.out.println("배고픔 : " + p.isHungry);
        
        // Person 인스턴스의 eat() 메서드 호출
        p.eat();
        System.out.println("배고픔 : " + p.isHungry);
        
        System.out.println("----------------");
        
        // 또 다른 Person 인스턴스 생성(p2)
        Person p2 = new Person();
        p2.name = "영희";
        p2.age = 30;
        
        System.out.println("이름 : " + p2.name);
        System.out.println("나이 : " + p2.age);
        p2.work();
        System.out.println("배고픔 : " + p2.isHungry);
        
    }
 
}
 
// Person 클래스
// 멤버변수 : 이름(name, 문자열), 나이(age, 정수형), 배고픔상태(isHungry, boolean형)
// 메서드
// 1) work() : 파라미터 없음, 리턴값 없음. "일한다" 출력 후 isHungry 변수값을 true 로 변경
// 2) eat() : 파라미터 없음, 리턴값 없음. "밥 먹는다" 출력 후 isHungry 변수값을 false 로 변경
class Person {
    // 클래스 내에서 선언하는 멤버변수(인스턴스변수)들은 클래스 내의 대부분의 위치에서 접근 가능
    String name; // 만약 초기화하지 않으면 null 이 기본값
    int age; // 0 기본값
    boolean isHungry; // false 기본값
    
    public void work() {
        System.out.println("일한다!");
        isHungry = true; // 메서드 내에서 멤버변수 접근 시 변수명만으로 바로 접근 가능
    }
    
    public void eat() {
        System.out.println("밥 먹는다!");
        isHungry = false;
 
        // 메서드 정의 및 호출 복습
        
        // 1. 1 ~ 10 까지 정수를 차례대로 출력하는 print() 메서드 호출
        // => 파라미터 없음, 리턴값 없음
        print();
        
        System.out.println("--------------");
        
        // 2. 1 ~ 10 까지 정수의 합을 리턴하는 total() 메서드 호출 후 리턴값 출력
        // => 파라미터 없음. 리턴값 있음(int형)
        int total = total();
        System.out.println("합계 : " + total);
        
        System.out.println("--------------");
        
        // 3. 정수 num 을 전달받아 1 ~ num 까지 차례대로 출력하는 print2() 메서드 호출
        // => 파라미터 있음(정수 1개), 리턴값 없음
        print2(100);
        
        System.out.println("--------------");
        
        // 4. 정수 num을 전달받아 1 ~ num 까지 정수의 합을 리턴하는 total2() 메서드 호출
        // => 파라미터 있음(정수 1개). 리턴값 있음(int형)
//        int total2 = total2(100);
//        System.out.println("합계 : " + total2);
        
        System.out.println("합계 : " + total2(100));
        
        System.out.println("--------------");
        
        // 5. 정수 a 와 b 를 전달받아 a ~ b 까지 정수의 합을 리턴하는 total3() 메서드 호출
        // => 파라미터 있음(정수 2개), 리턴값 있음(int형)
        System.out.println("합계 : " + total3(1, 10));
        
//        total3(10); // 파라미터가 2개이므로, 반드시 2개의 데이터 전달 필수!
        
    }
 
    // 5. 정수 a 와 b 를 전달받아 a ~ b 까지 정수의 합을 리턴하는 total3() 메서드 정의
    // => 파라미터 있음(정수 2개), 리턴값 있음(int형)
    public static int total3(int a, int b) {
        int total = 0;
        for(int i = a; i <= b; i++) {
            total += i;
        }
        
        return total;
    }
    
    
    // 1. 1 ~ 10 까지 정수를 차례대로 출력하는 print() 메서드 정의
    // => 파라미터 없음, 리턴값 없음
    public static void print() {
        for(int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }
    
 
    // 2. 1 ~ 10 까지 정수의 합을 리턴하는 total() 메서드 정의
    // => 파라미터 없음. 리턴값 있음(int형)
    public static int total() {
        int total = 0;
        
        for(int i = 1; i <= 10; i++) {
            total += i;
        }
        
        return total;
    }
 
    
    // 3. 정수 num 을 전달받아 1 ~ num 까지 차례대로 출력하는 print2() 메서드 정의
    // => 파라미터 있음(정수 1개), 리턴값 없음
    public static void print2(int num) {
        for(int i = 1; i <= num; i++) {
            System.out.println(i);
        }
    }
    
    
    // 4. 정수 num을 전달받아 1 ~ num 까지 정수의 합을 리턴하는 total2() 메서드 정의
    // => 파라미터 있음(정수 1개). 리턴값 있음(int형)
    public static int total2(int num) {
        int total = 0;
        
        for(int i = 1; i <= num; i++) {
            total += i;
        }
        
        return total;
    }
    
    }
    
// Car 클래스 인스턴스 생성 후 다음과 같이 멤버변수 초기화하여 출력
        // 차종 : SONATA
        // 차량번호 : 12가1234
        // 최대속력 : 240 km/h
        // 현재속력 : 0 km/h
        Car car = new Car();
        car.carName = "SONATA";
        car.carNumber = "12가1234";
        car.maxSpeed = 240;
//        car.speed = 0; // 기본값이 0 이므로 생략 가능
        
//        System.out.println("차종 : " + car.carName);
//        System.out.println("차량번호 : " + car.carNumber);
//        System.out.println("최대속력 : " + car.maxSpeed + " km/h");
//        System.out.println("현재속력 : " + car.speed + " km/h");
        
        // 차량 정보를 출력하는 carInfo() 메서드 호출하여 차종, 번호, 속력 정보 출력
        car.carInfo();
        
        // 차량 속력 증가를 위해 speedUp() 메서드를 호출하여 증가시킬 속력값 전달
        car.speedUp(50); // 현재속력 0 + 증가속력 50 = 50 km/h 출력
        System.out.println("--------------");
        car.speedUp(250); // 현재속력 50 + 증가속력 250 = 최대속력 도달했으므로 240 km/h 출력
        System.out.println("--------------");
        car.speedUp(100); // 최대속력 도달했으므로 240 km/h 출력
        System.out.println("--------------");
        
        
        // 차량 속력 감소를 위해 speedDown() 메서드를 호출하여 감소시킬 속력값 전달
        car.speedDown(100); // 현재속력 240 - 감소속력 100 = 140 km/h 출력
        System.out.println("--------------");
        car.speedDown(300); // 현재속력 140 - 감소속력 300 = 0 보다 작으므로 0 km/h 출력
        System.out.println("--------------");
        car.speedDown(50); // 0 보다 작으므로 0 km/h 출력
    }
 
}
 
/*
 * 자동차(Car) 클래스 정의
 * 
 * 멤버변수
 *   - 차종명(carName, 문자열)
 *   - 차량번호(carNumber, 문자열)
 *   - 최대속력(maxSpeed, 정수)
 *   - 현재속력(speed, 정수)
 *   
 * 메서드
 *   - carInfo() 메서드 정의 : 파라미터 없음, 리턴값 없음
 *     => 차종, 차량번호, 최대속력, 현재속력을 출력
 *   
 *   - speedUp() 메서드 정의 : 파라미터 있음(속력값 value 전달), 리턴값 없음
 *     => 전달받은 속력값(value)을 현재속력(speed)에 누적하고, "현재 속력 : XXX km/h" 출력
 *     => 단, 증가한 현재속력(speed)이 최대속력(maxSpeed)보다 클 경우
 *        "최대 속력 도달!" 출력 후 현재속력(speed)을 최대속력(maxSpeed)으로 변경
 *   
 *   - speedDown() 메서드 정의 : 파라미터 있음(속력값 value 전달), 리턴값 없음
 *     => 전달받은 속력값(value)을 현재속력(speed)에서 차감하고, "현재 속력 : XXX km/h" 출력
 *     => 단, 감소한 현재속력(speed)이 0보다 작거나 같을 경우
 *        "차량 정지!" 출력 후 현재속력(speed)을 0으로 변경
 */
class Car {
    String carName;
    String carNumber;
    int maxSpeed;
    int speed;
    
    // 차종, 차량번호, 최대속력, 현재속력을 출력하는 메서드 carInfo() 정의
    public void carInfo() {
        System.out.println("차종 : " + carName);
        System.out.println("차량번호 : " + carNumber);
        System.out.println("최대속력 : " + maxSpeed + " km/h");
        System.out.println("현재속력 : " + speed + " km/h");
    }
    
    // 속력증가 메서드 speedUp() 정의
    public void speedUp(int value) {
        speed += value; // 현재속력에 전달받은 속력 누적
        
        // 현재속력 > 최대속력 일 경우 현재속력을 최대속력으로 고정
        if(speed > maxSpeed) {
            System.out.println("최대속력 도달!");
            speed = maxSpeed;
        }
        
        System.out.println("현재속력 : " + speed + " km/h");
    }
    
    // 속력감소 메서드 speedDown() 정의
    public void speedDown(int value) {
        speed -= value; // 현재속력에서 전달받은 속력 차감
        
        // 현재속력 <= 0 일 경우 현재속력을 0으로 고정
        if(speed <= 0) {
            System.out.println("차량 정지!");
            speed = 0;
        }
        
        System.out.println("현재속력 : " + speed + " km/h");
    }
    
}
 
public class Test {
 
    public static void main(String[] args) {
        /*
         * 은행계좌 개설 - Account 인스턴스 생성(2개) 및 다음과 같이 초기화 후 출력
         * -----------------------------
         * 계좌번호 : 111-1111-111
         * 예금주명 : 홍길동
         * 현재잔고 : 100000원
         * -----------------------------
         * 계좌번호 : 123-4567-890
         * 예금주명 : 본인이름
         * 현재잔고 : XXXXXX원
         */
        Account acc1 = new Account(); // 인스턴스 생성
        // 인스턴스 주소가 저장된 참조변수 acc1 을 사용하여 인스턴스 멤버에 접근 가능
        acc1.accountNo = "111-1111-111";
        acc1.ownerName = "홍길동";
        acc1.balance = 100000;
        
        // 참조변수를 사용하여 인스턴스 변수 값 출력
//        System.out.println("계좌번호 : " + acc1.accountNo);
//        System.out.println("예금주명 : " + acc1.ownerName);
//        System.out.println("현재잔고 : " + acc1.balance + "원");
        
        // Account 클래스 내에 정의된 showAccountInfo() 메서드 호출하여 변수 값 출력
        acc1.showAccountInfo();
        
        System.out.println("----------");
        // 입금
        acc1.deposit(5000);
        System.out.println("----------");
        acc1.deposit(800000);
        
        System.out.println("----------");
        // 출금
        int myMoney = acc1.withdraw(500000);
        System.out.println("출금된 금액 : " + myMoney + "원");
        System.out.println("----------");
        myMoney = acc1.withdraw(500000);
        System.out.println("출금된 금액 : " + myMoney + "원");
        
        System.out.println("================================");
        
        Account acc2 = new Account();
        
        acc2.accountNo = "123-4567-890";
        acc2.ownerName = "이연태";
        acc2.balance = 1111223;
        
        acc2.showAccountInfo();
        
        acc2.deposit(99999);
        
        System.out.println("출금된 금액 : " + acc2.withdraw(99999) + "원");
        System.out.println("출금된 금액 : " + acc2.withdraw(999999999) + "원");
        
        System.out.println("=====================");
        
        // 인스턴스(객체)를 생성하지 않은 상태로 인스턴스 멤버 사용 불가!
//        Account acc3 = null;
//        System.out.println("계좌번호 : " + acc3.accountNo);
        
    }
 
}
 
/*
 * 은행계좌(Account) 클래스
 * - 멤버변수
 *   1. 계좌번호(accountNo) - 문자열 "XXX-XXXX-XXX"
 *   2. 예금주명(ownerName) - 문자열 "XXX)
 *   3. 현재잔고(balance) - 정수
 * - 메서드
 *   1. showAccountInfo() : 계좌번호, 예금주명, 현재잔고 출력하는 메서드 
 *      => 파라미터, 리턴타입 모두 X
 *   2. deposit() : 입금 기능 => 파라미터(입금금액 amount, 정수형), 리턴값 X
 *         - 전달받은 입금금액(amount)을 현재잔고(balance)에 누적
 *         - 잔고 누적 후 다음과 같이 출력
 *           "입금금액 : XXXX원"
 *           "현재잔고 : XXXX원"
 *      ex) acc1.deposit(50000); // => 현재잔고 100000원 + 입금금액 50000원 = 현재잔고 150000원
 *   3. withdraw() : 출금기능 => 파라미터(출금할금액 amount, 정수형), 리턴타입 정수형
 *         - 전달받은 출금할금액(amount)을 출력하고, 현재잔고와 비교 수행
 *           1) 현재잔고 < 출금할금액 일 경우
 *              "잔고가 부족합니다." 출력
 *              "현재잔고 : XXXX원" 출력
 *              => 0 리턴
 *           2) 현재잔고 >= 출금할금액 일 경우
 *              현재잔고에서 출금할 금액을 차감한 후
 *              "현재잔고 : XXXX원" 출력
 *              출금금액 리턴
 *      ex) 잔고가 10000원 일 때
 *          int result = acc1.withdraw(100000) 실행 시
 *          "출금할 금액 : 100000원"
 *          "잔고가 부족합니다."
 *          "현재잔고 : 10000원"
 *          
 *          int result = acc1.withdraw(5000) 실행 시
 *          "출금할 금액 : 5000원"
 *          "현재잔고 : 5000원"
 *          5000원 리턴
 *            
 */
class Account {
    String accountNo; // 계좌번호
    String ownerName; // 예금주명
    int balance; // 현재잔고
    
    // 1. showAccountInfo() : 계좌번호, 예금주명, 현재잔고 출력하는 메서드 
    public void showAccountInfo() {
        System.out.println("계좌번호 : " + accountNo);
        System.out.println("예금주명 : " + ownerName);
        System.out.println("현재잔고 : " + balance + "원");
    }
    
    // 2. deposit() : 입금 기능 => 파라미터(입금금액 amount, 정수형), 리턴값 X
    public void deposit(int amount) {
        // 잔고 누적 후 다음과 같이 출력
        // "입금금액 : XXXX원"
        // "현재잔고 : XXXX원"
        balance += amount;
        System.out.println("입금금액 : " + amount + "원");
        System.out.println("현재잔고 : " + balance + "원");
    }
    
    // 3. withdraw() : 출금기능 => 파라미터(출금할금액 amount, 정수형), 리턴타입 정수형
    public int withdraw(int amount) {
        // 1) 현재잔고 < 출금할금액 일 경우
        // "잔고가 부족합니다." 출력
        // "현재잔고 : XXXX원" 출력
        // => 0 리턴
        System.out.println("출금할 금액 : " + amount + "원");
        
//        if(balance < amount) {
//            System.out.println("잔고가 부족합니다.");
//            System.out.println("현재잔고 : " + balance + "원");
//            
//            return 0; // 현재 메서드(withdraw()) 수행을 종료하고 호출한 곳으로 돌아감(0 리턴)
//        } 
//        // if() 문에서 return 0 문장을 만나므로 조건식이 false 일 경우인 
//        // else 문을 따로 정의하지 않고 if 문 바깥쪽에 문장을 그대로 정의해도 됨
//        
//        // 2) 현재잔고 >= 출금할금액 일 경우
//        // 현재잔고에서 출금할 금액을 차감한 후
//        // "현재잔고 : XXXX원" 출력
//        // 출금금액 리턴
//        balance -= amount;
//        System.out.println("현재잔고 : " + balance + "원");
//        
//        return amount; // 현재 메서드(withdraw()) 수행을 종료하고 호출한 곳으로 돌아감(금액 리턴)
        
        
        // 만약, if문과 else if 문을 조합하여 두 가지 경우에 다른 값을 리턴해야할 경우
        // if문과 else if 문 모두 거짓일 때 리턴할 문장이 없으면 오류 발생!
        // => 따라서, 각각 문장에서 return 문을 사용하고 else 문에서 return 을 수행하거나
        //    아니면, 각 if 문에서는 작업만 수행한 후 리턴값을 설정하여
        //    if문이 모두 끝난 후 통합 return 을 수행하면 된다!
        if(balance < amount) {
            System.out.println("잔고가 부족합니다.");
            System.out.println("현재잔고 : " + balance + "원");
            
            // 리턴할 금액(amount)을 0원으로 설정
            amount = 0;
        } else if(balance >= amount) {
            balance -= amount;
            System.out.println("현재잔고 : " + balance + "원");
        }
        
        // 최종금액을 리턴
        return amount;
        
        
    }
    
}
 
 

리턴 값이 있는 메서드의 경우 생길 수 있는 오류에 대해서 한 번 더 짚어보고 시작을 했다. 리턴 값이 있는 메서드의 경우 무조건 리턴 값이 있어야 하는데 if 문을 사용하였을 경우 리턴 값이 출력이 안 되는 경우도 있기 때문에 신중하게 생각을 해서 코딩을 해야 한다. 오류가 발생했을 시 리턴 값을 먼저 확인하면서 오류를 해결해 나가야겠다. 이번 시간엔 메서드를 활용하여 은행계좌를 조회해 보는 시간을 가졌다. 코딩들이 점점 복잡해져 가고 있지만 시간 가는 줄 모르고 아주 집중이 잘되어서 배우는 즐거움이 있는 시간이었다. 저번에 배웠던 메서드의 활용 편이라 기본이 잘 잡혀 있다면 쉽게 느껴지는 시간이었을 것 같다. 인스턴스화를 통해 참조 변수의 값만 초기화 해 가며 사용을 했는데 조금 어렵게 느껴졌던 참조 변수라는 개념이 머릿속에서 자리 잡아가고 있는 걸 깨닫는 시간이었다.