Java - Class선언, Method() 선언

 
/*
 * 클래스(class) 정의
 * - 객체 분석 결과물을 토대로 설계도에 해당하는 클래스를 정의
 * - 클래스 내에는 객체의 속성을 저장할 멤버변수를 선언하고, 
 *   객체의 동작을 정의할 메서드를 정의한다.
 * - 아직 실체를 갖는 객체(= 인스턴스)가 아니므로 변수에 값을 저장할 필요는 없다.
 *   (단, 필요에 따라 저장도 가능)
 * 
 * < 기본 문법 >
 * [접근제한자] class 클래스명 {
 *         // 멤버변수
 *         // 메서드
 * }
 * 
 * 
 * ex) 사람 클래스 정의
 *     - 속성 : 이름, 나이, 키
 */
public class 사람 {
    // 객체의 속성을 저장하는 멤버변수 선언
    String 이름;
    int 나이;
    double 키;
}
 
 
// 동물(Animal) 클래스 정의
// 속성 : 이름(name, 문자열), 나이(age, 정수)
public class Animal {
    String name;
    int age;
}
 
 
 
public class Ex {
 
    public static void main(String[] args) {
            /*
             * 정의된 클래스에 대한 인스턴스(객체) 생성 = 구현 단계
             * - 힙(Heap) 메모리 공간에 인스턴스를 생성하여, 생성된 인스턴스의 주소값을
             *   참조형 변수에 저장하여, 참조변수를 통해 인스턴스에 접근하도록 함.
             *   
             * < 인스턴스 생성 기본 문법 >
             * 클래스명 참조변수명 = new 클래스명();
             * => new 키워드를 통해 인스턴스가 Heap 공간에 생성되고
             *    참조변수에 생성된 인스턴스 주소가 저장됨
             *    
             * < 인스턴스의 멤버에 접근하는 기본 문법 >
             * 참조변수명.멤버변수명 또는 참조변수명.메서드명() 형태로 접근
             */
        // Animal 클래스의 인스턴스 생성
//        Animal ani; // Animal 클래스 타입 참조변수 선언
//        ani = new Animal(); // Animal 인스턴스 생성 후, 생성된 주소를 참조변수에 전달
        // => 선언과 인스턴스 생성이 분리된 문장을 하나로 결합할 수 있다!
        Animal ani = new Animal();
        
        // 참조변수를 사용하여 생성된 인스턴스에 접근한 뒤 인스턴스 변수 값 변경
        // => 참조변수명.인스턴스변수명 형태로 접근
        ani.name = "멍멍이"; // 인스턴스 내의 변수 name 값을 "멍멍이" 로 변경
        ani.age = 3; // 인스턴스 내의 변수 age 값을 3 으로 변경
        
        // 인스턴스 변수에 저장된 값 출력
        System.out.println("이름 : " + ani.name);
        System.out.println("나이 : " + ani.age);
        
        // 멍멍이에 해당하는 인스턴스가 생성된 상태
        
        System.out.println("---------------------");
        
        // 멍멍이는 그대로 두고 새로 야옹이에 해당하는 인스턴스 생성
        Animal ani2 = new Animal();
        
        ani2.name = "야옹이";
        ani2.age = 2;
        
        System.out.println("이름 : " + ani2.name);
        System.out.println("나이 : " + ani2.age);
        
        // Animal 타입 ani2 인스턴스가 생성되더라도
        // 기존의 ani 인스턴스는 그대로 유지됨
        
        System.out.println("이름 : " + ani.name);
        System.out.println("나이 : " + ani.age);
        
        System.out.println("==================================");
        
        // Student 클래스의 인스턴스 생성(참조변수명 : s)
        Student s = new Student();
        // id : 20201111   이름 : 홍길동   학과명 : 빅데이터
        s.id = 20201111;
        s.name = "홍길동";
        s.className = "빅데이터";
        System.out.println("ID : " + s.id);
        System.out.println("이름 : " + s.name);
        System.out.println("학과 : " + s.className);
        
        Student s2 = new Student();
        s2.id = 20202222;
        s2.name = "이순신";
        s2.className = "전자정부";
        System.out.println("ID : " + s2.id);
        System.out.println("이름 : " + s2.name);
        System.out.println("학과 : " + s2.className);
        
    }
 
}
 
