달력

52025  이전 다음

  • 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

'EveryThing'에 해당되는 글 125건

  1. 2017.07.20 Read Code(Chap.06)
  2. 2017.07.20 Read Code(Chap.05)
  3. 2017.07.20 Read Code(Chap.04)
  4. 2017.07.20 Read Code(Chap.03)
  5. 2017.07.20 Read Code(Chap.02)
  6. 2017.07.20 Java 정리 지침
  7. 2017.07.20 Read Code(Chap.01)
  8. 2017.07.18 Java Virtual Machine
  9. 2017.06.23 오라클 시험
  10. 2017.06.19 No.019 PL/SQL 커서 [2017-06-14]

Read Code(Chap.06)

Legend 개발자/Java 2017. 7. 20. 16:15
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
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
------------------------------------------------------------------------------------------
package chap06;
 
import javax.swing.JFrame;
 
public class AWTThread {
    public static void main(String[] args) {
        ThreadGroup group = Thread.currentThread().getThreadGroup();
        group.list();
        JFrame frame = new JFrame("AWTThread");
        group.list();
        frame.setSize(150, 100);
        frame.setVisible(true);
        group.list();
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class Bread {
    public static void main(String[] args) {
        int bbang = 10;
        System.out.printf("창고의 현재 빵의 재고량:%d%n", bbang);
        GoodsHouse gh = new GoodsHouse(10);
        Consumer c1 = new Consumer(gh);
        Procedur p1 = new Procedur(gh);
        Thread t1 = new Thread(c1);
        Thread t2 = new Thread(p1);
        t1.start();
        t2.start();
    }
}
 
class GoodsHouse {
    private int house;
 
    public GoodsHouse(int house) {
        this.house = house;
    }
 
    public void setHouse(int house) {
        this.house = house;
    }
 
    public int getHouse() {
        return house;
    }
}
 
class Consumer implements Runnable {
    GoodsHouse gh;
 
    Consumer(GoodsHouse gh) {
        this.gh = gh;
    }
 
    public void run() {
        while (true) {
            synchronized (gh) {
                int house = gh.getHouse();
                System.out.printf("<소비자> 빵의 현재 갯수:%d%n", --house);
                gh.setHouse(house);
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        }
    }
}
 
class Procedur implements Runnable {
    GoodsHouse gh;
 
    Procedur(GoodsHouse gh) {
        this.gh = gh;
    }
 
    public void run() {
        while (true) {
            synchronized (gh) {
                int house = gh.getHouse();
                System.out.printf("<생산자> 빵의 현재 갯수:%d%n", ++house);
                gh.setHouse(house);
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class DaemonThread {
    public static void main(String[] args) {
        RunnableClass2 runnable = new RunnableClass2();
        Thread thread = new Thread(runnable);
        thread.setDaemon(true);
        thread.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException ie) {
 
        }
        Thread user = Thread.currentThread();
        System.out.println("DaemonThread:" + user.getName());
        System.out.println("DaemonThread:" + user.isDaemon());
        System.out.println("DaemonThread: main() end.");
    }
}
 
class RunnableClass2 implements Runnable {
    private Thread current;
    private boolean running = true;
 
    public void run() {
        current = Thread.currentThread();
        while (running) {
            try {
                Thread.sleep(1000);
                System.out.println("RunnableClass:" + current.getName());
            } catch (InterruptedException ie) {
                System.out.println("RunnableClass:" + ie.getMessage());
            }
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class DemmonThreadClass {
    public static void main(String[] args) {
        DemmonThread dt = new DemmonThread();
        Thread t1 = new Thread(dt, "쓰레드1:");
        Thread t2 = new Thread(dt, "쓰레드2:");
        t1.setDaemon(true);
        t2.setDaemon(false);
        t1.start();
        t2.start();
    }
 
}
 
class DemmonThread implements Runnable {
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
 
            }
System.out.printf("%d번째 -> %s : 데몬상태 : %s %n", i, Thread.currentThread().getName(),
            (Thread.currentThread().isDaemon()) ? "데몬쓰레드(O)" : "데몬쓰레드(X)");
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class Rectangle extends Shape implements Runnable {
    public Rectangle(double width) {
        super(width);
    }
 
    public Rectangle(double height, double width) {
        super(height, width);
    }
 
    public double area() {
        return getWidth() * getHeight();
    }
 
    public double round() {
        return (getWidth() + getHeight()) * 2;
    }
 
    public void run() {
        System.out.printf("사각형의 넓이는 :%f%n", area());
        System.out.printf("사각형의 둘레는 :%f%n", round());
    }
 
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
import javax.swing.JFrame;
 
public class RunnableSample1 extends JFrame implements Runnable {
    String name;
 
    RunnableSample1(String name) {
        this.name = name;
    }
 
    public static void main(String[] args) {
        RunnableSample1 rs = new RunnableSample1("Runnable 클래스1");
        Thread t1 = new Thread(rs);
        Thread t2 = new Thread(new RunnableSample1("Runnable클래스1"));
        Thread t3 = new Thread(new RunnableSample1("Runnable클래스2"));
        Thread t4 = new Thread(new RunnableSample1("Runnable클래스3"));
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t1 = new Thread(rs);
        t1.start();
    }
 
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.printf("%s => %d%n", name, i);
            try {
                Thread.sleep(100);
            } catch (Exception e) {
            }
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public abstract class Shape {
    private double height, width;
 
    public abstract double area();
 
    public abstract double round();
 
    public Shape(double width) {
        super();
        this.width = width;
    }
 
    public Shape(double height, double width) {
        super();
        this.height = height;
        this.width = width;
    }
 
    public double getWidth() {
        return width;
    }
 
    public void setWidth(double width) {
        this.width = width;
    }
 
    public double getHeight() {
        return height;
    }
 
    public void setHeight(double height) {
        this.height = height;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class ShapeAreaRound {
    public static void main(String[] args) {
        // Rectangle r=new Rectangle(10,12.3);
        // Triangle t=new Triangle(10,12.3);
        // Thread t1=new Thread(r);
        // Thread t2=new Thread(t);
        // t1.start();
        // t2.start();
        Rectangle r = null;
        Triangle t = null;
        Thread t1 = null;
        Thread t2 = null;
        for (double w = 1.5, h = 3.5; w < 10.0 || h < 7.5; w += 0.05, h += 0.06) {
            r = new Rectangle(w, h);
            t = new Triangle(w, h);
            t1 = new Thread(r);
            t2 = new Thread(t);
            t1.start();
            t2.start();
            try {
                Thread.sleep(10000000);
            } catch (Exception e) {
            }
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class StopThread {
    public static void main(String[] args) {
        RunnableClass runnable = new RunnableClass();
        Thread thread = new Thread(runnable);
        thread.start();
        try {
            Thread.sleep(3000);
            ;
        } catch (InterruptedException ie) {
            runnable.stop();
            System.out.println("StopThread: main() end.");
        }
    }
}
 
class RunnableClass implements Runnable {
    private Thread current;
    private boolean running = true;
 
    public void stop() {
        running = false;
        current.interrupt();
    }
 
    public void run() {
        current = Thread.currentThread();
        while (running) {
            try {
                Thread.sleep(1);// stop check here
                System.out.println("RunnableClass: running.");
                for (int i = 0; i < 100000000; i++) {
                }
                Thread.sleep(1);// stop check here
            } catch (InterruptedException ie) {
                System.out.println("run() : " + ie.getMessage());
            }
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class ThreadForExample {
    public static void main(String[] args) {
        ThreadFor tf = new ThreadFor();
        tf.start();
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
 
            }
            System.out.printf("main메소드 : %d%n", i);
        }
    }
}
 
class ThreadFor extends Thread {
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
 
            }
            System.out.printf("main메소드 : %d%n", i);
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class ThreadGroupClass {
    public static void main(String[] args) {
        ThreadGroup tg = new ThreadGroup("그룹1");
        ThreadGroup tg1 = new ThreadGroup(tg, "그룹2");
        ThreadGroup tg2 = new ThreadGroup(tg1, "그룹3");
        ThreadGroupRunnable a, b;
        a = new ThreadGroupRunnable();
        b = new ThreadGroupRunnable();
        Thread t1, t2, t3, t4;
        t1 = new Thread(tg, a, "쓰레드1");
        t2 = new Thread(tg1, a, "쓰레드2");
        t3 = new Thread(tg2, b, "쓰레드3");
        t4 = new Thread(tg2, b, "쓰레드4");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
 
class ThreadGroupRunnable implements Runnable {
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.printf("%d번째 그룹:%s, 쓰레드명:%s%n", i, 
                        Thread.currentThread().getThreadGroup().getName(),
                        Thread.currentThread().getName());
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class ThreadJoinClass {
    public static void main(String[] args) {
        ThreadJoin td = new ThreadJoin();
        Thread t = new Thread(td, "첫번쨰 쓰레드");
        Thread t1 = new Thread(td, "두번쨰 쓰레드");
        td.thread = t;
        t.start();
        td.thread = t1;
        t1.start();
        System.out.println("join 메소드 실행 시작");
        try {
            t.join(10);
        } catch (InterruptedException e) {
 
        }
        System.out.println("join 매소드 실행 종료");
    }
}
 
class ThreadJoin implements Runnable {
    Thread thread;
 
    public void run() {
        System.out.println("run 메소드 실행 시작" + thread.getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
 
        }
        System.out.println("run 메소드 실행 종료" + thread.getName());
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class ThreadPriority {
    public static void main(String[] args) {
        ThreadPriorityClass tc = new ThreadPriorityClass();
        Thread t1 = new Thread(tc, "Thread 1:");
        Thread t2 = new Thread(tc, "Thread 2:");
        Thread t3 = new Thread(tc, "Thread 3:");
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
        t3.setPriority(Thread.NORM_PRIORITY);
        t1.start();
        t2.start();
        t3.start();
    }
}
 
class ThreadPriorityClass implements Runnable {
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
            }
            System.out.printf("쓰레드명:%s -> 우선순위 %d%n", 
                            Thread.currentThread().getName(),
                            Thread.currentThread().getPriority());
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class ThreadSample1 extends Thread {
    String name;
 
    ThreadSample1(String name) {
        this.name = name;
    }
 
    public static void main(String[] args) throws Exception {
        ThreadSample1 ts1 = new ThreadSample1("쓰레드1");
        ThreadSample1 ts2 = new ThreadSample1("쓰레드2");
        ThreadSample1 ts3 = new ThreadSample1("쓰레드3");
        ThreadSample1 ts4 = new ThreadSample1("쓰레드4");
        ts1.start();
        ts2.start();
        ts3.start();
        ts4.start();
    }
 
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.printf("%s => %d%n", name, i);
            try {
                Thread.sleep(100);
            } catch (Exception e) {
            }
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class Triangle extends Shape implements Runnable {
    public Triangle(double width) {
        super(width);
    }
 
    public Triangle(double height, double width) {
        super(height, width);
    }
 
    public void run() {
        System.out.printf("삼각형의 넓이는 :%f%n", area());
        System.out.printf("삼각형의 둘레는 :%f%n", round());
    }
 
    public double area() {
        return getWidth() * getHeight() / 2;
    }
 
    public double round() {
        return getWidth() + getHeight();
    }
 
}
 
------------------------------------------------------------------------------------------
 
package chap06;
 
public class WaitThread {
    public static void main(String[] args) {
        RunnableClass1 runnable = new RunnableClass1();
        Thread thread = new Thread(runnable);
        thread.start();
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
                runnable.loop();
            } catch (InterruptedException ie) {
            }
        }
        runnable.stop();
        System.out.println("WaitThread:main()");
    }
}
 
class RunnableClass1 implements Runnable {
    private Thread current;
    private boolean running = true;
    private boolean waiting;
    private int interval = 500;
 
    public void stop() {
        running = false;
        current.interrupt();
    }
 
    public synchronized void loop() {
        waiting = !waiting;
        if (!waiting) {
            String name = Thread.currentThread().getName();
            System.out.println(name + ":RunnableClass: notify.");
            notify();
        }
        Thread.yield();
    }
 
    public void run() {
        current = Thread.currentThread();
        String name = current.getName();
        while (running) {
            try {
                synchronized (this) {
                    if (waiting) {
                        System.out.println(name + ":RunnableClass:wait.");
                        wait();
                    } else {
                        Thread.sleep(interval);
                        System.out.println(name + ":RunnableClass:skip.");
                    }
                }
            } catch (InterruptedException ie) {
                System.err.println(name + ":RunnableClass:" + ie.getMessage());
            }
        }
    }
}
 
------------------------------------------------------------------------------------------
 cs

'Legend 개발자 > Java' 카테고리의 다른 글

Read Code(Chap.08)  (0) 2017.07.20
Read Code(Chap.07)  (0) 2017.07.20
Read Code(Chap.05)  (0) 2017.07.20
Read Code(Chap.04)  (0) 2017.07.20
Read Code(Chap.03)  (0) 2017.07.20
Posted by 전설의아이
|

Read Code(Chap.05)

Legend 개발자/Java 2017. 7. 20. 15:27
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
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
------------------------------------------------------------------------------------------
package chap05;
 
public class ClassCastExceptionClass {
    public static void main(String[] args) {
        ClassCastSubClass cs;
        ClassCastSuperClass css;
        ClassCastSuperClass css1;
        try {
            cs = new ClassCastSubClass();
            css = cs;
            css.print();
            cs.print();
            // css1=(ClassCastSuperClass1)cs;//IS A의 관계 아님
            // cs=(ClassCastSuperClass)css;//ClassCastSuperClass 상위 클래스
            Object ob = css;
            // css=(Object)ob;//Object 상위 클래스 임
            css = (ClassCastSuperClass) ob;
            css.print();
            // if(css instanceof ClassCastSuperClass1){
            // css1=css;
            // }
            Object ob1 = new Object();
            String st = new String("test");
            // String str=(String)ob1;
            if (st instanceof Object) {
                ob1 = st;
            }
            if (ob1 instanceof String) {
                String str = (String) ob1;
            }
        } catch (Exception e) {
            System.out.println(e.toString());
        }
        System.out.println("프로그램 종료");
    }
}
 
class ClassCastSuperClass {
    int a = 5;
 
    public void print() {
        System.out.println(a);
    }
}
 
class ClassCastSubClass extends ClassCastSuperClass {
    int a = 10;
 
    public void print() {
        System.out.println(a);
    }
}
 
class ClassCastSuperClass1 {
    int a = 5;
 
    public void print() {
        System.out.println(a);
    }
}
 
------------------------------------------------------------------------------------------
 
package chap05;
 
public class CreateInvoke extends SuperExceptionClass {
    public static void main(String[] args) {
        CreateInvoke i = null;
        try {
            i = new CreateInvoke();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            System.out.println("프로그램 종료");
        }
    }
 
    CreateInvoke() throws ArithmeticException, Exception {
 
    }
}
 
class SuperExceptionClass extends Exception {
    public SuperExceptionClass() throws Exception {
        throw new Exception("Super Exception");
    }
}
 
------------------------------------------------------------------------------------------
 
package chap05;
 
import java.io.*;
import java.io.FileNotFoundException;
 
public class FileFindException {
    public static void main(String[] args) {
        FileFindRead fr = null;
        String str = "";
        try {
            File f = new File("D:/test.txt");
            // File이라는 클래스를 통해서 파일존재 여부를 팡악할 수 있음.
            if (f.exists() && f.isFile()) {
                // f.exeist는 파일이 있는냐라고 물어본다.
                // f.isFile은 해당파일이 파일인지 폴더인지 확인해준다.
                // 맞으면 True값을 return
                System.out.println("파일존재");
                fr = new FileFindRead(new FileInputStream("D:/test.txt"));
                // FileInputStram을 호출해서 FileFindRead라는 생성자를 호출한다.
            } else {
                System.out.println("파일 존재 하지 않음");
            }
        } catch (FileNotFoundException e) {
            System.err.println(e.toString());
        }
        try {
            str = fr.readLine();
        } catch (IOException e) {
            System.err.println(e.toString());
        } finally {
            try {
                fr.fis.close();
            } catch (Exception e) {
                System.err.println(e.toString());
            }
        }
        System.out.println(str);
    }
}
 
class FileFindRead {
    FileInputStream fis;
 
    FileFindRead(FileInputStream fis) {
    // FileFindRead 생성자의 매개변수인 FileInputStream 변수명 fis를 멤버변수 fis에 넣어줌
        this.fis = fis;
    }
 
    public String readLine() throws IOException {
        String str = "", st;
        BufferedReader br = null;
        if (fis != null) {
            br = new BufferedReader(new InputStreamReader(fis));
            // InputStreamReader가 없으면 한글이 깨진다.
            while ((st = br.readLine()) != null) {
                System.out.println(str);
                str += st;
            }
            throw new IOException();
        }
        return str;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap05;
 
import java.io.*;
 
public class GuGuDan {
    int num;
 
    public static void main(String[] args) {
        GuGuDan ml = new GuGuDan();
        try {
            System.out.println("2~9사이의 숫자만 입력합니다.");
            boolean f = true;
            do {
                try {
                    if (ml.readNumber()) {
                        f = false;
                        ml.print(ml.num);
                    } else {
                        throw new NumberFormatException("2~9사이 숫자");
                    }
                } catch (NumberFormatException e) {
                    System.out.println(e.getMessage());
                }
            } while (f);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
 
    public void print(int dan) {
        System.out.printf("-----%d단-----%n", dan);
        for (int i = 1; i <= 9; i++) {
            System.out.printf("%d * %d = %d %n", dan, i, dan * i);
        }
        System.out.println("-------------");
    }
 
    public boolean readNumber() throws IOException, NumberFormatException {
        boolean f = false;
        BufferedReader br = null;
        String st = null;
        br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("원하는 단수를 입력하시오: ");
        st = br.readLine();
        int num = Integer.parseInt(st);
        if (num >= 1 && num <= 9) {
            f = true;
            this.num = num;
        }
        br.close();
        return f;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap05;
 
import java.io.*;
 
public class InputNumberLoopException {
    int num;
 
    public static void main(String[] args) {
        InputNumberLoopException il = new InputNumberLoopException();
        try {
            System.out.println("1~10사이의 숫자만 입력합니다.");
            boolean f = true;
            do {
                try {
                    if (il.readNumber()) {
                        f = false;
                        System.out.println(il.num * 10);
                    }
                } catch (NumberFormatException e) {
 
                }
            } while (f);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
 
    public boolean readNumber() throws IOException, NumberFormatException {
        boolean f = false;
        BufferedReader br = null;
        String st = null;
        br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("숫자를 입력해주세요:");
        st = br.readLine();
        int num = Integer.parseInt(st);
        if (num >= 1 && num <= 10) {
            f = true;
            this.num = num;
        }
        br.close();
        return f;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap05;
 
public class MethodInvoke {
    public static void main(String[] args) {
        String result = "undone";
        try {
            MethodInvoke invoke = new MethodInvoke();
            result = invoke.method();
        } catch (UserException2 ue) {
            System.err.println(ue.getReason());
        } finally {
            System.err.println("finally =" + result);
        }
    }
 
    public String method() throws UserException2 {
        if (true)
            throw new UserException2("User Reason");
        return ("method done.");
    }
}
 
class UserException2 extends Exception {
    private String reason;
 
    public UserException2(String cause) {
        reason = cause;
    }
 
    public String getReason() {
        return reason;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap05;
 
public class MethodOverridingException extends MethodOverringSuperClass {
    public static void main(String[] args) {
        MethodOverridingException m;
        m = new MethodOverridingException();
        try {
            System.out.println("-----1-----");
            m.method();
            System.out.println("-----2-----");
        } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            System.out.println("프로그램 종료");
        }
    }
 
    protected String method() throws ArithmeticException {
        if (true)
            new ArithmeticException("하위클래스 method");
        return "하위클래스";
    }
}
 
class MethodOverringSuperClass {
    protected String method(String ar) throws Exception {
        if (true)
            new Exception("상위 클래스 Method");
        return "상위클래스";
    }
}
 
------------------------------------------------------------------------------------------
 
package chap05;
 
public class NotYet {
    public static void main(String[] args) {
        AssertTest at = new AssertTest();
        at.method();// false이면 오류 발생
    }
}
 
class AssertTest {
    boolean value = false;
 
    void method() {
        assert value;
        System.out.println("AssertTest.method()");
    }
}
 
------------------------------------------------------------------------------------------
 
package chap05;
 
import java.io.*;
 
public class NumberFormatExceptionClass {
    public static void main(String[] args) throws IOException {
        BufferedReader br;
        br = new BufferedReader(new InputStreamReader(System.in
        // 표준입력 : 키보드 입력
        ));
        String st = "";
        System.out.println("숫자를 입력하세요");
        st = br.readLine();
        System.out.println(st);
        new Atype(new Btype());
        int num = 0;
        try {
            num = Integer.parseInt(st);
        } catch (NumberFormatException e) {
            System.out.println("숫자를 다시 입력하세요:");
            st = br.readLine();
        } finally {
            System.out.println(num * 10);
        }
    }
}
 
class Atype {
    Atype(Btype b) {
 
    }
}
 
class Btype {
 
}
 
------------------------------------------------------------------------------------------
 
package chap05;
 
public class StackTrace {
    public static void main(String[] args) {
        try {
            StackTrace trace = new StackTrace();
            trace.method();
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("exception: " + e.getMessage());
            e.printStackTrace();
        }
    }
 
    public void method() {
        int[] array = new int[2];
        System.out.println(array[2]);
    }
}
 
// throw 예외상황을 던져주는 것
// throws는 예외상황을
 
------------------------------------------------------------------------------------------
 
package chap05;
 
public class ThrowException {
    public static void main(String[] args) {
        new ThrowExceptionClass().print();
    }
}
 
class ThrowExceptionClass {
    public void print() {
        System.out.println("예외상황발생시키기");
        int a = 5, b = 0, c = 0;
        try {
            c = a / b;
            throw new Exception("예외상황 발생 :예외객체 생성");
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException:" + e.toString());
            // throw new Exception("예외상황 발생: 예외객체 생성")
        } catch (NullPointerException e) {
            System.out.println("NullPounterException:" + e.toString());
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("ArrayIndexOutOfBoundsException:" + e.toString());
        } catch (Exception e) {
            System.out.println("Exception:" + e.toString());
        } finally {
            System.out.println("exception 처리 종료");
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap05;
 
public class ThrowsException {
    public static void main(String[] args) {
        ThrowsExceptionClass te = new ThrowsExceptionClass();
        try {
            te.print();
        } catch (Exception e) {
            e.printStackTrace();
        } // printStackTrace란? 에러를 출력하는 역할.
        try {
            int a = te.print(3);
            System.out.println(a);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            String st = te.print("예외처리");
            System.out.println(st);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 
class ThrowsExceptionClass {
    public void print() throws Exception {
        System.out.println("예외상황 Throws 하기");
        throw new Exception("예외상황 객체생성");
    }
 
    public int print(int a) throws Exception {
        try {
            System.out.println("예외상황 Throws 하기1");
            throw new Exception("예외상황 객체생성");
        } catch (Exception e) {
            System.out.println("예외상황 Throw Exception 처리");
        } finally {
            System.out.println("예외상황 Throws finally 블록 수행");
        }
        return a * 10;
    }
 
    public String print(String str) throws Exception {
        String reStr = "테스트:" + str;
        int a = 5, b = 0, c = 0;
        System.out.println("예외상황 Throws 하기2");
        c = a / b;
        return reStr;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap05;
 
public class ThrowsSample {
    public static void main(String[] args) {
        ThrowsSampleClass t = new ThrowsSampleClass();
        System.out.println("print 메소드 수행 전");
        try {
            t.print();
        } catch (Exception e) {
            System.out.println(e.toString());
        }
        System.out.println("print 메소드 수행 후");
        System.out.println("print1 메소드 수행 전");
        // try{
        // t.print1();
        // }catch(Exception e){}
        System.out.println("프로그램 정상종료");
    }
}
 
class ThrowsSampleClass {
    public void print() throws ArithmeticException, NullPointerException {
        int c = 0;
        c = 5 / 0;
    }
 
    public void print1() {
        int c = 0;
        c = 5 / 0;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap05;
 
public class UserException extends Exception {
    // Exception 클래스를 상속 받아야만 Exception이 된다.
    private String exceptionName;
 
    public static void main(String[] args) {
        UserException ue;
        try {
            throw new UserException("내가만든 예외처리");
            // throw new TestException("내가만든 예외처리")
            // 실행할 수 없는 이유는 TestException은
            // Exception 상속을 받지 않았기 때문에 Exception이 아니다.
            // System.out.println(ue.getName());
        } catch (UserException e) {// 하위클래스에서 예외처리르 받는다.
            System.out.println(e.getName());
            // getName()은 이름을 호출하는 것이며,
            // 여기서는 String 타입인 "내가만든 예외처리"를 실행한다.
        } catch (Exception e) {// 하위클래스에서 예외처리를 받을 수 없을 경우,
                                // 상위클래스에서 예외처리를 받는다.
            System.out.println(e.toString());
            // Exception의 경우 상위클래스가 Object이기 때문에 toString을 쓴 것이다.
        } finally {
            System.out.println("예외처리 종료");
        }
        System.out.println("프로그램 정상종료");
    }
 
    public UserException(String exceptionName) {
        this.exceptionName = exceptionName;
    }
 
    public String getName() {
        return exceptionName;
    }
}
 
class TestException {
    private String exceptionName;
 
    public TestException(String exceptionName) {
        this.exceptionName = exceptionName;
    }
 
    public String getName() {
        return exceptionName;
    }
}
 
------------------------------------------------------------------------------------------
 cs

'Legend 개발자 > Java' 카테고리의 다른 글

Read Code(Chap.07)  (0) 2017.07.20
Read Code(Chap.06)  (0) 2017.07.20
Read Code(Chap.04)  (0) 2017.07.20
Read Code(Chap.03)  (0) 2017.07.20
Read Code(Chap.02)  (0) 2017.07.20
Posted by 전설의아이
|

Read Code(Chap.04)

Legend 개발자/Java 2017. 7. 20. 15:23
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
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
------------------------------------------------------------------------------------------
package chap04;
 
public class AbstractDefine {
    public static void main(String[] args) {
        InterfaceDefine i;
        AbstractClass a;
        NormalClass n;
        // i=new InterfaceDefine();//인터페이스는 객체를 생성할 수가 없음
        // a=new AbstractClass();//추상클래스는 객체를 생성할 수가 없음
        n = new NormalClass();
        a = new NormalClass();
        i = new NormalClass();
        n.print();
        n.print("테스트");
        n.print(300);
        a.print();
        a.print("테스트"); // a.print(300); int를 받는 것이 없어서 사용불가
        i.print();
        i.print("테스트");
        i.print(300);
    }
}
 
class NormalClass extends AbstractClass implements InterfaceDefine {
    // 클래스는 선언부()만 있으면 안되고 구현부{}를 무조건 만들어야 한다.
    // extends 를 통해서 AbstractClass와 NormalClass는 is a 관계가 성립되었다.
    // 추상클래스로부터 상속을 받을때 상속받은 것 중
    // abstract가 있는 메소드는 반드시 재정의 해주어야 한다.
    // implements를 통해서 InterfaceDefine을 상속받았다.
    // Interface를 상속받을 경우 반드시 구현부를 재정의해주어야 한다.
    int a;
 
    // public void print(String str){}
    public void print() {// 재정의를 할경우 반환형 데이터 타입도 똑같아야 한다.
        System.out.println("일반클래스");// print
    }
 
    public void print(int a) {
        System.out.println("일반클래스 print 구현(재정의)" + a);
    }
}
 
abstract class AbstractClass {
    // 추상클래스, class 내에 abstract가 하나라도 있으면
    // class에 abstract라고 표시해야 함.
    int a;
 
    abstract public void print();
 
    public void print(String str) {// 선언부와 구현부가 다있는 메소드
        System.out.println("추상클래스:" + str);
    }
}
 
interface InterfaceDefine {
    // 인터페이스, 구현부가 없어야 한다. 선언부만 존재함, 선언만 하는 것이 인터페이스
    // 그래서 인터페이스는 상속을 해줄 수 있지만 인터페이스에 있는 값은 반드시
    // 초기화해야하고 반대로 class를 상속받을 수는 없다.
    public static final int a = 10;
 
    public int b = 15;
 
    public void print();
 
    // 메소드 구현부가 없어야 함
    // public void print(String str){System.out.println("추상클래스:"+str);}
    public void print(String str);
 
    public void print(int a);
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class AnonymouseClassTest {
    public static void main(String[] args) {
        AnonymouseClassTest at = new AnonymouseClassTest(); // 생성자
        at.println();// 메소드 호출
    }
 
    public void println() {// 메소드
        System.out.println(toString());// 출력
        // 객체 만들기 시작
        new AnonymouseClassTest() {
            // 익명의 클래스를 생성했으므로 주소에 $로 연결되어 표시가 되어 있다.
            AnonymouseClassTest at1 = new AnonymouseClassTest();
            // 자기자신을 두번째 객체생성
            // OuterClass를 사용하여 객체를 생성하면 생성이 안된다.
 
            public void print() {// 메소드
                System.out.println(at1.toString());
                // 그래서 첫번째 자기자신과 다른 주소를 만들어냄
                System.out.println(toString());
                // InnerClass 주소 출력
            }
        }.print();// 메소드 호출
        new AnonymouseInnerClassTset() {
            // 익명의 클래스, 클래스 안에 new 키워드를 작성한 후
            // 생성자를 만들면 익명의 InnerClass가 되는 것이다.
            public void print() {
                System.out.println(toString());
            }
        }.print();
    }
}
 
class AnonymouseInnerClassTset {
 
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class AnonymouseInnerClass {
    int mem = 700;
 
    public static void main(String[] args) {
        AnonymouseClass a = new AnonymouseClass(100, "테스트");
        a.println();
        AnonymouseInnerClassDefine ai = new AnonymouseInnerClassDefine();
    }
 
    AnonymouseInnerClass(String str) {
        System.out.println("AnonymouseInnerClass 클래스 생성자: " + str);
    }
}
 
class AnonymouseInnerClassDefine {// 익명 클래스
    AnonymouseInnerClassDefine(String[] ar) {
        System.out.println(ar.length);
        System.out.println(ar[0]);
        System.out.println(ar[1]);
    }
 
    AnonymouseInnerClassDefine() {
        System.out.println("익명 클래스 생성자");
    }
}
 
class AnonymouseClass {// 클래스
    int a;
    String str;
 
    AnonymouseClass(int a, String str) {// 생성자
        this.a = a;
        this.str = str;
    }
 
    static {// static 블록 (클래스안에 있다.)
        System.out.println("클래스(정적) 블록");
    }
    {// 그냥 객체 블록 (클래스안에 있다.)
        System.out.println("객체 블록");
    }
 
    public void println() {// 메소드는 호출을 해야만 실행이 되고, 클래스는 적재가 된다.
        System.out.println("----------메소드 시작 ----------");
        // AnonymouseInnerClassDefine ai=
        new AnonymouseInnerClassDefine() {
            // 이것은 생성자인데 Anonymous 클래스라고도 불린다.
            // System.out.println("익명의 InnerClass"); 여기서 주석을 풀면 out에
            // 에러가 뜨는데 뜨는 이유는 out은 static으로 선언되었기 때문이다.
            // AnonymouseClass a=new AnonymouseClass();는OuterClass이기 때문에 만들
            // 수가없다.
            AnonymouseInnerClass b = new AnonymouseInnerClass(str);
 
            // 익명의 InnerClass는 밖에 있는 것을 사용할 수가 없다.
            public void print() {
                System.out.println("익명의 InnerClass Print");
                System.out.println("익명의 InnerClass mem: " + b.mem);
            }
        }.print();
        // static{System.out.println("클래스(정적)블록");}
        // static블록은 메소드 안에 작성할 수가 없다.
        {// 그냥 객체 블록 (메소드 안에 있다.)
            System.out.println("메소드 객체 블록");
        } // 블록은 {}; 세미콜론이 생략이 가능하지만 배열은 불가능하다.
        String str[] = { "익명의 InnerCLass1", "익명의 InnerClass2" };
        // 이렇게 작성을 하면 배열로 인식을 한다.
        new AnonymouseInnerClassDefine(str);// 객체생성
        System.out.println("----------메소드 종료 ----------");
        // System.out.println("익명의 InnerClass");
 
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class ArrayDefine {
    int a[], y;
    // 이렇게 작성을 할 경우 int 기본형 변수 배열 a를 선언하고,
    // int 기본형 변수 y를 선언한 것이다. 여기서 y는 배열이 아니다.
    int[] b, c;
    // int 기본형 변수 배열 b,c 선언, int옆에 []를 붙일 경우 뒤에 선언한 모든
    // 변수명은 다 배열 형태를 가진다. 객체든 배열이든 Default 값은 NULL이다.
    String str[];// String 참조형변수 배열 str 선언
    Integer[] d, e;// Integer 참조형변수 배열 d,e 선언
    Integer f;// Integer 참조형변수 f 선언
 
    public static void main(String[] args) {
        ArrayDefine ad = new ArrayDefine();// 객체 생성
        ad.a = new int[5];
    // 배열a 에 int 타입방을 5개 만듬, 배열이기 때문에 a에다가 5개 방의 주소를 넣는것이다.
        ad.y = 3;
        ad.b = new int[10];
    // 배열b 에 int 타입방을 10개 만듬, 배열이기 때문에 b에다가 10개 방의 주소를 넣는것이다.
        ad.c = new int[7];
    // 배열c 에 int 타입방을 7개 만듬, 배열이기 때문에 c에다가 7개 방의 주소를 넣는것이다.
        System.out.printf("%d, %d, %d%n", ad.a.length, ad.b.length, ad.c.length);
        ad.str = new String[3];
    // 객체 배열 str에 참조형변수 String 타입 방을 3개 만들고, 3개의 주소를 str에 넣어준다.
        ad.d = new Integer[3];// Wrapper 클래스에 속하는 메소드를 객체화한 것이다.
        ad.e = new Integer[5];
        ad.f = new Integer(ad.y);
// Integer이라는 객체에 매개변수 5라는 값을 넣어주는 것이다.
        System.out.printf("%d, %d, %d%n", ad.str.length, ad.d.length, ad.e.length);
        System.out.printf("%d, %d, %d%n", ad.f, ad.f.MAX_VALUE, ad.f.MIN_VALUE);
        System.out.printf("%d ~ %d%n", Byte.MAX_VALUE, Byte.MIN_VALUE);
        System.out.print(" " + (Math.pow(2, 31) - 1));
        System.out.println(ad.f.max(5, 10));
        System.out.println(ad.f.min(5, 10));
        System.out.println(ad.f.parseInt("123") + ad.f.parseInt("121"));
        // parseInt는 형변환을 하는 것이다.
        System.out.println(ad.f.valueOf("123").intValue() + 
                           ad.f.valueOf("125").intValue());
        // intValue를 써야 숫자로 만들어준다.
        System.out.println(ad.f.valueOf("123") + ad.f.valueOf("100"));
        System.out.println(ad.f.toString());
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class ArrayInitial {
    int a[], b[][];// int타입 배열 a 와 이차원배열 b를 선언
    int[] c, d[];// 이차원배열은 이렇게 작성할수도 있다.
    String str[], st[][];//
    Byte bt[], byt[][];
 
    public static void main(String[] args) {
        ArrayInitial ai = new ArrayInitial();// 객체생성
        ai.a = new int[3];// 방3개 만들기
        ai.a[0] = 5;
        ai.a[1] = 7;// 방에 값 넣기
        System.out.printf("%d, %d, %d%n", ai.a[0], ai.a[1], ai.a[2]);// 출력
        for (int i = 0; i < ai.a.length; i++) {// 반복문
            ai.a[i] = i + 5;// 배열에 값을 반복문으로 초기화
            System.out.println(ai.a[i]);
        }
        int b[] = { 5, 7, 9 };
        int c[] = new int[3];
        c[0] = 5;
        c[1] = 7;
        c[2] = 9;
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }
        /* 기본형 2차원 배열 */
        ai.b = new int[3][];// 2차원 배열작성방법1
        ai.b[0] = new int[2];
        ai.b[0][0] = 1;
        ai.b[0][1] = 2;
        ai.b[1] = new int[2];
        ai.b[1][0] = 3;
        ai.b[1][1] = 4;
        ai.b[2] = new int[2];
        ai.b[2][0] = 5;
        ai.b[2][1] = 6;
 
        int[] d[] = new int[3][2];// 2차원 배열작성방법2
        d[0][0] = 1;
        d[0][1] = 2;
        d[1][0] = 3;
        d[1][1] = 4;
        d[2][0] = 5;
        d[2][1] = 6;
 
        int[] e[] = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
        // 2차원 배열작성방법3 배열의 모든 구성요소를 다 알고있을 때 사용
        int k[][];
        k = ai.b;
        ai.print(k);
        k = d;
        ai.print(k);
        k = e;
        ai.print(k);
 
        ai.str = new String[3];
        ai.str[0] = "홍길동";
        ai.str[1] = "이몽룡";
        ai.str[2] = "성춘향";
        System.out.printf("%s,%s,%s%n", ai.str[0], ai.str[1], ai.str[2]);
 
        ai.st = new String[3][];
        ai.st[0] = new String[2];
        ai.st[0][0] = "홍길동";
        ai.st[0][1] = "이몽룡";
        ai.st[1] = new String[1];
        ai.st[1][0] = "성춘향";
        ai.st[2] = new String[1];
        ai.st[2][0] = "강감찬";
        String[] s[] = { { "홍길동", "이몽룡" }, { "성춘향" }, { "강감찬" } };
        ai.print(ai.st);
        ai.print(s);
 
        ai.bt = new Byte[3];
        ai.bt[0] = 7;
        ai.bt[1] = 8;
        ai.bt[2] = 9;
        Byte[] z;
        z = ai.bt;
        ai.print(z);
        ai.bt[0] = new Byte(ai.bt[0]);
        ai.bt[0] = new Byte((byte) 10);
        ai.bt[1] = new Byte(ai.bt[1]);
        ai.bt[2] = new Byte(ai.bt[2]);
        ai.print(ai.bt);
        java.util.Vector v[] = new java.util.Vector[3];
        v[0] = new java.util.Vector();
        v[1] = new java.util.Vector();
        v[2] = new java.util.Vector();
        v[0].add("홍길동");
        v[0].add("성춘향");
        v[0].add("이몽룡");// Vector 안에는 객체만 들어갈 수 가 있다.
        System.out.println(v[0]);
        // ai.byt={{1,2},{3,4}}이렇게 작성을 하면 오류이다.
        ai.byt = new Byte[2][2];
        ai.byt[0] = new Byte[2];
        ai.byt[0][0] = 1;
        ai.byt[0][1] = 2;
        ai.byt[1] = new Byte[2];
        ai.byt[1][0] = 3;
        Byte[][] byt = { { 1, 2 }, { 3, 4 } };
        ai.print(ai.byt);
        ai.print(byt);
    }
 
    public void print(int[][] k) {
        for (int i = 0; i < k.length; i++) {
            for (int j = 0; j < k[i].length; j++) {
                System.out.printf("%d,\t", k[i][j]);
            }
            System.out.println("\n-------------------");
        }
    }
 
    public void print(Byte[] k) {
        for (int i = 0; i < k.length; i++) {
            System.out.printf("%d,\t", k[i]);
        }
        System.out.println();
    }
 
    public void print(Byte[][] k) {
        for (int i = 0; i < k.length; i++) {
            for (int j = 0; j < k[i].length; j++) {
                System.out.printf("%d,\t", k[i][j]);
            }
            System.out.println("\n-------------------");
        }
    }
 
    public void print(String[][] k) {
        for (int i = 0; i < k.length; i++) {
            for (int j = 0; j < k[i].length; j++) {
                System.out.printf("%s,\t", k[i][j]);
            }
            System.out.println("\n-------------------");
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class EraseGarbage {
    public static void main(String[] args) {
        new GarbageObject();
        Runtime rt = Runtime.getRuntime();
        long current = rt.freeMemory();
        long before = current;
        do {
            current = rt.freeMemory();
            System.out.println("1: befor =" + before);
            System.out.println("1: current=" + current);
        } while (current <= before);
        new GarbageObject();
        current = rt.freeMemory();
        before = current;
        do {
            rt.gc();
            current = rt.freeMemory();
            System.out.println("2:before =" + before);
            System.out.println("2:current=" + current);
        } while (current <= before);
    }
}
 
class GarbageObject {
    protected void finalize() throws Throwable {
        super.finalize();
        String name = Thread.currentThread().getName();
        System.out.println("finalize() name =" + name);
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;//패키지 lecture
 
public class InnerClass {// 클래스 InnerClass
    public static void main(String[] args) {// 메인 메소드
        NormalClassDefine ncd = new NormalClassDefine(50);
        OuterClassDefine ocd = new OuterClassDefine(100);
        // 숫자 100을 지우면 에러가 발생한다
        // 그 이유는 OuterClassDefine에 ()생성자가 없기 때문이다.
        // InnerClassDefine icd=new InnerClassDefine(200);
        // InnerClass는 이렇게 작성할수가 없다.
        // InnerClassDefine icd;
        // 이렇게 선언하면 오류가 난다 그 이유는 InnerClass이기 때문이다.
        OuterClassDefine.InnerClassDefine icd = ocd.new InnerClassDefine(200);
        // 위에 ocd를 선언했기 때문에 이렇게 작성할 수가 있다.
        OuterClassDefine.InnerClassDefine icd1 
        = new OuterClassDefine(100).new InnerClassDefine(200);
        // 위 두개의 작성방식은 같다.
        System.out.printf("ncd:%d, ocd:%d, icd:%d, icd1:%d%n",
                         ncd.a, ocd.a, icd.a, icd1.a);
        ncd.a = ocd.a = icd.a = 300;// 모든 값을 100으로 초기화
        System.out.printf("ncd:%d, ocd:%d, icd:%d, icd1:%d%n",
                         ncd.a, ocd.a, icd.a, icd1.a);
    }
}
 
class NormalClassDefine {// 클래스 NormalClassDefine
    int a;// 객체 맴버변수
 
    NormalClassDefine(int a) {
        this.a = a;
    }// 생성자 매=멤
}
 
class OuterClassDefine {// OuterClass 생성
    int a;// 객체 맴버변수
 
    class InnerClassDefine {// InnerClass 생성
        int a;// 객체 맴버변수
 
        InnerClassDefine(int a) {
            this.a = a;
        }// 생성자, 멤버변수 초기화
    }
 
    OuterClassDefine(int a) {
        this.a = a;
    }// 생성자, 멤버변수 초기화
}// OuterClass와 InnerClass는 상속관계가 아니다.
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class InstanceBlock {
    public static void main(String[] args) {
        InstanceBlockClass ib;
        ib = new InstanceBlockClass();
        System.out.printf("%d,%d%n", ib.a, ib.b);
        ib = new InstanceBlockClass(10, 15);
        System.out.printf("%d,%d%n", ib.a, ib.b);
        ib = new InstanceBlockClass(100);
        System.out.printf("%d,%d%n", ib.a, ib.b);
    }
}
 
class InstanceBlockClass {
    {
        a = 2;
        b = 1;
    }
    int a = -1, b = -3;
    {
        a = 5;
        b = 3;
    }
 
    public InstanceBlockClass() {
    }
 
    public InstanceBlockClass(int a) {
        this.a = a;
    }
 
    public InstanceBlockClass(int a, int b) {
        this.a = a;
        ;
        this.b = b;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class InterfaceObject {
    public static void main(String[] args) {
        InterfaceImplementClass iis;
        TestInterface ti;
        SuperInterface si;
        iis = new InterfaceImplementClass();
        iis.print();
        System.out.println(iis.print(true));
        iis.print(100);
        iis.print("테스트");
        ti = new InterfaceImplementClass();
        ti.print();
        System.out.println(iis.print(true));
        ti.print(100);
        ti.print("테스트");
        si = new InterfaceImplementClass();
        /* si.print(); */ System.out.println(iis.print(true));
        /* si.print(100); */ si.print("테스트");
    }
}
 
class InterfaceImplementClass implements TestInterface {
    public String print(boolean b) {
        if (b)
            return "참";
        else
            return "거짓";
    }
 
    public void print(String str) {
        System.out.println(str);
    }
 
    public void print(int a) {
        System.out.println(a);
    }
 
    public void print() {
        System.out.println("print 구현");
    }
}
 
interface TestInterface extends SuperInterface, SubInterface {
    public void print(int a);
}
 
interface SubInterface {
    public void print();
}
 
interface SuperInterface {
    public String print(boolean b);
 
    public abstract void print(String str);
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class Outer1 {
    private int out = 10;// 접근범위 private int 타입 변수명 out 값은 10
 
    public static void main(String[] args) {
        Outer1.Inner inner = new Outer1().new Inner();
        System.out.println("in = " + inner.in);
        Outer1 outer = new Outer1();
        outer.om();
    }
 
    public void om() {
        Inner inner = new Inner();
        inner.im();
    }
 
    public class Inner {
        Outer1 outer = Outer1.this;
        Inner inner = this;
        private int in = 5;
 
        void im() {
            System.out.println("out = " + out);
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
import javax.swing.*;
import java.awt.event.*;
 
public class OuterN extends JFrame {
    public static void main(String[] args) {
        JFrame frame = new OuterN();
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent we) {
                System.exit(0);
            }
        });
        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class OverridingAccessModifier {
    public static void main(String[] args) {
        OverridingAccessModifierSubClass oams 
        = new OverridingAccessModifierSubClass();
        OverridingAccessModifierSuperClass oamsc 
        = new OverridingAccessModifierSuperClass();
        oams.print();
        oamsc.print();
        System.out.println(oams.equals(5));
        System.out.println(oams.equals("테스트"));
        System.out.println(oams.equals(new OverridingAccessModifierSubClass()));
 
    }
}
 
class OverridingAccessModifierSubClass extends OverridingAccessModifierSuperClass {
    // , OverridingAccessModifierSuperClass1
    // 상위 클래스는 오직 1개, 하위클래서에서 범위지정자는 상위클래스보다 크거나 같아야 한다.
    public void print() {
        System.out.println("하위클래스 print 메소드");
 
    }
}
 
//class Access Modifier(접근제한자)는 default(기본값), public만 사용가능
class OverridingAccessModifierSuperClass {
    // extends Object //명시적으로 사용시 기입하면 되나 생략 가능
    public void print() {
        System.out.println("상위클래스 print 메소드");
    }
 
    public int equals(String str) {
        System.out.println(super.toString());
        return 0;
    }
 
    public boolean equals(int a) {
        return false;
    }
 
    public boolean equals(Object obj) {
        // 최상위클래스인 Object를 재정의 한것이다.
        // overloading 규칙 범위지정자와 반환명 매개변수 데이터 타입이 같아야 한다.
        return super.equals(obj);
    }
}
 
class OverridingAccessModifierSuperClass1 {
 
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
import java.util.Date;
 
public class PackageImportTarget {
    String str; // 맴버변수1
    Date dat; // 맴버변수2
 
    public PackageImportTarget(String str) { // 생성자1
        this.str = str;
    }
 
    public PackageImportTarget(String str, Date dat) {// 생성자2
        this.str = str;
        this.dat = dat;
    }
 
    public String print() {
        if (str != null && dat != null)
            return str + dat.toString();
        else if (dat != null)
            return "" + dat.getYear();
        else if (str != null)
            return str;
        else
            return "null";
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
import java.sql.Date;
 
public class PackageScope {
    public static void main(String[] args) {
        Date dat = new Date(117, 5, 28);// 1900월 0월~11월
        System.out.println(dat);
        // System.out.println(dat.valueOf("yyyy-m-d"));
        PackageImportTarget pit;
        pit = new PackageImportTarget("테스트");
        System.out.println(pit.print());
        pit = new PackageImportTarget("테스트1", dat);
        System.out.println(pit.print());
 
    }
 
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class PrivateConstructor {
    public static void main(String[] args) {
        PrivateConstructorClass pcc = PrivateConstructorClass.getInstance();
        PrivateConstructorClass pcc1 = PrivateConstructorClass.getInstance();
        System.out.println(pcc);
        System.out.println(pcc1);
        // 두개가 같은 주소를 참조한다.
 
    }
}
 
class PrivateConstructorClass {// PrivateContructorClass클래스
    private PrivateConstructorClass() {
        // 접근범위 private PrivateContructorClass생성자
        System.out.println("PrivateContructorClass 객체생성");
    }
 
    private static PrivateConstructorClass pcc;
 
    public static PrivateConstructorClass getInstance() {
        if (pcc == null)
            pcc = new PrivateConstructorClass();
        // 여러 내용을 같은 주소에 사용하기 위해 만든것
        return pcc;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class StaticinnerClass {
    public static void main(String[] args) {
        OuterClassStaticInner.StaticInnerClass os, os1;
        os = OuterClassStaticInner.StaticInnerClass.getInstance();
        os.print(new int[3]);// 배열 매개변수 a=3으로 입력하여 출력
        int a[] = new int[5];// int 타입 변수명 배열a에 방 5개 생성
        for (int i = 0; i < a.length; i++) {
            if (i == 0)
                a[i] = 1;
            else
                a[i] = ++a[i - 1];
            System.out.println(a[i]);
        }
        os1 = os.getInstance1(a);
        os1.print();
    }
}
 
class OuterClassStaticInner {
    static int a = 10;// 클래스멤버변수
 
    static void print() {// 클래스멤버메소드
        System.out.println(a);// 출력
    }
 
    static class StaticInnerClass {// Inner클래스
        int a[];// a[] 멤버변수 배열 선언
 
        public static StaticInnerClass getInstance() {// Inner클래스의 매소드
            return new StaticInnerClass();
        }
 
        public StaticInnerClass getInstance1(int a[]) {
            // 메소드 int타입 a[]을 매개변수로 사용함.
            this.a = a;// 멤버변수는 매개변수이다.
            return this;// StaticInnerClass를 반환한다.
        }
 
        public void print(int[] a) {
            for (int i = 0; i < a.length; i++)
                // 반복문 시작 a[]가 배열이기 때문에 배열을 생성한다.
                System.out.println(a[i]);
        }
 
        public void print() {// 메소드
            for (int i = 0; i < a.length; i++)
                System.out.println(a[i]);
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class SuperSub {
    public static void main(String[] args) {
        Super sup = new Sub();
        Sub sub = new Sub();
        sup.method();
        System.out.println("sup.var : " + sup.var);
        sub.method();
        System.out.println("sup.var : " + sub.var);
        System.out.println("getVar var :" + sub.getVar());
        System.out.println("getVar super.var :" + sub.getVarSuper());
        System.out.println(sup);
        System.out.println(sub);
    }
}
 
class Super {
    int var = 10;
 
    public void method() {
        System.out.println("Super : " + var);
    }
}
 
class Sub extends Super {
    int var = 20;
 
    public void method() {
        System.out.println("sub : " + var);
    }
 
    public int getVar() {
        return var;
    }
 
    public int getVarSuper() {
        return super.var;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap04;
 
public class ThisSuper {
    public static void main(String[] args) {
        S_uper s_up1 = new S_ub(100);
        S_uper s_up2 = new S_ub();
        if (s_up2 == s_up2.getThis()) {
            System.out.println("'sup2 == getThis()' is equal");
        }
    }
}
 
abstract class S_uper {
    int var;
 
    S_uper() {
        System.out.println("S_uper()");
    }
 
    S_uper(int i) {
        this();
        System.out.println("S_uper(" + i + ")");
        var = i;
    }
 
    public void method() {
        System.out.println("S_uper.this : " + var);
    }
 
    public abstract S_ub getThis();
}
 
class S_ub extends S_uper {
    int var;
 
    S_ub() {
        System.out.println("S_ub()");
    }
 
    S_ub(int i) {
        super(i + 10);
        System.out.println("S_ub(" + i + ")");
        var = i;
        this.method();
    }
 
    public void method() {
        super.method();
        System.out.println("S_ub.this :" + this.var);
        System.out.println("S_ub.super :" + super.var);
    }
 
    public S_ub getThis() {
        System.out.println("S_ub.getThis()");
        return (this);
    }
}
 
------------------------------------------------------------------------------------------
 cs

 

'Legend 개발자 > Java' 카테고리의 다른 글

Read Code(Chap.06)  (0) 2017.07.20
Read Code(Chap.05)  (0) 2017.07.20
Read Code(Chap.03)  (0) 2017.07.20
Read Code(Chap.02)  (0) 2017.07.20
Java 정리 지침  (0) 2017.07.20
Posted by 전설의아이
|

Read Code(Chap.03)

Legend 개발자/Java 2017. 7. 20. 12:01
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
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
------------------------------------------------------------------------------------------
package chap03;
 
public class ConstructorCreate {
    public static void main(String[] args) {
        ConstructorCreateClass cc = null, cd = null;
        // 참조형변수 객체초기화 변수명cc,cd에 null값 초기화
        if (cc == null)
            cc = new ConstructorCreateClass();
        // new키워드를 통해 생성자의 주소를 만듬
        System.out.println(cc.getName());
        // ConstructorCreateClass의 getName메소드 출력
        System.out.println(cc.num);
        // ConstructorCreateClass의 num값이 들어간 생성자 호출
        cc.setName("홍길동");
        // 멤버변수 name값을 홍길동으로 초기화 setName은 변수
        System.out.println(cc.getName());
        // ConstructorCreateClass의 getName메소드를 호출
        System.out.println(cc);
        // 만들어놓은 생성자의 주소를 출력 주소를 출력할때 자동으로 Object의 String을
        // 통해서 출력됨 System.out.println(cd.equals(cc));//NullPointerException이
        // 발생함, 그냥 Null 값이라서 정상적인 종료가 안된다.
        cd = cc;// cd값이 cc와 같다고 초기화
        System.out.println(cd);
        // cd의 주소를 출렸했으나 cc와 같다고 했기 때문에 같은 추소가 출력됨
        if (cc == null)
            cc = new ConstructorCreateClass();
        // ConstructorCreateClass()생성자의 주소를 초기화
        System.out.println(cc);
        // 새로만든 생성자의 주소 출력
        System.out.println(cc.num);
        // 후위증가 num++이 두번출렸되었으나 1이 출력된 이유는 주소가 바뀌어서 그런거임
        System.out.println(cc.getName());
        // ConstructorCreateClass의 getName메소드를 호출
        System.out.println(cd.getName());
        // cd는 cc와 같고 같은 이름을 호출
        cc = new ConstructorCreateClass("성춘향");
        // 참조형변수 cc의의 주소를 새로만들면서 성춘향이라는 값을 입력
        System.out.println("------------------");
        // "--------------" 호출
        System.out.println(cc.getName());
        // 성춘향이라는 이름 호출
        System.out.println(cc.num);
        // 여기서 값을 출력하면 1이나오는데 아래 생성자 this();를 주석처리하면 값이
        // 0으로 나온다. 값이 0으로 나오는 이유는 num++이 후위증가인데 num을 사용하지
        // 않아서 0으로 출력이 되는 것이다. 그러나 this();를 호출한다는 것은 생성자()를
        // 호출한다는 뜻이기 때문에 num++값이 후위증가되어 1값이 나온다
        ConstructorCreateSuperClass ccs;
        // 참조형 변수 ConstructorCreateSuperClass 변수명 ccs
        ConstructorCreateClass ccc;
        // 참조형 변수 ConstructorCreateClass 변수명 ccc
        ccs = new ConstructorCreateSuperClass();
        // 변수명 ccs 의 default생성자 주소 만듬
        ccc = new ConstructorCreateClass();
        // 변수명 ccc의 default생성자 주소를 만듬
        System.out.println(ccs.val);
        // 변수명ccs의 val값인 데이터타입 double인 3.14f를 호출, ccs의 default 값은
        // ccs의()값을 호출하도록 설계가 되어있기때문에 val값이 3.14f로 호출이된다.
        // 그러나 float타입이 double타입으로 바뀌기 때문에 double타입으로 출력이 된다.
        System.out.println(ccs.getVal());
        // 변수명ccs의 default생성자값을 호출 원리는 위와 같다.
        System.out.println(ccc.getVal());
        // 변수명ccc의 default생성자값을 호출, 디폴트값에 2.718float타입을 호출했으나
        // 상위클래스에서 호출하는 것이므로 다시 2.718f값이 ccs() default생성자로
        // 가게된다. 같은 원리로 실행이되고, float타입이 double타입으로 변해서 출력이된다.
        System.out.println(ccc.num);
        // 여기서 ccc값에 num값은 num++이기 때문에 후위증가로 값이 1이 출력이된다.
        ccs = ccc;
        // ccs와 ccc는 상속관계이며 ccs가 ccc보다 상위클래스이기 때문에 값을 넣는 것이
        // 가능하다. Auto Casting ccc=(ConstructorCreateClass)ccs; 반대로 할경우
        // Casting을 해줘야한다. 역으로하면 데이터가 짜리는 문제가 발생한다.
        System.out.println(ccs.getVal());
        // Auto Casting 된 이후 ccs의 default생성자를 호출한것이다. ccc값은
        // System.out.println(ccs.num); 여기서 num을 출력할 수 없는 이유가 ccs=ccc
        // Auto Casting하는 과정에서 num값이 사라졌기 때문이다. num값이 사라지는 이유는
        // ccc가 ccs로 Casting(형변환)하는 과정에서 ccs에 num값에 대한 것이 아무것도
        // 없기 때문에 num값이 사라지는 것이다.
    }
}
 
class ConstructorCreateClass extends ConstructorCreateSuperClass {
    // '앞'은 '뒤'에꺼로부터 상속받는다.
    long num;// 멤버변수 선언
    String name;// 멤버변수 선언
 
    ConstructorCreateClass() {
        super(2.718f);
        num++;
        name = "";
    }// 생성자
 
    ConstructorCreateClass(String name) {// 맴버변수명 name 타입 String인 생성자를 생성
        // this();//this()의 뜻은 ()안에 아무것도 안들어 있는 생성자를 호출하라는 뜻이다.
        super(2.718f);
        // 상위 클래스의 double타입 생성자를 호출한 것이다. default 생성자를 명시적으로
        // 작성한 후 주석처리를 하면 오류가 발생한다.
        this.name = name;
        // this에 생성자가 없으면 super에서 불러오나 super도 주석처리하면 오류가 발생한다.
    }// 생성자는 한번 호출이 가능하다. this현재클라스의 멤버변수를 사용한다라고 정의함
 
    public void setName(String name) {
        // super();//생성자는 첫줄에만 써야하기 때문에 오류가 난다.
        this.name = name;
    }// 멤버메소드는 여러번 호출이 가능하다. 그 이유는 생성자를 호출하려면 메모리에
    // 주소를만들어줘야 하기 때문이다. this는 무조건 첫줄에 작성해야 한다.
 
    public String getName() {
        return name;
    }// 멤버메소드
}
 
class ConstructorCreateSuperClass {
    double val;// 멤버변수 double데이터타입 변수명val 선언
 
    ConstructorCreateSuperClass(double val) {
        this.val = val;
    }
 
    // double타입 생성자를 만듬, 현재 float타입의 생성자가 없으나
    ConstructorCreateSuperClass() {
        this(3.14f);
    }
 
    // float타입보다 큰 double타입이 있으므로 this(float타입)이 가능하다. 생성자는 객체를
    // 생성할 때만 사용하고 그외에는 사용할 수 없다. 생성자는 .연산자로 접근할 수 없다.
    public double getVal() {
        return val;
    }// 멤버메소드
}
 
------------------------------------------------------------------------------------------
 
package chap03;
 
public class ConstructorObject {
    public static void main(String[] args) {
        int a = 5;
        SuperConstructorClass scc;
        scc = new SuperConstructorClass();
        System.out.println(scc.equals(scc));
        System.out.println(scc.toString());
        System.out.println(scc);
        scc = new SubConstructorClass();
        System.out.println(scc);
    }
}
 
class SuperConstructorClass {
    String str;
 
    SuperConstructorClass(String str) {
        this.str = str;
    }
 
    SuperConstructorClass() {
        this("test");
    }
 
    public String toString() {
        return str;
    }
}
 
class SubConstructorClass extends SuperConstructorClass {
    SubConstructorClass(String str) {
        super(str);
        System.out.println(str);
    }
 
    SubConstructorClass() {
        this("test1");
    }
}
 
------------------------------------------------------------------------------------------
 
package chap03;
 
public class Member {
    private static int count;
    static {
        count = 0;
    }
 
    public static int getCount() {
        return (count);
    }
 
    private String name;
    private String tel;
    {
        ++count;
    }
 
    public Member(String n) {
        name = n;
    }
 
    public Member(String n, String p) {
        name = n;
        tel = p;
    }
 
    public void setTel(String p) {
        tel = p;
    }
 
    public String getName() {
        return (name);
    }
 
    public String getTel() {
        return (tel);
    }
}
 
------------------------------------------------------------------------------------------
 
package chap03;
 
public class OverloadingMethod {
    public static void main(String[] args) {
        ElementSchoolClass esc = new ElementSchoolClass();
        esc.setInit(6);
        esc.setInit("홍길동");
        System.out.println(esc.toString());
        esc.setInit(3, "성춘향");
        System.out.println(esc.toString());
    }
}
 
class SchoolClass extends Object {
    protected int grade;
    private String name;
 
    public void setInit(int grade) {
        System.out.printf("%d%n", grade);
        // 여기서 호출하는 grade는 지역변수 grade이다.
        if (grade >= 1 && grade <= 6)
            ;
        // grade의 범위를 지정해주었다. 1<=grade<=6
        this.grade = grade;
        // this 키워드를 사용하여 멤버변수 grade를 호출하여 지역변수grade와
        // 같은 값이라는 것을 나타낸다.
    }
 
    public void setInit(String name) {
        this.name = name;// 지역변수 name은 멤버변수 name과 같다.
    }
 
    public void setInit(int grade, String name) {
        // this.grade=grade; //객체자신의 멤버변수를 접근할 때는 this를 사용한다.
        // this.name=name; 매개변수와 매개변수가 같다고 말할 때 this를 사용한다.
        this.setInit(grade);
        // 위와 같이 작성을 해도되지만 위에서 정의를 했기 때문에 이렇게 작성해도된다.
        setInit(name);
        // 위와 같은 의미지만 this는 생략해도된다.
    }
 
    public String toString() {
        // 접근범위 public 타입 String 변수명 toString, 위에서tostring을 호출한다.
        if (grade < 1 || grade > 6)
            return "객체의 학년을 초기화를 해주세요.";// 조건식 제작(29~31)
        else if (name == null || name.length() <= 0)
            return "객체의 성명을 초기화를 해주세요.";
        else
            return grade + "학년,성명 :" + name; // 값을 return한다.
    }
 
    public int getGrade() {
        return grade;
    }// return을 한 이유가 grade 값을 뽑아내야 다른 곳에서 사용할 수 있기 때문이다.
 
    public String getName() {
        return name;
    }// return을 한 이유가 name 값을 뽑아내야 다른 곳에서 사용할 수 있기 때문이다.
}
 
class ElementSchoolClass extends SchoolClass {// Is a 관계
    public void setInit(int grade) {// setInit를 재정의(overriding)를 했다.
        System.out.printf("%d%n", grade);
        if (grade >= 1 && grade <= 6)
            ;// grade의 조건식 1<=grade<=6을 지정해주었다.
        super.setInit(grade);
        // 멤버변수 점근 보다 지역변수 접근을 하는 것이 더 좋다.
        // 여기서 super를 사용했기 때문에재정의된 setInit가 아닌
        // 상위에 있는 setInit를 호출했다.
    }
 
    public String toString() {
        if (getGrade() < 1 || getGrade() > 6)
            return "객체의 학년을 초기화를 해주세요.";
        // 하위클래스에서 상위클래스의 grade와 name 값을 뽑으려면
        // 상위클래스에서 값을 return 해줘야 한다.
        else if (getName() == null || getName().length() <= 0)
            return "객체의 성명을 초기화를 해주세요.";
        else
            return getGrade() + "학년,성명 :" + getName();
    }
}
 
------------------------------------------------------------------------------------------
 
package chap03;
 
public class OverridingMethod {
    public static void main(String[] args) {
        SubClassMethod sc = new SubClassMethod();
        sc.print("test");
        sc.print();
        // SuperClassMethod를 호출하는 이유는 매개변수가 없기 떄문이고
        // 아래 두개의 클래스는 매개변수를 받고 있다.
        SubClassMethod.print();
        // SubClassMethod를 호출했으나 매개변수가 없어서
        // 상위 클래스의 매소드를 호출했다.
        SuperClassMethod.print();
        // SuperClassMethod의 매소드를 호출했다.
    }
}
 
class SuperClassMethod {
    int memVariable = 5;
 
    public static void print() {
        System.out.println("SuperClass print()");
    }
 
    public void print(String msg) {// 매개변수로 String타입 msg를 받는다
        System.out.printf("SuperClass variable :%d%n", memVariable);
        System.out.printf("SuperClass print(%s)%n", msg);
    }
}
 
class SubClassMethod extends SuperClassMethod {
    // SubClassMethod는 SuperClassMethod로부터 상속받는다.
    int memVariable = 3;
 
    public void print(String str) {// 상위에서 선언한 두번째 메소드를 재정의한 것이다.
        System.out.printf("SuperClass variable :%d%n", super.memVariable);
        System.out.printf("SuperClass variable :%d%n", this.memVariable);
        System.out.printf("SuperClass variable :%d%n", memVariable);
        System.out.printf("SubClass print(%s)%n", str);//
    }
}
 
class SubClassMethod2 extends SuperClassMethod {
    public void print(char str) {
        // 재정의 한 것이 아니다.재정의를 하려면
        // >=접근범위, 공통대상지정자, 메소드 이름, 객체 타입이 일치해야한다
        System.out.printf("SubClass print(%s)%n", str);
    }
}
 
class SubClassMethod3 extends SuperClassMethod {
    public void print(String str) {
        // 하나의 클래스에서 4개의 변수를 받는 다양성 overriding 예시이다.
        System.out.printf("SubClass print(%s)%n", str);
    }
 
    public void print(int a) {
        System.out.printf("SubClass print(%s)%n", a);
    }
 
    public void print(String str, String msg) {
        System.out.printf("SubClass print(%s), %s %n", str, msg);
    }
}
 
------------------------------------------------------------------------------------------
 
package chap03;
 
public class PrimitiveVariable {
    public static void main(String[] args) {
        PrimitiveClass pc = new PrimitiveClass(100);
        ReferenceClass rc = new ReferenceClass(pc);
        pc.setNum(50);
        rc.setNum(new PrimitiveClass(100));
        // 여기서 매개변수 값을 넣을 때는 주소가 변하는 것이 아니기 때문에 값만변한다.
        // pc.setNum(50); rc.setNum(null); null값을 넣으면 주소자체가 바뀌기 때문에 달라진다.
        System.out.println(pc);// print pc
        System.out.println(rc);// print rc
        rc.setName(new String("홍길동"));
        // 자바에서는 String만을 별도로 취급하여 문자열을 나타나도록 되어있기 때문에
        // String 타입은 값도 주소도 아닌 문자열을 넘긴다.
        System.out.println(rc.getName());
        System.out.println(rc.getPrimitiveClass());
    }
}
 
class PrimitiveClass {
    int num;// 생성자와 메소드의 차이점은 반환값이 있고 없고 이다.
 
    public PrimitiveClass(int num) {
        this.num = num;
    }
 
    public void setNum(int num) {
        this.num = num;
    }
    // public String toString(){return "기본형 :"+num;}
    // 문자열과 숫자열을 합치면 문자열이 된다. Object에 있는 String을 불러서 호출했다.
}
 
class ReferenceClass {
    PrimitiveClass num;
    String name;
 
    public ReferenceClass(PrimitiveClass num) {
        this.num = num;
    }
 
    // 참조형 변수는 값이 아닌 주소를 넣는다.
    public void setNum(PrimitiveClass num) {
        this.num = num;
    }
 
    // 멤버메소드에 있는 매개변수도 참조형 변수를 사용했다.
    public String toString() {
        return "참조형 :" + num;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    // 멤버메소드 선언 매개변수는 String 타입 변수명 name인 참조형 변수이다. 
    // 맴버변수는 지역변수이다.
    public String getName() {
        return name;
    }//
 
    public PrimitiveClass getPrimitiveClass() {
        return num;
    }
    // 멤버메소드의 반환형은 PrimitiveClass이다.
    // 그러므로 PrimitiveClass 데이터 타입을 따라야하기 때문에 반환타입이 int가 되는 것이다.
 
}
 
------------------------------------------------------------------------------------------
 
package chap03;
 
public class StaticBlock {
    public static void main(String[] args) {
        StaticBlockClass sb = new StaticBlockClass();
        // 여기서 출력을 할때 static이 생성자보다 우선적으로 출력되기 때무넹 1값이 출력이 된다.
        // 1값이 출려이 완료된후 생성자의 int=100이 실행이 되서 int 값이 100이 나오게 된다.
        StaticBlockSuperClass sbs = new StaticBlockSuperClass();
        // 생성자()를 new라는 키워드를 선언을 하면 객체가 된다.
        System.out.println(sb.cnt); // 변수sb의 cnt값을 호출한다.
        System.out.println(StaticBlockClass.cnt);// 위와 같은 뜻
        System.out.println(sbs.pi); // 변수sbs의 pi값을 호출한다.
        System.out.println(StaticBlockSuperClass.pi);// 위와 같은 뜻
    }
}
 
class StaticBlockClass extends StaticBlockSuperClass {
    // '앞'은 '뒤'에꺼로부터 상속받는다.
    // 상속을 받을 경우 하위클래스의 생성자를 객체로 만들어 호출하면 순서는
    // (1)상위클래스 static (2)하위클래스 static (3)상위클래스 생성자 (4)하위클래스 생성자가
    // 호출이되고 그후에 이어서 상위클래스를 호출을 해도 (5)상위클래스 생성자만 출력이 된다.
    // (5)만 출력이 되는 이유는 static은 메모리에 주소가 있기 때문에 한번만 적재가 되어서
    // 호출이 안된다.
    // VR기계는 주소가 있는 곳에 값을 한번 적재를 하면 다시 값을 적재를 할 필요성을 못느끼기
    // 때문에 static이 한번만 출력이 되는 것이다. 즉,있는데 왜또올려?이다.
    // 상속을 받지 않을 경우 하위클래스의 생성자를 호출할 경우
    // (1)하위클래스 static (2)하위클래스 생성자만 호출이되고 그후에 이어서 상위클래스를
    // 호출을 하면 (3)상위클래스 static (4)상위클래스 생성자이 호출이 된다.
    protected static int cnt;
 
    StaticBlockClass() {
        cnt = 100;
        System.out.println("StaticBlockClass 생성자 호출");
    }
 
    static {
        ++cnt; // 정적변수를 초기화하기 때문에 cnt=100이였던 것을 ++cnt로 초기화
        System.out.println(cnt); // print실행으로 ++cnt로 인해 1이 출력
    }
}   // 상속을 받을 때 하위클래스에서 정적주소로 객체를 생성하면 상위 클래스 객체 및 
    // static으로 선언된 것도 주소에 적재되기 때문에 호출이 된다.
 
class StaticBlockSuperClass { 
    // static으로 선언된 값은 위에서부터 아래로 차례대로 읽어내려간다.
    public static double pi;
    // 접근범위 public 정적주소 double타입 멤버변수명이 pi인 멤버변수 선언
 
    StaticBlockSuperClass() {// 생성자() 호출
        pi = 2.7182818; // 생성자()에 자연로그값을 넣어준다.
        System.out.println("StaticBlockSuperClass 생성자 호출");
    }
 
    static {
        System.out.println("파이값은 :" + pi);
    }
    static {
        pi = 3.141592;
        System.out.println(pi); // static으로 선언된 변수만 사용가능
    };
}
 
------------------------------------------------------------------------------------------
 
package chap03;
 
public class StaticBlock1 {
    public static void main(String[] args) {
        System.out.printf("%d,%d%n", StaticBlock1Class.a, StaticBlock1Class.b);
        new StaticBlock1Class();// 객체생성과 무관하게 값이 a=7, b=8이 된다.
        System.out.printf("%d,%d%n", StaticBlock1Class.a, StaticBlock1Class.b);
    }
}
 
class StaticBlock1Class {
    static int a = 1;
    static {//
        // this();
        // super();
        // this.toString()
        a = 5;
        b = 4;
    }
    static int b = 2;
    static {
        a = 7;
        b = 8;
    }
    {// 객체를 생성할때 나오는 인스턴스 초기화 블럭이다.
        this.toString(); // 사용가능 static이 붙은 것은 사용 불가능
        a = 10;
        b = 11;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap03;
 
import java.io.BufferedReader;
//읽어오는 역할
import java.io.InputStreamReader;
//바이트단위를 Character단위로 바꿔주는 역할을 한다.
import java.io.IOException;
// 지금 키보드로 입력을 하는 것과 출력하는 것에 대한 예외상황을 처리하는 역할을 가진다.
 
public class TeamMemList {
    public static void main(String[] args) {
        TeamMemList tmList = new TeamMemList();
        tmList.input();
        tmList.list();
    }
 
    private Member[] pl;
    private BufferedReader br;
 
    public TeamMemList() {
        pl = new Member[3];
        pl[0] = new Member("홍길동", "010-123-1234");
        pl[1] = new Member("이몽룡");
        pl[2] = new Member("성춘향", "010-123-5678");
        br = new BufferedReader(new InputStreamReader(System.in));
    }
 
    public void input() {
        for (int i = 0; i < pl.length; i++) {
            if (pl[i].getTel() == null) {
                System.out.println(pl[i].getName() + "'s tel?");
                try {
                    String tel = br.readLine();
                    pl[i].setTel(tel);
                } catch (IOException ioe) {
                }
            }
        }
    }
 
    public void list() {
        System.out.println("멤버수 =" + Member.getCount());
        for (int i = 0; i < pl.length; i++) {
            System.out.println(pl[i].getName() + "" + pl[i].getTel());
        }
    }
}
------------------------------------------------------------------------------------------
 cs

'Legend 개발자 > Java' 카테고리의 다른 글

Read Code(Chap.05)  (0) 2017.07.20
Read Code(Chap.04)  (0) 2017.07.20
Read Code(Chap.02)  (0) 2017.07.20
Java 정리 지침  (0) 2017.07.20
Read Code(Chap.01)  (0) 2017.07.20
Posted by 전설의아이
|

Read Code(Chap.02)

Legend 개발자/Java 2017. 7. 20. 10:54
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
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
------------------------------------------------------------------------------------------
package chap02;
 
public class AbstactModifier {
    public static void main(String[] args) {
        SubClassImplement sci = new SubClassImplement();
        sci.print();
        sci.print1();
        SuperClass sc = new SubClassImplement();
        sc.print();
    }
}
 
abstract class SuperClass {
    // abstract voidprint(){System.out.println("추상클래스");}
    // 추상메소드는 구현부 없음
    abstract void print();
 
    void print1() {
        System.out.println("추상클래스의 일반 메소드");
    }
}
 
class SubClassImplement extends SuperClass {
    void print() {
        System.out.println("추상클래스의 메소드 재정의");
    }
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class AsignementOperator {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        short a1, a2, a3, a4, a5;
        a1 = a2 = a3 = a4 = 3;
        System.out.printf("%d, %d, %d, %d\n", a1, a2, a3, a4);
        a1 = (a2 > a3) ? a4 : 100;
        a2 = (a2 > a3) ? a4 : (short) ((a3 == a4) ? 30 : 70);
        a2 += (a2 == a3) ? a4 : 50;
        System.out.printf("%d, %d, %d, %d", a1, a2, a3, a4);
 
        a1 = a2 = a3 = a4 = a5 = 5;
        a1 >>= 1; // a1=a1>>1; 5/2 =>2 0000 .... 0101 => 0000 .... 0010
        a2 <<= 1; // a2=a2<<1; 5*2 =>10 0000 .... 0101 => 0000 .... 1010
        a3 >>>= 1; // a3=a3>>>1; 5/2 =>2 0000 .... 0101 => 0000 .... 0010
        a4 &= 3; // a4=a4&3; 0000 .... 0101 & 0000 .... 0011 => 0000 .... 0001
        a5 |= 3; // a5=a5&3; 0000 .... 0101 | 0000 .... 0011 => 0000 .... 0111
 
        // boolean b1,b2,b3;
        // b1&&false;
        // b2||false;
        // b3!false;
        a1 += 4;
        a2 -= 3;
        a3 *= 2;
        a4 /= 2;
        System.out.printf("%x, %x, %x, %x\n", a1, a2, a3, a4);
 
    }
 
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class BitOperator {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        byte a1, a2, a3;
        a1 = a2 = a3 = 7; // 0000 0111
        System.out.printf("%x, %x, %x\n", a1, a2, a3);
        a1 = 1 & 3; // 0000 ... 0001
                    // 0000 ... 0011
                    // 결과0000 ... 0001
        a2 = 1 | 3; // 0000 ... 0001
                    // 0000 ... 0011
                    // 결과0000 ... 0011
        a3 = 1 ^ 3; // 0000 ... 0001
                    // 0000 ... 0011
                    // 결과0000 ... 0010
        System.out.printf("%x, %x, %x\n", a1, a2, a3);
 
        a1 = ~4; // 0000 ... 0100
                    // 결과1111 ... 1011
        a2 = ~5; // 0000 ... 0101
                    // 결과1111 ... 1010
        a3 = ~6; // 0000 ... 0110
                    // 결과1111 ... 1001
        System.out.printf("%x, %x, %x\n", a1, a2, a3);
 
    }
 
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class DoWhileContinue {
 
    public static void main(String[] args) {
 
        int i, a;
        a = i = 0;
        while (a++ < 5)
            System.out.printf("a=%d%n", a);
 
        while (++i < 5) {
            System.out.printf("i=%d%n", i);
        }
 
        a = i = 0;
 
        do {
            System.out.printf("a=%d%n", a);
        } while (++a < 5);
 
        do {
            if (i % 2 == 0)
                continue; // 짝수일 때 continue가 실행이 되서 홀수만 출력된다.
            System.out.printf("i=%d%n", i);
        } while (++i < 5);
    }
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class FinalModifier {
    public static void main(String[] args) {
        SubClass sc = new SubClass();
        sc.print();
        sc.print1();
        sc.print2();
    }
}
 
class SubClass extends MainClass {
    // void print1(){} //재정의 할 수 없음(overriding)
    void print() {
        System.out.printf("하위 클래스 :%d, %f%n", a, PI);
    }// 재정의
 
    void print2() {
        // PI=3.14; //상수화된 변수이므로 값을 변경 못함
        a = 100;
        System.out.printf("%d,%f%n", a, PI);
    }
}
 
// final //class에 final 선언시 상속 못함
class MainClass {
    int a = 5;
    final double PI = 3.141592;
 
    void print() {
        System.out.printf("%d,%f%n", a, PI);
    }
 
    final void print1() {
        System.out.printf("%d,%f%n", a, PI);
    }
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class ForLoop {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            System.out.printf("%d,", i);
        }
        System.out.println();
        int i = 0;
        for (; i < 10; i++) {
            System.out.printf("%d,", i);
        }
        System.out.println();
        i = 0;
        for (; i < 10;) {
            System.out.printf("%d,", i);
            i++;
        }
        for (int a = 0, j = 1; a < 10 || j < 100; a++, j += 3) {
            System.out.printf("%d, %d \n", a, j);
        }
    }
 
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class ForWhileDoCompare {
 
    public static void main(String[] arg) {
        int a, b, c;
        a = b = c = 0;
        for (; a < 5; a++)
            System.out.printf("a=%d, ", a);
        System.out.println();
        while (b++ < 5)
            System.out.printf("b=%d, ", b);
        System.out.println();
        do
            System.out.printf("c=%d, ", c);
        while (c++ < 5);
        System.out.println();
 
        a = b = c = 0;
        for (; a < 5; a++)
            System.out.printf("a=%d, ", a);
        System.out.println();
        while (b < 5) {
            System.out.printf("b=%d, ", b);
            b++;
        }
        System.out.println();
        do
            System.out.printf("c=%d, ", c);
        while (c++ < 5);
        System.out.println();
    }
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class IfCondition {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        float a1, a2;
        a1 = a2 = 7.12f;
        int b1, b2;
        b1 = b2 = 5;
        if (a1 > a2)
            System.out.printf("참: %f, %f\n", a1, a2);
        if (a1 > a2)
            System.out.printf("참: %f, %f\n", a1, a2);
        else
            System.out.printf("거짓: %f, %f\n", a1, a2);
        if (b1 == b2)
            System.out.printf("참: %d==%d\n", b1, b2);
        if (b1 == b2) {
            System.out.printf("참: %d==%d\n", b1, b2);
        } else {
            System.out.printf("거짓: %d==%d\n", b1, b2);
        }
 
        if (b1 == b2) {
            System.out.printf("참: %d==%d\n", b1, b2);
        } else if (a1 == a2) {
            System.out.printf("참: %f==%f\n", a1, a2);
        } else {
            System.out.printf("거짓: %d==%d\n", b1, b2);
            System.out.printf("거짓: %f==%f\n", a1, a2);
        }
        if (a1 == a2)
            if (b1 == b2) { // 중첩 if 문이다.위에꺼랑 아랫꺼의 결과는 똑같다.
                System.out.printf("참: %f==%f\n", a1, a2);
                System.out.printf("참: %d==%d\n", b1, b2);
            }
        if (a1 == a2 || b1 == b2) {
            System.out.printf("참: %f==%f\n", a1, a2);
            System.out.printf("참: %d==%d\n", b1, b2);
        }
 
    }
 
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class LogicalOperator {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        boolean op1 = false, op2 = true;
        int a1, a2, a3, a4;
        a1 = a2 = a3 = a4 = 5;
        // System.out.println(op1+","+op2+"="+(op1&&op2));
        // System.out.println(op1+","+op2+"="+(op1||op2));
        // System.out.println(a1+","+a2+"="+(a1>a2&&a3==a4));
        // System.out.println(a1+","+a2+"="+(a1>a2||a3==a4));
        System.out.println(a1 + "," + a2 + "=" + (a1 > a2 && a3++ == a4));
        System.out.println(a1 + "," + a2);
        System.out.println(a1 + "," + a2 + "=" + (a1 == a2 || a3-- == ++a4));
        System.out.println(a1 + "," + a2);
        String str1 = "";
        String str2 = null;
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str1.equals(str2));
        System.out.println(str1 == str2);
        System.out.println(str1 == null);
        System.out.println(str2 == null);
        System.out.println(str1.length());
        System.out.println(str2.length());
 
    }
 
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class LoopBreackContinueLabel {
 
    public static void main(String[] args) {
        loop1: for (int i = 0; i < 5; i++) {
            loop2: for (int a = 0; a < 3; a++) {
                if (a == i) {
                    System.out.printf("%d==%d skip", a, i);
                    continue loop2;
                }
                if (a > i) {
                    System.out.printf("%d>%d skip", a, i);
                    continue loop1;
                }
                if (a == 2) {
                    System.out.printf("%d==2 break", a);
                    break loop1;
                }
                System.out.printf("%d, %d%n", i, a);
            }
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class ReturnKeyWord {
 
    public static void main(String[] args) {
        print();
        print("홍길동");
        print("성춘향");
        String str = print1();
        int a = print2();
        print2();
    }
 
    /*
     * 메소드는 맴버 변수와 똑같으나 ()와;의 차이가 있다. 변수는 선언하고 초기값을 가진다.
     * 클래스도 선언부와 구현부로 나누어진다. 클래스 오른쪽에 있는것은 클래스 명이다.
     */
    // public static void print; // 이것은 맴버변수이나 void 데이터 타입이 없다.
    /*
     * public abstract void print4(); 미구현 메소드는 static대신 abstract로 작성해야 한다. 
     * 이것이 들어가려면 클래스도 static를 abstract로 바꿔줘야 한다.
     */
    public static void print() {// [맴버 메소드라고도 한다]반환형이 없으면 static 옆에 
                                // void가 들어간다.return이 들어갈 수 없음.
        System.out.println("print 메소드 호출됨\n");
    }
 
    public static void print(String str) {// [메소드는 선언부와 구현부로 이루어진다]
                                          // 반환형이 없으면 static 옆에 void가 들어간다.
        System.out.printf("매개변수 값이 %s 인 print메소드 호출됨\n", str);
    }
 
    public static String print1() {// 반환형이 있으면 static 옆에 해당되는 객체타입과 
                                   // 구현부에는 return이 들어간다.
        System.out.printf("print1 메소드 호출됨\n");
        return null;
    }
 
    public static int print2() {// 반환형이 있으면 static 옆에 해당되는 기본타입과 
                                // 구현부에는 return이들어간다.
        System.out.printf("print2 메소드 호출됨\n");
        return 0;
    }
 
    public static double print3() {// 반환형이 있으면 static 옆에 해당되는 기본타입과
                                   //  구현부에는 return이 들어간다.
        System.out.printf("print2 메소드 호출됨\n");
        return 0.0f;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class SameClassAccessModifier {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TestSameClass test = new TestSameClass();// default 생성자이다.
        test.print();
        test.print1();
        test.print2();
        // test.print3();//접근제한됨
        // System.out.printf("a=%d%n",test.a);//접근제한됨
        System.out.printf("b=%d%n", test.b);
        System.out.printf("c=%d%n", test.c);
        System.out.printf("d=%d%n", test.d);
    }
}
 
class TestSameClass { // 위에꺼와는 다른 클래스임, SameClassAccessModifier와
                        // TestSameClass는 한 패키지안에 있다.
    private int a;// 다른 클래스 사용 불가능함
    int b;
    protected int c;
    public int d;
 
    public void print() {
        System.out.printf("a=%d%n", a);
    }
 
    // 다른 클래스도 사용가능함
    void print1() {
        System.out.printf("b=%d%n", b);
    }
 
    // 다른 클래스도 사용가능함
    protected void print2() {
        System.out.printf("c=%d%n", c);
    }
 
    // 다른 클래스도 사용가능함
    private void print3() {
        System.out.printf("d=%d%n", d);
        print();
        // 같은 클래스 내에서는 호출이 가능하다 다른 클래스에서는 호출할 수가 없다.
    }
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class SameClassAccessModifierExtends {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TestSameClassExtends test = new TestSameClassExtends();
        test.print();
        test.print1();// 여기에 print1을 호출한적을 없으나
                      // 아래 클래스에 TestSameClass 상속을 받았기 때문에 쓸 수가 있다.
        test.print2();// 여기에 print2을 호출한적을 없으나
                      // 아래 클래스에 TestSameClass 상속을 받았기 때문에 쓸 수가 있다.
 
    }
}
 
class TestSameClassExtends extends TestSameClass {
    // TestSameClass와 상속관계가 있다. 이로서 선언하지 않은 것을 접근할 수 있다.
    public void print() {// 재정의 Overwriting했다
        // System.out.printf("a=%d%n", a); //private 접근 제한
        System.out.printf("b=%d%n", b);
        System.out.printf("c=%d%n", c);
        System.out.printf("d=%d%n", d);
    }
}
 
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class StaticModifier {
    static {
        System.out.println("정적블럭");
    }
    static int a = 5;
    int b = 7;
 
    public static void main(String[] args) {
        System.out.println(a);
        System.out.println(new StaticModifier().b);
        StaticCall sc = new StaticCall();
        sc.print();
        // 이거는 아래 클래스에서 static으로 되어 있지 않기 때문에
        // 객체로 생성해야만 사용할 수가 있다.
        StaticCall.print1();
        // 아래 StaticCall class에 print1은 static으로 되어 있으므로 
        // 이렇게 사용할 수가 있다.
        sc.print1();
        // StaticCall.print();//사용못함
        System.out.println(a);
        System.out.println(new StaticModifier().b);
    }
}
 
class StaticCall {
    public void print() {
        StaticModifier.a = 100;
        System.out.println(StaticModifier.a);
    }
 
    static void print1() {
        System.out.println("정적메소드" + StaticModifier.a);
    }
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class StaticModirierCounter {
    public static void main(String[] args) {
        StaticCount sc = new StaticCount(); // 객체를 생산, new는 키워드
        sc.counter();
        StaticCount sc1 = new StaticCount();
        sc1.counter();
        StaticCount sc2 = new StaticCount();
        sc2.counter();
 
        System.out.println(sc.getCounterA());
        System.out.println(sc.getCounterB());
        System.out.println(sc1.getCounterA());
        System.out.println(sc1.getCounterB());
        System.out.println(sc2.getCounterA());
        System.out.println(sc2.getCounterB());
 
    }
}
 
class StaticCount {
    private static int countA = 0;
    // 정적변수를 선언했다. 정적변수는 계속 같은 주소에 있기 때문에 누적이 된다.
    private int countB = 0;
    // 정적변수가 아닌 변수를 선언했다.
 
    public void counter() {
        countA++;
        countB++;
    }
 
    public String getCounterA() {
        return "countA:" + countA;
    }
 
    public String getCounterB() {
        return "countB:" + countB;
    }
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class SwitchCaseCondition {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a1;
        byte b1;
        short c1;
        char d1;
        a1 = c1 = b1 = 1;
        d1 = (char) c1;
        switch (a1) {
        case 1:
            System.out.printf("case 1: %d\n", a1);
        case 2:
            System.out.printf("case 2: %d\n", a1);
        default:
            System.out.printf("default:%d\n", a1);
        }
        switch (b1) {
        case 1:
            System.out.printf("case 1: %d\n", b1);
            break;
        case 2:
            System.out.printf("case 2: %d\n", b1);
            break;
        default:
            System.out.printf("default:%d\n", b1);
        }
        d1 = (char) 65;
        System.out.printf("d1 = %c\n", d1);
        switch (d1) {
        case 'A':
            System.out.printf("case 1: %c\n", d1);
            break;
        case 'B':
            System.out.printf("case 1: %c\n", d1);
            break;
        default:
            System.out.printf("default: %c\n", d1);
        }
    }
}
 
------------------------------------------------------------------------------------------
 
package chap02;
 
public class WhileForBreakLabel {
 
    public static void main(String[] args) throws Exception {
        loopLabel: while (true) {
            for (int i = 0; true; i++) {
                int ch;
                System.out.printf("%d입력:", i);
                ch = System.in.read(); // a enter
                switch (ch) {
                // switch-case문은 byte, short, character, int만 들어 간다.
                case 65:
                    System.out.println("A종료");
                    break loopLabel;
                case 'b':
                    System.out.println("종료");
                    break loopLabel;
                case 'c':
                    System.out.println("skip");
                    continue;
                // default :System.out.println((char)ch);
                default:
                    System.out.println(ch);
                }
            }
        }
 
        for (int i = 'A'; i <= 'Z'; i++)
            System.out.printf("%c,", (char) i);
        for (int i = 'A'; i <= 'Z'; i++)
            System.out.printf("%d,", i);
 
    }
}
 
------------------------------------------------------------------------------------------
 cs

'Legend 개발자 > Java' 카테고리의 다른 글

Read Code(Chap.04)  (0) 2017.07.20
Read Code(Chap.03)  (0) 2017.07.20
Java 정리 지침  (0) 2017.07.20
Read Code(Chap.01)  (0) 2017.07.20
Java Virtual Machine  (0) 2017.07.18
Posted by 전설의아이
|

Java 정리 지침

2017. 7. 20. 10:40

보호되어 있는 글입니다.
내용을 보시려면 비밀번호를 입력하세요.

Read Code(Chap.01)

Legend 개발자/Java 2017. 7. 20. 10:20
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
------------------------------------------------------------------------------------------
package chap01;
 
public class ConditionOperator {
 
    public static void main(String[] args) { 
        // TODO Auto-generated method stub
        int a = 3, b = 5;
        boolean flag = false;
        char c1 = 'A', c2 = 'B', c3 = 'a', c4 = 'b';
        String str1 = "가", str2 = "나";
        System.out.println(a > b);
        // System.out.println(flag>true); //논리형(boolean) 데이터 타입은 비교안됨
        System.out.println(!flag); // 논리형은 논리연산 가능
        System.out.println(c1 > c2);
        System.out.println(c1 > c3);
        System.out.println(c4 > c3);
        // System.out.println(str1>str2); //문자열은 크거나 작은 관계연산 안됨
        System.out.println(str1 == str2); // 주소번지 비교
        System.out.println(str1 == str1);
        System.out.println("가나 주소:" + (str1 == "가"));
        System.out.println("가나 주소:" + (str1 == "가나"));
        System.out.println("가나 내용:" + str1.equals("가나"));
        System.out.println(str1 instanceof String);
        System.out.println(str1 instanceof Object);
 
    }
 
}
 
------------------------------------------------------------------------------------------
 
package chap01;
 
import java.awt.Graphics;
 
import javax.swing.JApplet;
 
public class HelloApplet extends JApplet {
    public void paint(Graphics g) {
        g.drawString("HelloApplet", 10, 20);
        g.drawString("Width" + HelloApplet.WIDTH, 10, 40);
        new JApplet().repaint();
        new HelloApplet().repaint();
        g.drawString("Width : " + JApplet.WIDTH, 10, 60);
        JApplet japplet = new JApplet();
        HelloApplet happlet = new HelloApplet();
        String str = new String("대한민국");
        String str1 = "대한민국";
        Object obj = new Object();
        obj = str;
        str = (String) obj;
        japplet = happlet;
        happlet = (HelloApplet) japplet;
 
    }
}
 
------------------------------------------------------------------------------------------
 
package chap01;
 
public class MathOperater {
 
    public static void main(String[] args) {
        int i = 5;
        byte b = 5;
        b = (byte) (b + 7);
        short s = 5;
        s = (short) (s - 3);
        long l = 51;
        float ft = 3.141592f;
        double db = 3.141592e10;
        boolean bn = false;
        ft = (float) db;
        System.out.printf("%d\n", i);
        System.out.printf("%d\n", b);
        System.out.printf("%d\n", s);
        System.out.printf("%d\n", l);
        System.out.printf("%10.3f %,.5f\n", ft, db);
        System.out.printf("%5b\n", bn);
        bn = bn != bn;
        System.out.printf("%5b\n", bn);
        bn = !bn;
        System.out.printf("%5b\n", bn);
        int z, y, x;
        z = y = x = 10;
        System.out.printf("%5d , %5d , %5d \n", x, y, z);
 
        // System.out.printf("%d\n",i);
        // System.out.printf("%h\n",i);
        // System.out.printf("%x\n",i);
        // System.out.printf("%o\n",i);
        // System.out.printf("%f\n",(float)i); //형변환
        // System.out.printf("%e\n",(double)i);
 
    }
}
 
------------------------------------------------------------------------------------------
 
package chap01;
 
public class ObjectVariable {
    static String str = "대한민국";
    String str1 = "대한민국1";
    String str2 = new String("대한민국2");
    static int num = 123;
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int i = 0;
        int b = 077;
        int c = 0x77;
        int d = 77;
        System.out.println(str);
        System.out.println(i);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(ObjectVariable.num);
        System.out.println(ObjectVariable.str);
    }
 
}
 
------------------------------------------------------------------------------------------
 
package chap01;
 
public class OneOperand {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // int a1=5;
        // int a2=7;
        // int a3=9;
        // int a4=8;
        // System.out.printf("%5d, %5d\n", a1, a2);
        // System.out.printf("%5d, %5d\n", a3, a4);
        // a1++; a2--; ++a3; --a4;
        // System.out.printf("%5d, %5d\n", a1, a2);
        // System.out.printf("%5d, %5d\n", a3, a4);
        // a1=-a1; a2=-a2; a3=~a3;
        // System.out.printf("%5d, %5d\n", a1, a2);
        // System.out.printf("%5d, %5d\n", a3, a4);
        // System.out.printf("%5b\n", !(a3>a4));
 
        int b1, b2, b3, b4, b5;
        b1 = b2 = b3 = b4 = 1;
        b5 = ++b1 + ++b2 + ++b3 + ++b4;
        System.out.printf("%5d, %5d, %5d, %5d\n", b1, b2, b3, b4);
        System.out.printf("%5d ", b5);
        b1 = ++b1 + ++b1 + ++b1 + ++b1;
        System.out.printf("%5d ", b1);
        b1 = 1;
        b1 = b1++ + b1++ + b1++ + b1++;
        System.out.printf("%5d ", b1);
        b2 = --(b2);
        b3 = ++(b3);
        b4 = (b4)++;
        System.out.printf("%5d, %5d, %5d\n", b2, b3, b4);
        b2 = -(++b2);
        b3 = +(b3++);
        b4 = ~(b4--);
 
        System.out.printf("%5d, %5d, %5d\n", b2, b3, b4);
 
    }
 
}
 
------------------------------------------------------------------------------------------
 
package chap01;
 
public class ShiftOperator {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a1, a2, a3;
        int b1, b2, b3;
        a1 = a2 = a3 = 7;
        b1 = b2 = b3 = 4;
        System.out.printf("%x,%x,%x\n", a1, a2, a3);
        System.out.printf("%x,%x,%x\n", b1, b2, b3);
        a1 = a1 >> 2; // 0000 0100 = 0000 0001 >>는 나누기 2라고 할 수 있다.
        a2 = a2 << 2; // 0000 0100 = 0001 0000 <<는 곱하기 2라고 할 수 있다.
        a3 = a3 >>> 2; // 0000 0100 = 0000 0001 최상위비트가 따라가므로 
                       // 최상위비트가 0이되어서 무조건양수가 된다.
        b1 = b1 >> 2; // 0000 0111 = 0000 0001
        b2 = b2 << 2; // 0000 0111 = 0001 1100
        b3 = b3 >>> 2; // 0000 0111 = 0000 0001
        System.out.printf("%x,%x,%x\n", a1, a2, a3);
        System.out.printf("%x,%x,%x\n", b1, b2, b3);
        b1 = b2 = b3 = -4;
        b1 = b1 >>> 3; // 1111 1100 = 0001 .... 1111 1111
        b2 = b2 >>> 2; // 1111 1100 = 0011 .... 1111 1111
        b3 = b3 >>> 1; // 1111 1100 = 0111 .... 1111 1111
        System.out.printf("%x,%x,%x\n", b1, b2, b3);
 
    }
}
 
------------------------------------------------------------------------------------------
 cs

'Legend 개발자 > Java' 카테고리의 다른 글

Read Code(Chap.04)  (0) 2017.07.20
Read Code(Chap.03)  (0) 2017.07.20
Read Code(Chap.02)  (0) 2017.07.20
Java 정리 지침  (0) 2017.07.20
Java Virtual Machine  (0) 2017.07.18
Posted by 전설의아이
|

Java Virtual Machine

Legend 개발자/Java 2017. 7. 18. 17:13

 

Java Virtual Machine 의 내부 구조를 큰 형태로 분리해보면 클래스 로더 서브 시스템(Class Loader Subsystem), 실행 데이터 영역(Runtime Data Area), 실행 엔진(Execution Engine)으로 나눌 수 있다.

 

1. 클래스 파일

 클래스 파일은 개발자가 만들거나 이미 만들어진 프로그램을 의미한다. 개발자가 개발하는 자바 프로그램은 .java 이며 이파일이 자바 컴파일러에서 컴파일 과정을 거치면 .class 파일이 생성된다. 이렇게 컴파일 과정을 거쳐 생성된 클래스 파일은 JVM에서 실행 가능하다. JAVA 프로그램은 하나 혹은 그 이상의 클래스 파일들로 구성이 되고 이들 클래스 파일이 서로 유기적으로 동작하면서 프로그램은 자기의 기능을 수행하게 된다.

 

2. 클래스 로더 서브 시스템

 자바 클래스파일은 위의 그림에서와 같이 OS에서 직접 동작하지 않고 JVM위에서 동작한다. JVM은 실행할 클레스 파일을 읽고, JVM 메모리에 올려놓는 과정이 필요한데 이 과정을 클래스 로딩이라고 한다. 그리고 이 작업은 JVM의 클래스 로더 서브 시스템이 담당한다. 클래스 로더 서브 시스템을 줄여서 클래스 로더라고 부르며 클래스 로더는 다음과 같은 과정으로 JVM 메모리에 클래스 파일을 로딩한다.

 

1. JVM에서 실행할 클래스 파일의 내부 구조를 분석한다.

어떤 메소드가 있는지 어떤 변수가 선언되어 있는지 그리고 각각의 성격은 어떤지 모두 분석한다.

 

2. 부석된 내용을 바탕으로 성격에 따라 구분하고 각각 JVM의 적합한 메모리 영역에 데이터를 올려놓는다.

 

3. 분류된 데이터는 JVM의 특별한 메모리 영역에 저장되어 있다가 클래스가 실행되면 JVM의 실행 영역의 힙 메모리로 복사된다. 그리고 시스템 리소스를 활용해서 클래스를 실행 시킨다.

 

 클래스를 분석하는 과정에서 클래스 로더는 자바 언어의 기능 중 하나인 리플렉션 기법을 사용하여 컴파일된 클래스의 내부를 분석한다.

 자바는 클래스를 동적으로 로딩할 수 있는 구조를 가지고 있고 이를 동적 로딩(Dynamic loading)이라 한다.

 프로그램을 실행하는 도중에 새로운 클래스를 로딩할 수 있음을 의미한다. 클래스 파일을 로딩하는 시점에 따라서 다음과 같이 나뉠 수 있다.

1. 로드타임 동적 로딩 : 프로그램 실행 초기에 클래스를 로딩하는 것.

 

2. 런타임 동적 로딩 : 프로그램 실행 중간에도 클래스를 로딩하는 것.

 

3. 실행 데이터 영역

 클래스 로더로부터 분석된 데이터를 저장하고 실행 도중 필요한 데이터를 저장하는 영역. 메모리에 올라간 클래스, 객체, 변수들이 저장되는 곳으로 크게 다섯개 영역(메소드, 스택, 힙, 레지스터, 네이티브메소드)으로 구분되어 있다.

 

1. 메소드 영역

 클래스 로더에 의해서 로딩된 클래스가 저장되는 곳,

 클래스는 메소드와 클래스 변수로 구서오디어 있는데 이를 클래스의 메타 정보라고 한다.

 JVM에서 클래스를 실행하면 메소드 영역에서 클래스 정보를 복사하고 힙 영역에서 메모리를 할당하여 실행한다.

 JVM 메모리 영역중 가장 먼저 데이터가 저장되는 영역이다.

 

2. 스택 영역

 클래스 실행은 곧 메소드 호출을 의미한다. 또한 메소드는 다른 메소드를 호출할 수 있다.

 호출된 (실행된) 메소드 정보가 저자오디는 곳, 실해이 끝나면 저장된 정보는 삭제된다.

 메소드가 실행될 때마다 저장되는 메소드 정보에는 매개변수, 지역변수, 복귀주소 등이있다.

 이 영역에서는 스택을 데이터 관리 방법으로 사용한다(LIFO)때문에 메소드의 호출정보나 호출 순서 등을 추적하기 편리하다.

 

3. 힙 영역

 JVM의 실행 데이터 영역중 가장 중요한 역할을 담당한다.

 객체는 클래스가 실행될 때 생성되서 힙 영역에 저장된다. (객체가 생성되면 힙영역에 할당됨) 그러므로 힙 영역은 JVM에서 가장 중요한 데이터를 저장함과 동시에 매우 세밀한 관리가 이뤄지는 곳이다.

 힙 영역은 다시 여러개의 영역(Young, Peranent, Old)으로 나눠져있고 클래스 파일이 실행 되면 메소드 영역에서 클래스 정보를 복사하여 힙 영역에 실행할 클래스를 위한 메모리를 할당한다. 즉 힙 영역은 동적으로 데이터가 생성되고 소멸되는 영역이다. 그래서 JVM 성능 향상을 위해서 튜닝이 가능한 영역이기도 하다.

 

3-1. Young Generation

 Young 영역은 다시 Eden, Servivor1, Servivor2 영역으로 나뉜다.

 이름에서 추측되듯이 각 영역들은 얼마나 데이터를 오랫동안 저장하고 있ㅇ야 하는지에 따라서 구분된다.

 Young 영역은 프로그램 내부에 어떤 코드가 실행되면서 새롭게 생긴 데이터가 저장되는 부분이고,  Young 영역의 데이터가 계속해서 사용되면 Old 영역으로 이동하게 된다. 그리고 Permanent 영역은 클래스에 대한 정보가 저장되는 곳이다.

 JVm은 데이터의 목적과 수명에 따라서 저장 여역을 달리하여 관리하고 있다.

 Young 여역에 저장된 데이터의 사용이 끝나고 일정 시간 동안 사용되지 않으면 그 데이터는 지워진다.

 이때 힙 여역의 데이터를 지우는 것은 JVM의 일부분인 가비지 컬렉터(GC)이다

 *가비지 컬렉터가 데이터를 삭제하는 알고리즘은 힙의 세부 영역에 따라서 다르게 적용(수행되는 빈도와 지우는 속도) Young영역에 사용되는 가비지 컬렉터는 자주 그리고 빠르게 수행되는 알고리즘(Young영역 데이터 저장과 삭제 빈번)

 

3-2 Old Generation

 빈번하게 사용되는 데이터가 Young 영역에서 Old 영역으로 이동.

 Young 영역과 비교했을 때 Old 영역에서는 오랫동안 데이터가 보관된다.

 Old 영역에서 실해되는 가비지 컬렉터의 알고리즘은 Young 영역보다 수행 횟수가 적으며 속도도 느리다. (저장되는 기간이 길어짐)

 

3-3 Permanent Generation

 클래스들의 정보가 저장되는 영역.

 JVM에서 클래스 정보를 바탕으로 메모리 위에 객체를 빠르게 생성하기 위해 저장하는 곳.

 힙 영역을 이렇게 세 가지 영역으로 나눠서 데이터를 저장하는 이유는

 첫째, 보다 효율적으로 데이터를 관리하기 위함 - 자주 사용되는 데이터는 더 오랫동안 보관하여 전체적인 효율성 증대.

 둘째, 가비지 컬렉터가 실행되는 동안에 발생하는 STW(Stop The World)를 줄이기 위해서다.

 *STW: 가비지 컬렉터가 실행되는 동안 JVM의 다른 기능들이 잠시 멈추는 것을 의미. (가비지 컬렉터가 데이터를 지우는데 누군가 다시 그 데이터를 참조하려 할 때 문제가 발행할 수도 있기 때문) 따라서 STW가 자주 발생하면 그만큼 프로그램 실행 시간이 늘어나고 이는 성능 저하의 원인이 됨.

 

4. 레지스터 영역 

 현재 JVM이 수행할 명령어의 주소를 저장하는 메모리 공간 (개발자가 특별히 개입할 필요가 없는 영역)

 

5. 네이티브 메소드 스택 영역

 OS의 시스템 정보, 리소스를 사용하거나 접근하기 위한 코드로 보통 C, C++로 작성한다.

 이러한 매개변수나 지역변수 등의 네이티브 메소드를 위한 영역으로 이에 대한 정보가 저장된다.

 자바 프로그램과 OS 사이에 JVM이 존재하기 때문에 자바는 시스템에 직접 접근하기 어려운 형태다.

 하지만 JNI(Java Native Interface) API를 사용하면 자바 프로그램에서 OS 시스템에 대한 접근이 가능하다.

 이때 사용되는 네이티브 메소드들에 대한 정보가 네이티브 메소드 스택 영역에 저장된다.

 

----------------------------------------------------------------------------------------------------------------------

 

 

그림을 보면 JVM의 메모리 모델이 크게

1. Method Area 2. Heap 3. Stack 4. Native Method Stack 으로 이뤄진 것을 알 수 있다.

 

모든 부분에 간략히 설명을 하겠지만, 자바를 쓸 때 주로 다루는 두 가지 영역에 대해 알아보자!!

객체를 생성할 때 실제로 어떠한 일이 일어나는지 이해하려면 일단 자바에서 모든 것이 어디에서 사는지, 그리고 얼마나 오랫동안 사는지를 알아야 한다.

즉, 스택과 힙을 더 배워야 한다.

 

일단 스택은 메소드 호출과 지역변수가 사는 곳으로, 힙은 모든 객체가 사는 곳으로 알아두자!

메소드를 호출하면 그 메소드는 stack의 맨 위에 올라간다. 실제로 스택에 들어가는 것은 스택 프레임인데, 여기에는 실행하는 코드와 모든 지역변수의 값을 포함한 메소드의 상태가 들어간다.

 

헌데, 지역변수로 들어있는 객체는 어떻게 되나?

즉, 아래에서 지역변수 h는 어떻게 되나?

public void Write(){

 Human h = new Human();

}

 

원시 변수가 아닌 변수에는 객체 자체가 아닌 객체에 대한 레퍼런스가 들어가있게 된다.

역시 이미 말한데로 객체는 실제로 힙안에 있게 되고 지역변수 h만 스택에 들어간다.

 

지역변수가 스택에서 산다면 인스턴스 변수는 어디에서 사나?

 참고) 인스턴스 변수란? 클래스의 안, 메소드 밖에서 선언 된 변수

 

new Human()같은 명령을 내리면 JVM은 힙에 Human()을 위한 공간을 만들어야 한다.

 

헌데, 얼마만큼의 공간을 만들어야하나? 그 객체를 저장하기에 충분한 공간을만들어야 할텐데!

그렇기 때문에 그 객체의 모든 인스턴스 변수를 저장하는데 충분한 공간을 확보하게 된다.

따라서 인스턴스 변수는 힙에, 그 변수가 속하는 객체안에서 살게 된다!

 

하지만, 인스턴스변수가 객체라면?

즉 Human 객체에 Body 객체가 들어가 있다면? (=Human 에 Body 유형의 레퍼런스 변수가 있다면?)

새로운 객체에 원시 변수가 아닌 객체 레퍼런스인 인스턴스 변수가 들어있다면

레퍼런스가 참조하는 객체를 저장할 공간도 마련해줘야 할까?

정답은 "그렇지않다" 이다. Body 레퍼런스 변수가 들어갈 공간만 확보하면 된다.

private Body body;

 

레퍼런스 변수에 새로운 Body 객체를 대입하기 전까지는 힙에 실제 Body 객체가 만들어지지 않는다.

private Body body = new Body();

참고) 레퍼런스 변수의 크기는 얼마일까?

레퍼런스 변수의 크기는 알수없다. 또한 메모리 관련 문제에서 중요한 것은 레퍼런스 변수의 크기와 개수가 아닌 객체의 개수, 그리고 그 객체의 실제 크기이다.

또한 모든 객체 레퍼런스의 크기는 똑같다!!(JVM 종류별로 다를 수 는 있다.)

 

한 눈에 보는 메모리 구조

1. Method Area

 - JVM의 모든 Thread들이 공유하는 데이터 영역

 - Class 정보

 - Method정보(Method의 바이트 코드)

 - 멈버변수 정보,

 - Static변수(Class 변수)

 

2. Heap

 - 프로그램 상에서 데이터를 저장하기 위해 동적(실행시간)으로 할당하여 사용하는 영역

 - "new" 연산자로 생성된 객체와 배열을 저장

 - 주로 실행시간에 생성되는 객체를 저장

 - GC(GarbageCollection)으로 관리 되는 영역

   n Permanent Space : Class에 대한 Meta 정보를 저장하는 공간 => 정보는 컴파일러에 의해 최적화에 사용된다. (JITs)

     u Method of a class(including the bytecodes)

     u Nam es of the classes

     u Constant pool information

     u JVM으로부터 만들어진 내부 객체 ex: java/lang/Object

   n New Generation

     u Eden : 새로(new) 생긴 모든객체

     u Survivor1(From)

        | Minor GC에 의해서 Eden, Survivor 2영역의 객체 중 활성화된 객체만 이동하여 위치

        | Old Space로 이동되기 전의 객체만 위치

     u Survivor 2(To)

        | Minor GC에 의해서 Eden, Survivor 1영역의 객체 중 활성화된 객체만 이동하여 위치

        | Old Space로 이동되기 전의 객체만 위치

   n Old Generation

     u Survivor 1, Survivor 2 영역에서 이동해온 객체만 위치

     u Full GC의 대상이 되는 객체가 위치

 

참고) Class는 Permanent Space에, 객체는 Heap으로 왜 따로 저장되는 것일까?

객체(인스턴스)는 클래스를 인스턴스화 한 것이다.

따라서 JVM 내부적으로도 이 둘의 구현방식(객체를 힙에다가, 클래스를 Permanet에다가) 은 매우 비슷하다.

 

근데 왜 Permanent 와 Heap으로 각각 따로 저장하는 걸까?

여기에는 2가지 이유가 있다고 한다.

첫 번째는 철학적(philosophical인 이유이다.

class는 Java 구현의 일부이다. 따라서, 힙에 Java 자체의 데이터 구조를 채울수는 없다.

→ 아마도 JVM 역시 수많은 .class 파일로 구현되기 때문인듯하다.

 

두번째는 기술적인 이유이다.

원래 Permanent Space는 없었고, 객체와 클래스는 함께 저장되었다. 예전의 클래스들은 대부분 정적(Static)이었다.

Custom Class Loader는 거의 사용되지 않았고, Unloading 되는 클래스도 적었다.

(허나, 지금은 아니기에) 성능 최적화를 위해 Perm anent Space가 생기게 되었고 클래스를 여기에 넣게 되었다.

 

3. Java Stack

 - Method가 호출될 때마다 스택 플레임이 생성, 이것이 쌓여 스택을 구성.

 - 수행되는 Method 정보, 지역변수, 매개변수, 연산 중발생하는 임시데이터 저장.

 - JVM은 스택 영역을 실행중인 Thread에 따라 각각 구성

 

4. Native Method Stacks

 - Native Method 호출 시 native Method의 매개변수, 지역변수 등 을 바이트코드로 저장

 

----------------------------------------------------------------------------------------------------------------------

 

왜 JVM의 구조를 이해해야 하는가?

 - 예를 들어 시스템 프로젝트를 수행시 하루에 200만 개의 트랜잭션을 처리해야 한다면 성능의 대한 부분을 고려하지 않을 수 없다. 이에 따라 자바 가상머신인 JVM 작동원리를 이해하여 트랜잭션에 대한 응답시간, 또는 처리량의 염두해두고 코딩을 해야합니다.

 - 정보시스템의 설계 및 개발단계의 오류로인한 성능 저하 문제가 약 33% (설계 오류, 아키텍처 오류, 어플리케이션 코드 오류)를 차지 하고 있으며 특히, 설계 또는 아키텍처의 오류는 개선에 따르는 비용과 시간이 타 부분에 비하여 막대하므로 정보 시스템 구축 시 프로젝트 전 단계에 걸쳐 지속적으로 성능관리를 수행하고 그 결과를 검증하는 것이 중요하다.

 

JVM은 정의된 Specification을 구현한 하나의 독자적인 Runtime Instance라고 할 수 있다.

JVM의 역할은 쉽게 말해 우리가 작성한 Java 프로그램. Web Application Server(WAS)등을 구별하지 않고 Java 프로그램의 범주에 들어가는 모든 것들을 실행시키게 된다. 이것은 바로 Java에서 JVM이 핵심이라고 말하는 이유이다.

JVM 특징

 - 스택기반의 가상머신 : 대표적인 컴퓨터 아키텍처인 인텔 x86 아키텍처나 ARM 아키텍처와 같은 하드웨어가 레지스터 기반으로 동작하는데 비해 JVM은 스택 기반으로 동작합니다.

 - 가비지 컬렉션 ㅣ C언어에서 malloc(), free() 통해 메모리를 통제, but java는 JVM이 이 기능을 해줌

 - 플랫폼에 독립적 : 프로그램 실행구조와 비교해 가면서 설명

 

자바 프로그램의 실행구조 : 운영체제는 자바 가상머신을 실행시키고, 자바 가상머신은 자바 프로그램을 실행시키는 구조

일반적인 프로그램의 실행구조 : 일반적인 프로그램은 Windows 나 Linux 같은 운영체제 위에서 실행이 됨

 

Class Loader : JVM 내로 Class를 Load하고 Link를 통해 적절히 배치하는 일련으 ㅣ작업을 수행하는 모듈, Runtime시에 동적으로 Class를 Load함

Runtime Data Areas : JVM이라는 프로그램이 운영체제 위에서 실행되면서 할당받는 메모리 여역이다. 런타임 데이터 영역은 6개의 영역으로 나눌 수 있다.

Execution Engine : 클래스 로더를 통해 JVM 내의 런타임 데이터 영역에 배치된 바이트코드는 실행 엔진에 의해 실행된다. 실행엔진은 자바 바이트코드를 명령어 단위로 읽어서 실행한다.

 

JVM의 기본적인 수행과정

1. Class Loadder System을 통해 Class 파일들을 JVM으로 로딩한다.

2. 로딩된 Class 파일들은 Execution Engine을 통해 해석된다.

3. 해석된 프로그램은 Runtime Data Areas에 배치되어 실직적인 수행이 이루어지게 된다. 이러한 실행 과정 속에서 JVM은 필요에 따라 Thread Synchronization 과 Garbage Collection 같은 관리작업을 수행하게 된다.

 

자바 프로그램

 Java에서 프로그램을 실행한다는 것은 Class 파일을 JVM으로 로딩하고 Bytecode를 해석(Interpret)하는 작업은 물론, 메모리 등의 리소스를 할당하고 관리하며 정보를 처리하는 일련의 작업들을 포괄한다. 이 때 JVM은 쓰레드 관리 및 Gabage Collection과 같은 메모리 재생 작업도 수행한다.

 

일반적인 프로그램

1. 로딩

윈도우 시스템에서 실행파일은 PE(Portable Excutable)파일 형식을 가지고 있습니다.

Visual studio로 컴파일하면 .exe의 확장자를 가진 파일이 생성되게 됩니다.

바로 이 파일이 PE파일형식을가지고 있습니다.

프로그램 실행 명령이 내려지면 OS는 PE파일의 header 부분을 분석해서 프로그램의 진입지점을 적절하게 메인 메모리에 로딩하게 됩니다.

그 후 프로그램의 명령에 따라 필요한 순차적으로 명령어들을 로딩하게 됩니다.

 

2. 패치(Instruction Fetch)

메모리에 로딩된 프로그램은 CPU를 동작시키기 위한 명령어인 인스트럭션(Instruction)의 집합이라고 할 수 있습니다.

컴파일이라는 것은 결과적으로 우리의 소스 코드를 CPU가 이해할 수 이쓴ㄴ 인스트럭션으로 변화시켜 주는 것입니다.

프로그램이 실행되기 위해서는 메모리에 로딩된 인스트럭션들을 순차적으로 CPU로 읽어들여야 합니다.

이러한 과정을 인스트럭션 패치라고 합니다.

 

3. 디코딩(Instruction Decoding)

그림 2번의 8d 44 24 0c는 16진수로 표현 되었을 뿐 0,1 로 구성된 바이너리 코드입니다.

실행을 위해서는 0,1 로 구성된 바이너리 코드를 각 필드별로 분해하여 어떤 종류의 연산을 수행 할 것인지를 결정해야 하고

 연산에 필요한 연산자를 레지스터에 인가시키는 작업이 필요합니다.

이러한 작업을 디코딩이라고 합니다.

 

4. 실행(Execution)

 디코딩 과정에서 수행 될 연산의 종류는 연산코드의 형식으로 CPU에서 실질적인 연산을 수행하는 산술논리 연산장치(arithmetic-logic unit): ALU에 입력됩니다.

ALU는 연산코드에 맞춰서 레지스터에 저장된 연산자들을 이용하여 연산을 수행하게 됩니다.

하나의 인스트럭션이 실행을 마치면 다시 새로운 인스트럭션을 패치해 오게 되는 과정을 반복하게 됩니다.

 

Runtime Data Areas는

 - 메소드 영역 (메소드의 바이트 코드,   클래스 변수)

 - 힙(heap) 영역 (객체)

 - 스택(stack) 영역 (매개변수, 지역변수)

 - PC 레지스터

 - Native 메소드 스택

로 구성된다.

 

메소드 영역 : 모든 스레드가 공유하는 영역으로 JVM이 시작될 때 생성된다. JVM이 읽어 들인 각각의 클래스와 인터페이스에 대한 런타임 상수 풀, 필드와 메서드 정보, Static변수, 메서드의 바이트코드 등을 보관한다.

힙(Heap) 영역 : 인스턴스 또는 객체를 저장하는 공간으로 가비지 컬렉션 대상이다. JVM 성능 등의 이슈에서 가장 많이 언급되는 공간이다.

스택(stack) 영역 : JVM 스택은 각 스레드마다 하나씩 존재하며 스레드가 시작될 때 생성된다. 스택 프레임(Stack Frame)이라는 구조체를 저장하는 스택으로, JVM은 오직 JVM 스택에 스택 프레임을 추가하고 (push) 제거하는 (pop) 동작만 수행한다.

PC 레지스터 : 각 스레드마다 하나씩 존재하며 스레드가 시작될 때 생성된다. PC 레지스터는 현재 수행 중인 JVM 명령의 주소를 갖는다.

Native 메소드 스텍 : 각 스레드마다 하나씩 존재하며 스레드가 시작될 때 생성된다. PC 레지스터는 현재 수행 중인 JVM 명령의 주소를 갖는다.

 

- Runtime Data Areas는 Process로서의 JVM 프로그램을 수행하기 위해 OS로부터 할당 받는 메모리 영역

- Runtime Data Areas는 Java Application, 특히 Web Application Server(WAS)를 사용할 때 가장 빈번하게 성능문제가 발생하는 영역(Memory Leak, Garbage Collection)

- Runtime Data Area는 각각의 목적에 따라 5개 영역으로 나뉨

1) PC Registers : 프로그램의 실행은 CPU에서 명령어, 즉 인스트럭션(Instruction)을 수행하는 과정으로 이루어진다. CPU는 이러한 Instruction을 수행한느 동안 필요한 정보를 레지스터라고 하는 CPU 내의 기억장치를 사용한다. 연산의 결과값을 메모리로 전달하기 전에 CPU 어딘가에 잠시 머무르도록 해야 한다. 이 때 사용하는 CPU 어딘가에 잠시 머무르도록 해야 한다. 이때 사용하는 cpu내의 기억장치를 레지스터이다.

2) JVM Stack : Thread의 수행 정보를 기록하는 Frame을 저장하는 메모리 영역

3) Native Method Stacks : Java는 java외의 언어로 작성된 프로그램, API 툴킷 등과의 통합을 쉽게 하기 위하여 JNI(Java Native Interface)라는 표준 규약을 제공, 다시 말해 Native Code로 되어 있는 Function의 호출을 Java프로그램 내에서 직접 수행할 수도 있고 그 결과 값을 받아 올 수도 있게 된 것이다.

4) Method Area : 모든 Thread 들이 공유하는 메모리 영역이다. 이 영역은 Load 된 Type을 저장하는 노리적 메모리 공간으로 정의할 수 있다. 여기서 Type이란 Class나 Interface를 의미

5) Java Heap : Java Heap은 단지 Instance (또는 Object)와 Array 객체 두 가지 종류만 저장되는 공간, 자바 힙은 모든 Thread 들에 의 해 공유된다.

 

정리된 Runtime areas

 런타임 데이터 영역은 JVM 이라는 프로그램이 운영체제 위에서 실행되면서 할당받는 메모리 영역이다. 런타임 데이터 영역은 6개의 영역으로 나눌 수 있다. 이중 PC레지스터(PC Register), JVM 스택(JVM Stack), 네이티브 메서드 스택(Native Method Stack)은 스레드마다 하나씩 생성되며 힙(Heap), 메서드 영역(Method Area), 런타임 상수 풀(Runtime Constant Pool)은 모든 스레드가 공유해서 사용한다.

 

PC 레지스터 : PC(Program Counter) 레지스터는 각 스레드마다 하나씩 존재하며 스레드가 시작될 때 생성된다. PC 레지스터는 현재 수행 중인 JVM 명령의 주소를 갖는다.

 

JVM 스택 : JVM 스택은 각 스레드마다 하나씩 존재하며 스레드가 시작될 때 생성된다. 스택 프레임(Stack Frame)이라는 구조체를 저장하는 스택으로, JVM은 오직 JVM 스택에 스택 프레임을 추가하고(push) 제거하는 (pop) 동작만 수행한다. 예외 발생 시 printStackTrace() 등의 메서드로 보여주는 Stack Trace의 각 라인은 하나의 스택 프레임을 표현한다.

 

네이티브 메서드 스택 : 자바 외의 언어로 작성된 네이티브 코드를 위한 스택이다. 즉 JNI(Java Native Interface)를 통해 호출한는 C/C++등의 코드를 수행하기 위한 스택으로, 언어에 맞게 C스택이나 C++스택이 생성된다.

 

메서드 영역 : 메서드 여영ㄱ은 모든 스레드가 공유하는 여역으로 JVM이 시작될 때 생성된다. JVM이 읽어 들인 각각의 클래스와 인터페이스에 대한 런타임 상수 풀, 필드와 메서드 정보, Static변수, 메서드의 바이트코드 등을 보관한다. 메서드 영역은 JVM 벤더마다 다양한 형태로 구현할수 있으며, 오라클 핫스팟 JVM(HotSpot JVM)에서는 흔히 Permanent Area, 혹은 Permanent Generation(PermGen)이라고 불린다. 메서드 영역에 대한 가비지 컬렉션은 JVM 벤더의 선택 사항이다.

 

런타임 상수 풀 : 클래스 파일 포맷에서 constant_pool 테이블에 해당하는 영역이다. 메서드 영역에 포함되는 여역이긴 하지만, JVM 동작에서 가장 핵심적인 역할을 수행하는 곳이기 때문에 JVM 명세에서도 따로 중요하게 기술한다. 각 클래스와 인터페이스의 상수 뿐만 아니라 메서드와 필드에 대한 모든 레퍼런스까지 담고 있는 테이블이다. 즉, 어떤 메소드나 필드를 참조할 때 JVM은 런타임 상수 풀을 통해 메서드나 필드의 실제 메모리상 주소를 찾아서 참조한다.

 

힙 : 인스턴스 또는 객체를 저장하는 공간으로 가비지 컬렉션 대상이다. JVM 성능 등의 이슈에서 가장 많이 언급되는 공간이다. 힙 구성 방식이나 가비지 컬렉션 방법 등은 JVM 벤더의 재량이다.

Young Generation : 이 영역은 Java 객체가 생성되자마자 저장되고, 생긴지 얼마 안되는 객체가 저장되는 곳이다. Java 객체가 생성되면 이 영역에 저장되다가 시간이 지남에 따라 우선순위가 낮아지면 Old 영역으로 옮겨진다.

Old Generation : Young Generation 영역에서 저장되었던 객체중에 오래된 객체가 이동되어서 저장되는 영역

perm 영역 : Class, Method 등의 Code등이 저장되는 영역으로 JVM에 의해서 사용된다.

 

그렇다면 메모리를 누가 생성 및 해제할까?

- 할당된 메모리를 누가 어떻게 해제 될까? 바로 Garbage Collector가 Garbage Collection을 통해 메모리를 해제한다. (메모리의 해제란 Heap이나 Method Area에 있는 특정한 Object를 Memory에서 삭제한다는 의미

- Java에서는 개발자가 프로그램 코드로 메모리를 명시적으로 해제하지 않기 때문에 가비지 컬렉터(Garbage Collector)가 더 이상 필요 없는(쓰레기)객체를 찾아 지우는 작업을 한다.

- GC에 대해서 알아보기 전에 알아야 할 용어

  stop-the-world란, GC을 실행하기 위해 JVM이 에플리케이션 실행을 멈추는 것이다. CG를 실행하기 위해 JVM이 애플리케이션 실행을 멈추는 것이다. Stop-the-world가 발생하면 GC를 실행하는 쓰레드를 제외한 나머지 쓰레드는 모두 작업을 멈춘다. GC 작업을 완료한 이후에야 중단했던 작업을 다시 시작한다. 어떤 GC 알고리즘을 사용하더라도 stop-the-world는 발생한다. 대개의 경우 GC 튜닝이란 이 stop-the-world 시간을 줄이는 것이다.

- GC가 만들어지는 2가지 전제조건

  대부분의 객체는 금방 접근 불가능 상태(unreachable)가 된다.

  오래된 객체에서 젊은 객체로의 참조는 아주 적게 존재한다.

 

GC의 정의 및 중요성

GC정의 및 역할

- 저는 GC입니다. 개발자가 요청한 메모리를 할당 합니다. 또한 개발자가 프로그램 코드로 메모리를 명시적으로 해제하지 않기 때문에 제가 더 이상 필요 없는 (쓰레기) 객체를 찾아 치우는 작업을 합니다. 또한 개발자들로 하여금 Memory관련 문제에서 큰 고민을 하지 않게 만들어 주었죠, 그러나 가끔 저도 실수할때도 있어요. 개발자의 의도와는 다르게 프로그램ㅇ르 수행하는 과정에서 멈추기도 하고 CPU의 사용에 민감한 프로그램의 경우 CPU Time 스케줄링에 어려움을 주기도 한답니다. 특히 요즘과 같이 WAS를 많이 사용하는 경우 지속적인 지연현상은 서비스의 불만을 초래하기도 합니다

GC의 중요성

- 그렇다면 왜 제가(GC) 중요할까요?? Minor GC의 경우 보통 0.5초이내에 끝나기 때문에 큰 문제가 되지 않아요. 그러나 FullGC의 경우엔 보통 수초가 소요 되고, Full GC동안에는 Java Application이 멈취버리기 때문에 문제가 될 수 있기 때문이죠

 

GC절차

- 자바 객체는 Eden 영역에 태어납니다. 이를 memory 할당(allocation)이라 합니다. 즉 Eden은 모든 Java 객체의 고향이죠

- Eden 영역이 간당간당해져서 GC 필요성이 생기면 살아야 할 놈은 S0으로 복사합니다.

- Eden 영역을 다 날립니다(사실은 이때 S1 영역도 같이 날립니다.)

- 또 Eden에 Java 객체들이 태어납니다.

- 그러다 또 Eden이 간당간당하면 이번엔 살아야 할 놈들을 S1으로 복사합니다. 이 땐 S0에서도 살아야 할 놈들은 S1으로 복사합니다.

- 또 한번 Eden과 S0를 다 날립니다.

 

마지막으로 메모리 크기도 지정하지 않고 Timeout 로그가 수도 없이 출력된다면 여러분의 시스템에서 GC 튜닝을 하는 것이 좋다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

'Legend 개발자 > Java' 카테고리의 다른 글

Read Code(Chap.04)  (0) 2017.07.20
Read Code(Chap.03)  (0) 2017.07.20
Read Code(Chap.02)  (0) 2017.07.20
Java 정리 지침  (0) 2017.07.20
Read Code(Chap.01)  (0) 2017.07.20
Posted by 전설의아이
|

오라클 시험

Legend 개발자/Oracle 2017. 6. 23. 17:25

과목 1

1.  데이터 베이스 선정할 때 고려할 사항이 아닌 것

답 : 비용/안정성/범용성/용량/성능(속도)

- 계층형 데이터베이스 : 계층형 데이터 베이스는 데이터의 관계를 트리 구조로 정의하고, 부모, 자식 형태를 갖는 구조이다. 풀어서 말하면 상위에 레코드가 복수의 하위 레코드를 갖는 구조이다. 하지만 데이터의 중복이 문제가 생긴다.

- 네트워크형 데이터베이스 : 네트워크형 데이터베이스는 계층형 데이터의 데이터 중복 문제를 해했고, 레코드간의 다양한 관계를 그물처럼 갖는 구조이다. 하지만 복잡한 구조 때문에 추후에 구조를 변경한다면 많은 어려움이 따른다.

- 관계형 데이터 베이스 : 관계형 데이터베이스는 우리가 흔히 표현하는 행(Column), 열(Record)로 구성된Table간의 관계를 나타낼때 사용한다. 우리는 이렇게 표현된 데이터를  SQL(Structured Query Language)을 사용하여 데이터 관리 및 접근을 한다.

- NoSQL 데이터베이스 : NoSQL 데이터베이스는 관계형 데이터베이스보다 덜 제한적인 일관성 모델을 이용한다. 키(key)와 값(value)형태로 저장되고, 키를 사용해 데이터 관리 및 접근을 한다.


 

2.  데이터 베이스 생성할 때 사용하는 명령어

답 : CREATE

- DDL(CREATE)

- CREATE DATABASE [DB명];


3.  데이터 베이스 정의(어)와 관련 없는 것

답 : (DDL, DML, DCL) (CREATE, ALTER, DROP, TRUNCATE)

DDL;Data Definition Language : 스키마를 정의하거나 조작하기 위해 사용

- CREATE : 정의

- ALTER : 수정

- DROP : 삭제

- TRUNCATE : DROP 후 CREATE

DML;Data Manipulation Language : 데이터를 조작하기 위해 사용

- SELECT : 조회

- INSERT : 추가

- DELETE : 삭제

- UPDATE : 변경

DCL;Data Control Language : 데이터를 제어하기 위해 사용

- COMMIT : 트랜잭션 작업 결과를 반영

- ROLLBACK : 트랜잭션의 작업 취소 및 원상복구

- GRANT : 사용자에게 권한 부여

- REVOKE : 사용자 권한 취소

 

4.  데이터 베이스 용량 산정할 때 고려할 사항이 아닌 것

답: 데이터 건수 및 용량 산정(조사), 헤더 사이즈 평균 길이, 30% 여유공간,

3. 테이블 설계

3.1 데이터 건수 및 용량 산정

 1) 데이터 건수와 길이 산정

 - 테이블 크기를 산정하기 위한 양식을 업무 담당자에게 배포하여 데이터 건수와 산정근거를 조사한다.

업무명 

테이블명 

초기건수 

월발생건수 

보관기간 

 

 

 

 

 

 - 데이터 없이 빈 테이블을 구성하여 SQL문을 통하여 정확한 테이블별 row의 길이를 구할 수 있다.

2) 테이블 총크기 산정

 - 조사된 데이터 건수와 길이를 바탕으로, 계산 공식이 반영된 Excel 양식을 이용하여 자동으로 산정한다.

 - Row 길이에 헤더 사이즈를 감안하여 평균 길이를 구한다.

 - 30% 정도의 여유공간을 감안하여 테이블의 총크기를 구한다.

테이블명 

최종길이 

초기건수 

월발생건수 

보관기간 

총데이터건수 

총크기 

 

 

 

 

 

 

 

 

- 한 개의 BLOCK에 Available 한 Bytes - 1958

- 각 initrans 는 23 Bytes

- PCT_FREE : Table 의 pctfree 값(default 10)

- ADJ_ROW_SIZE : 각 row 의 평균 SIZE 추정치

- ROW_COUNT : table 의 row 의 갯수

- BLOCK_SIZE : 1 block의 크기 (단위: K)

 

5.  테이블을 생성하거나 삭제하는 명령어는 무엇인가?

답 : (DDL, DML, DCL) (CREATE, ALTER, DROP, TRUNCATE)

CREATE TABLE 문장을 실행하여 테이블을 생성 합니다.


No.032 테이블 삭제

DROP TABLE 문장은 Oracle8 테이블의 정의를 삭제 합니다. 테이블을 삭제할 때 데이터베이스는 테이블에 있

는 모든 자료와 그와 연관된 모든 INDEX를 DROP 하고 사용하고 있던 공간을 돌려줍니다.

- 테이블의 모든 구조와 데이터가 삭제 됩니다.

- DDL 문장이기 떄문에 TRANSACTION 이 COMMIT 됩니다.

- 모든 인덱스가 삭제 됩니다.

- VIEW나 SYNONYM은 남지만 사용시 ERROR가 발생합니다.

- 테이블의 OWNER 나 DROP ANY TABLE 권한을 가진 사용자만이 테이블을 삭제할 수 있습니다.

- Syntax

 DROP TABLE table_name [CASCADE CONSTRAINT] 

- 일단 실행된 DROP TABLE 문장은 복구(ROLLBACK)할 수 없습니다. ORACLE SERVER 은 DROP TABLE 문장을

실행할 때 삭제 여부를 질문하지 않습니다.


No.012 DELETE 문장

- DELETE 문장을 사용하여 테이블로부터 기존의 자료를 삭제할 수 있다.

- WHERE 절을 명시하여 특정 행이나 행들을 삭제할 수 있다.

- WHERE 절을 생략하면 테이블의 모든 행이 삭제 된다.

- Syntax

 DELETE [FROM] table_name

 [WHERE condition];


No.030 TRUNCATE TABLE 문장

- 테이블의 OWNER 이거나 DELETE TABLE 권한을가진 사용자가 테이블의 모든 행을 삭제(구조는 삭제되지 않

는다)하고 사용하고 있던 기억 공간을 모두 해체할 경우에 사용합니다.

- 삭제된 행은 복구(ROLLBACK)할 수 없습니다.

- Syntax

  TRUNCATE TABLE table_name;

- DELETE 문장은 테이블의 모든 행을 삭제할 수 있지만, 저장 공간을 해제할 수 없습니다.



6.  사용권한을 줄 때 사용하는 명령어?

답: GRANT

GRANT


7.  테이블 수정할 때 사용하는 쿼리문

답: ALTER - ADD(열 추가), MODIFY(수정), RENAME(이름 수정), UPDATE(행 수정) 

No.020 테이블을 수정

- 테이블을 생성한 이후에 열을 생략 되었거나, 열 정의를 변경할 필요가있을 수 있다.

- 테이블의 구조를 변경할 경우 ALTER TABLE 명을 사용하여 변경 한다.


No.021 새로운 열 추가

- 새로운 열을 추가 할 수는 있지만 테이블에 있는 기존의 열은 DROP 할 수 없다.

- 열이 위치를 기술할 수 없으며 항상 테이블에서 마지막에 위치 합니다.

- 열을 추가할 때 테이블이 행을 포함하고 있다면 새로운 열은 이미 존재하는 열을 NULL로 초기화 한다.

- Syntax

 ALTER TABLE table_name

 ADD (column datatype [DEFAULT expr ]

 [,column datatype [DEFAULT expr ], , , , , , , , ] 


No.022 열 수정

- ALTER TABLE의 MODIFY 절을 사용하여 열의 정의를 수정할 수 있습니다.

- 열의 수정은 열의 자료형, 크기, DEFAULT VALUE입니다.

- Syntax

 ALTER TABLE table_name

 MODIFY (column datatype [DEFAULT expr ]

 [,column datatype [DEFAULT expr ], , , , , , , , ] 

- 숫자열의 정밀도나 폭을 증가할 수 있다.

- 열이 모두 NULL이거나 테이블에 자료가 없으면 열의 폭을 감소시킬 수 있다.

- 열이 NULL 을 포함하면 열의 자료형을변경할 수 있다.

- 열이 NULL을 포함하거나 크기를 변경하지 않으면 CHAR을 VARCHAR2로 변경하거나 그 반대의 겨우도 가능하다.

- 열의 DEFAULT VALUE를 변경하는 것은 이후의 INSERT 문장에만 영향을 미칩니다.



8.  테이블 구조 확인

답: DESC table_name;

DESC table_name;


9.  다음중 NULL 값에 대한 설명으로 부적절한 것

답: NULL IS 값, 산술X, PK NOT NULL, NULL타입 

No.010 Null 값의 처리

행이 특정 열에 대한 데이터 값이 없다면, 값은 null이 됩니다. null 값은 이용할 수 없거나 지정되지 않았거나, 알 수 없거나 또는 적용할 수 없는 값입니다. null 값은 0 이나 공백과는 다릅니다. 0은 숫자이며 공백은 문자입니다. 열이 NOT NILL 로 정의되지 않았거나, 열이 생성될 때 PRIMARY KEY로 정의되지 않았다면, 어떤 데이터형의 열은 null 값을 포함할 수 있습니다.


No.011 Null에 대하여

- NULL은 이용할 수 없고 할당되지 않고 알려져 있지않고 적용 불가한 값을 의미한다.

- NULL이란 0이나 공백(space)과 다르다.

- NULL 값을 포함한 산술 표현식 결과는 NULL이 된다.

- column에 데이터 값이 없으면 그 값 자체가 널 또는 널 값을 포함하고 있다.

- NULL 값은 1 바이트의 내부 저장


No.012 NVL 함수

- Null값을 어떤 특정한 값(실제 값)으로 변환하는데 사용한다.

- 사용될 수 있는 데이터 타입은 날짜, 문자, 숫자입니다.

- NVL 함수를 사용할 때 전환되는 값의 데이터 타입을 일치 시켜야 한다.



10. 외래키에 대한 설명 중 옳은 것

답: 아래읽어야함

No.012 FOREIGN KEY(FK)

- FOREIGN KEY는 DETAIL 쪽에서 정의한다.

- MASTER TABLE 의 PRIMARY KEY, UNIQUE KEY로 정의된 열을 지정할 수 있으며 열의 값과 일치하거나

NULL 값이어야 한다.

- FOREIGN KEY는 열 또는 열의 집합을 지정할 수 있으며 동일 테이블 또는 다른 테이블간의 관계를 지정할

수 있다.

- ON, DELETE, CASCADE 을 사용하여 DETAIL TABLE 에서 관련된 행을 삭제하고 MASTER TABLE에서 삭제를

허용할 수 있다.

- Syntax

 column datatype [CONSTRAINT constraint_name]

 REFERENCES table_name (column1[,column2, , , ] [ON DELETE CASCADE])

 column datatype,

 , , , , , , , , , , ,

 [CONSTRAINT constraint_name] FOREIGN KEY (column1[,column2, , ,])

 REFERENCES table_name (column1[,column, , , ] [ON DELETE CASCADE]) 


No.013 PRIMARY KEY(PK) 와 FOREIGN KEY(FK)

- FOREIGN KEY 값은 MASTER TABLE 에서 존재하는 값과 일치해야 하거나 NULL 이 되어야 한다.

- FOREIGN KEY 값은 데이터 값을 기초로 하여 순전히 논리적이지 분리적이거나 포인터가 아니다.

- MASTER TABLE(parent)은 참조 당하는 쪽(DEPT TABLE)을 테이블을 의미하고 DETAIL TABLE(child)은 참조하는

쪽(EMP TABLE)의 테이블을 의미한다.

- MASTER TABLE(참조 당하는 쪽)을 먼저 생성하여야 한다.

- MASTER TABLE 에 PRIMARY KEY 또는 UNIQUE KEY로 설정된 열을 DETAIL TABLE 에서 참조하여야 한다.

- MASTER TABLE 과 DETAIL TABLE의 참조하는 열과 참조 당하는 쪽의 자료형과 크기가 일치해야 한다.



 

과목2

1.  오라클 데이터 타입이 아닌것?

답: VARCHAR2, CHAR, NUMBER, DATE, LONG, CLOB, RAW, LONG RAW, BLOB, BFILE

VARCHAR2(n)  : 가변 길이 문자 데이터(1~4000byte)

CHAR(n)         : 고정 길이 문자 데이터(1~2000byte)

NUMBER(p,s)   : 전체 p자리 중 소수점 이하 s자리(p:1~38, s:-84~127)

DATE             : 7byte (BC 4712년 1월 1일부터 AD 9999년 12월 31일)

LONG            : 가변 길이 문자 데이터(1~2Gbyte)

CLOB             : 단일 바이트 가변 길이 문자 데이터(1~4Gbyte)

RAW(n)          : n byte의 원시 이진 데이터(1~2000)

LONG RAW     : 가변 길이 원시 이진 데이터(1~2Gbyte)

BLOB             : 가변 길이 이진 데이터(1~4Gbyte)

BFILE             : 가변 길이 외부 파일에 저장된 이진 데이터(1~4Gbyte)


2.  모든 컬럼열을 검색하는 쿼리문

답: ALL_TAB_COLUMNS;

모든 SYSTEM테이블 정보 : SELECT * FROM ALL_TABLES;

모든 SYSTEM컬럼열 정보 : SELECT * FROM ALL_TAB_COLUMNS;

모든 현재사용자컬럼열 SELECT * FROM COLS;


 

3.  이름이 n문자로 끝나는 것을 검색하는 쿼리문

답: WHERE column LIKE %n

No.008 LIKE 연산자

- 검색 STRING 값에 대한 와일드 카드 검색을 위해서 LIKE 연산자를 사용한다.

- 검색 조건은 LITERAL 문자나 숫자를 포함할 수 있다.

- '%'는 문자가 없거나 하나 이상의 문자를 '_'는 하나의 문자와 대치됩니다.

- 패턴 일치 문자를 조합할 수 있습니다.

- '%' 나 '_'에 대해서 검색하기 위해서는 Escape 식별자를 이용할 수 있습니다.

- WHERE column LIKE ‘%A\_A% ESCAPE’\’;’

(해석 : \문자를 _ 앞에 작성하여 ESCAPE를 활성화하고 _를 문자로 인식하게 만든다.)

- 기본 날짜 형식이 'YY-MM-DD'일 경우는 WHERE hiredate LIKE '82%';로 기술한다.

- SQL> ALTER SESSION SET NLS_DATE_FORMAT = 'YY-MM-DD'; 명령어로 연결되어 있는 SQL*Plus 창

(SESSION)에서 날짜 타입을 바꿀 수 있다.


4.  오라클 논리연산자가 아닌것

답: AND, OR, NOT

논리연산자는 AND, OR, NOT이 있다.


5.  ORDER BY 절에서 낮은 순으로 정렬할 때 쓰는 키워드

답: ASC

오름차순 ASC   저→고 낮은 순서대로

내림차순 DESC 고→저 높은 순서대로


6.  데이터 양이 많을 경우 검색 속도를 향상시키기 위한 것

답: INDEX

INDEX

No.002 인덱스의 특징

- 인덱스는 테이블의 값을 빠르게 액세스 하도록 하는 데이터베이스 객체이다.

- 데이터를 빠르게 찾기 위한 B*TREE을 써서 디스크 입출력 횟수를 줄인다.

- Oracle8 Server가 인덱스를 자동적으로 사용하고 유지 보수 한다.

- 인덱스를 만들면 사용자가 직접 조작할 필요가 없게 된다.

- 인덱스는 논리적으로도 물리적으로도 테이블과는 독립적이다.

- 언제든지 생성하거나 삭제할 수 있으며 이는 테이블이나 다른 인덱스에 영향을 주지 않는다는 의미이다.


7.  오라클 함수중 대소문자를 조작하는 함수가 아닌 것

답: LOWER, UPPER, INITCAP

LOWER : 대소문자가 혼합되어 있거나 대문자인 문자열을 소문자로 변환합니다

UPPER : 대문자가 혼합되어 있거나 소문자인 문자열을 대문자로 변환 합니다.

INITCAP : 각 단어의 첫번째 문자를 대문자로 나머지 문자는 소문자로 변경합니다.



8.  게시판 날짜를 저장할 때 사용하는 오라클 키워드

답: TO_DATE

To_DATE

No.004 특정 날짜 값 삽입

- 형식 DD-MON-YY 는 항상 날짜 값을 입력할 때 사용한다. 이 형식은 현재 세기에 대한 DEFAULT 세기를 다시 호출한다. 또한 날짜가 시간 정보를 포함하므로 DEFAULT 시간은 자정(00:00:00)이다. 날짜를 다른 세기로 입력하거나 또는 특정 시간을 요구 한다면 TO_DATE 함수를 사용하여라.


9.  뷰

답: 아래읽어야함

No.001 VIEW의 개념

테이블이나 다른 VIEW을 기초로 한 논리적인 테이블이고 VIEW는 자체의 데이터는 없지만 테이블의 데이터를

보거나 변경할 수 있는 창과 같다. VIEW은 실제적으로는 질의 문장을 가진다.


No.002 VIEW의 장점

- VIEW은 데이터베이스의 선택적인 내용을 보여줄 수 있기 때문에 데이터베이스에 대한 액세스를 제한한다.

- 복잡한 질의어를 통해 얻을 수 있는 결과를 간단한 질의어를 써서 구할 수 있게 한다.

- 데이터 독립성을 허용한다.

- 동일한 데이터의 다른 VIEW를 나타낸다.

- 조인을 한 것처럼 여러 테이블에 대한 데이터를 VIEW을 통해볼 수 있다.

- 한 개의 VIEW로 여러 테이블에 대한 데이터를 검색할 수 있다.

- 특정 평가기준에 따른 사용자 별로 다른 데이터를 액세스 할 수 있다.


No.003 Simple VIEW와 Complex VIEW

Simple VIEW

 Complex VIEW

- 오직 하나의 테이블에서만 데이터가 유래된다

- 데이터 그룹 또는 함수를 포함하지 않는다.

- VIEW를 통해 DML 수행 가능

- 다중 테이블에서 데이터가 유래된다.

- 데이터 그룹 또는 함수를 포함한다.

- VIEW을 통한 DML을 항상 허용하지 않는다.


No.004 VIEW의 생성

- CREATE VIEW 문장 내에서 SUBQUERY을 내장하여 VIEW를 생성한다.

- SUBQUERY은 복합 SELECT 구문을 포함할 수 있고 ORDER BY 절을 포함할 수 없다.

- Syntax

CREATE [OR REPLACE] [FORCE | NOFORCE] VIEW view_name [(alias[,alias, , , , ])]

 AS Subquery

 [WITH CHECK OPTION [CONSTRAINT constraint ]]

 [WITH READ ONLY]

OR REPLACE                 이미 존재한다면 다시 생성한다.

FORCE Base Table          유무에 관계없이 VIEW을 만든다.

NOFORCE                    기본 테이블이 존재할 경우에만 VIEW를 생성한다.

view_name                   VIEW의 이름

Alias                           Subquery를 통해 선택된 값에 대한 Column명이 된다.

Subquery                     SELECT문장을 기술한다.

WITH CHECK OPTION     VIEW에 의해 액세스 될 수 있는 행만이 입력, 갱신될 수 있다.

Constraint                    CHECK OPTION 제약 조건에 대해 지정된 이름이다.

WITH READ ONLY          이 VIEW에서 DML이 수행될 수 없게 한다.

- VIEW을 정의하는 질의어는 조인, 그룹, Subquery를 포함하는 복잡한 SELECT 문장으로 구성될 수 있다.

- VIEW을 정의하는 질의어에는 ORDER BY절을 쓸 수 없다.

- 제약 조건의 이름을 명시하지 않으면 시스템이 SYS_Cn 형태의 이름을 지정한다.

- VIEW을 삭제하거나 재생성하지 않고 VIEW의 정의를 변경하려면 OR REPLACE 옵션을 쓸 수 있다.


No.005 VIEW의 구조 및 이름 확인

- 일단 VIEW가 생성되면, VIEW의 이름과 VIEW 정의를 보기 위해 USER_VIEWS 라는 데이터 사전 테이블을 질

의할 수 있습니다.

- VIEW을 만드는 SELECT 문장의 텍스트는 LONG 열에 저장됩니다.


No.006 데이터 액세스 VIEW

- VIEW을 사용하여 데이터를 액세스할 때 ORACLE SERVER은 다음 작업을 수행합니다.

- USER_VIEWS 데이터 사전 테이블에서 VIEW 정의를 검색합니다.

- VIEW 기반 테이블에 대한 액세스 권한을 확인합니다.

- VIEW 질의를 기본 테이블 또는 테이블들에서의 동등한 작업으로 전환합니다.


No.007 VIEW의 수정

- OR REPLACE 옵션은 비록 이 이름이 이미 존재할지라도 VIEW가 생성될 수 있도록 해주므로 그 소유자에 대

한 오래된 VIEW 버전업할 수 있다.

- CREATE VIEW 절에서 열 별칭을 지정할 때 별칭은 SUBQUERY 의 열과 동일한 명령으로 나열됨을 명심하십

시오.


No.008 복합 VIEW 생성

- 두 테이블로부터 값을 출력하는 그룹 함수를 포함하는 복잡한 VIEW를 생성합니다.

- VIEW의 어떤 열이 함수나 표현식에서 유래되었다면 별칭은 필수적입니다.


No.009 VIEW에서 DML 연산 수행

- 단순 VIEW에서 DML 연산을 수행할 수 있습니다.

- VIEW가 다음을 포함 한다면 행을 제거할 수 없습니다.

① 그룹 함수 ② GROUP By절 ③ DISTINCT 키워드

- 다음을 포함한다면 VIEW에서 데이터를 수정할 수 없습니다.

① 그룹 함수 ② GROUP BY 절 ③ DISTINCT 키워드 ④ 표현식으로 정의된 열 ⑤ ROWNUM 의사열

- 다음을 포함한다면 VIEW에서 데이터를 추가할 수 없습니다.

① 그룹 함수 ② GROUP BY절 ③ DISTINCT 키워드 ④ 표현식으로 정의된 열 ⑤ ROWNUM의사열

⑥ VIEW에 의해 선택되지 않은 NOT NULL열이 기본 테이블에 있을 경우


No.010 WITH CHECK OPTION 절 사용

- VIEW을 통해 참조 무결성 체크를 수행하는 것이 가능합니다. 또한 데이터베이스 LEVEL 에서 제약 조건을 적

용할 수 있습니다.

- VIEW은 데이터 무결성을 보호하기 위해 사용될 수 있지만, 사용은 매우 제한됩니다.

- VIEW을 통해 수행되는 INSERT와 UPDATE는 WITH CHECK OPTION 절이 있으면 VIEW을 가지고 검색할 수

없는 행 생성을 허용하지 않음을 명시합니다. 그러므로 삽입되거나 갱신되는 데이터에 대해서 무결성 제약 조

건과 데이터 검증 체크를 허용합니다.

- VIEW가 선택하지 않은 행에 대해 DML 작업을 수행하려고 하면, 지정된 제약 조건 명과 함께 에러가 출력됩

니다.


No.011 DML 연산 부정

- WITH READ ONLY 옵션으로 VIEW을 생성하면 VIEW에서 DML 연산을 수행할 수 없습니다.

- VIEW에서 임의의 행에서 DML 연산을 수행하려고 하면 ORACLE SERVER 에러 ORA-01752가 발생합니다.


No.012 VIEW의 제거

- VIEW는 데이터베이스에서 기본 테이블을 기반으로 하기 때문에 테이터 손실 업이 VIEW를 제거할 수 있다.

- Syntax

DROP VIEW view_name; 



10. 프로시져

답: 프로시져

Procedure

CREATE PROCEDURE name

IS

BEGIN

statements;

statements;

[EXCEPTION]

END:

'Legend 개발자 > Oracle' 카테고리의 다른 글

Team Project SQL  (0) 2017.11.07
No.019 PL/SQL 커서 [2017-06-14]  (0) 2017.06.19
No.018 PL/SQL 조건문 [2017-06-14]  (0) 2017.06.19
No.017 PL/SQL 쿼리 [2017-06-14]  (0) 2017.06.19
No.016 PL/SQL 변수 [2017-06-14]  (0) 2017.06.16
Posted by 전설의아이
|

No.019 PL/SQL 커서 [2017-06-14]

Legend 개발자/Oracle 2017. 6. 19. 14:30

1. 커서의 개념

 ORACLE SERVER은 SQL 문장을 실행하기 위하여 Private SQL Area 이라 불리는 작업 영역을 사용합니다. Private SQL Area에 이름을 붙이고 저장된 정보를 액세스하기 위해 PL/SQL CURSOR를 사용한다. 블록의 실행 부분이 SQL 문장을 실행할 때 PL/SQL은 SQL 식별자를 가지는 암시적 CURSOR를 생성하고 자동적으로 이 CURSOR를 관리합니다. 명시적 CURSOR는 명시적으로 선언되고 프로그래머에 의해 명명됩니다.

 

1.1 CURSOR의 종류

1.1.1 암시적 CURSOR

 ORACLE SERVER은 명시적으로 선언된 CURSOR 와 관련 없는 각 SQL 문장을 수행하기 위해 CURSOR를 암시적으로 생성하여 사용한다. PL/SQL 은 SQL CURSOR 로써 가장 최근의 암시적 CURSOR를 참조할 수 있도록 해 줍니다. SQL CURSOR 를 제어하기 위해 OPEN, FETCH, CLOSE 를 사용할 수 없지만 가장 최근에 실행된 SQL 문장에 대한 정보를 얻기 위한 CURSOR 속성을 사용할 수 있다. (SQL%ROWCOUNT, SQL%NOTFOUND, SQL%ISOPEN 등)

 

1.1.2 명시적 CURSOR

 다중 행 SELECT 문장에 의해 RETURN 되는 각 행을 개별적으로 처리하기 위해 명시적 CURSOR를 사용합니다. 다중 행 질의에 의해 RETURN 된 행의 집합은 result set 이라 불립니다. 그것의 크기는 검색 조건에 일치하는 행의 수입니다.

 

가) 명시적 CURSOR의 함수

 1) 질의에 의해 RETURN된 첫번째 행부터 행 하나씩 처리할 수 있다.

 2) 현재 처리되는 행의 특랙을 유지 합니다.

 3) 프로그래머가 PL/SQL 블록에서 수동으로 제어할 수 있습니다.

 

참고

 암시적 CURSOR에 대한 인출(FETCH)은 배열 인출(FETCH)이며, 두번째 행의 존재는 여전히 TOO_MANY_ROWS 예외가 발생합니다. 그러므로 다중 인출을 수행하고 작업 영역에서 구문 분석된 질의를 재실행하기 위해 명시적 CURSOR를 사용할 수 있습니다.

 

1.2 명시적 CURSOR의 제어

 명시적 CURSOR를 사용하기 위해서는 4가지 단계를 거처야 한다.

 1) 수행되기 위한 질의의 구조를 정의하고 이름을 지정함으로써 CURSOR를 선언한다.

 2) CURSOR를 OPEN한다. OPEN 문장은 질의를 실행하고 참조되는 임의의 변수를 바인드 합니다. 질의에 의해 식별된 행을 active set이라 불리고 인출(FETCH) 가능합니다.

 3) CURSOR에서 데이터를 인출(FETCH)합니다. FETCH 문장은 CURSOR에서 변수로 현재 행을 로드합니다. 각 인출(FETCH)은 활성 셋(active set)에서 다음 행으로 그 포인터를 이동하도록 합니다.

 4) CURSOR를 CLOSE 합니다. CLOSE 문장은 행의 활성 셋(active set)을 해제 합니다. 이제 새로운 활성 셋(active set)을 생성하기 위해 CURSOR를 다시 OPEN할 수 있습니다.

 

1.3 DECLARE CURSOR

 명시적으로 CURSOR를 선언하기 위해 CURSOR 문장을 사용한다. 질의 내에서 변수를 참조할 수 있지만 CURSOR 문장 전에 선언되어야 한다.

 

1.3.1 Syntax

 cursor_name        PL/SQL 식별자

 select_statement   INTO절이 없는 SELECT 문장

 

1.4 OPEN CURSOR

 질의를 수행하고 검색 조건을 충족하는 모든 행으로 구성된 결과 셋을 생성하기 위해 CURSOR를 OPEN한다. CURSOR는 이제 결과 셋에서 첫번째 행을 가리킴니다.

 

1.4.1 Syntax

 

나) OPEN 문장은 다음의 작업을 수행한다.

 1) 문맥 영역에 대해 동적으로 메모리를 할당하여 중요한 프로세싱 정보를 포함 합니다.

 2) SELECT 문장을 구문 분석합니다.

 3) 입력 변수를 바인드 합니다.

 4) 결과 셋을 식별합니다. 즉 검색 조건을 충족시키는 행의 집합입니다. OPEN 문장이 실행될 때 결과 셋에 있는 행을 변수로 읽어 들이지 않습니다. 그대신 FETCH 문장이 행을 읽습니다.

 5) 포인터는 활성 셋에서 첫번째 행에 위치합니다.

 

1.5 FETCH CURSOR

 FETCH 문장은 결과 셋에서 하나의 행을 읽어 들입니다. 각 인출(FETCH) 후에 CURSOR 는 결과 셋에서 다음 행으로 이동한다.

 

1.5.1 Syntax

 

Guidelines

 1) SELECT 문장의 열과 같은 개수의 변수를 FETCH 문장의 INTO 절에 포함시켜 좌측부터 1대 1대응 되도록 데이터 형과 길이가 같아야 합니다.

 2) CURSOR에 대한 레코드를 정의하고 FETCH INTO 절에서 레코드를 참조할 수 있습니다.

 3) CURSOR가 RETURN 할 행을 포함하는지 테스트합니다. FETCH 시 아무 값도 읽지 않아도 즉 활성 셋에서 프로세스할 남겨진 행이 없는 경우에도 오류가 발생되지 않습니다.

 4) FETCH 문장은 다음 작업을 수행합니다.

  ①활성 셋에서 다음 행으로 포인터를 이동합니다.

  ②현재 행에 대한 정보를 출력 PL/SQL 변수로 읽어 들입니다.

  ③포인터가 활성 셋의 끝에 위치하게 되면 CURSOR 는 FOR LOOP를 탈출 합니다.

 

1.6 CLOSE CURSOR

 CLOSE 문장은 CURSOR를 사용할 수 없게 하고 결과 셋의 정의를 해제합니다. SELECT 문장이 다 처리된 완성 후에는 CURSOR를 닫습니다. 필요하다면 CURSOR를 다시 열수도 있습니다. 그러므로 활성 셋을 여러 번 설정할 수 있다.

 

1.6.1 Syntax

 

Guidelines

 CLOSE문장은 context area를 해제 합니다. 커서를 닫지 않고 PL/SQL 블록을 종료하는 것이 가능하다 할 지라도 리소스를 다시 가능하게 하기 위해 명시적으로 선언된 임의의 커서를 닫는 습관을 들여야 합니다. 데이터베이스 매개변수(initial parameter file)에서 OPEN_CURSORS 매개변수에 의해 결정되는 사용자마다 해당하는 커서의 수에는 최대 한계가 있습니다. 디폴트로 OPEN_CURSORS=50 입니다.

 

1.7 명시적 CURSOR의 속성

 명시적 CURSOR로 CURSOR에 대해 상태 정보를 얻기 위한 4가지 속성이 있습니다.

속성

타입 

설명 

%ISOPEN 

BOOLEAN 

CURSOR가 열리면 TRUE 

%NOTFOUND 

BOOLEAN 

가장 최근의 인출(FETCH)이 행을 RETURN하지 않으면 TRUE 

%FOUND 

BOOLEAN 

가장 최근의 인출(FETCH)이 행을 RETURN하면 TRUE

%ROWCOUNT

NUMBER

지금까지 RETURN된 행의 총 수

 

1.8 복수 인출(FETCH) 제어

 명시적 CURSOR에서 여러 행을 처리하기 위해서 반복적으로 인출(FETCH)을 수행하는 루프를 정의합니다. 결과적으로 활성 셋의 모든 행은 처리되고 인출(FETCH)이 실패하면 %NOTFOUND 속성을 TRUE로 설정한다. CURSOR에 대해 참조하기 전에 각 이눌(FETCH)의 성공을 테스트 하기 위해 명시적 CURSOR를 사용합니다.

 

문제 1) 부서번호를 입력받아 사원번호, 이름, 급여를 출력하는 SCRIPT를 작성하여라.

 

1.9 CURSOR 와 RECORD

 테이블에서 열의 구조를 사용하기 위해 RECORD를 정의할 수 있다. 또한 명시적 CURSOR에서의 열 목록을 기초로 하여 RECORD를 정의할 수 있습니다. 이것은 단순히 인출할 수 있기 때문에 활성 셋의 행을 처리하기가 편리하다. 그러므로 행 값은 RECORD의 해당 필드 안으로 직접 LOAD 된다.

 

문제2)DEPT 테이블의 내용을 조회하는 SCRIPT을 작성하여라. 단 %ROWTYPE을 사용하여라.

 

문제 3) DEPT 테이블의 내용을 조회하는 SCRIPT을 작성하여라. 단 RECORD TYPE을 선언하여 사용하여라.

 

1.10 CURSOR와 FOR LOOP

 CURSOR FOR LOOP는 명시적 CURSOR 에서 행을 처리합니다. LOOP에서 각 반복마다 CURSOR를 열고 행을 인출(FETCH)하고 모든 행이 처리되면 자동으로 CURSOR가 CLOSE 되므로 사용하기가 편리합니다.

 

1.10.1 Syntax

  record_name   암시적으로 선언된 RECORD 이름

  cursor_name   선언되어 있는 CURSOR의 이름

 

Guidelines

 1) LOOP를 제어하는 RECORD를 선언하지 마십시오.

 2) 필요하다면 LOOP내에서 CURSOR의 속성을 이용하십시오.

 3) 필요하다면 FOR문 안에서 CURSOR 이름 다음에 괄호로 CURSOR 에 대한 매개변수를 묶어 사용하십시오.

 4) CURSOR 작업이 수동으로 처리되어야 할 때는 FOR LOOP를 사용하지 마십시오.

 5) LOOP가 시작될 때 질의를 정의할 수 있습니다. 질의 표현식은 SELECT 부속문장이라 불리고 CURSOR는 FOR LOOP 내에서만 사용할 수 있습니다. 이름을 가지고 CURSOR가 선언되지 않기 때문에 그속성을 사용할 수는 없습니다.

 

문제 4) CURSOR FOR LOOP를 사용하여 DEPT 테이블의 자료를 조회하여라.

 

1.11 SUBQUERY를 사용한 CURSOR FOR LOOP

 PL/SQL 이 SUBQUERY를 치환 하도록 하기 때문에 CURSOR는 선언할 필요가 없다.

 

1.11.1 Syntax

  subquery     SELECT 문장을 기술

 

문제 5) SUNQUERY를 사용한 CURSOR FOR LOOP를 이용하여 DEPT 테이블의 내용을 조회하여라.

'Legend 개발자 > Oracle' 카테고리의 다른 글

Team Project SQL  (0) 2017.11.07
오라클 시험  (0) 2017.06.23
No.018 PL/SQL 조건문 [2017-06-14]  (0) 2017.06.19
No.017 PL/SQL 쿼리 [2017-06-14]  (0) 2017.06.19
No.016 PL/SQL 변수 [2017-06-14]  (0) 2017.06.16
Posted by 전설의아이
|

티스토리툴바