반응형

Stack 


▶ 여러 개의 데이터 항목들이 일정한 순서로 나열된 자료구조

▶ 한쪽 끝에서만 새로운 항목을 삽입하거나 기존의 항목을 제거할 수 있다.

(L)ast (I)n (F)irst (O)ut ==> LIFO방식

▶Vector 클래스를 상속받아서 구현된다.



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
package stack;
 
import java.util.Stack;
import java.util.Vector;
 
public class StackTest {
    public static void main(String[] args) {
        // stack은 Vector를 상속받는다.
        //Vector<String> stack = new Stack<String>();
        
        Stack<String> s = new Stack<String>();
        
//        s.push("a");
//        s.push("b");
//        s.push("c");
//        
//        while(!s.isEmpty()) {
//            String value = s.pop();
//            System.out.println(value);
//        }
//        
//        s.pop(); // Exception occurs when stack is empty
 
        s.push("a");
        s.push("b");
        s.push("c");
        
        System.out.println(s.pop());
        System.out.println(s.peek()); // 제일 위에 어떤 값이 있는지 확인만 해줌, pop은 안함..
        System.out.println(s.pop());
    }
}
 
cs


Queue


▶ 리스트와 유사한 자료구조

▶ 항목들의 리스트에서 가장 마지막에 새로운 항목이 추가된다.

▶ 기존 항목의 제거는 리스트의 처음에서 일어난다.

(F)irst (I)n (F)irst (O)ut ==> FIFO방식

▶ LinkedList를 상속받아서 구현




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
package queue;
 
import java.util.LinkedList;
import java.util.Queue;
 
public class QueueTest {
    public static void main(String[] args) {
        // Queue는 LinkedList를 상속받는다.
        // Queue ==> (F)irst (O)ut (F)irst (I)n
        // Queue는 KAFKA(Message Queue)에서 많이 사용한다.
        Queue<String> q = new LinkedList<String>();
        
        //데이터 삽입
        q.offer("a");
        q.offer("b");
        q.offer("c");
        
        // 데이터 출력
        while(!q.isEmpty()) {
            String value = q.poll();
            System.out.println(value);
        }
    }
}
 
cs


반응형
반응형

[Java]Overriding/Overloading이 뭐야? 같은거 아냐?


는 절대 아니다.

둘의 공통점을 꼽자면 객체지향 4대 특징 중 하나인 다형성을 지원한다는 점이다.



Overriding(오버라이딩)?

상속받은 자식 클래스에서 부모 클래스의 필드 또는 메소드가 마음에 들지 않아 재정의할 경우 

이것을 Override(오버라이딩)라고 한다.

여기서 상속이란?

부모가 자식에게 물려주는 행위를 일컫는데..

이미 잘 개발된 클래스를 재사용해서 새로운 자식 클래스를 만들기 때문에 코드의 중복을 줄여준다.




Overloading(오버로딩)?

오버로딩은 메소드 오버로딩과 생성자 오버로딩 두가지가 있다.

이 두가지를 함수적 측면에서 본다면 같은 의미이다.


오버로딩은 같은 함수명으로 함수를 여러번 정의할 수 있는데 단, 조건이 있다.

오버로딩의 조건

1. 같은 함수명

2. 다른 유형과 개수의 매개변수


반응형

'Programming Language > JAVA' 카테고리의 다른 글