// 하나의 java 파일에 여러개의 클래스를 정의할 수도 있다!
// 단, java 파일 이름과 동일한 클래스 앞에 public 이 붙지만
// 그 외의 클래스는 public 키워드를 제외하고 클래스 정의해야함
 
// 학생(Student) 클래스 정의
// 속성 : 학번(id, 정수형), 이름(name, 문자열), 학과명(className, 문자열)
class Student {
    int id;
    String name;
    String className;
}
 
/*
         * 메서드(Method)
         * - 작업의 최소 단위(= 작업을 실행하는 코드들의 모음)
         * - 반드시 호출되어야만 사용할 수 있음
         *   => 호출하는 메서드 : Caller, 호출 당하는 메서드 : Worker
         * - 메서드 호출 시 전달하는 값을 파라미터(Parameter, 매개변수) 라고 하며,
         *   => 파라미터는 없을 수도 있고, 여러개 일 수도 있다.
         * - 메서드가 호출되면 작업을 수행한 후에 반드시 호출한 위치로 돌아감
         *   => 메서드 작업 수행 후 돌아갈 때 가지고 가는 값을 리턴값이라고 함
         * - main() 메서드는, 자바에서 유일하게 프로그램 실행 시 자동으로 호출되는 메서드
         *   => 프로그램 시작점이라고 함
         * 
         * < 메서드 정의 기본 문법 >
         * [제한자] 리턴타입 메서드명([파라미터...]) {
         *         // 메서드 호출 시 수행할 코드들...
         *         [return [리턴값];]
         * }
         * 
         * < 메서드 형태 4가지 >
         * 1. 파라미터도 없고, 리턴값도 없는 메서드
         * 2. 파라미터는 없고, 리턴값만 있는 메서드
         * 3. 파라미터만 있고, 리턴값은 없는 메서드
         * 4. 파라미터도 있고, 리턴값도 있는 메서드
         * 
         */
        
        // Worker 메서드 호출
        // => 호출할 메서드의 이름을 사용하여 메서드 호출하고, 파라미터가 있을 경우 값 전달
        
        // 1. 파라미터도 없고, 리턴값도 없는 메서드 호출
        System.out.println("동생아! 불 좀 끄고 가라!");
        sister_1(); // sister_1() 메서드 호출(sister_1() 메서드로 흐름이 이동함)
        // => 파라미터가 없으므로 소괄호() 안에 아무 데이터도 전달하지 않음
        System.out.println("동생이 불을 끄고 갔다!");
        
        // 주의! 리턴값이 없는 메서드를 출력문에서 호출하거나 변수에 대입 불가능
//        System.out.println(sister_1()); // 오류 발생!
        
        System.out.println("--------------------------");
        
        // 2. 파라미터는 없고, 리턴값만 있는 메서드 호출
        System.out.println("동생아! 물 좀 떠다 도!");
        String result = sister_2(); // sister_2() 메서드 호출
        // => 파라미터가 없으므로 소괄호() 안에 아무 데이터도 전달하지 않음
        // => 리턴타입이 String 이므로 리턴받는 데이터를 변수에 저장하거나
        //    또는 출력문 등에 사용할 수 있다!
        System.out.println("동생이 가져다 준 것 : " + result); // 리턴받은 값을 변수에 저장한 경우
//        System.out.println("동생이 가져다 준 것 : " + sister_2()); // 리턴값을 바로 사용하는 경우
        
        
        System.out.println("--------------------------");
        
        // 3. 파라미터만 있고, 리턴값은 없는 메서드 호출
        System.out.println("동생아! 돈 줄 테니 과자 사먹어라!");
