hyeonga_code

Java_32_클래스 객체 배열 본문

Java

Java_32_클래스 객체 배열

hyeonga 2023. 9. 27. 05:59
반응형

 


        
 - 데이터가 많을 경우 각각 객체를 선언하지 않고 배열을 활용합니다.

    - 클래스/객체 배열
     1. 객체의 개수를 정의합니다.
2. 각 개체를 생성합니다.
- 생성자를 통해 객체를 생성해야 합니다.

=====     

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
package oop.basic;
//모든 클래스는 패키지 안에 생성합니다.
 
public class StudentApp {
    // 모든 함수_메소드는 클래스 안에 작성합니다.
    
    // 별칭을 지정합니다.
    static void printInfo(Student student) {        
        /*
            - Scope 내의 코드에 대해 별칭을 지정하여 실행할 수 있습니다.
                '별칭' {
                    별칭으로 지정할 코드
                }
            - 문제
                - 외부에서 Scope 내의 변수에 접근할 수 없습니다.
            >>> 별칭은 내부 변수를 초기화 하는 매개 변수_()를 제공합니다.
                        - 매개 변수 이름은 내부 변수 이름과 동일하게 작성합니다.
                '별칭'('매개 변수 이름') {
                    별칭으로 지정할 코드
                }
            >>> Compile 하기 위해 매개 변수의 데이터 타입을 알려주어야 합니다.
                '별칭'('데이터 타입' '매개 변수 이름') {
                    별칭으로 지정할 코드
                }
            >>> 반환할 데이터 타입을 지정해주어야 합니다.
                void '별칭'('데이터 타입' '매개 변수 이름') {
                    별칭으로 지정할 코드
                }
            >>> static을 통해 클래스 이름을 통해 객체를 생성하지 않고도 접근이 가능합니다.
                static void '별칭'('데이터 타입' '매개 변수 이름') {
                    별칭으로 지정할 코드
                }
         */
        System.out.println("printInfo : " + student.studentName);
    }
    
    public static void main(String[] args) {
        // Java의 모든 코드는 함수 안에 작성합니다.
        /*
            - 'Student.java'에서 작성한 Student 클래스를 사용하기
                1) 클래스 spec을 만족하는 객체를 생성합니다.
                2) 데이터 저장
         */
        
        Student student1 = new Student();    
            /* 
                - 복합형 데이터를 다루는 클래스이기 때문에 new 로 객체를 생성합니다.
                - 대입 연산자의 왼쪽 부터 실행됩니다.
                    - Heap 공간에 Student() 메소드의 객체를 생성합니다.
                        - 클래스의 spec의 조건을 충족시키는지 확인합니다.
                    - Stack 공간에 Heap 공간의 Student() 메소드의 메모리의 주소를 
                        student1 변수에 저장합니다.
             */
        
        // 데이터 저장
        student1.studentName = "stName1";
        student1.address = "Address 123-123";
            /*
                - 클래스의 spec에 맞는 객체의 정보를 저장합니다.
                    '클래스 이름'.'멤버 변수 이름' = '저장할 값';
             */
        
        // 데이터 출력
        student1.showStudentInfo();
            /*
                Name : stName1
                Address : Address 123-123
                    - showStudentInfo() 함수를 호출하여 실행합니다.
                        - 함수를 작성한 페이지에 가지 않는 한 함수의 자세한 내용을 알 수 없습니다.
             */
        
        System.out.println(student1.studentName);
        
        Student student2 = new Student();    // 새로운 메소드 객체를 생성합니다.
        student2.studentName = "stName2";
        student2.showStudentInfo();
            /*
                Name : stName2
                Address : null
                    - student2 객체와 student1 객체는 다른 객체이므로 다른 정보가 출력됩니다.
                    - student2 객체에 address 정보를 저장하지 않았으므로 null 값이 출력됩니다.
             */
        System.out.println();
        printInfo(student2);
            /*
                printInfo : stName1
             */
        
        // 멤버 변수 접근
        Student student3 = new Student();
        student3.setStudentName("stName3");                // 값을 저장합니다.
        System.out.println();
        System.out.println("student3.getStudentName() : " + student3.getStudentName());    
                // 값을 불러옵니다.
        System.out.println("student3.studentName : " + student3.studentName);        
                // 값을 출력합니다.
            /*
                student3.getStudentName() : stName3
                student3.studentName : stName3
             */
 
        // 멤버 변수 접근 제한
        /*
        student3.grade();
            - 오류 : The method grade() is undefined for the type Student
            - Student 클래스에서 private으로 선언한 grade의 값에 접근할 수 없습니다.
         */
        System.out.println();
        System.out.println("student3.getGrade() : " + student3.getGrade());
            /*
                student3.getGrade() : 0
             */
 
        student3.setGrade(7);
        System.out.println();
        System.out.println("student3.setGrade(7) : " + student3.getGrade());
            /*
                student3.setGrade(7) : 7
             */
        
        // 생성자
        Student student4 = new Student(1);
        student4.setStudentName("stName4");
        student4.setGrade(2);
        student4.showStudentInfo();
            /*
                Name : stName4
                Address : null
                ID : 1
             */
        
        Student student5 = new Student("stName5");
        student5.showStudentInfo();
            /*
                Name : stName5
                Address : null
                ID : 0
             */
        
        Student student6 = new Student(2,"stName6","Address 456-456",2);
        student6.showStudentInfo();
            /*
                Name : stName6
                Address : Address 456-456
                ID : 2
             */
        
        // 객체 배열
        Student students[] = {
                student6, 
                new Student(3"stName7""Address 789-789"1),
                new Student("stName8")    
                    // 이름 데이터만 넘겨주는 생성자가 존재하므로 가능합니다.
        };
        
        for(int i=0; i<3; i++) {    // 출력
            students[i].showStudentInfo();;
        }
            /*
                Name : stName6
                Address : Address 456-456
                ID : 2
                Name : stName7
                Address : Address 789-789
                ID : 3
                Name : stName8
                Address : null
                ID : 0
             */
        
        // 대량 데이터 등록/출력
        Student stu[] = new Student[100];
        for (int i=1; i<=100; i++) {        // 데이터 저장
            stu[i-1= new Student(i, "stName "+i, "Address"+i, 2);
        }
        for (int i=1; i<=100; i++) {        // 데이터 출력
            System.out.println(i + "\t" + stu[i-1].studentName + "\t" 
                                    + stu[i-1].address + "\t" + stu[i-1].getGrade());
        }
            /*
                1    stName 1    Address1    2
                2    stName 2    Address2    2
                3    stName 3    Address3    2
                ...
                100    stName 100    Address100    2
             */
    }
}






