책 이미지
책 정보
· 분류 : 국내도서 > 컴퓨터/모바일 > 프로그래밍 언어 > 자바
· ISBN : 9788994492049
· 쪽수 : 1000쪽
· 출판일 : 2019-12-30
책 소개
목차
Chapter 1. 자바를 시작하기 전에
01 자바(Java)란? ··············································································································2
02 자바의 역사 ···················································································································3
03 자바의 특징 ···················································································································4
04 자바 가상 머신(JVM) ····································································································6
05 자바 개발도구(JDK) 설치하기 ······················································································7
06 자바 개발도구(JDK) 설정하기 ····················································································11
07 자바 API문서 설치하기 ·······························································································15
08 첫 번째 자바 프로그램 작성하기 ················································································16
09 자바 프로그램의 실행과정 ··························································································18
10 이클립스 설치하기 ······································································································19
11 이클립스로 자바 프로그램 개발하기 ··········································································23
12 이클립스의 뷰, 퍼스펙티브, 워크스페이스 ·································································26
13 이클립스 단축키 ··········································································································28
14 이클립스의 자동 완성 기능 ··························································································30
15 주석(comment) ··········································································································32
16 자주 발생하는 에러와 해결방법 ·················································································34
17 책의 소스와 강의자료 다운로드 ·················································································36
18 이클립스로 소스파일 가져오기 ···················································································38
19 이클립스에서 소스파일 내보내기 ···············································································41
Chapter 2. 변수
01 화면에 글자 출력하기 - print( )과 println( ) ······························································46
02 덧셈 뺄셈 계산하기 ·····································································································47
03 변수의 선언과 저장 ···································································································48
04 변수의 타입 ··················································································································50
05 상수와 리터럴 ·············································································································51
06 리터럴의 타입과 접미사 ·····························································································52
07 문자 리터럴과 문자열 리터럴 ·····················································································53
08 문자열 결합 ·················································································································54
09 두 변수의 값 바꾸기 ···································································································55
10 기본형과 참조형 ··········································································································56
11 기본형의 종류와 범위 ·································································································57
12 printf를 이용한 출력 ·································································································58
13 printf를 이용한 출력 예제 ··························································································59
14 화면으로부터 입력받기 ·······························································································61
15 정수형의 오버플로우 ·································································································62
16 부호있는 정수의 오버플로우 ·····················································································64
17 타입 간의 변환방법 ·····································································································66
연 습 문 제 ···························································································································67
Chapter 3. 연산자
01 연산자와 피연산자 ······································································································70
02 연산자의 종류 ·············································································································71
03 연산자의 우선순위 ······································································································72
04 연산자의 결합규칙 ······································································································73
05 증감 연산자 ++과 -- ································································································74
06 부호 연산자 ·················································································································76
07 형변환 연산자 ·············································································································77
08 자동 형변환 ·················································································································78
09 사칙 연산자 ·················································································································79
10 산술 변환 ····················································································································80
11 Math.round( )로 반올림하기 ······················································································83
12 나머지 연산자 ·············································································································84
13 비교 연산자 ··················································································································85
14 문자열의 비교 ·············································································································86
15 논리 연산자 && || ! ································································································87
16 논리 부정 연산자 ········································································································90
17 조건 연산자 ·················································································································91
18 대입 연산자 ··················································································································93
19 복합 대입 연산자 ··········································································································94
연 습 문 제 ···························································································································95
Chapter 4. 조건문과 반복문
01 if문 ·······························································································································98
02 조건식의 다양한 예 ·····································································································99
03 블럭{} ························································································································100
04 if - else문 ··················································································································101
05 if - else if문 ···············································································································102
06 if - else if문 예제 ······································································································103
07 중첩 if문 ····················································································································104
08 중첩 if문 예제 ···········································································································105
09 switch문 ···················································································································106
10 switch문의 제약조건 ·································································································107
11 switch문의 제약조건 예제 ·······················································································108
12 임의의 정수만들기 Math.random( ) ········································································109
13 for문 ··························································································································110
14 for문 예제 ·················································································································112
15 중첩 for문 ·················································································································113
16 while문 ·····················································································································115
17 while문 예제1 ··········································································································116
18 while문 예제2 ··········································································································117
19 do - while문 ··············································································································118
20 break문 ····················································································································119
21 continue문 ···············································································································120
22 break문과 continue문 예제 ···················································································121
23 이름 붙은 반복문 ······································································································122
24 이름 붙은 반복문 예제 ·····························································································123
연 습 문 제 ·························································································································125
Chapter 5. 배열
01 배열이란? ·················································································································130
02 배열의 선언과 생성 ···································································································131
03 배열의 인덱스 ···········································································································132
04 배열의 길이(배열이름.length) ··················································································133
05 배열의 초기화 ···········································································································134
06 배열의 출력 ···············································································································135
07 배열의 출력 예제 ······································································································136
08 배열의 활용(1) – 총합과 평균 ·················································································137
09 배열의 활용(2) – 최대값과 최소값 ··········································································138
10 배열의 활용(3) – 섞기(shuffle) ···············································································139
11 배열의 활용(4) - 로또 번호 만들기 ··········································································140
12 String배열의 선언과 생성 ························································································141
13 String배열의 초기화 ·································································································142
14 String클래스 ·············································································································143
15 String클래스의 주요 메서드 ·····················································································144
16 커맨드 라인을 통해 입력받기 ···················································································145
17 이클립스에서 커맨드라인 매개변수 입력하기 ··························································146
18 2차원 배열의 선언 ····································································································147
19 2차원 배열의 인덱스 ·································································································148
20 2차원 배열의 초기화 ·································································································149
21 2차원 배열의 초기화 예제1 ·····················································································150
22 2차원 배열의 초기화 예제2 ·····················································································151
23 2차원 배열의 초기화 예제3 ·····················································································152
24 Arrays로 배열 다루기 ······························································································153
연 습 문 제 ·························································································································154
Chapter 6. 객체지향 프로그래밍 I
01 객체지향 언어 ···········································································································160
02 클래스와 객체 ···········································································································161
03 객체의 구성요소 – 속성과 기능 ··············································································162
04 객체와 인스턴스 ·········································································································163
05 한 파일에 여러 클래스 작성하기 ··············································································164
06 객체의 생성과 사용 ···································································································165
07 객체의 생성과 사용 예제 ··························································································168
08 객체배열 ····················································································································169
09 클래스의 정의(1) – 데이터와 함수의 결합 ······························································170
10 클래스의 정의(2) – 사용자 정의 타입 ·····································································171
11 선언위치에 따른 변수의 종류 ···················································································173
12 클래스 변수와 인스턴스 변수 ···················································································174
13 클래스 변수와 인스턴스 변수 예제 ··········································································175
14 메서드란? ················································································································176
15 메서드의 선언부 ········································································································177
16 메서드의 구현부 ········································································································178
17 메서드의 호출 ···········································································································179
18 메서드의 실행 흐름 ···································································································180
19 메서드의 실행 흐름 예제 ···························································································181
20 return문 ····················································································································182
21 반환값 ·······················································································································183
22 호출스택(call stack) ································································································184
23 기본형 매개변수 ········································································································185
24 참조형 매개변수 ········································································································186
25 참조형 반환타입 ······································································································187
26 static 메서드와 인스턴스 메서드 ·············································································188
27 static 메서드와 인스턴스 메서드 예제 ····································································189
28 static을 언제 붙여야 할까? ·······················································································190
29 메서드 간의 호출과 참조 ··························································································191
30 오버로딩(overloading) ····························································································192
31 오버로딩(overloading) 예제 ···················································································194
32 생성자(constructor) ·······························································································195
33 기본 생성자(default constructor) ·········································································196
34 매개변수가 있는 생성자 ···························································································198
35 매개변수가 있는 생성자 예제 ···················································································199
36 생성자에서 다른 생성자 호출하기 - this( ) ······························································200
37 객체 자신을 가리키는 참조변수 - this ···································································202
38 변수의 초기화 ···········································································································203
39 멤버변수의 초기화 ···································································································204
40 멤버변수의 초기화 예제1 ·························································································205
41 멤버변수의 초기화 예제2 ·························································································206
연 습 문 제 ·························································································································207
Chapter 7. 객체지향 프로그래밍 Ⅱ
01 상속 ···························································································································222
02 상속 예제 ··················································································································224
03 클래스 간의 관계 – 포함관계 ··················································································225
04 클래스 간의 관계 결정하기 ·····················································································226
05 단일 상속(single inheritance) ················································································227
06 Object클래스 – 모든 클래스의 조상 ······································································228
07 오버라이딩(overriding) ····························································································229
08 오버라이딩의 조건 ····································································································230
09 오버로딩 vs. 오버라이딩 ··························································································231
10 참조변수 super ········································································································232
11 super( ) – 조상의 생성자 ·······················································································233
12 패키지(package) ·····································································································234
13 패키지의 선언 ···········································································································235
14 클래스 패스(classpath) ···························································································236
15 import문 ···················································································································237
16 static import문 ·······································································································238
17 제어자(modifier) ·······································································································239
18 static – 클래스의, 공통적인 ···················································································240
19 final – 마지막의, 변경될 수 없는 ··········································································241
20 abstract – 추상의, 미완성의 ··················································································242
21 접근 제어자(access modifier) ················································································243
22 캡슐화와 접근 제어자 ·······························································································244
23 다형성(polymorphism) ·····························································································246
24 참조변수의 형변환 ·····································································································248
25 참조변수의 형변환 예제 ···························································································249
26 instanceof 연산자 ····································································································250
27 매개변수의 다형성 ·····································································································251
28 매개변수의 다형성 예제 ···························································································253
29 여러 종류의 객체를 배열로 다루기 ··········································································254
30 여러 종류의 객체를 배열로 다루기 예제 ·································································255
31 추상 클래스(abstract class) ···················································································257
32 추상 메서드(abstract method) ···············································································258
··················································································268
41 디폴트 메서드와 static메서드 예제 ·········································································269
42 내부 클래스(inner class) ·························································································270
43 내부 클래스의 종류와 특징 ······················································································271
44 내부 클래스의 선언 ···································································································272
45 내부 클래스의 제어자와 접근성 ···············································································273
46 내부 클래스의 제어자와 접근성 예제1 ····································································274
47 내부 클래스의 제어자와 접근성 예제2 ·····································································275
48 내부 클래스의 제어자와 접근성 예제3 ····································································276
49 내부 클래스의 제어자와 접근성 예제4 ····································································277
50 내부 클래스의 제어자와 접근성 예제5 ····································································278
51 익명 클래스(anonymous class) ·············································································279
52 익명 클래스(anonymous class) 예제 ····································································280
연 습 문 제 ·························································································································281
Chatper 8. 예외처리
01 프로그램 오류 ···········································································································292
02 예외 클래스의 계층구조 ···························································································293
03 Exception과 RuntimeException ···········································································294
04 예외 처리하기 – try - catch문 ·················································································295
05 try - catch문에서의 흐름 ··························································································296
06 예외의 발생과 catch블럭 ·························································································297
07 printStackTrace( )와 getMessage( ) ····································································299
08 멀티 catch블럭 ········································································································300
09 예외 발생시키기 ········································································································301
10 checked예외, unchecked예외 ·············································································302
11 메서드에 예외 선언하기 ···························································································303
12 메서드에 예외 선언하기 예제1 ················································································304
13 메서드에 예외 선언하기 예제2 ················································································305
14 finally블럭 ·················································································································306
15 사용자 정의 예외 만들기 ··························································································307
16 사용자 정의 예외 만들기 예제 ·················································································308
17 예외 되던지기(exception re - throwing) ································································310
18 연결된 예외(chained exception) ···········································································312
19 연결된 예외(chained exception) 예제 ··································································314
연 습 문 제 ·························································································································316
Chapter 9. java.lang패키지와유용한 클래스
01 Object클래스 ············································································································324
02 Object클래스의 메서드 - equals( ) ········································································325
03 equals( )의 오버라이딩 ····························································································326
04 Object클래스의 메서드 - hashCode( ) ··································································327
05 Object클래스의 메서드 - toString( ) ······································································328
06 toString( )의 오버라이딩 ··························································································329
07 String클래스 ·············································································································330
08 문자열(String)의 비교 ·······························································································331
09 문자열 리터럴(String리터럴) ····················································································332
10 빈 문자열(empty string) ··························································································333
11 String클래스의 생성자와 메서드 ·············································································334
12 join( )과 StringJoiner ······························································································337
13 문자열과 기본형 간의 변환 ······················································································338
14 문자열과 기본형 간의 변환 예제 ··············································································339
15 StringBuffer클래스 ··································································································340
16 StringBuffer의 생성자 ·····························································································341
17 StringBuffer의 변경 ·································································································342
18 StringBuffer의 비교 ·································································································343
19 StringBuffer의 생성자와 메서드 ··············································································344
20 StringBuffer의 생성자와 메서드 예제 ·····································································346
21 StringBuilder ···········································································································347
22 Math클래스 ···············································································································348
23 Math의 메서드 ··········································································································349
24 Math의 메서드 예제 ·································································································350
25 래퍼(wrapper) 클래스 ······························································································351
26 래퍼(wrapper) 클래스 예제 ·····················································································352
27 Number클래스 ·········································································································353
28 문자열을 숫자로 변환하기 ························································································354
29 문자열을 숫자로 변환하기 예제 ···············································································355
30 오토박싱 & 언박싱 ····································································································356
31 오토박싱 & 언박싱 예제 ···························································································357
연 습 문 제 ·························································································································358
Chapter 10. 날짜와 시간 & 형식화
01 날짜와 시간 ···············································································································366
02 Calendar클래스 ·······································································································367
03 Calendar 예제1 ······································································································368
04 Calendar 예제2 ······································································································370
05 Calendar 예제3 ······································································································371
06 Calendar 예제4 ······································································································372
07 Calendar 예제5 ······································································································373
08 Date와 Calendar간의 변환 ·····················································································374
09 형식화 클래스 ···········································································································375
10 DecimalFormat ·······································································································376
11 DecimalFormat 예제1 ····························································································377
12 DecimalFormat 예제2 ····························································································378
13 SimpleDateFormat ·································································································379
14 SimpleDateFormat 예제1 ······················································································380
15 SimpleDateFormat 예제2 ······················································································381
16 SimpleDateFormat 예제3 ······················································································382
연 습 문 제 ·························································································································383
Chapter 11. 컬렉션 프레임웍
01 컬렉션 프레임웍 ········································································································388
02 컬렉션 프레임웍의 핵심 인터페이스 ········································································389
03 Collection인터페이스 ································································································390
04 List인터페이스 ··········································································································391
05 Set인터페이스 ··········································································································392
06 Map인터페이스 ········································································································393
07 ArrayList ··················································································································394
08 ArrayList의 메서드 ··································································································395
09 ArrayList 예제 ·········································································································396
10 ArrayList의 추가와 삭제 ··························································································398
11 Java API소스보기 ····································································································399
12 LinkedList ················································································································400
13 LinkedList의 추가와 삭제 ·······················································································401
14 ArrayList와 LinkedList의 비교 ···············································································402
15 Stack과 Queue ·······································································································403
16 Stack과 Queue의 메서드 ·······················································································404
17 Stack과 Queue 예제 ······························································································405
18 인터페이스를 구현한 클래스 찾기 ············································································406
19 Stack과 Queue의 활용 ···························································································407
20 Stack과 Queue의 활용 예제1 ················································································408
21 Stack과 Queue의 활용 예제2 ················································································409
22 Iterator, ListIterator, Enumeration ········································································411
23 Iterator, ListIterator, Enumeration 예제 ······················································· 412
24 Map과 Iterator ·········································································································413
25 Arrays의 메서드(1) - 복사 ·······················································································414
26 Arrays의 메서드(2) - 채우기, 정렬, 검색 ································································415
27 Arrays의 메서드(3) - 비교와 출력 ··········································································416
28 Arrays의 메서드(4) - 변환 ······················································································417
29 Arrays의 메서드 예제 ······························································································418
30 Comparator와 Comparable ··················································································420
31 Comparator와 Comparable 예제 ·········································································421
32 Integer와 Comparable ···························································································422
33 Integer와 Comparable 예제 ··················································································423
34 HashSet ···················································································································424
35 HashSet 예제1 ········································································································425
36 HashSet 예제2 ········································································································426
37 HashSet 예제3 ········································································································427
38 HashSet 예제4 ········································································································428
39 TreeSet ····················································································································429
40 이진 탐색 트리(binary search tree) ······································································430
41 이진 탐색 트리의 저장과정 ······················································································431
42 TreeSet의 메서드 ····································································································432
43 TreeSet 예제1 ·········································································································433
44 TreeSet 예제2 ·········································································································434
45 TreeSet 예제3 ·········································································································435
46 HashMap과 Hashtable ··························································································436
47 HashMap의 키(key)와 값(value) ···········································································437
48 HashMap의 메서드 ·································································································438
49 HashMap 예제1 ······································································································439
50 HashMap 예제2 ······································································································441
51 HashMap 예제3 ······································································································442
52 Collections의 메서드 - 동기화 ···············································································443
53 Collections의 메서드 - 변경불가, 싱글톤 ·······························································444
54 Collections의 메서드 - 단일 컬렉션 ·······································································445
55 Collections 예제 ······································································································446
56 컬렉션 클래스 정리 & 요약 ······················································································448
연 습 문 제 ·························································································································449
Chapter 12. 지네릭스, 열거형, 애너테이션
01 지네릭스(Generics) ·································································································458
02 타입 변수 ··················································································································459
03 타입 변수에 대입하기 ·······························································································460
04 지네릭스의 용어 ········································································································461
05 지네릭 타입과 다형성 ·······························································································462
06 지네릭 타입과 다형성 예제 ······················································································463
07 Iterator
08 HashMap
09 제한된 지네릭 클래스 ·······························································································466
10 제한된 지네릭 클래스 예제 ······················································································467
11 지네릭스의 제약 ········································································································468
12 와일드 카드 ···············································································································469
13 와일드 카드 예제 ······································································································470
14 지네릭 메서드 ···········································································································471
15 지네릭 타입의 형변환 ·······························································································473
16 지네릭 타입의 제거 ···································································································474
17 열거형(enum) ···········································································································475
18 열거형의 정의와 사용 ·······························································································476
19 열거형의 조상 – java.lang.Enum ··········································································477
20 열거형 예제 ··············································································································478
21 열거형에 멤버 추가하기 ···························································································479
22 열거형에 멤버 추가하기 예제 ···················································································480
23 애너테이션이란? ·······································································································481
24 표준 애너테이션 ········································································································483
25 @Override ···············································································································484
26 @Deprecated ··········································································································485
27 @FunctionalInteface ·····························································································486
28 @SuppressWarnings ·····························································································487
29 메타 애너테이션 ········································································································488
30 @Target ···················································································································489
31 @Retention ··············································································································490
32 @Documented, @Inherited ···················································································491
33 @Repeatable ··········································································································492
34 애너테이션 타입 정의하기 ························································································493
35 애너테이션의 요소 ····································································································494
36 모든 애너테이션의 조상 ···························································································497
37 마커 애너테이션 ········································································································498
38 애너테이션 요소의 규칙 ···························································································499
39 애너테이션의 활용 예제 ···························································································500
연 습 문 제 ·························································································································502
Chapter 13. 쓰레드
01 프로세스(process)와 쓰레드(thread) ·····································································506
02 멀티쓰레딩의 장단점 ································································································507
03 쓰레드의 구현과 실행 ·······························································································508
04 쓰레드의 구현과 실행 예제 ······················································································509
05 쓰레드의 실행 - start( ) ····························································································510
06 start( )와 run( ) ·········································································································511
07 main쓰레드 ···············································································································512
08 싱글쓰레드와 멀티쓰레드 ·························································································513
09 싱글쓰레드와 멀티쓰레드 예제1 ··············································································514
10 싱글쓰레드와 멀티쓰레드 예제2 ··············································································515
11 쓰레드의 I/O블락킹(blocking) ·················································································517
12 쓰레드의 I/O블락킹(blocking) 예제1 ·····································································518
13 쓰레드의 I/O블락킹(blocking) 예제2 ·····································································519
14 쓰레드의 우선순위 ····································································································520
15 쓰레드의 우선순위 예제 ···························································································521
16 쓰레드 그룹(thread group) ·····················································································523
17 쓰레드 그룹(thread group)의 메서드 ·····································································524
18 데몬 쓰레드(daemon thread) ·················································································525
19 데몬 쓰레드(daemon thread) 예제 ········································································526
20 쓰레드의 상태 ···········································································································527
21 쓰레드의 실행제어 ····································································································528
22 sleep( ) ·····················································································································529
23 sleep( ) 예제 ············································································································530
24 interrupt( ) ················································································································531
25 interrupt( ) 예제 ·······································································································532
26 suspend( ), resume( ), stop( ) ···············································································533
27 suspend( ), resume( ), stop( ) 예제 ······································································534
28 join( )과 yield( ) ········································································································535
29 join( )과 yield( ) 예제 ································································································536
30 쓰레드의 동기화(synchronization) ·········································································537
31 synchronized를 이용한 동기화 ··············································································538
32 synchronized를 이용한 동기화 예제1 ···································································539
33 synchronized를 이용한 동기화 예제2 ···································································540
34 wait( )과 notify( ) ······································································································541
35 wait( )과 notify( ) 예제1 ···························································································542
36 wait( )과 notify( ) 예제2 ···························································································545
연 습 문 제 ·························································································································548
Chapter 14. 람다와 스트림
01 람다식(Lambda Expression) ·················································································552
02 람다식 작성하기 ········································································································553
03 람다식의 예 ···············································································································554
04 람다식은 익명 함수? 익명 객체! ··············································································555
05 함수형 인터페이스(Functional Interface) ······························································556
06 함수형 인터페이스 타입의 매개변수, 반환 타입 ······················································557
07 java.util.function패키지 ···························································································559
08 java.util.function패키지 예제 ··················································································561
09 Predicate의 결합 ·····································································································562
10 Predicate의 결합 예제 ····························································································563
11 컬렉션 프레임웍과 함수형 인터페이스 ····································································564
12 컬렉션 프레임웍과 함수형 인터페이스 예제 ····························································565
13 메서드 참조 ···············································································································566
14 생성자의 메서드 참조 ·······························································································567
15 스트림(stream) ·········································································································568
16 스트림의 특징 ···········································································································569
17 스트림 만들기 - 컬렉션 ····························································································571
18 스트림 만들기 - 배열 ·······························································································572
19 스트림 만들기 – 임의의 수 ·····················································································573
20 스트림 만들기 – 특정 범위의 정수 ·········································································574
21 스트림 만들기 – 람다식 iterate( ), generate( ) ················································· 575
22 스트림 만들기 – 파일과 빈 스트림 ·········································································576
23 스트림의 연산 ···········································································································577
24 스트림의 연산 - 중간연산 ························································································578
25 스트림의 연산 - 최종연산 ························································································579
26 스트림의 중간연산 - skip( ), limit( ) ········································································580
27 스트림의 중간연산 - filter( ), distinct( ) ··································································581
28 스트림의 중간연산 - sorted( ) ···············································································582
29 스트림의 중간연산 - Comparator의 메서드 ··························································583
30 스트림의 중간연산 – map( ) ···················································································585
31 스트림의 중간연산 – map( ) 예제 ··········································································586
32 스트림의 중간연산 – peek( ) ·················································································587
33 스트림의 중간연산 – flatMap( ) ·············································································588
34 스트림의 중간연산 – flatMap( ) 예제 ·····································································589
35 Optional
36 Optional
37 Optional
38 OptionalInt, OptionalLong, OptionalDouble ·················································· 593
39 Optional
40 스트림의 최종연산 – forEach( ) ·············································································595
41 스트림의 최종연산 - 조건검사 ·················································································596
42 스트림의 최종연산 – reduce( ) ··············································································597
43 스트림의 최종연산 – reduce( )의 이해 ··································································598
44 스트림의 최종연산 – reduce( ) 예제 ·····································································599
45 collect( )와 Collectors ····························································································600
46 스트림을 컬렉션, 배열로 변환 ··················································································601
47 스트림의 통계 - counting( ), summingInt( ) ··························································602
48 스트림을 리듀싱 - reducing( ) ················································································603
49 스트림을 문자열로 결합 - joining( ) ········································································604
50 스트림의 그룹화와 분할 ···························································································605
51 스트림의 분할 - partitioningBy( ) ···········································································606
52 스트림의 분할 - partitioningBy( ) 예제 ··································································608
53 스트림의 그룹화 - groupingBy( ) ···········································································611
54 스트림의 그룹화 - groupingBy( ) 예제 ··································································613
55 스트림의 변환 ···········································································································618
연 습 문 제 ·························································································································620
Chapter 15. 입출력
01 입출력(I/O)과 스트림(stream) ··················································································624
02 바이트 기반 스트림–InputStream,OutputStream ··································································625
03 보조 스트림 ···············································································································626
04 문자기반 스트림 – Reader, Writer ·······································································627
05 바이트 기반 스트림과 문자 기반 스트림의 비교 ······················································628
06 InputStream과 OutputStream ···············································································629
07 InputStream과 OutputStream 예제1 ····································································630
08 InputStream과 OutputStream 예제2 ····································································631
09 InputStream과 OutputStream 예제3 ····································································632
10 FileInputStream과 FileOutputStream ···································································634
11 FileInputStream과 FileOutputStream 예제1 ·····························································635
12 FileInputStream과 FileOutputStream 예제2 ·····························································636
13 FilterInputStream과 FilterOutputStream ······························································637
14 BufferedInputStream ······························································································638
15 BufferedOutputStream ··························································································639
16 BufferedOutputStream 예제 ··················································································640
17 SequenceInputStream ··························································································642
18 SequenceInputStream 예제 ··················································································643
19 PrintStream ··············································································································644
20 문자 기반 스트림 – Reader ···················································································645
21 문자 기반 스트림 – Writer ·····················································································646
22 FileReader와 FileWriter ·························································································647
23 StringReader와 StringWriter ·················································································649
24 BufferedReader와 BufferedWriter ·······································································650
25 InputStreamReader, OutputStreamWriter ···························································651
26 표준 입출력(Standard I/O) ·····················································································653
27 표준 입출력의 대상변경 ···························································································654
28 표준 입출력의 대상변경 예제 ···················································································655
29 File ····························································································································656
30 File 예제1 ·················································································································657
31 File 예제2 ·················································································································659
32 File 예제3 ·················································································································660
33 File 예제4 ·················································································································661
34 직렬화(serialization) ································································································662
35 ObjectInputStream, ObjectOutputStream ···························································663
36 직렬화가 가능한 클래스 만들기 ···············································································665
37 직렬화 대상에서 제외시키기 - transient ································································666
38 직렬화와 역직렬화 예제1 ·························································································667
39 직렬화와 역직렬화 예제2 ·························································································668
40 직렬화와 역직렬화 예제3 ·························································································669
연 습 문 제 ·························································································································670
Chapter 16. 네트워킹
01 네트워킹(networking)이란? ····················································································676
02 클라이언트와 서버(client & server) ········································································677
03 IP주소(IP address) ··································································································678
04 네트워크 주소와 호스트 주소 ···················································································679
05 InetAddress클래스 ··································································································680
06 InetAddress클래스 예제 ·························································································681
07 URL(Uniform Resource Locator) ·········································································682
08 URL클래스 ················································································································683
09 URL클래스 예제 ·······································································································684
10 URLConnection클래스 ···························································································685
11 URLConnection클래스 예제1 ················································································687
12 URLConnection클래스 예제2 ················································································688
13 URLConnection클래스 예제3 ················································································689
14 소켓(socket) 프로그래밍 ·························································································690
15 TCP와 UDP ··············································································································691
16 TCP소켓 프로그래밍 ································································································692
17 Socket과 ServerSocket ·························································································693
18 TCP소켓 프로그래밍 예제1 ·····················································································694
19 TCP소켓 프로그래밍 예제2 ·····················································································696
20 UDP 소켓 프로그래밍 - Client ················································································699
21 UDP 소켓 프로그래밍 - Server ··············································································700
책속에서