//        sister_3(200); // sister_3() 메서드 호출(파라미터에 리터럴 직접 전달)
        // => 파라미터가 있으므로 소괄호() 안에 전달할 데이터 지정(변수 또는 리터럴 사용)
        
        int money = 200;
        sister_3(money); // sister_3() 메서드 호출(파라미터에 변수값 전달)
        
        System.out.println("--------------------------");
        
        // 4. 파라미터도 있고, 리턴값도 있는 메서드 호출
        // => 파라미터가 있으므로 소괄호() 안에 전달할 데이터 지정(변수 또는 리터럴 사용)
        // => 리턴타입이 String 이므로 리턴받는 데이터를 변수에 저장
        System.out.println("동생아! 200원으로 새우깡 좀 사온나!");
        String snack = sister_4(200); // sister_4() 메서드 호출(파라미터에 변수값 전달)
        System.out.println("동생이 사다준 것 : " + snack);
        
        
    } // main() 메서드 끝
    
    // --------- 4. 파라미터도 있고, 리턴값도 있는 메서드 정의 ---------
    // => 파라미터가 있으므로, 메서드 선언부 소괄호() 안에 전달받는 데이터를 저장할 변수를 선언 
    // => 리턴값이 있으므로 리턴타입 부분에 리턴할 데이터의 타입을 명시(ex. 문자열 = String)
    //    => 반드시 메서드 종료 시점에서 리턴값을 return 문을 사용하여 명시해야함!
    public static String sister_4(int sisterMoney) {
        System.out.println("오빠가 새우깡 사오라고 " + sisterMoney + "원을 줬다!");
        return "새우깡";
    }
    
    
    // 메서드 정의(= 호출당하는 메서드 = Worker 메서드)
    // --------- 1. 파라미터도 없고, 리턴값도 없는 메서드 정의 ---------
    // => 파라미터가 없으므로 메서드 선언부의 소괄호() 안에 아무것도 명시하지 않음
    // => 리턴값이 없으므로 리턴타입 부분에 void 를 명시(void = 리턴할 데이터가 없다는 특수 타입)
    public static void sister_1() {
        // sister_1() 메서드 호출 시 수행할 작업들을 기술
        System.out.println("동생 : 오빠가 불 끄라고 해서 불을 껐다!");
        
        return; // 리턴값이 없을 경우 return; 만 써도 되고, 생략해도 됨
        // => 메서드 내에서 return 문을 만나면 현재 메서드 수행이 종료되고 호출한 곳으로 돌아감
    } // => 메서드 수행 종료 후 호출한 곳으로 돌아감
    
    
    // --------- 2. 파라미터는 없고, 리턴값만 있는 메서드 정의 ---------
    // => 파라미터가 없으므로 메서드 선언부의 소괄호() 안에 아무것도 명시하지 않음
    // => 리턴값이 있으므로 리턴타입 부분에 리턴할 데이터의 타입을 명시(ex. 문자열 = String)
    //    => 반드시 메서드 종료 시점에서 리턴값을 return 문을 사용하여 명시해야함!
    public static String sister_2() {
        System.out.println("동생 : 오빠가 물 떠오라고 시켰다!");
        System.out.println("동생 : 물을 떠다 줬다!");
        
        // return 문을 사용하여 리턴타입 String 에 해당하는 데이터 리턴
//        return "물"; // 리터럴을 직접 리턴하거나
        
        // 변수를 사용하여 변수에 값을 저장한 뒤 리턴할 수 있음
        String str = "물";
        return str;
    }
    
    
    // --------- 3. 파라미터만 있고, 리턴값은 없는 메서드 정의 ---------
    // => 파라미터가 있으므로, 메서드 선언부 소괄호() 안에 전달받는 데이터를 저장할 변수를 선언
    // => 리턴값이 없으므로 리턴타입 부분에 void 를 명시(void = 리턴할 데이터가 없다는 특수 타입)
    public static void sister_3(int sisterMoney) { // int형 데이터 1개 전달받아 sisterMoney 에 저장
        // => 전달받은 데이터가 저장된 파라미터를 사용하여 작업 수행 가능
        System.out.println("동생 : 오빠가 과자 사먹으라고 준돈 " + sisterMoney + "원");
        sisterMoney -= 200;
        System.out.println("동생 : 과자 사먹고 남은돈 " + sisterMoney + "원");
        
        // 리턴타입이 void 이므로 return 문을 생략하거나 return; 형태의 문장만 사용 가능
//        return; // 메서드 내에서 return 문을 만나면 현재 메서드를 종료하고 돌아감(생략 가능)
    }
 
} // 클래스 끝
 
 
 
public class Test {
 