 - 세 명의 이름과 전화번호 관리하기
=====     

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.util.*;
 
class Member {
    // 클래스 생성
    String name;
    // 이름 객체 생성
    String tel;
    // 번호 객체 생성
    Member(String name, String tel) {
        // 이름과 번호 객체를 가지는 생성자 생성
        this.name = name;
        this.tel = tel;
    }
 
    void disp() {
        // 출력 생성자 생성
        System.out.println(name + "\'s phone number : " + tel);
    }
}
 
public class same {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Member[] mb = new Member[3];
        // 클래스 배열 생성 _ 객체의 개수 지정
        for (int i = 0; i < 3++i) {
            // 각 객체 생성하기 위함
            // 
            System.out.print("Input name:");
            String name = in.next();
            System.out.print("Input tel: ");
            String tel = in.next();
            mb[i] = new Member(name, tel);
            // 각각의 객체를 생성자를 이용하여 생성하는 곳
        }
 
        for (int i = 0; i < 3++i) {
            mb[i].disp();
        }
    }
}






 - 인원수를 입력받아 그 인원수 만큼 이름, 국어, 영어점수를 입력받아 이름, 총점, 순위를 출력
=====     

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
import java.util.*;
 
class Member {
    String name;
    int kor, eng;
    // 성적 변수
    int tot;
    // 총점
    int lank = 1;
    // 랭킹
 
    Member(String name, int kor, int eng) {
        // 생성자 서언
        this.name = name;
        this.kor = kor;
        this.eng = eng;
        this.tot = kor + eng;
    }
 
    void disp() {
        // 출력
        System.out.println(name + "'s total score : " + tot + " | lank : " + lank);
    }
}
 
public class same {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 입력 기능
        System.out.print("Input people count: ");
        int people = in.nextInt();
        // 인원수 입력 받기 
        Member[] mb = new Member[people];    // 객체 선언부
        // 입력받은 인원수 크기의 배열 생성
 
        for (int i = 0; i < people; i++) {
            // 인원 수 만큼 입력 받기
            System.out.print("Input name: ");
            String name = in.next();
            System.out.printf("Input %s's kor: ", name);
            int kor = in.nextInt();
            System.out.printf("Input %s's eng: ", name);
            int eng = in.nextInt();
            mb[i] = new Member(name, kor, eng);    // 객체 생성부
        }
 
        for (int i = 0; i < people; ++i) {
            // i = 내 성적
            for (int j = 0; j < people; ++j) {
                // j = 다른 학생 성적
                if (mb[i].tot < mb[j].tot) {
                    // 내 성적이 다른 학생 성적의 총 점보다 작으면
                    mb[i].lank++;
                    // 내 순위를 하나 올린다.
                }
            }
        }
 
        for (int i = 0; i < people; ++i) {
            mb[i].disp();
        }
    }
}

 

반응형