[Java] Stack & Queue  (0) 2019.01.04
[Java] final 넌 누구냐?!  (0) 2018.12.27
[Java] 접근 제한자(Access Modifier)에 대해서 알아보자  (0) 2018.12.27
[급여관리 프로그램(Has~A 만)  (1) 2018.07.16
[Java]Enum  (0) 2018.07.12
반응형

final이 가진 의미는 필드, 메소드, 클래스에 따라 각각 달라진다.


1. 필드에 final이 붙으면?

1
public final int A = 1234;
cs

상수를 뜻한다.

개발자들끼리의 약속으로 상수는 모두다 대문자로 지정해야한다.



2. 메소드에 final이 붙으면?

1
2
3
public final void func() {
        // Override 금지
}
cs


Override 금지!!


3. 클래스에 final이 붙으면?


대표적인 final 키워드가 붙은 클래스이다.

클래스에 final 키워드가 붙는다면 다른 클래스에서 해당 클래스를 상속 금지한다.




끝-

반응형
반응형

접근 제한자(Access Modifier)는 외부에서 해당 클래스에 접근할 수 있는 정도를 말한다.


외부에서 모두 접근할 수 있는 public부터 자기 자신만 접근 가능한 private까지 4가지의 접근 지정자가 존재한다.



4가지의 접근 제한자를 그림으로 표현하면 다음과 같다.





1. 모두 다 접근 가능한 public


public은 내부 외부에서 모두 접근이 가능하다. 

적용할 수 있는 범위 >> 클래스, 필드, 생성자, 메소드



2. 자식만 접근 가능한 protected


protected는 상속 받은 자식 클래스에서만 접근이 가능하다.

자식 클래스가 아닌 다른 패키지에 소속된 클래스는 접근이 불가능하다.

적용할 수 있는 범위 >> 필드, 생성자, 메소드



3. 나의 패키지 내에서만 접근 가능한 default


클래스를 선언할 때 public을 생략했다면 알게 모르게 클래스는 default 접근 제한을 가진다.

default는 같은 클래스 내에서만 접근이 가능하다.

다른 클래스는 접근이 불가능하다.

적용할 수 있는 범위 >> 클래스, 필드, 생성자, 메소드



4. 나 빼고 아무도 안돼 private


private는 모든 외부 클래스에서 접근이 불가능하다.

적용할 수 있는 범위 >> 필드, 생성자, 메소드

필드를 private로 설정했다면 public 접근 제한자를 가진 getter, setter 메소드를 통해서만 외부와 공유 가능하다.



반응형

'Programming Language > JAVA' 카테고리의 다른 글

[Java]Overriding / Overloading이 뭐야? 같은거 아냐?  (0) 2018.12.27
[Java] final 넌 누구냐?!  (0) 2018.12.27
[급여관리 프로그램(Has~A 만)  (1) 2018.07.16
[Java]Enum  (0) 2018.07.12
클래스 구성요소  (0) 2018.07.10
반응형
MainClass는 프로그램 진입점으로 관리자/사용자 여부를 판별합니다.
 
관리자 로그인 실패시 사용자로 간주하여 사용자모드(사번, 비밀번호 입력 후 일치 데이터가 있을 경우 해당 직원 데이터에 대해 출력)로 자동적으로 넘어갑니다. 관리자 모드에서는 정규직 비정규직 최대 인원수를 입력받고 데이터의 입력, 출력, 수정, 삭제, 검색 기능을 사용할 수 있습니다.

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
/*
 * MainClass.java
 * 프로그램 진입점...
 */
package hasA;
 
import java.util.Scanner;
 
public class MainClass {
 
    private Administrator admin;
 
    public MainClass() {
        this.admin = new Administrator("aa""1234");
    }
 
    public static void main(String[] args) {
 
        MainClass mc = new MainClass();
 
        Scanner sc = new Scanner(System.in);
 
        char prev = 'y';
 
        do {
            boolean pass = false;
 
            pass = mc.admin.identiAdmin(); // 관리자인지 아닌지 확인
 
            if (pass) { // 관리자
                mc.admin.whatAreYouGoing();// 정규직 관리로 갈지 비정규직으로 갈지 확인하는 함수        
            } else {
                System.out.println("사용자 모드..");
                System.out.print("검색하고 싶은 사번을 입력하세요(R_ / P_) : ");
                String num = sc.next();
                System.out.print(num + " 직원의 비밀번호를 입력하세요 : ");
                String password = sc.next();
 
                if (num.charAt(0== 'R') { // 정규직
                    if (mc.admin.getRegularManagement() != null)
                        mc.admin.getRegularManagement().userSearch(num, password);
                    else
                        System.out.println("데이터 나타낼 수 없음");
                } else { // 비정규직
                    if (mc.admin.getPartTimeEmployeeManagementSystem() != null)
                        mc.admin.getPartTimeEmployeeManagementSystem().userSearch(num, password);
                    else
                        System.out.println("데이터 나타낼 수 없음");
                }                
            }
            System.out.println("---------- 페이지  ----------");
            System.out.println("이 페이지 수행 기능 ");
            System.out.println("-> 관리자 로그인 페이지");
            System.out.println("이 페이지 머물기(y) / 프로그램 종료(n): ");
            prev = sc.next().charAt(0);
        } while (prev != 'n');
 
        System.out.println();
        System.out.println("프로그램 종료");
 
    }
}
 
cs



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * ManagementSystem.java
 * 해당 인터페이스는 관리클래스를 관리
 */
package hasA;
 
public interface ManagementSystem {
 
    // 입력
    public void input();
    // 수정
    public void modifi();
    // 삭제
    public void delete();
    // 검색
    public void search();
    // 출력
    public void allOutput();
    
}
 
cs


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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
/*
 * RegularManagement.java
 */
 
package hasA;
 
import java.util.Scanner;
 
/*
 * 이곳은 정규직 관리 클래스 입니다.
 * 정규직 직원에 대한 데이터 입력을 담당합니다.
*/
public class RegularManagement implements ManagementSystem {
    private RegularEmployee[] re; // 정규직직원클래스
    private SalaryManagement sm; // 급여관리클래스
    private int numOfRegular; // 정규직 최대 인원수
    private int empCount; // 입력받을 직원 수
    private int empIndex; // 현재 입력받을 수 있는 reference index
 
    public RegularManagement() {
        this(0);
    }
 
    public RegularManagement(int numOfRegular) {
        this.numOfRegular = numOfRegular;
 
        // 사람 수 만큼 정규직 직원 생성
        re = new RegularEmployee[this.numOfRegular];
        sm = null;
 
        empCount = 0;
        empIndex = 0;
    }
 
    // setter,getter
    public RegularEmployee[] getRe() {
        return re;
    }
 
    public void setRe(RegularEmployee[] re) {
        this.re = re;
    }
 
    public SalaryManagement getSm() {
        return sm;
    }
 
    public long getSalary(RegularEmployee re) {
        this.sm = new SalaryManagement(re);
        this.sm.putOnRecord();
        return this.sm.getRealSalary();
    }
 
    public void setNumOfRegular(int numOfRegular) {
        this.numOfRegular = numOfRegular;
    }
 
    public int getNumOfRegular() {
        return numOfRegular;
    }
 
    // 입력
    public void input() {
 
        Scanner sc = new Scanner(System.in);
 
        if (empIndex == numOfRegular) { // 입력을 다 하였을 경우..
            System.out.println("더 이상 입력할 수 없습니다.");
        } else {
            System.out.print("정규직 직원 몇명 입력하시겠어요? ");
            this.empCount = sc.nextInt(); // 입력받을 직원 수
            System.out.println();
 
            if (empCount + empIndex > numOfRegular) {
                System.out.println("입력할 수 있는 범위를 초과하였습니다..");
                System.out.println("다시 시도해주세요..");
            } else {
                for (int i = 0; i < empCount; i++) {
                    re[empIndex] = new RegularEmployee();
 
                    System.out.println("정규직 " + (empIndex + 1+ "번째 직원 정보 입력");
 
                    // 사번
                    re[empIndex].setEmpNum(empIndex + 1);
 
                    // 이름입력
                    System.out.print((empIndex + 1+ "번째 직원 이름 입력 : ");
                    String name = sc.next();
                    System.out.println();
 
                    // 나이입력
                    System.out.print((empIndex + 1+ "번째 직원 나이 입력 : ");
                    int age = sc.nextInt();
                    System.out.println();
 
                    // 생년월일
                    System.out.print((empIndex + 1+ "번째 직원 생년월일 입력(YYYY-MM-DD) : ");
                    String birth = sc.next();
                    System.out.println();
 
                    // 주소
                    System.out.print((empIndex + 1+ "번째 직원 주소 입력 : ");
                    String address = sc.next();
                    System.out.println();
 
                    // 연락처
                    System.out.print((empIndex + 1+ "번째 직원 연락처 입력 : ");
                    String tel = sc.next();
                    System.out.println();
 
                    // 이메일 입력
                    System.out.print((empIndex + 1+ "번째 직원 이메일 입력 : ");
                    String email = sc.next();
                    System.out.println();
 
                    // 은행명 입력
                    System.out.print((empIndex + 1+ "번째 직원 은행명 입력 : ");
                    String bankName = sc.next();
                    System.out.println();
 
                    // 계좌 입력
                    System.out.print((empIndex + 1+ "번째 직원 계좌 입력 : ");
                    String account = sc.next();
                    System.out.println();
 
                    // 개인정보 입력
                    re[empIndex].setPersonalInfo(name, age, birth, address, tel, email, bankName, account);
 
                    // 직책 입력
                    int pos = 0;
                    do {
                        System.out.println((empIndex + 1+ "번째 직원 해당되는 직책 번호를 선택하세요");
                        System.out.println("1.신입사원  2.사원  3.대리  4.과장  5.팀장  6.차장  7.부장  8.전무  9.이사  10.대표이사");
                        System.out.print("-> ");
                        pos = sc.nextInt();
                    } while ((pos >= 1 && pos <= 10== false); // 직책 선택을 잘못 했을 경우
                    re[empIndex].setPosition(Position.getPosition(pos));
                    System.out.println();
 
                    // 소속팀 입력
                    System.out.print((empIndex + 1+ "번째 직원 소속팀 입력 : ");
                    re[empIndex].setTeam(sc.next());
                    System.out.println();
 
                    // 소속부서 입력
                    System.out.print((empIndex + 1+ "번째 직원 소속부서 입력 : ");
                    re[empIndex].setDept(sc.next());
                    System.out.println();
 
                    // 입사년도 입력
                    System.out.print((empIndex + 1+ "번째 직원 입사년도 입력(YYYY) : ");
                    re[empIndex].setYear(sc.nextInt());
                    System.out.println();
 
                    // 비밀번호 입력
                    System.out.print((empIndex + 1+ "번째 직원 비밀번호 입력 : ");
                    re[empIndex].setPassword(sc.next());
                    System.out.println();
 
                    // 사용자에게 입력받을 필요가 없는 부분 등록..
                    // 급여등록 : 직책으로 급여계산
                    long salary = this.getSalary(re[empIndex]); // 급여관리 클래스에서 실급여 계산하고 salary변수에 입력
                    re[empIndex].setSalary(salary); // 입력된 급여를 해당 직원 급여에 입력
 
                    empIndex++;
                }
            }
        }
    }
 
    // 수정
    public void modifi() { // 이름검색
 
        Scanner sc = new Scanner(System.in);
 
        if (empIndex == 0) {
 
            System.out.println("직원정보가 없습니다.");
        } else {
 
            System.out.print("검색하고 싶은 직원 이름을 입력하세요 : ");
            String tmpName = sc.next();
 
            boolean exist = true;
 
            for (int i = 0; i < empIndex; i++) {
                if (re[i].getPersonalInfo().getName().equals(tmpName)) {
 
                    System.out.println("수정하고 싶은 데이터를 선택하세요..");
                    System.out.println("1.이름  2.나이  3.생일  4.주소 5.전화번호  6.이메일  7.은행명  8.계좌");
                    System.out.println("9.직책  10.소속팀  11.소속부서 12.근속년도  13.비밀번호");
                    System.out.print("-> ");
                    int num = sc.nextInt(); // 번호 선택
 
                    String sTmp = "";
                    int iTmp = 0;
                    long salary = 0;
 
                    switch (num) {
                    case 1// 이름수정
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        re[i].getPersonalInfo().setName(sTmp);
                        break;
                    case 2// 나이 수정
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        iTmp = sc.nextInt();
                        re[i].getPersonalInfo().setAge(iTmp);
                        break;
                    case 3// 생년월일수정
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        re[i].getPersonalInfo().setBirth(sTmp);
                        break;
                    case 4// 주소 수정
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        re[i].getPersonalInfo().setAddress(sTmp);
                        break;
                    case 5// 전화번호 수정
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        re[i].getPersonalInfo().setTel(sTmp);
                        break;
                    case 6// 이메일 수정
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        re[i].getPersonalInfo().setEmail(sTmp);
                        break;
                    case 7// 은행명 수정
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        re[i].getPersonalInfo().setBankName(sTmp);
                        break;
                    case 8// 계좌 수정
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        re[i].getPersonalInfo().setAccount(sTmp);
                        break;
                    case 9// 직책수정
                        int pos = 0;
                        do {
                            System.out.println("수정할 데이터를 입력하세요 : ");
                            System.out.println("1.신입사원  2.사원  3.대리  4.과장  5.팀장  6.차장  7.부장  8.전무  9.이사  10.대표이사");
                            System.out.print("-> ");
                            pos = sc.nextInt();
                        } while ((pos >= 1 && pos <= 10== false); // 직책 선택을 잘못 했을 경우
                        re[i].setPosition(Position.getPosition(pos));
                        // 급여등록 -> 직책이 수정되면 insentive가 바뀌므로...
                        salary = this.getSalary(re[i]); // 급여관리 클래스에서 실급여 계산하고 salary변수에 입력
                        re[i].setSalary(salary); // 입력된 급여를 해당 직원 급여에 입력
                        break;
                    case 10// 팀 수정
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        re[i].setTeam(sTmp);
                        break;
                    case 11// 부서 수정
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        re[i].setDept(sTmp);
                        break;
                    case 12// 근속년도 수정
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        iTmp = sc.nextInt();
                        re[i].setYear(iTmp);
                        // 급여등록 -> 근속년도가 수정되면 basicSalary가 바뀌므로...
                        salary = this.getSalary(re[empIndex]); // 급여관리 클래스에서 실급여 계산하고 salary변수에 입력
                        re[i].setSalary(salary); // 입력된 급여를 해당 직원 급여에 입력
                        break;
                    case 13// 비밀번호 수정
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        re[i].setPassword(sTmp);
                        break;
                    default:
                        System.out.println("잘못 입력하였습니다.");
                    }
                    exist = true;
                    System.out.println();
                    System.out.println("수정완료!!");
                }
                if (!exist)
                    System.out.println("검색하신 " + tmpName + " 직원에 대한 정보가 없습니다.");
 
            }
        }
    }
 
    // 삭제
    public void delete() {
 
        Scanner sc = new Scanner(System.in);
 
        if (empIndex == 0) {
 
            System.out.println("직원정보가 없습니다.");
        } else {
 
            System.out.print("삭제할 직원의 이름을 입력하세요 : ");
            String tmpName = sc.next();
 
            boolean exist = false;
 
            for (int i = 0; i < empIndex; i++) {
                if (re[i].getPersonalInfo().getName().equals(tmpName)) {
                    re[i] = null;
                    exist = true;
                }
                System.out.println("삭제완료!!");
            }
            if (!exist)
                System.out.println("검색하신 " + tmpName + " 직원에 대한 정보가 없습니다.");
        }
    }
 
    // 검색
    public void search() { // 이름 검색
 
        Scanner sc = new Scanner(System.in);
 
        if (empIndex == 0) {
 
            System.out.println("직원정보가 없습니다.");
        } else {
 
            System.out.print("검색하고 싶은 직원 이름을 입력하세요 : ");
            String tmpName = sc.next();
 
            boolean exist = false;
 
            for (int i = 0; i < empIndex; i++) {
                if (re[i].getPersonalInfo().getName().equals(tmpName)) {
                    disp(re[i]);
 
                    exist = true;
                }
            }
            if (!exist)
                System.out.println("검색하신 " + tmpName + " 직원에 대한 정보가 없습니다.");
 
            exist = !exist;
        }
    }
 
    // 출력
    public void allOutput() {
 
        if (empIndex == 0) {
 
            System.out.println("직원정보가 없습니다.");
        } else {
 
            System.out.println("-----------------------------------");
            System.out.println("----------정규직 직원 전체 출력----------");
            System.out.println("-----------------------------------");
 
            for (int i = 0; i < empIndex; i++) {
                if (re[i] != null) {
                    System.out.println((i + 1+ "번째 직원 출력");
                    disp(re[i]);
                }
            }
        }
    }
 
    public void userSearch(String num, String password) { // 사용자에서 사번과 이름을 받아옴
 
        if (empIndex == 0) {
            System.out.println("직원정보가 없습니다.");
        } else {
            for (int i = 0; i < empIndex; i++) {
                if (re[i] != null) {
                    if (re[i].getEmpNum().equals(num) && re[i].getPassword().equals(password))
                        disp(re[i]);
                }
            }
        }
    }
 
    public void disp(RegularEmployee re) {
        System.out.println("----------------------------------------");
        System.out.println("사번 : " + re.getEmpNum()); // 사번
        // 직원 개인정보 출력
        System.out.println("이름 : " + re.getPersonalInfo().getName()); // 이름
        System.out.println("나이 : " + re.getPersonalInfo().getAge()); // 나이
        System.out.println("연락처 : " + re.getPersonalInfo().getBirth()); // 연락처
        System.out.println("주소 : " + re.getPersonalInfo().getAddress()); // 주소
        System.out.println("전화번호 : " + re.getPersonalInfo().getTel()); // 전화번호
        System.out.println("이메일 : " + re.getPersonalInfo().getEmail()); // 이메일
        System.out.println("은행명 : " + re.getPersonalInfo().getBankName()); // 은행명
        System.out.println("계좌번호 : " + re.getPersonalInfo().getAccount()); // 계좌번호
        System.out.println("직책 : " + re.getPosition()); // 직책
        System.out.println("소속팀 : " + re.getTeam()); // 소속팀
        System.out.println("소속부서 : " + re.getDept()); // 소속부서
        System.out.println("급여 : " + re.getSalary()); // 급여
        System.out.println("근속년도 : " + re.getYear()); // 근속년도
        System.out.println("----------------------------------------");
    }
}
 
cs


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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
package hasA;
 
import java.util.Scanner;
 
public class PartTimeEmployeeManagementSystem implements ManagementSystem {
 
    private PartTimeEmployee[] partTimeEmployee; // 비정규직 직원 클래스
    private SalaryManagement salaryManagement; // 급여관리 클래스
    private int maxNum; // 비정규직 최대 인원수
    private int empCount; // 입력받을 직원 수
    private int empIndex; // 현재 입력받을 수 있는 reference index
 
    public PartTimeEmployeeManagementSystem() {
        this(0);
    }
 
    public PartTimeEmployeeManagementSystem(int maxNum) {
 
        this.maxNum = maxNum;
        /*
         * PartTimeEmployeeManagementSystem을 생성한 클래스에서 비정규직 수를 최대로 받아 그만큼 생성합니다.
         */
        partTimeEmployee = new PartTimeEmployee[maxNum];
        salaryManagement = null;
 
        empCount = 0;
        empIndex = 0;
    }
 
    // setter,getter
 
    public PartTimeEmployee getPartTimeEmployee(int index) { // 주입된 index를 통해 partTimeEmployee[index]의 값을 return
        return partTimeEmployee[index];
    }
 
    public void setPartTimeEmployee(PartTimeEmployee[] pe) {
        this.partTimeEmployee = pe;
    }
 
    public SalaryManagement getSalaryManagement() {
        return salaryManagement;
    }
 
    public void setSalaryManagement(PartTimeEmployee pe) {
        salaryManagement = new SalaryManagement(pe);
        salaryManagement.putOnRecord();
    }
 
    public void setNumOfRegular(int maxNum) {
        this.maxNum = maxNum;
    }
 
    public int getNumOfRegular() {
        return maxNum;
    }
 
    public PartTimeEmployee getClass(int index) {
        return partTimeEmployee[index];
    }
 
    public long getSalary(PartTimeEmployee pe) {
        this.salaryManagement = new SalaryManagement(pe);
        this.salaryManagement.putOnRecord();
        return this.salaryManagement.getRealSalary();
    }
 
    // 입력
    public void input() {
 
        Scanner sc = new Scanner(System.in);
 
        if (empIndex == maxNum) { // 입력을 다 하였을 경우..
            System.out.println("더 이상 입력할 수 없습니다.");
        } else {
            System.out.print("비정규직 직원 몇명 입력하시겠어요? ");
            this.empCount = sc.nextInt(); // 입력받을 직원 수
            System.out.println();
 
            if (empCount + empIndex > maxNum) {
                System.out.println("입력할 수 있는 범위를 초과하였습니다..");
                System.out.println("다시 시도해주세요..");
            } else {
                for (int i = 0; i < empCount; i++) {
                    partTimeEmployee[empIndex] = new PartTimeEmployee();
 
                    System.out.println("비정규직 " + (empIndex + 1+ "번째 직원 정보 입력");
 
                    // 사번
                    partTimeEmployee[empIndex].setEmpNum(empIndex + 1);
 
                    // 이름입력
                    System.out.print((empIndex + 1+ "번째 직원 이름 입력 : ");
                    String name = sc.next();
                    System.out.println();
 
                    // 나이입력
                    System.out.print((empIndex + 1+ "번째 직원 나이 입력 : ");
                    int age = sc.nextInt();
                    System.out.println();
 
                    // 생년월일
                    System.out.print((empIndex + 1+ "번째 직원 생년월일 입력(YYYY-MM-DD) : ");
                    String birth = sc.next();
                    System.out.println();
 
                    // 주소
                    System.out.print((empIndex + 1+ "번째 직원 주소 입력 : ");
                    String address = sc.next();
                    System.out.println();
 
                    // 연락처
                    System.out.print((empIndex + 1+ "번째 직원 연락처 입력 : ");
                    String tel = sc.next();
                    System.out.println();
 
                    // 이메일 입력
                    System.out.print((empIndex + 1+ "번째 직원 이메일 입력 : ");
                    String email = sc.next();
                    System.out.println();
 
                    // 은행명 입력
                    System.out.print((empIndex + 1+ "번째 직원 은행명 입력 : ");
                    String bankName = sc.next();
                    System.out.println();
 
                    // 계좌 입력
                    System.out.print((empIndex + 1+ "번째 직원 계좌 입력 : ");
                    String account = sc.next();
                    System.out.println();
 
                    // 개인정보 입력
                    partTimeEmployee[empIndex].setPersonalInfo(name, age, birth, address, tel, email, bankName,
                            account);
 
                    // 소속팀 입력
                    System.out.print((empIndex + 1+ "번째 직원 소속팀 입력 : ");
                    partTimeEmployee[empIndex].setTeam(sc.next());
                    System.out.println();
 
                    // 소속부서 입력
                    System.out.print((empIndex + 1+ "번째 직원 소속부서 입력 : ");
                    partTimeEmployee[empIndex].setDept(sc.next());
                    System.out.println();
 
                    // 입사년도 입력
                    System.out.print((empIndex + 1+ "번째 직원 입사년도 입력(YYYY) : ");
                    partTimeEmployee[empIndex].setYear(sc.nextInt());
                    System.out.println();
 
                    // 계약기간 입력
                    System.out.print((empIndex + 1+ "번째 직원 계약기간 : ");
                    partTimeEmployee[empIndex].setPeriod(sc.nextInt());
                    System.out.println();
 
                    // 비밀번호 입력
                    System.out.print((empIndex + 1+ "번째 직원 비밀번호 입력 : ");
                    partTimeEmployee[empIndex].setPassword(sc.next());
                    System.out.println();
 
                    ///////////
                    // 사용자에게 입력을 받을 필요가 없는 부분
                    partTimeEmployee[empIndex].setEndOfDate(); // 퇴사일자 = 입사년도 + 계약기간
 
                    // 사용자에게 입력받을 필요가 없는 부분 등록..
                    // 급여등록 : 직책으로 급여계산
                    // 급여등록
                    long salary = this.getSalary(partTimeEmployee[empIndex]);
                    partTimeEmployee[empIndex].setSalary(salary);
                    System.out.println();
 
                    empIndex++;
                }
            }
        }
    }
 
    // 수정
    public void modifi() {// 이름검색
 
        Scanner sc = new Scanner(System.in);
 
        if (empIndex == 0) {
 
            System.out.println("직원정보가 없습니다.");
        } else {
 
            System.out.print("검색하고 싶은 직원 이름을 입력하세요 : ");
            String tmpName = sc.next();
 
            boolean exist = true;
 
            for (int i = 0; i < empIndex; i++) {
                if (partTimeEmployee[i].getPersonalInfo().getName().equals(tmpName)) {
 
                    System.out.println("수정하고 싶은 데이터를 선택하세요..");
                    System.out.println("1.이름  2.나이  3.생일  4.주소 5.전화번호  6.이메일  7.은행명  8.계좌번호");
                    System.out.println("9.소속팀  10.소속부서  11.입사년도  12.계약기간  13.비밀번호");
                    System.out.print("-> ");
                    int num = sc.nextInt(); // 번호 선택
 
                    String sTmp = "";
                    int iTmp = 0;
 
                    switch (num) {
                    case 1// 이름
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        partTimeEmployee[i].getPersonalInfo().setName(sTmp);
                        break;
                    case 2// 나이
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        iTmp = sc.nextInt();
                        partTimeEmployee[i].getPersonalInfo().setAge(iTmp);
                        break;
                    case 3// 생일
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        partTimeEmployee[i].getPersonalInfo().setBirth(sTmp);
                        break;
                    case 4// 주소
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        partTimeEmployee[i].getPersonalInfo().setAddress(sTmp);
                        break;
                    case 5// 전화번호
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        partTimeEmployee[i].getPersonalInfo().setTel(sTmp);
                        break;
                    case 6// 이메일
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        partTimeEmployee[i].getPersonalInfo().setEmail(sTmp);
                    case 7// 은행명
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        partTimeEmployee[i].getPersonalInfo().setBankName(sTmp);
                    case 8// 계좌
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        partTimeEmployee[i].getPersonalInfo().setAccount(sTmp);
                        break;
                    case 9// 팀
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        partTimeEmployee[i].setTeam(sTmp);
                        break;
                    case 10// 소속부서
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        partTimeEmployee[i].setDept(sTmp);
                        break;
                    case 11// 입사년도
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        iTmp = sc.nextInt();
                        partTimeEmployee[i].setYear(iTmp);
                        break;
                    case 12// 계약기간
                        System.out.println("수정할 데이터를 입력하세요 : ");
                        iTmp = sc.nextInt();
                        partTimeEmployee[i].setPeriod(iTmp);
                        break;
                    case 13// 비밀번호
                        System.out.print("수정할 데이터를 입력하세요 : ");
                        sTmp = sc.next();
                        partTimeEmployee[i].setPassword(sTmp);
                        break;
                    default:
                        System.out.println("잘못 입력하였습니다.");
                    }
                    exist = true;
                    System.out.println();
                    System.out.println("수정완료!!");
                }
                if (!exist)
                    System.out.println("검색하신 " + tmpName + " 직원에 대한 정보가 없습니다.");
 
            }
        }
    }
 
    // 삭제
    public void delete() {
 
        Scanner sc = new Scanner(System.in);
 
        if (empIndex == 0) {
 
            System.out.println("직원정보가 없습니다.");
        } else {
 
            System.out.print("삭제할 직원의 이름을 입력하세요 : ");
            String tmpName = sc.next();
 
            boolean exist = true;
 
            for (int i = 0; i < empIndex; i++) {
                if (partTimeEmployee[i].getPersonalInfo().getName().equals(tmpName)) {
                    partTimeEmployee[i] = null;
                    exist = true;
                }
                if (!exist)
                    System.out.println("검색하신 " + tmpName + " 직원에 대한 정보가 없습니다.");
            }
        }
    }
 
    // 검색
    public void search() {
 
        Scanner sc = new Scanner(System.in);
 
        if (empIndex == 0) {
 
            System.out.println("직원정보가 없습니다.");
        } else {
 
            System.out.print("검색하고 싶은 직원 이름을 입력하세요 : ");
            String tmpName = sc.next();
 
            boolean exist = false;
 
            for (int i = 0; i < empIndex; i++) {
                if (partTimeEmployee[i].getPersonalInfo().getName().equals(tmpName)) {
                    this.disp(partTimeEmployee[i]);
 
                    exist = true;
                }
                if (!exist)
                    System.out.println("검색하신 " + tmpName + " 직원에 대한 정보가 없습니다.");
 
                exist = !exist;
 
            }
        }
    }
 
    // 출력
    public void allOutput() {
 
        if (empIndex == 0) {
 
            System.out.println("직원정보가 없습니다.");
        } else {
 
            boolean exist = true;
 
            System.out.println("-----------------------------------");
            System.out.println("----------비정규직 직원 전체 출력----------");
            System.out.println("-----------------------------------");
 
            for (int i = 0; i < empIndex; i++) {
                if (partTimeEmployee[i] != null) {
                    System.out.println((i + 1+ "번째 직원 출력");
                    this.disp(partTimeEmployee[i]);
                    exist = true;
                }
                if (!exist)
                    System.out.println("직원 정보가 없습니다.");
            }
        }
    }
 
    public void userSearch(String num, String password) { // 사용자에서 사번과 이름을 받아옴
 
        if (empIndex == 0) {
            System.out.println("직원정보가 없습니다.");
        } else {
            for (int i = 0; i < empIndex; i++) {
                if (partTimeEmployee[i] != null) {
                    if (partTimeEmployee[i].getEmpNum().equals(num)
                            && partTimeEmployee[i].getPassword().equals(password))
                        this.disp(partTimeEmployee[i]);
                }
            }
        }
    }
 
    public void disp(PartTimeEmployee pe) {
        System.out.println("----------------------------------------");
        System.out.println("사번 : " + pe.getEmpNum()); // 사번
        // 직원 개인정보 출력
        System.out.println("이름 : " + pe.getPersonalInfo().getName()); // 이름
        System.out.println("나이 : " + pe.getPersonalInfo().getAge()); // 나이
        System.out.println("연락처 : " + pe.getPersonalInfo().getBirth()); // 연락처
        System.out.println("주소 : " + pe.getPersonalInfo().getAddress()); // 주소
        System.out.println("전화번호 : " + pe.getPersonalInfo().getTel()); // 전화번호
        System.out.println("이메일 : " + pe.getPersonalInfo().getEmail()); // 이메일
        System.out.println("은행명 : " + pe.getPersonalInfo().getBankName()); // 은행명
        System.out.println("계좌번호 : " + pe.getPersonalInfo().getAccount()); // 계좌번호
        System.out.println("소속팀 : " + pe.getTeam()); // 소속팀
        System.out.println("소속부서 : " + pe.getDept()); // 소속부서
        System.out.println("급여 : " + pe.getSalary()); // 급여
        System.out.println("근속년도 : " + pe.getYear()); // 근속년도
        System.out.println("계약기간 : " + pe.getPeriod() + "년"); // 계약기간
        System.out.println("퇴사일자 : " + pe.getEndOfDate() + "년"); // 퇴사일자
        System.out.println("----------------------------------------");
    }
}
 
cs

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
/**
 * PersonalInfo.java
 */
package hasA;
 
import java.util.Date;
 
public class PersonalInfo {
 
    private String name;// 이름
    private int age;// 나이
    private String birth;// 생년월일
    private String address;// 주소
    private String tel;// 연락처
    private String email;// email
    private String bankName; //은행
    private String account;
 
    public PersonalInfo() {
        this(""0"""""""""""");
    }
 
    public PersonalInfo(String name, int age, String birth, String address, 
            String tel, String email, String bankName, String account) {
        super();
        this.name = name;
        this.age = age;
        this.birth = birth;
        this.address = address;
        this.tel = tel;
        this.email = email;
        this.bankName = bankName;
        this.account = account;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = new String(name);
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getBirth() {
        return birth;
    }
 
    public void setBirth(String birth) {
        this.birth = new String(birth);
    }
 
    public String getAddress() {
        return address;
    }
 
    public void setAddress(String address) {
        this.address = new String(address);
    }
 
    public String getTel() {
        return tel;
    }
 
    public void setTel(String tel) {
        this.tel = tel;
    }
 
    public String getEmail() {
        return email;
    }
 
    public void setEmail(String email) {
        this.email = new String(email);
    }
 
    public String getBankName() {
        return bankName;
    }
 
    public void setBankName(String bankName) {
        this.bankName = bankName;
    }
 
    public String getAccount() {
        return account;
    }
 
    public void setAccount(String account) {
        this.account = account;
    }
    
}
cs


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
/**
 * RegularEmployee.java
 */
package hasA;
 
import java.util.Date;
 
 
 
//정규직 클래스는 필드와 게터 세터만 존재함
//사번,개인정보,직책,소속팀,소속부서,급여,근속년도,비밀번호,생성자
public class RegularEmployee {
 
    // 사번
    private String empNum;
    // 개인정보
    private PersonalInfo pi;
    // 직책
    private String position;
    // 소속팀
    private String team;
    // 소속부서
    private String dept;
    // 급여(월급)
    private long salary;
    // 근속년도
    private int year;
    // 비밀번호
    private String password;
    
 
    public RegularEmployee() {
        this("",""""""00"");        
    }
 
    public RegularEmployee(String empNum,String position, String team, String dept, long salary, int year, String password)
    {
        this.empNum = empNum;
        pi = new PersonalInfo();
        this.position =position;
        this.team=team;
        this.dept=dept;
        this.salary=salary;
        this.year=year;
        this.password = password;
    }
    
    // 사번
    public String getEmpNum() {
        return empNum;
    }
 
    public void setEmpNum(int index) {
        this.empNum = new String("R" + index);
    }
    
    //개인정보 입력
    public void setPersonalInfo(String name, int age, String birth, 
            String address, String tel, String email, String bankName, String account) {
        pi = new PersonalInfo();
        pi.setName(name);
        pi.setAge(age);
        pi.setBirth(birth);
        pi.setAddress(address);
        pi.setTel(tel);
        pi.setEmail(email);
        pi.setBankName(bankName);
        pi.setAccount(account);
    }
    
    public PersonalInfo getPersonalInfo() {
        return pi;
    }
    
 
    // 직책
    public String getPosition() {
        return position;
    }
 
    public void setPosition(String position) {
        this.position = new String(position);
    }
 
    // 소속팀
    public String getTeam() {
        return team;
    }
 
    public void setTeam(String team) {
        this.team = new String(team);
    }
 
    // 소속부서
    public String getDept() {
        return dept;
    }
 
    public void setDept(String dept) {
        this.dept = new String(dept);
    }
 
    // 급여
    public long getSalary() {
        return salary;
    }
 
    public void setSalary(long salary) {
        this.salary = salary;
    }
 
    // 근속년도
    public int getYear() {
        return year;
    }
 
    public void setYear(int year) {
        //올해 몇년도?
        //Date date = new Date();
        int thisYear = 2018;
        
        //근속년도 구하기(올해 - 입사년도)
        this.year = thisYear - year;
    }
 
    // 비밀번호
    public String getPassword() {
        return password;
    }
 
    public void setPassword(String password) {
        this.password = new String(password);
    }
 
}
 
cs


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
/**
 * Position.java
 */
package hasA;
 
public class Position { 
    
    public static String getPosition(int pos) {
    
        switch(pos) {
            case 1
                return "신입사원";
            case 2
                return "사원";
            case 3
                return "대리";
            case 4
                return "과장";
            case 5
                return "팀장";
            case 6
                return "차장";
            case 7
                return "부장";
            case 8
                return "전무";
            case 9
                return "이사";
            case 10
                return "대표이사";
            default :
                return "null";
        }
    }
}
cs

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
/**
 * PartTimeEmployee.java
 */
package hasA;
 
import java.util.Date;
 
public class PartTimeEmployee {
 
    private String empNum;// 사번
    private PersonalInfo personalInfo; // 개인정보
    private String team;// 소속팀
    private String dept;// 소속부서
    private long salary;// 급여
    private int year;// 근속년도
    private int period;// 계약기간
    private int endOfDate;// 퇴사일자
    private String password;// 비밀번호
 
    public PartTimeEmployee() {
        this(0""""000"""");
    }
 
    public PartTimeEmployee(int empIndex, String team, String dept, int salary, int year, int period, String endOfDate, String password) {
        this.empNum = "P" + empIndex;
        personalInfo = new PersonalInfo();
        this.team = team;
        this.dept = dept;
        this.salary = salary;
        this.year = year;
        this.period = period;
        endOfDate = endOfDate;
        this.password = password;
    }
 
    // this.개인정보 set
    public void setPersonalInfo(String name, int age, String birth, 
            String address, String tel, String email, String bankName, String account) {
        personalInfo = new PersonalInfo();
        personalInfo.setName(name);
        personalInfo.setAge(age);
        personalInfo.setBirth(birth);
        personalInfo.setAddress(address);
        personalInfo.setTel(tel);
        personalInfo.setEmail(email);
        personalInfo.setBankName(bankName);
        personalInfo.setAccount(account);
    }
 
    // this.개인정보 return
    public PersonalInfo getPersonalInfo() {
        return personalInfo;
    }
 
    public int getYear() {
        return year;
    }
 
    public void setYear(int year) {
        this.year = year;
    }
 
    public String getEmpNum() {
        return empNum;
    }
 
    public void setEmpNum(int empIndex) {
        this.empNum = "P" + empIndex;
    }
 
    public long getSalary() {
        return salary;
    }
 
    public void setSalary(long salary) {
        this.salary = salary;
    }
 
    public String getPassword() {
        return password;
    }
 
    public void setPassword(String password) {
        this.password = password;
    }
 
    public String getTeam() {
        return team;
    }
 
    public void setTeam(String team) {
        this.team = team;
    }
 
    public String getDept() {
        return dept;
    }
 
    public void setDept(String dept) {
        this.dept = dept;
    }
 
    public int getPeriod() {
        return period;
    }
 
    public void setPeriod(int period) {
        this.period = period;
    }
 
    public int getEndOfDate() {
        return endOfDate;
    }
 
    public void setEndOfDate() {
        this.endOfDate = this.year + this.period;
    }
}
cs

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
/**
 * SalaryManagement.java
 */
package hasA;
 
/*
 * 기본급, 수당, 세금, 실급여는 각자 계산하여 넣기
 */
public class SalaryManagement {
 
    // private String empNum; // 사원(사원번호를 통해 검색)
    private RegularEmployee regular;
    private PartTimeEmployee partTime;
    private char divRP; // 정규직인지 비정규직인지 확인하는 변수
    private long insentive;// 수당
    private long tax; // 세금
    private long basicSalary;// 기본급
    private long realSalary; // 실급여
 
    public SalaryManagement(RegularEmployee regular) { // 정규직
        /*
         * divRP는 급여관리 객체를 만드는 클래스에서 해당 직원 사번의 첫글자 정규직 = R / 비정규직 = P로 판단함
         */
 
        this.regular = regular;
        partTime = null;
        this.divRP = 'R';
        insentive = tax = basicSalary = realSalary = 0// 전부 long
    }
 
    public SalaryManagement(PartTimeEmployee partTime) { // 비정규직
        /*
         * divRP는 급여관리 객체를 만드는 클래스에서 해당 직원 사번의 첫글자 정규직 = R / 비정규직 = P로 판단함
         */
        regular = null;
        this.partTime = partTime;
        this.divRP = 'P';
        insentive = tax = basicSalary = realSalary = 0;
    }
 
    public void setDiviRP() {
        if (regular.getEmpNum().charAt(0== 'R') { // 입력된 사번이 정규직일경우 사번의 첫번째 글자가 R이므로 해당 if문은 정규직을 위한 if문
            this.divRP = 'R';
        } else {// 입력된 사번이 비규직일경우 사번의 첫번째 글자가 P이므로 해당 if문은 비정규직을 위한 if문
            this.divRP = 'P';
        }
    }
 
    public void putOnRecord() { // 해당 직원에 대해 계산할 수 있는 함수 모두 호출
        setBasciSalary();
        if (divRP == 'R')
            setInsentive(); // 비정규직은 수당이 없음
        setTax();
        setRealSalary();
    }
 
    // 기본급 입력
    public void setBasciSalary() { // 근속년도를 받아와 기본급여 측정
        // 근속년도에 따라 기본급여 나누기
        // basicSalary = 근속년도에 따른 기본급여
 
        int man = 10000;
 
        if (divRP == 'P') { // 비정규직이라면..
            this.basicSalary = 100 * man;
        } else {
            // 근속년도에 따라 측정
            if (this.regular.getYear() == 0 && this.regular.getYear() < 1)
                this.basicSalary = 150 * man;
            else if (this.regular.getYear() >= 1 && this.regular.getYear() < 4)
                this.basicSalary = 200 * man;
            else if (this.regular.getYear() >= 4 && this.regular.getYear() < 9)
                this.basicSalary = 300 * man;
            else if (this.regular.getYear() >= 9 && this.regular.getYear() < 15)
                this.basicSalary = 400 * man;
        }
    }
 
    public long getBasciSalary() {
        return basicSalary;
    }
 
    public void setInsentive() { // 직책 받아오기
        /*
         * insentive = 직책에 따른 수당 관리 비정규직 : 0% 신입사원 : 15% 사원 : 30% 대리 : 50% 과장 : 70% 팀장 :
         * 80% 차장 : 90% 부장 : 100% 전무 : 130% 이사 : 150% 회장 : 200%
         * 
         * insentive 계산 방법 : 기본급 * 직책에 따른 퍼센트 계산
         */
 
        // 수당 입력
 
        String pos = this.regular.getPosition();// 직책 받아오기
        switch (pos) {
        case "신입사원":
            this.insentive = (int) (this.basicSalary * 0.15);
            break;
        case "사원":
            this.insentive = (int) (this.basicSalary * 0.3);
            break;
        case "대리":
            this.insentive = (int) (this.basicSalary * 0.5);
            break;
        case "과장":
            this.insentive = (int) (this.basicSalary * 0.7);
            break;
        case "팀장":
            this.insentive = (int) (this.basicSalary * 0.8);
            break;
        case "차장":
            this.insentive = (int) (this.basicSalary * 0.9);
            break;
        case "부장":
            this.insentive = (int) (this.basicSalary * 1);
            break;
        case "전무":
            this.insentive = (int) (this.basicSalary * 1.3);
            break;
        case "이사":
            this.insentive = (int) (this.basicSalary * 1.5);
            break;
        case "대표이사":
            this.insentive = (int) (this.basicSalary * 2);
            break;
        default:
            //System.out.println("잘못된 입력입니다.");
        }
    }
 
    public long getInsentive() {
        return (long)insentive;
    }
 
    public void setTax() {
        // 세금 계산방법 : (기본급 + 수당) *15 %
        // 세금 입력
        this.tax = (long) ((this.basicSalary + this.insentive) * 0.15);
    }
 
    public long getTax() {
        return this.tax;
    }
 
    public long getRealSalary() {
        return this.realSalary;
    }
 
    public void setRealSalary() {
        // 실급여 계산방법 = 기본급 + 수당 - 세금
        // 실급여 입력
        this.realSalary = this.basicSalary + this.insentive - this.tax;
    }
 
}
 
cs


반응형
반응형

Enum개념과 사용법 이를 응용하기 위해 좀 많이 헤맸다.


TestEnum 클래스를 만들고 여기서 StudentEnum을 사용하여 열거형의 이름과 인덱스를 구해보고자 한다.


Enum을 생성하는 방법은  클래스를 만들어서 사용하는 방법,

클래스 내부에 선언해서 사용하는 방법 등..

여러가지가 있지만 나는 Enum클래스를 따로 생성하여 실행 할 것이다.


StudentEnum.java

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
package hasA;
 
public enum StudentEnum {
    //Student Enum이 가질 열거형
    NAME(0"이름"), 
    KOR(1,"국어"), 
    ENG(2"영어"), 
    MATH(3,"수학"), 
    SUM(4"총합"), 
    AVG(5"평균");
    
    private int studentIndex;
    private String studentName;
    
    StudentEnum(int studentIndex, String subjectName) {
        this.studentIndex = studentIndex;
    }
 
    //getStudentIndex의 Getter
    public int getStudentIndex() {
        return studentIndex;
    }
 
    //getStudentName의 Getter
    public String getStudentName() {
        return studentName;
    }
}
 
cs


TestEnum.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package hasA;
 
public class TestEnum {
    
    private StudentEnum se;
    
    public void getValue() {
        
        StudentEnum[] tmpSe = this.se.values();
        
        //각각 해당하는 열거형 이름값 가져오기
        for(int i=0; i<tmpSe.length; i++) {
            System.out.println(tmpSe[i].toString());
        }
    }
    
    public static void main(String[] args) {
        
        TestEnum te = new TestEnum();
 
        te.getValue();
    }
}
 
cs

TestEnum.java에서 getValue()는 StudentEnum의 열거형 값을 가져온다.

tmpSe레퍼런스에 this.se.value()를 통해 StudentEnum의 열거형을 배열 레퍼런스로 바꿔 저장한다.

이후 for문을 돌리면서 값을 출력..


좀 더 공부해야겠다..ㅎ


반응형

+ Recent posts