    public static void main(String[] args) {
        // 1. 파라미터도 없고, 리턴값도 없는 메서드 호출
        // => "Hello, World!" 문자열을 10번 반복 출력하는 메서드 hello() 호출
        hello();
        
        // => 구구단을 2단 ~ 9단까지 차례대로 출력하는 메서드 gugudan() 호출
        gugudan();
        
        System.out.println("-----------------------");
        
        // 2. 파라미터는 없고, 리턴값만 있는 메서드 호출
        // => "아이티윌 부산교육센터" 문자열을 리턴하는 메서드 itwill() 호출
        //    => 리턴되는 문자열을 변수 result 에 저장한 후 출력
        String result = itwill();
        System.out.println(result);
        
        System.out.println("------------------------");
        
        // 3. 파라미터만 있고, 리턴값은 없는 메서드 호출
        // => hello2() 호출하여 반복할 횟수를 전달
        hello2(10); // "Hello, World!" 문자열이 5번 출력되도록 지정
        
        System.out.println("------------------------");
        
        // 4. 파라미터도 있고, 리턴값도 있는 메서드 호출
        // => abs() 메서드를 호출하여 절대값을 계산할 정수 전달 후 리턴값(absNum)을 출력
        int absNum = abs(-5);
        System.out.println("절대값 : " + absNum);
        
    } // main() 메서드 끝
 
    // --------- 4. 파라미터도 있고, 리턴값도 있는 메서드 정의 ---------
    // => 정수(num) 1개를 전달받아 절대값을 리턴하는 메서드 abs() 정의
    public static int abs(int num) {
        if(num < 0) {
            num = -num; // 절대값 계산
        }
        
        return num;
    }
    
    
    // --------- 1. 파라미터도 없고, 리턴값도 없는 메서드 정의 ---------
    // => "Hello, World!" 문자열을 10번 반복 출력하는 메서드 hello() 정의
    public static void hello() {
        // "Hello, World!" 문자열을 10번 반복 출력
        for(int i = 1; i <= 10; i++) {
            System.out.println("Hello, World!");
        }
    }
    
    // => 구구단을 2단 ~ 9단까지 차례대로 출력하는 메서드 gugudan() 정의
    public static void gugudan() {
        // 구구단 출력
        for(int dan = 2; dan <= 9; dan++) {
            System.out.println(" < " + dan + "단 >");
            
            for(int i = 1; i <= 9; i++) {
                System.out.println(dan + " * " + i + " = " + (dan * i));
            }
            
            System.out.println();
        }
    }
    
    // ---------- 2. 파라미터는 없고, 리턴값만 있는 메서드 정의 -----------
    // => 문자열 "아이티윌 부산교육센터" 를 리턴하는 메서드 itwill() 정의
    public static String itwill() {
//        return "아이티윌 부산교육센터";
        
        String result = "아이티윌 부산교육센터";
        return result;
    }
    
    
    // --------- 3. 파라미터만 있고, 리턴값은 없는 메서드 정의 ---------
    // => 정수값(num) 전달받아 "Hello, World!" 를 num 값 만큼 반복 출력하는 메서드 hello2() 정의
    public static void hello2(int num) {
        // "Hello, World!" 문자열을 num 번 반복 출력
        for(int i = 1; i <= num; i++) {
            System.out.println("Hello, World!");
        }
    }
    
    
 
} // 클래스 끝
 

오늘은 Class와 Method()에 대해서 배워보았는데 첫 시간부터 매일 쓰던 것들이 클래스와 메서드였단 걸 알게 되었고, 여러 개 만들어서 간단하게 가져다 쓸 수 있단 것도 배웠고 많은 걸 배웠던 날이었다. 오늘부터는 복습을 아주 열심히 해야 할거 같다. Method()를 Class 안에서 선언해야 한다는 것도 알게 되었고 정의한 Method()를 다른 클래스에서 인스턴스화를 통해 서로 다른 클래스에서도 사용이 가능하다는 것도 알게 되었고 여러 개의 클래스를 결합하여 복잡해지기 시작하는 것이 더 재미있어지고 있는 것 같다. Method() 정의할 때 파라미터라는 입력값과 리턴 값이 있고 없고 void를 사용해야 하는 경우와 아닌 경우를 배울 수 있었고, 인스턴스화를 통해 다른 클래스에서 정의된 변수를 주소 값만 가져와서 참조 변수로 사용하여 다른 클래스에서 정의된 변숫값은 변경되지 않고 들고 온 참조 변수의 값만 바뀐다는 것도 알게 되었고 Method()의 정의 부분에서 파라미터가 있고 없고, 리턴 값이 있고 없고의 조합으로 많은 걸 할 수 있단 걸 알게 되었다. 한 번에 좀 많은 걸 배운 느낌의 하루였다.