독서평

도서관에서 가장 최근에 나온 JAVA 기본서여서 덥석 보게 되었습니다.
제목에서 알 수 있다시피 JAVA를 공부하지 않은 초보자를 대상으로 하기 때문에 학원에서 강의하듯 알고 있는 부분들은 빨리 넘어가실 수 있습니다.
또한 저자가 강의를 하는 듯한 필체로 글이 쓰여 있어서 마치 학원 강의를 듣는듯한 느낌을 갖게 됩니다.
전반적인 난이도는 낮지만 초보자들이 꼭 알아야 할 요소들을 필요한 부분에 배치하였기 때문에, 중급자 이상이신 분들도 리마인드하는 셈치고 보셔도 좋을듯합니다.
참고로 2009년 08월 12일 출간이며, JDK 6 Update 11을 기준으로 설명되어 있습니다.

책 소개 : http://www.orentec.co.kr/booklist/JAVA_BASIC_1/book_sub1.php
온라인 강의 : http://www.orentec.co.kr/teachlist/JAVA_BASIC_1/teach_sub1.php

목차 및 내용정리

아래 내용은 목차별로 개인적으로 정리한 내용입니다.
빠르게 정리한 내용이므로 문법이 틀리거나 오타가 있을 수도 있습니다.

Chapter 01. Let’s Start JAVA!

01-1. 자바의 세계로 오신 여러분을 환영합니다.
01-2. 자바 프로그램의 이해와 실행의 원리
01-3. 첫 번째 자바 프로그램의 관찰과 응용
01-4. 컴파일의 대상에서 제외되는 주석!

Chapter 02. 변수(Variable)와 자료형(Data Type)

02-1. 변수의 이해와 활용
02-2. 정수 표현방식의 이해
02-3. 실수 표현방식의 이해
02-4. 자료형의 이해

실수표현
- IEEE754에 따라 저장함.
- 정밀도를 포기함 (double num = 1.000001; 이 표현은 1.000001에 가까운 수를 저장함을 의미함)
- 실수형은 정밀도 기준으로 선택하라 : float – 4byte(6자리 정밀도), double – 8byte (15자리 정밀도)
- double e = 1.2e-3; (1.2*10^-3 을 의미)
정수표현
- 대부분의 cpu가 int에서 고속연산함.
- 따라서 byte/short 연산시 int로 변환하는 과정을 거치므로, 연산이 필요하면 int를 사용하라. byte/short는 저장의 용도로 사용하라.
- int num = 0xA0E; (0X : 16진수)
- int num = 0752; (0 : 8진수)
문자
- char ch = ‘한’;
- char ch = 54260;

Chapter 03. 상수와 형 변환(Type Casting)

03-1. 자료형을 기반으로 표현이 되는 상수
03-2. 자료형의 변환

상수도 메모리에 저장됨. 변수처럼 변경되지 않음. 상수=리터럴(literal)
모든 정수(1, 2, 3…)은 int로 표현 및 저장됨 : 4byte
모든 실수(1.2, 1.3…)은 double로 표현 및 저장됨 : 8byte

int num = 1000000000000; // 범위 초과 오류
long num = 1000000000000;  // 값이 int라서 오류
long num = 1000000000000L; // 값이 long이라서 정상 처리 (L 접미)
float num 12.45;  // 값이 double 이라서 오류
float num 12.45F; // 값이 float 이라서 정상 처리 (F 접미)

int num = 1000000000000; // 범위 초과 오류

long num = 1000000000000; // 값이 int라서 오류

long num = 1000000000000L; // 값이 long이라서 정상 처리 (L 접미)

float num 12.45; // 값이 double 이라서 오류

float num 12.45F; // 값이 float 이라서 정상 처리 (F 접미)

자동 형변환 (implict conversion)
- double num = 20; (20은 정수 -> 실수인 double로 형 변환됨 -> 20.0)
- byte -> short -> int -> long -> float -> double
- char -> int -> long -> float -> double
명시적 형 변환 (Explicit Conversion)
- int num = (int)3.15; // 3

Chapter 04. 연산자(Operator)

04-1. 자바에서 제공하는 이항 연산자들
04-2. 자바에서 제공하는 단항 연산자들
04-3. 비트와 관련이 있는 연산자들

이항 연산자 (binary operator) : 피연산자가 2개

- System.out.printf(7/3); // 7:정수, 3:정수 --> 정수연산 -> 2
- System.out.printf(7.0F/3.0F); // 7.0F:실수, 3.0F:실수 --> 실수연산 -> 2.333333
- System.out.printf((float)7/3); // (float)7:실수, 3:정수 --> 3.0F 실수 형변환 -> 실수연산 -> 2.333333
- System.out.printf(7.2%2.0); // 연산은 되지만 나머지 연산에서 의미가 없다. 실수형 나머지를 허용하지 않는 언어도 있음.

- System.out.printf(7/3); // 7:정수, 3:정수 --> 정수연산 -> 2

- System.out.printf(7.0F/3.0F); // 7.0F:실수, 3.0F:실수 --> 실수연산 -> 2.333333

- System.out.printf((float)7/3); // (float)7:실수, 3:정수 --> 3.0F 실수 형변환 -> 실수연산 -> 2.333333

- System.out.printf(7.2%2.0); // 연산은 되지만 나머지 연산에서 의미가 없다. 실수형 나머지를 허용하지 않는 언어도 있음.

Short-Circuit Evaluation (Lazy Evaluation)
- 가장 빠르게 연산을 진행하기 위한 계산방식
- false && XXXX : XXXX는 볼 필요 없음
- true || XXXX : XXXX는 볼 필요 없음
- XXXX 에서 대입이 일어나지 않아야 함

Chapter 05. 실행흐름의 컨트롤

05-1. if 그리고 else
05-2. switch와 break
05-3. for, while 그리고 do~while
05-4. continue & break
05-5. 반복문의 중첩

if ~ else ~
switch { case ~ }
while(조건) { ~ }
do { ~ } while(조건)
for( ~ ) { ~ }
for(int i=0, j=7; i<j; i++, j–) { ~ }

continue, break : 가장 근접한 반복문에 적용

outerLoop : for ( ~ )
{
for( ~~~ )
{
    ~
    break outerLoop; // label 사용시 가장 가까운 for( ~~~ ) 가 아니라, outerLoop : for ( ~ )를 빠져나감.
}
}

outerLoop : for ( ~ )

{

for( ~~~ )

{

break outerLoop; // label 사용시 가장 가까운 for( ~~~ ) 가 아니라, outerLoop : for ( ~ )를 빠져나감.

}

Chapter 06. 메소드와 변수의 스코프

06-1. 메소드에 대한 이해와 메소드의 정의
06-2. 변수의 스코프
06-3. 메소드의 재귀호출

Chapter 07. 클래스와 인스턴스

07-1. 클래스의 정의와 인스턴스의 생성
07-2. 생성자(Constructor)
07-3. 자바의 이름 규칙(Naming Rule)

final : 상수화 시키는 키워드, 한번의 초기화 가능

Fruit f1 = new Fruit(); // (1) new Fruit() : 메모리에 객체 할당
                        // (2) f1 = : 저장된 메모리 주소 할당 (refrence)
Fruit f2 = f1;          // (3) 참조변수인 f2는 f1과 같은 메모리를 참조

Fruit f1 = new Fruit(); // (1) new Fruit() : 메모리에 객체 할당

// (2) f1 = : 저장된 메모리 주소 할당 (refrence)

Fruit f2 = f1; // (3) 참조변수인 f2는 f1과 같은 메모리를 참조

Naming Rule
- 클래스 : 대문자로 시작, CirclePoint
- 메소드, 변수 : 카멜 표기법, addYourMoney
- 상수 : 대문자, final int COLOR_RAINBOW = 7;

Chapter 08. 클래스 패스와 패키지

08-1. 클래스 패스(Class Path)의 지정
08-2. 패키지(Package)의 이해

클래스 패스 : set classpath=.;c:\my\sub;
패키지

orange.area.Circle c1 = new orange.area.Circle();         // orange.area : 패키지, orange : 패키지, area : 서브패키지
                                                          // orange의 상위가 classpath에 선언되어야 클래스 찾을 수 있음)
orange.perimeter.Circle c2 = new orange.area.Circle();    // Circle : 패키지를 통해 area와 perimeter를 구분할 수 잇음.
                                                          // 같은 이름의 .class 파일을 다른 디렉토리에 생성 가능해짐

orange.area.Circle c1 = new orange.area.Circle(); // orange.area : 패키지, orange : 패키지, area : 서브패키지

// orange의 상위가 classpath에 선언되어야 클래스 찾을 수 있음)

orange.perimeter.Circle c2 = new orange.area.Circle(); // Circle : 패키지를 통해 area와 perimeter를 구분할 수 잇음.

// 같은 이름의 .class 파일을 다른 디렉토리에 생성 가능해짐

Chapter 09. 접근제어 지시자와 정보은닉, 그리고 캡슐화

09-1. 정보은닉(Information Hiding)
09-2. 접근제어 지시자(Access Control Specifiers)
09-3. public 클래스와 default 클래스
09-4. 어떤 클래스를 public으로 선언할까요?
09-5. 캡슐화(Encapsulation)

접근제어
- private : 클래스 내부에서만 접근
- public : 모든 클래스에서 접근
- protected : 동일 패키지(=default) & 상속한 클래스에서 접근
- X : 아무것도 없으면 default. 동일 패키지에서 접근
접근 범위 : public > protected > default > private
Access 메소드

private int age;
public void setAge(int a) { age = a; }
public int getAge() { return age; }

private int age;

public void setAge(int a) { age = a; }

public int getAge() { return age; }

default 생성자는 클래스의 접근제어 지시자와 동일한 것으로 선언됨.

Chapter 10. 클래스 변수와 클래스 메소드

10-1. static 변수(클래스 변수)
10-2. static 메소드(클래스 메소드)
10-3. System.out.println & public static void main

static 변수
- 모든 인스턴스가 공유 (public)
- 하나의 메모리 공간만 사용
- 인스턴스화 되기 전에 메모리 공간에 할당되어 초기화됨 (인스턴스 생성없이 new 사용가능)
- static 변수의 초기화는 JVM에 의해 메모리 공간에 올라감 (on-demand)
- instance간 data 공유 필요시 사용 (static final double PI = 3.14;)
static 메소드
- 인스턴스 변수를 사용할 수 없다 (static 메소드, static 변수는 공유되지만 인스턴스 변수는 공유되지 않기 때문)
java에서 메소드는 자신이 속한 클래스의 인스턴스 생성이 가능

class AAA
{
    public static void makeAAA()
    {
        ~~~
        AAA a1 = new AAA();
        ~~~
    }
}

class AAA

{

public static void makeAAA()

{

~~~

AAA a1 = new AAA();

~~~

}

Chapter 11. 메소드 오버로딩과 String 클래스

11-1. 메소드 오버로딩(Overloading)
11-2. String 클래스
11-3. API Document의 참조를 통한 String 클래스의 인스턴스 메소드 관찰
11-4. StringBuilder & StringBuffer 클래스
11-5. 단계별 프로젝트: 전화번호 관리 프로그램 01단계

오버로딩 (overloading)

class AAA
{
    // 매개 변수가 형이 다르거나, 갯수가 다르거나
    void f(int n1, int n2) { ~~ }       // (1)
    void f(int n1, double n2) { ~~ }    // (2)
}

class BBB
{
    AAA inst = new AAA();
    inst.f(10, 'a');  // 가까운 자료형을 사용함 (1)이 사용됨
}

class AAA

{

// 매개 변수가 형이 다르거나, 갯수가 다르거나

void f(int n1, int n2) { ~~ } // (1)

void f(int n1, double n2) { ~~ } // (2)

}

class BBB

{

AAA inst = new AAA();

inst.f(10, 'a'); // 가까운 자료형을 사용함 (1)이 사용됨

}

생성자 오버로딩

class Person
{
    public Pserson(int n1, int n2, int n3) { ~~ } // (1)
    public Pserson(int n1, int n2) { ~~ }
    {
        this(n1, n2, 0); // (1)을 사용
    }
}

class Person

{

public Pserson(int n1, int n2, int n3) { ~~ } // (1)

public Pserson(int n1, int n2) { ~~ }

{

this(n1, n2, 0); // (1)을 사용

}

String
- 큰 따옴표만으로 인스턴스 생성 가능 : String str = “kimstar”;
- 당연히 인스턴스 메소드 실행가능 : “kimstar”.length();
- String a = “A”; String b = “A”; 와 같을때 동일한 문자열은 중복하여 인스턴스화 되지 않는다. a와 b는 같은 메모리에 담긴 “A”를 참조한다.
- 문자열은 상수처럼 사용되고 변경되지 않는다. 따라서 문자열이 바뀌면 새로 만들어서 처리한다.
문자열 결합 최적화

String str1 = 1 + " aaa " + 2; // 문자열 결합시 내부적으로 3개의 인스턴스가 생겨서 처리하는 것은 아니다. 아래와 같이 내부적으로 변환된다.
String str2 = new StringBuilder().append(1).append(" aaa ").append(2).toString(); // 2개의 인스턴스가 생긴다. new StringBuilder() 할때 한번. 마지막으로 toString()할때 한번.

1 2	String str1 = 1 + " aaa " + 2; // 문자열 결합시 내부적으로 3개의 인스턴스가 생겨서 처리하는 것은 아니다. 아래와 같이 내부적으로 변환된다. String str2 = new StringBuilder().append(1).append(" aaa ").append(2).toString(); // 2개의 인스턴스가 생긴다. new StringBuilder() 할때 한번. 마지막으로 toString()할때 한번.

StringBuilder / StringBuffer는 사용법이 똑같다.
- StringBuilder : thread-safe. JDK 1.5 이상
- StringBuffer : thread-unsafe. JDK 1.0 이상

Chapter 12. 콘솔 입력과 출력

12-1. 콘솔 출력(Console Output)
12-2. 콘솔 입력(Console Input)
12-3. 단계별 프로젝트: 전화번호 관리 프로그램 02단계

System.out.println(AAA); // AAA 인스턴스의 toString()이 호출되어 반환되는 문자열을 매개변수로 사용.
System.out.printf("정수 %d, 실수 %f, 문자 %c", 12, 12.3, 'A');
Scanner kb = new Scanner(System.in); // Java 5.0에서 도입
int num = kb.nextInt();

System.out.println(AAA); // AAA 인스턴스의 toString()이 호출되어 반환되는 문자열을 매개변수로 사용.

System.out.printf("정수 %d, 실수 %f, 문자 %c", 12, 12.3, 'A');

Scanner kb = new Scanner(System.in); // Java 5.0에서 도입

int num = kb.nextInt();

Chapter 13. 배열(Array)

13-1. 배열이라는 존재가 필요한 이유
13-2. 1차원 배열의 이해와 활용
13-3. 다차원 배열의 이해와 활용
13-4. for-each
13-5. main 메소드로의 데이터 전달
13-6. 단계별 프로젝트: 전화번호 관리 프로그램 03단계

// 배열
int[] arr1 = new int[7]; // 정수형 배열 인스턴스 생성하여 arr1에서 참조

// 참조 모델
String[] str = new String[2];  // str은 2개의 문자열 인스턴스(str[0], str[1])를 참조. 
str[0] = "kim";                // str[0]은 "kim"이 담겨있는 메모리를 참조
str[1] = "star";

// 배열 선언 방법
int[] arr1 = new int[3] {1,2,3};
int[] arr2 = new int[] {1,2,3};
int[] arr3 = {1,2,3};

// 다차원 배열
int[][] arr1 = new int[3][4];
int[][] arr2 = new int[][] { {1,2}, {1,2,3}, {1,2,3,4}, {1,2,3,4,5} };
int[][] arr3 = { {1,2}, {1,2,3}, {1,2,3,4}, {1,2,3,4,5} };

// 행과 열의 분리 선언
int[][] arr = new int[2][];
arr[0] = new int[3];
arr[1] = new int[4];

// Ragged Array
int[][] arr = { {1,2}, {1,2,3,4} };

// for-each
for(int e : arr)
{
    sum += e; 

    // e는 참조만 가능하고, 수정할 수 없다.
    // 여기서의 e는 foreach 안에서만 유효하므로, 이 값을 변경해도 배열에 적용되지 않는다.
    // c#에서는 오류가 나는데.. java에서는 오류가 안나는듯함.
}

// 배열

int[] arr1 = new int[7]; // 정수형 배열 인스턴스 생성하여 arr1에서 참조

// 참조 모델

String[] str = new String[2]; // str은 2개의 문자열 인스턴스(str[0], str[1])를 참조.

str[0] = "kim"; // str[0]은 "kim"이 담겨있는 메모리를 참조

str[1] = "star";

// 배열 선언 방법

int[] arr1 = new int[3] {1,2,3};

int[] arr2 = new int[] {1,2,3};

int[] arr3 = {1,2,3};

// 다차원 배열

int[][] arr1 = new int[3][4];

int[][] arr2 = new int[][] { {1,2}, {1,2,3}, {1,2,3,4}, {1,2,3,4,5} };

int[][] arr3 = { {1,2}, {1,2,3}, {1,2,3,4}, {1,2,3,4,5} };

// 행과 열의 분리 선언

int[][] arr = new int[2][];

arr[0] = new int[3];

arr[1] = new int[4];

// Ragged Array

int[][] arr = { {1,2}, {1,2,3,4} };

// for-each

for(int e : arr)

{

sum += e;

// e는 참조만 가능하고, 수정할 수 없다.

// 여기서의 e는 foreach 안에서만 유효하므로, 이 값을 변경해도 배열에 적용되지 않는다.

// c#에서는 오류가 나는데.. java에서는 오류가 안나는듯함.

}

Chapter 14. 클래스의 상속 1: 상속의 기본

14-1. 상속은 재활용 + 알파(α)
14-2. 상속의 기본문법 이해
14-3. 상속과 접근제어 지시자
14-4. static 변수(메소드)의 상속과 생성자의 상속에 대한 논의

상속 이모저모
- 객체지향 패러다임은 재활용 관점에서는 실패한 패러다임이다.
- 재활용을 위해 상속을 사용하지 마라. (재활용하는 것이 새로 만드는 것보다 공수가 많음. 재활용을 위한 디자인은 어렵다)
- 상속을 통해 일련의 클래스에 대한 공통 규약을 정의할 수 있다.
용어 정리
- 상속받은 클래스 : 하위 클래스 (sub class), 유도 클래스 (derived class)
- 상속한 클래스 : 상위 클래스 (super class), 기초 클래스 (basic class)
super(…) : 상위 생성자 호출하여 초기화
디폴트 생성자

class AAA { int num1; } // 디폴트 생성자 AAA{} 생략됨
class BBB extends AAA { int num2; } // 디폴트 생성자 BBB( super(); ) 생략됨

1 2	class AAA { int num1; } // 디폴트 생성자 AAA{} 생략됨 class BBB extends AAA { int num2; } // 디폴트 생성자 BBB( super(); ) 생략됨

Chapter 15. 클래스의 상속 2: 오버라이딩

15-1. 상속을 위한 관계
15-2. 하위 클래스에서 메소드를 다시 정의한다면?
15-3. 참조변수의 인스턴스 참조와 instanceof 연산자

Is-a 관계 : 무선전화기는 전화기이다.
Has-a 관계 : 경찰은 총을 가지고 있다.
- 이 경우는 총을 경찰의 멤버로 가지는게 더 좋다.
- 총없는 경찰을 위해 코드가 더 많이 생성된다.
- 전기봉, 수갑 등을 가질 경우, 다중 상속해야 하는가?
오버라이드 : 하위 클래스에서 상위 클래스 재정의 –> 상위 클래스 메소드는 하위 클래스 매소드에 “가려진다”
상속 확인

if(box instanceof GoldPaperBox) { ~~~ }

1	if(box instanceof GoldPaperBox) { ~~~ }

Chapter 16. 클래스의 상속 3: 상속의 목적

16-1. 개인정보 관리 프로그램
16-2. 모든 클래스가 상속하는 Object 클래스
16-3. final 클래스와 final 메소드
16-4. 단계별 프로젝트: 전화번호 관리 프로그램 04단계

상속을 통해 연관된 일련의 클래스에 대한 “공통적인 규약”을 정의할 수 있다.

class Friend
{
    ~~~
    public void showBasicInfo() {}
}

class HighFriend extends Friend
{
    ~~~
    public void showBasicInfo() { System.out.println("고딩친구"); }
}

class UnivFriend extends Friend
{
    ~~~
    public void showBasicInfo() { System.out.println("대딩친구"); }
}

class AAA
{
    Friend f = new HighFriend();
    f.showBasicInfo();

    // Friend에 showBasicInfo() 메소드가 없었다면 형변환을 하여 showBasicInfo()를 수행해야 한다.
    // if(f instance of HighFriend)
    //{
    //  ((HighFriend)f).showBasicInfo();
    //}
}

class Friend

{

~~~

public void showBasicInfo() {}

}

class HighFriend extends Friend

{

~~~

public void showBasicInfo() { System.out.println("고딩친구"); }

}

class UnivFriend extends Friend

{

~~~

public void showBasicInfo() { System.out.println("대딩친구"); }

}

class AAA

{

Friend f = new HighFriend();

f.showBasicInfo();

// Friend에 showBasicInfo() 메소드가 없었다면 형변환을 하여 showBasicInfo()를 수행해야 한다.

// if(f instance of HighFriend)

//{

// ((HighFriend)f).showBasicInfo();

//}

}

위의 코드의 문제점과 해결
- Friend는 상속을 위해서만 만들어지고 하는게 없다.
- 이 경우 추상 클래스를 만드는게 좋다. showBasicInfo는 추상메소드로 만들어라.
- 추상 클래스로 만들면 아무것도 안하고 상속을 위해서만 만든 Friend 객체를 만들 수 없다.

Chapter 17. abstract와 interface 그리고 inner class

17-1. abstract 클래스
17-2. interface
17-3. Inner 클래스
17-4. Local 클래스와 Anonymous 클래스
17-5. 단계별 프로젝트: 전화번호 관리 프로그램 05단계

abstract : 추상 –> 완전치 않은
interface
- 다중 상속은.. 그냥 문법적인 얘기이다. 실무에서 다중 상속 용도로 거의 사용하지 않는다.
- A 클래스의 완성까지 못 기다리는 B 클래스 만들때 사용.
- A 클래스 내부는 관심없고, A의 인스턴스를 사용하여 B 클래스를 개발하고 싶을때
- instance는 약속이다.
interface를 abstract class로 변환 가능하다.

interface A
{
    void add(string a);
    int num = 1;
}

abstract class A
{
    public abstract void add(string a);
    public abstract final int num = 1;
}

interface A

{

void add(string a);

int num = 1;

}

abstract class A

{

public abstract void add(string a);

public abstract final int num = 1;

}

interface를 열거형 처럼 사용 (boolean이 없을때 사용하던 방법 같음)

interface Week { int MON = 1; TUE = 2; }

class A 
{
    int week = 1;
    switch(week) 
    {
        case Week.MON : ~~; break;
        case Week.TUE : ~~; break;
    }
}

interface Week { int MON = 1; TUE = 2; }

class A

{

int week = 1;

switch(week)

{

case Week.MON : ~~; break;

case Week.TUE : ~~; break;

}

interface를 어떠한 능력이 있음을 표시하기 위해 사용

interface UpperCasePrintable { // 비어있음 }
class A implements UpperCasePrintable { ~~~ } 
class B 
{ 
    ~~
    // 다른 클래스와 구분되는 "능력(~able)" 이 있음을 확인하고, 별도 조치 가능
    if(obj instanceof UpperCasePrintable) { ~~ }
}

interface UpperCasePrintable { // 비어있음 }

class A implements UpperCasePrintable { ~~~ }

class B

{

// 다른 클래스와 구분되는 "능력(~able)" 이 있음을 확인하고, 별도 조치 가능

if(obj instanceof UpperCasePrintable) { ~~ }

}

Inner Class

class OuterClass
{
    class InnerClass
    {
        InnerClass() { ~~~ }
    }
}

class Test
{
    OuterClass out1 = new OuterClass();
    OuterClass out2 = new OuterClass();

    OuterClass.InnerClass in1 = out1.new InnerClass();   // out1 안에 in1 인스턴스 생성
    OuterClass.InnerClass in2 = out1.new InnerClass();   // out1 안에 in2 인스턴스 생성
    OuterClass.InnerClass in3 = out2.new InnerClass();   // out2 안에 in3 인스턴스 생성
}

class OuterClass

{

class InnerClass

{

InnerClass() { ~~~ }

}

class Test

{

OuterClass out1 = new OuterClass();

OuterClass out2 = new OuterClass();

OuterClass.InnerClass in1 = out1.new InnerClass(); // out1 안에 in1 인스턴스 생성

OuterClass.InnerClass in2 = out1.new InnerClass(); // out1 안에 in2 인스턴스 생성

OuterClass.InnerClass in3 = out2.new InnerClass(); // out2 안에 in3 인스턴스 생성

}

Nested Class : Inner Class가 static 일때
Inner / Nested Class : 관계가 긴밀한 클래스를 논리적으로 묶기 위해 사용됨. 캡슐화와 가독성으로 인해 유지보수성 높아짐
Local Class
- Inner 클래스와 유사하지만 메소드내에 정의되고, 정의된 메소드 내에서만 인스턴스 생성과 참조변수 선언이 가능하다.
- 바깥에서도 사용하고 싶으면, Interface의 도움을 받아야 함.
- 매개변수는 final로만 사용가능 (메소드가 종료되면 매개변수도 사라지는데, Local 클래스에서 사용한 매개변수를 메모리에 저장하기 위해서는 final을 쓸 수 밖에 없어서 이렇게 강요당함)

interface Readable { public void read(); }

class OuterClass 
{
    private String myName;
    OuterClass(string name) { myName = name; }

    // 메소드 안에서 클래스 정의됨
    public Readable createLocalClassInst()
    {
        public LocalClass implements Readable
        {
            public void read() { System.out.println(myName); }
        }
    }
    return new LocalClass();
}

class Test
{
    OuterClass out1 = new OuterClass("kim");
    Readable localInst1 = out1.createLocalClassInst();
    localInst1.read();
}

interface Readable { public void read(); }

class OuterClass

{

private String myName;

OuterClass(string name) { myName = name; }

// 메소드 안에서 클래스 정의됨

public Readable createLocalClassInst()

{

public LocalClass implements Readable

{

public void read() { System.out.println(myName); }

}

return new LocalClass();

}

class Test

{

OuterClass out1 = new OuterClass("kim");

Readable localInst1 = out1.createLocalClassInst();

localInst1.read();

}

Annonymous 클래스 : 이름이 없는 local 클래스

interface Readable { public void read(); }

class OuterClass 
{
    private String myName;
    OuterClass(string name) { myName = name; }

    // 메소드 안에서 클래스 정의됨
    public Readable createLocalClassInst()
    {
        // 메소드 내부에서 사용되는 Local 클래스와 유사
        // 원래 interface는 몸체가 없어서 new를 사용할 수 없지만, 몸체를 {~~}로 채워서 new를 사용함
        return new Readable() 
        {
            public void read() { System.out.println(myName); }
        };
    }
}

class Test
{
    OuterClass out1 = new OuterClass("kim");
    Readable localInst1 = out1.createLocalClassInst();
    localInst1.read();
}

interface Readable { public void read(); }

class OuterClass

{

private String myName;

OuterClass(string name) { myName = name; }

// 메소드 안에서 클래스 정의됨

public Readable createLocalClassInst()

{

// 메소드 내부에서 사용되는 Local 클래스와 유사

// 원래 interface는 몸체가 없어서 new를 사용할 수 없지만, 몸체를 {~~}로 채워서 new를 사용함

return new Readable()

{

public void read() { System.out.println(myName); }

};

}

class Test

{

OuterClass out1 = new OuterClass("kim");

Readable localInst1 = out1.createLocalClassInst();

localInst1.read();

}

Chapter 18. 예외처리(Exception Handling)

18-1. 예외처리에 대한 이해와 try~catch문의 기본
18-2. 프로그래머가 직접 정의하는 예외의 상황
18-3. 예외 클래스의 계층도
18-4. 단계별 프로젝트: 전화번호 관리 프로그램 06단계

try ~ catch

try { ~~~ }
catch(Exception e)   // Exception은 Throwable 상속
{
    System.out.println(e.getMessage());
}
finally { ~~ }

try { ~~~ }

catch(Exception e) // Exception은 Throwable 상속

{

System.out.println(e.getMessage());

}

finally { ~~ }

Throwable 하위 클래스
- Exception : RuntimeException 등
- Error : VitualMachinError 등
사용자 정의 exception

class AgeException extends Exception
{
    public AgeException() 
    {
        super("유효한 나이가 아님");
    }
}

// throws : readAge()를 사용하는 놈들은 try~catch 해야 한다.
public static int readAge() throws AgeException
{
    ~~~
    if(age < 0)
    {
        AgeException ex = new AgeException();
        throw ex;   // 여기서 예외처리 매커니즘 기동하여 JVM이 처리한다. 메소드를 호출한 영역으로 예외를 던진다고 생각하면 됨
    }
}

class AgeException extends Exception

{

public AgeException()

{

super("유효한 나이가 아님");

}

// throws : readAge()를 사용하는 놈들은 try~catch 해야 한다.

public static int readAge() throws AgeException

{

~~~

if(age < 0)

{

AgeException ex = new AgeException();

throw ex; // 여기서 예외처리 매커니즘 기동하여 JVM이 처리한다. 메소드를 호출한 영역으로 예외를 던진다고 생각하면 됨

}

Chapter 19. 자바의 메모리 모델과 Object 클래스

19-1. 자바 가상머신의 메모리 모델
19-2. Object 클래스

java의 메모리 모델 = VM의 메모리 관리방식
- 메소드 영역 : 메소드의 바이트코드 & Static 변수를 저장 ==> main도 메소드이므로 대부분의 프로그램 흐름이 들어간다)
- 스택 영역 : 지역변수, 매개변수 저장 ==> 메소드 내에서만 유효한 것들
- 힙 영역 : 인스턴스 ==> 스택영역의 참조변수가 이곳의 인스턴스를 참고함. 인스턴스 소멸은 VM이 담당한다(GC)
Object 클래스의 finalize()
- protecte void finalize() throws Throwable
- 인스턴스가 소멸되기 전에 반드시 호출됨
- GC를 강제로 실행하기

    System.gc(); // 여기서 인스턴스 소멸이 유보되어 살아남는 놈도 있다.
    System.runFinalization();

1 2	System.gc(); // 여기서 인스턴스 소멸이 유보되어 살아남는 놈도 있다. System.runFinalization();

비교문
- == : 참조변수의 참조값을 비교
- equals : 인스턴스의 값을 비교
Object 클래스의 clone() 메소드
- protecte void clone() throws CloneNotSupportException
- 인스턴스의 복제
- clonable 인터페이스를 구현해야 함
- deep copy를 위해서는 clone 메소드를 오버라이딩하여 사용해야 함.
- 단, String 인스턴스는 deep copy 하지 않아도 된다.

Chapter 20. 자바의 다양한 기본 클래스

20-1. Wrapper 클래스
20-2. BigInteger 클래스와 BigDecimal 클래스
20-3. Math 클래스와 난수의 생성, 그리고 문자열 토큰(Token)의 구분

Wrapper 클래스
- Boolean, Integer, Charater, Byte, Short, Long, Float, Double
- Integer — unboxing –> int
- Integer <-- boxing --> int

// 사용법
Integer intValue1 = new Integer(10);
int intValue2 = intValue1.intValue();

// java 5.0 이후
Integer intValue1 = 10; // auto boxing
int intValue2 = intValue1; // auto unboxing

// 사용법

Integer intValue1 = new Integer(10);

int intValue2 = intValue1.intValue();

// java 5.0 이후

Integer intValue1 = 10; // auto boxing

int intValue2 = intValue1; // auto unboxing

매우 큰수 표현

BigInteger big = new BigInteger("100000000000000");

1	BigInteger big = new BigInteger("100000000000000");

BigDecimal

double e1 = 1.6;
double e2 = 0.1;
System.out.println(e1+e2); // 1.7000000000002 부정확하다.

BigDecimal e1 = new BigDecimal("1.6");  // 1.6을 전달하면 정밀도가 떨어지는 값을 전달하게 됨, 문자열로 전달할것
BigDecimal e2 = new BigDecimal("0.1");
System.out.println(e1+e2); // 1.7 정확하다.

double e1 = 1.6;

double e2 = 0.1;

System.out.println(e1+e2); // 1.7000000000002 부정확하다.

BigDecimal e1 = new BigDecimal("1.6"); // 1.6을 전달하면 정밀도가 떨어지는 값을 전달하게 됨, 문자열로 전달할것

BigDecimal e2 = new BigDecimal("0.1");

System.out.println(e1+e2); // 1.7 정확하다.

Math 클래스 : static 멤버로만 구성.
난수

Random r = new Random(); // seed를 생략하면 생성시마다 다른 seed가 적용됨

1	Random r = new Random(); // seed를 생략하면 생성시마다 다른 seed가 적용됨

StringTokenizer

StringTokenizer st = new StringTokenizer("11:22:33", ":");\
while(st.hasMoretoken())
    System.out.println(st.nextToken());

StringTokenizer st = new StringTokenizer("11:22:33", ":");\

while(st.hasMoretoken())

System.out.println(st.nextToken());

Chapter 21. 제네릭(Generics)

21-1. 제네릭 클래스의 이해와 설계
21-2. 제네릭을 구성하는 다양한 문법적 요소

제네릭 : 자료형의 일반화

// T가 매개변수화된 자료형임을 나타냄
class FruitBox<T>
{
    T item;
    public void store(T item) { this.item = item; }
    public T pullOut { return item; }
}

// T는 특정 인터페이스 구현 글래스
// T는 특정 상위클래스를 상속한 클래스
public static <T extends SimpleInterface> void show(T param)
{
~~~
}

// T를 배열로 전달 가능
public static <T> void showArray(T[] arr)
{
~~~
}

// 와일드 카드 사용 가능
FruitBox<? exteds Fruit> box1 = new FruitBox<Fruit>();  // ?는 Fruit 클래스 또는 Fruit를 하위 클래스 (Apple, Banana)
FruitBox<? exteds Fruit> box2 = new FruitBox<Apple>();
FruitBox<? supper Apple> box3 = new FruitBox<Apple>();  // ?는 Fruit 클래스 또는 Fruit의 상위 클래스 (Fruit, Object)

// 상속
class AAA<T> { T itemAAA; }
class BBB<T> extends AAA<T> { T itemBBB; }
class CCC extends AAA(String) { int itemCCC; } // CCC는 제네릭이여도 되고, 아니여도 된다. T를 String으로 지정하여 상속할 수 있다.

// 제네릭 인터페이스
interface MyInterface<T> { public T myFunc(T item); }
class MyImp1<T> implements MyInterface<T> { ~~~ }
class MyImp2 implements MyInterface<String > { ~~~ } // T를 String으로 지정하여 구현

// 기본형은 제네릭 클래스 인스턴스 생성에 사용할 수 없다.
Fruit<int> fb = new FruitBox<int>();             // X
Fruit<Interger> fb = new FruitBox<Interger>();   // O

// T가 매개변수화된 자료형임을 나타냄

class FruitBox<T>

{

T item;

public void store(T item) { this.item = item; }

public T pullOut { return item; }

}

// T는 특정 인터페이스 구현 글래스

// T는 특정 상위클래스를 상속한 클래스

public static <T extends SimpleInterface> void show(T param)

{

~~~

}

// T를 배열로 전달 가능

public static <T> void showArray(T[] arr)

{

~~~

}

// 와일드 카드 사용 가능

FruitBox<? exteds Fruit> box1 = new FruitBox<Fruit>(); // ?는 Fruit 클래스 또는 Fruit를 하위 클래스 (Apple, Banana)

FruitBox<? exteds Fruit> box2 = new FruitBox<Apple>();

FruitBox<? supper Apple> box3 = new FruitBox<Apple>(); // ?는 Fruit 클래스 또는 Fruit의 상위 클래스 (Fruit, Object)

// 상속

class AAA<T> { T itemAAA; }

class BBB<T> extends AAA<T> { T itemBBB; }

class CCC extends AAA(String) { int itemCCC; } // CCC는 제네릭이여도 되고, 아니여도 된다. T를 String으로 지정하여 상속할 수 있다.

// 제네릭 인터페이스

interface MyInterface<T> { public T myFunc(T item); }

class MyImp1<T> implements MyInterface<T> { ~~~ }

class MyImp2 implements MyInterface<String > { ~~~ } // T를 String으로 지정하여 구현

// 기본형은 제네릭 클래스 인스턴스 생성에 사용할 수 없다.

Fruit<int> fb = new FruitBox<int>(); // X

Fruit<Interger> fb = new FruitBox<Interger>(); // O

Chapter 22. 컬렉션 프레임워크(Collection Framework)

22-1. 컬렉션 프레임워크의 이해
22-2. Collection 인터페이스를 구현하는 제네릭 클래스들
22-3. Set 인터페이스를 구현하는 컬렉션 클래스들
22-4. Map 인터페이스를 구현하는 컬렉션 클래스들
22-5. 단계별 프로젝트: 전화번호 관리 프로그램 07단계

프레임워크 : 골격. 설계의 원칙과 구조가 정의됨(라이브러리와의 차이점)
컬렉션 : 자료구조 & 알고리즘
- 자료구조 : array, list, stack, queue, tree, hash ….
- 알고리즘 : sort, search ….
인터페이스 구조 (java.util 에 정의됨)
- Collection <-- Set, List, Queue
- Map<K, V>
List
인터페이스
- List <-- ArrayList, LinkedList
- ArrayList : 배열 기반. 길이를 늘리거나 삭제시 부하 많음. 참조가 빠름
- LinkedList : 링크드 리스트 기반. 길이를 늘리거나 삭제가 간단. 참조가 불편
Iterator 인터페이스
- 반복자
- collection 인터페이스에 iterator() 메소드 정의됨
  - iterator() 반환형은 Iterator 인터페이스임
  - descendingIterator()는 내림차순으로 정렬됨
- 주요 메소드
  - boolean hasNext()
  - E next()
  - void remove()
Set
인터페이스
- Set = 집합 : List와 달리 중복 안됨. 순서는 유지하지 않는다.
- HashSet
  클래스
  - 해쉬값을 계산하여, 이에 속하는 Set(집합)을 찾는다.
- TreeSet
  클래스
  - Set 인터페이스의 구현 클레스. 중복 안됨
  - Tree : 정렬됨
  - 정렬을 위해 필요시 Comparable 인터페이스 구현해야 함. 참고로 Integer에는 이미 구현되어 있다.
Map<K, V> 인터페이스
- Key는 중복 안됨, Key가 다르면 Value는 중복 가능
- HashMap<K, V> 클래스 : Hash 알고리즘 기반 – 빠른 검색
- TreeMap<K, V> 클래스 : Tree 알고리즘 기반 – 정렬되어 저장됨

Chapter 23. 쓰레드(Thread)와 동기화

23-1. 쓰레드의 이해와 생성
23-2. 쓰레드의 특성
23-3. 동기화(Synchronization)
23-4. 새로운 동기화 방식

쓰레드 생성 #1 : Thread 상속

class ShowThread extends Thread 
{
    String threadName;
    public showThread(String name) { threadName = name; }

    // Thread의 run()을 오버로딩함
    // start() 메소드는 run()을 대신 실행함
    // run()을 직접 호출하면 단순 메소드의 호출일뿐, 쓰레드 실행은 아니다. 
    pulic run()
    {
        ~~~~
    }
}

class Test
{
    public void main(~~~)
    {
        ShowThread th1 = new ShowThread("쓰레드1");

        // start()이 실행되면 JVM은 메모리 공간을 할당하고 리소스와 정보를 등록한다.
        th1.start();

    // 메인 메소드가 먼저 종료되어도 실행중인 thread 가 있다면 프로그램은 종료되지 않는다.
    // 실은.. main메소드도 thread로 실행되므로 "main thread"라 불린다.
    // 결론은.. 모든 thread가 종료되어야 프로그램이 종료된다.
    }
}

class ShowThread extends Thread

{

String threadName;

public showThread(String name) { threadName = name; }

// Thread의 run()을 오버로딩함

// start() 메소드는 run()을 대신 실행함

// run()을 직접 호출하면 단순 메소드의 호출일뿐, 쓰레드 실행은 아니다.

pulic run()

{

~~~~

}

class Test

{

public void main(~~~)

{

ShowThread th1 = new ShowThread("쓰레드1");

// start()이 실행되면 JVM은 메모리 공간을 할당하고 리소스와 정보를 등록한다.

th1.start();

// 메인 메소드가 먼저 종료되어도 실행중인 thread 가 있다면 프로그램은 종료되지 않는다.

// 실은.. main메소드도 thread로 실행되므로 "main thread"라 불린다.

// 결론은.. 모든 thread가 종료되어야 프로그램이 종료된다.

}

쓰레드 생성 #2 : 다른 클래스를 상속받아야 하면, 다중 상속을 위해 Runable 인터페이스를 구현

class AdderThread extends Sum Implements Runable
{
    ~~~~
    pulic run() { ~~~~ }
}

class AdderThread extends Sum Implements Runable

{

~~~~

pulic run() { ~~~~ }

}

쓰레드 스케쥴링
- 우선순위가 높은 쓰레드 우선 실행
- 우선순위가 동일한 쓰레드는 CPU 할당 시간을 분배함
- setPriority(int) 메소드 : 1(낮음)~10(높음)까지 우선순위 설정. 10단계는 OS마다 다를 수 있으므로 thread.MAX_PRIORITY 같은 상수를 사용하라.
- getPriority() : 현재 쓰레드의 우선순위를 리턴
쓰레드 생명주기
- new : 인스턴스화가 된 상태
- runnable : new상태에서 start() 호출후 “실행 가능”한 상태. 스케쥴러가 실행의 대상으로 선택해야 run() 호출하여 “실행”된다.
- dead : run()을 빠져나옴. 할당된 메모리 반환하고 끝난다.
- blocked
  - sleep(), join() 메소드 호출시, cpu 필요없는 입출력 연산시
  - cpu를 다른 thread에게 양보하고, 위의 조건이 해소되면 runnable 상태로 이전
쓰레드의 메모리 구조
- 각 쓰레드는 스택 영역을 할당받음
- main 쓰레드의 메소드 영역과 힙 영역은 공유하여 사용함 –> 동기화 필요
동기화 #1 : 동기화 메소드

// synchronized를 통해 동기화 문제는 해결함
// 성능이 떨어지므로 적절히 사용
// 동기화의 주체는 인스턴스이다. 메소드에 정의해도 inc()를 호출하면 동기화가 되는 영역은 인스턴스 전체이다.
public synchronized void inc() { num++; }

// synchronized를 통해 동기화 문제는 해결함

// 성능이 떨어지므로 적절히 사용

// 동기화의 주체는 인스턴스이다. 메소드에 정의해도 inc()를 호출하면 동기화가 되는 영역은 인스턴스 전체이다.

public synchronized void inc() { num++; }

동기화 #2 : 동기화 블록

public synchronized void add(int n1, int n2) 
{ 
    // this : 어디에 있는 열쇠(Lock, Monitor)를 사용하여 동기화 할 것인가를 지정함. this는 현재 인스턴스의 열쇠를 사용함을 의미
    // 서로 다른 동기화가 필요하다면 Object key = new Object(); synchronized(key) { ~~~} 와 같이 새로운 열쇠를 추가하여 사용할 것.
    synchronized(this)
    {
        num++;
    }
    return n1+n2;
}

public synchronized void add(int n1, int n2)

{

// this : 어디에 있는 열쇠(Lock, Monitor)를 사용하여 동기화 할 것인가를 지정함. this는 현재 인스턴스의 열쇠를 사용함을 의미

// 서로 다른 동기화가 필요하다면 Object key = new Object(); synchronized(key) { ~~~} 와 같이 새로운 열쇠를 추가하여 사용할 것.

synchronized(this)

{

num++;

}

return n1+n2;

}

thread 실행 순서 제어
- wait() : 누군가 깨워주기 기다림
- notify() : 하나의 쓰레드 깨움
- notifyAll() : 모든 쓰레드 깨움

// A 스레드에서 wait() 만나서 기다리게 됨
// wait, notify, notiryAll은 synchronized로 동기화 되어야 한다.
synchronized(this) { ~~~ wait(); ~~~} 

// B 쓰레드에서 모든 쓰레드를 깨우게 된다.
synchronized(this) { ~~~ notifyAll(); ~~~}

// A 스레드에서 wait() 만나서 기다리게 됨

// wait, notify, notiryAll은 synchronized로 동기화 되어야 한다.

synchronized(this) { ~~~ wait(); ~~~}

// B 쓰레드에서 모든 쓰레드를 깨우게 된다.

synchronized(this) { ~~~ notifyAll(); ~~~}

java.util.concurrent 패키지
- java 5.에서 등장

private final ReentrantLock key1 = new ReentrantLock();
~~~
// lock() ~ unlock() 까지 둘 이상의 쓰레드에서 동시 실행이 안된다. unlock의 꼭 실행되기 위해 finally 사용하자
key1.lock();
try { ~~~ }
catch { ~~~ }
finally { key.unlock(); }

private final ReentrantLock key1 = new ReentrantLock();

~~~

// lock() ~ unlock() 까지 둘 이상의 쓰레드에서 동시 실행이 안된다. unlock의 꼭 실행되기 위해 finally 사용하자

key1.lock();

try { ~~~ }

catch { ~~~ }

finally { key.unlock(); }

private final ReentrantLock entLock = new ReentrantLock();
private final Condition cond1 = entLock.newCondigion();

// 실행 순서를 제어하기 위해 아래의 메소드를 사용할 수 있다.
cond1.await();      // wait와 같음
cond1.signal();     // notify와 같음
cond1.signalAll();  // notifyAll와 같음

private final ReentrantLock entLock = new ReentrantLock();

private final Condition cond1 = entLock.newCondigion();

// 실행 순서를 제어하기 위해 아래의 메소드를 사용할 수 있다.

cond1.await(); // wait와 같음

cond1.signal(); // notify와 같음

cond1.signalAll(); // notifyAll와 같음

Chapter 24. 파일과 I/O 스트림

24-1. File I/O에 대한 소개
24-2. 필터 스트림의 이해와 활용
24-3. 문자 스트림의 이해와 활용
24-4. 스트림을 통한 인스턴스의 저장
24-5. Random Access 파일과 FILE 클래스
24-6. 단계별 프로젝트: 전화번호 관리 프로그램 08단계

InputStream 클래스
- InputStream <– FileInputStream, XxxInputStream
- InputStream : 바이트 단위로 읽어들이는 모든 입력 스트림의 상위 클래스
- abstract read() : 하위 클래스별로 읽는 방법이 다르므로 하위에서 구현해야 함. 더 이상 읽을게 없으면 -1
- close()
필터 스트림

InputStream in = new FileInputStream("data.bin");
DataInputStream fin = new DataInputStream(in); // FilterInputStream 상속
fin.readInt(); // int로 읽는다.

OutputStream out = new FileOutputStream("data.bin");
DataOutputStream fin = new DataOutputStream(out);  // FilterOutputStream 상속
fout.writeInt(1234); // int로 쓴다.

InputStream in = new FileInputStream("data.bin");

DataInputStream fin = new DataInputStream(in); // FilterInputStream 상속

fin.readInt(); // int로 읽는다.

OutputStream out = new FileOutputStream("data.bin");

DataOutputStream fin = new DataOutputStream(out); // FilterOutputStream 상속

fout.writeInt(1234); // int로 쓴다.

버퍼링 기능 제공하는 필터 스트림
- BufferedInputStream
- BufferedOutputStream : 버퍼가 꽉 차면 전송함. flush()하면 바로 전송함. close()될때 자동으로 flush()되니까 성능상 필요시만 flush()사용
버퍼링 & 실수형 저장하기 위한 스트림 조합

OutputStream out = new FileOutputStream("data.bin");
BufferedOutputStream bout = new BufferedOutputStream(out);  // 생성자 파라메터로 OutputStream를 받는다.
DataOutputStream dout = new DataOutputStream(bout);         // 생성자 파라메터로 OutputStream를 받는다. 따라서 상속된 BufferedOutputStream도 쓸 수 있다.

~~~
dout.close(); // 종료시 dout만 닫으면 연결된 스트림들은 차례로 종료된다.

OutputStream out = new FileOutputStream("data.bin");

BufferedOutputStream bout = new BufferedOutputStream(out); // 생성자 파라메터로 OutputStream를 받는다.

DataOutputStream dout = new DataOutputStream(bout); // 생성자 파라메터로 OutputStream를 받는다. 따라서 상속된 BufferedOutputStream도 쓸 수 있다.

~~~

dout.close(); // 종료시 dout만 닫으면 연결된 스트림들은 차례로 종료된다.

문자 스트림
- java는 유니코드로 문자를 표현한다.
- OS 인코딩에 맞춰 저장하고 읽기 위해서는 문자 스트림을 사용하라
- 최상위 클래스 : Reader, Writer
  - Reader <– FileReader
  - Writer <– FileWriter
- 버퍼 사용 : BufferedReader, BufferedWriter
  - 성능의 차이가 크기 때문에 이거 많이 쓰자.
- PrintWriter : PrintStream의 개선판. PrintStream의 Stream은 바이트 스트림을 의미하므로 문자열 처리에 적절치 않기 때문
스트림을 통한 인스턴스 처리
- ObjectInputStream : readObject()
- ObjectOutputStream : writeObject()
- 입출력 대상이 되는 인스턴스 클래스는 Serializable 구현해야 함. 이 클래스가 참조하는 인스턴스 변수도 Serializable 구현해야 함.
- 직렬화 대상에서 제외하고 싶은 인스턴스 변수 앞에는 transient 라고 선언
RandomAccessFile 클래스
- 특징
  - 입/출력 동시에 가능
  - 입/출력 위치 변경 가능
  - 파일만을 대상으로 한다.
- getFilePointer() : 현재 FP 위치를 리턴
- seek(long pos) : FP 이동
- readXXXX(), writeXXXX() : 동작을 수행후 FP가 이동된다.
File 클래스
- 특징
  - 디렉토리 생성/소멸
  - 파일 소멸
  - 디렉토리 파일 이름 출력
- getAbsoluitePath() : file의 절대 경로 리턴
- 참고사항
  - File.seperator : 윈도우 “\”, 리눅스 “/” 리턴
  - System.getProperty(“user.dir”) : 현재 디렉토리의 절대 경로 리턴

Chapter 25. Swing 컴포넌트와 이벤트 핸들링

25-1. Swing을 시작하기에 앞서
25-2. Swing 컴포넌트와 이벤트 핸들링
25-3. 레이아웃 매니저(Layout Manager)
25-4. 이벤트와 이벤트 리스너(Event Listener)
25-5. 다양한 Swing 컴포넌트
25-6. 단계별 프로젝트: 전화번호 관리 프로그램 09단계

AWT : 초기 GUI는 AWT 패키지를 사용 – OS 종속적
Swing : GUI를 순수 자바로 구현 – OS 비종속적
SWT : 이클립스에서 개발

CC BY-NC-ND 2.0 KR

이 저작물은 크리에이티브 커먼즈 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용할 수 있습니다.

난 정말 JAVA를 공부한 적이 없다구요

독서평

목차 및 내용정리

Chapter 01. Let’s Start JAVA!

Chapter 02. 변수(Variable)와 자료형(Data Type)

Chapter 03. 상수와 형 변환(Type Casting)

Chapter 04. 연산자(Operator)

Chapter 05. 실행흐름의 컨트롤

Chapter 06. 메소드와 변수의 스코프

Chapter 07. 클래스와 인스턴스

Chapter 08. 클래스 패스와 패키지

Chapter 09. 접근제어 지시자와 정보은닉, 그리고 캡슐화

Chapter 10. 클래스 변수와 클래스 메소드

Chapter 11. 메소드 오버로딩과 String 클래스

Chapter 12. 콘솔 입력과 출력

Chapter 13. 배열(Array)

Chapter 14. 클래스의 상속 1: 상속의 기본

Chapter 15. 클래스의 상속 2: 오버라이딩

Chapter 16. 클래스의 상속 3: 상속의 목적

Chapter 17. abstract와 interface 그리고 inner class

Chapter 18. 예외처리(Exception Handling)

Chapter 19. 자바의 메모리 모델과 Object 클래스

Chapter 20. 자바의 다양한 기본 클래스

Chapter 21. 제네릭(Generics)

Chapter 22. 컬렉션 프레임워크(Collection Framework)

Chapter 23. 쓰레드(Thread)와 동기화

Chapter 24. 파일과 I/O 스트림

Chapter 25. Swing 컴포넌트와 이벤트 핸들링

CC BY-NC-ND 2.0 KR

댓글 남기기 응답 취소

독서평

목차 및 내용정리

Chapter 01. Let’s Start JAVA!

Chapter 02. 변수(Variable)와 자료형(Data Type)

Chapter 03. 상수와 형 변환(Type Casting)

Chapter 04. 연산자(Operator)

Chapter 05. 실행흐름의 컨트롤

Chapter 06. 메소드와 변수의 스코프

Chapter 07. 클래스와 인스턴스

Chapter 08. 클래스 패스와 패키지

Chapter 09. 접근제어 지시자와 정보은닉, 그리고 캡슐화

Chapter 10. 클래스 변수와 클래스 메소드

Chapter 11. 메소드 오버로딩과 String 클래스

Chapter 12. 콘솔 입력과 출력

Chapter 13. 배열(Array)

Chapter 14. 클래스의 상속 1: 상속의 기본

Chapter 15. 클래스의 상속 2: 오버라이딩

Chapter 16. 클래스의 상속 3: 상속의 목적

Chapter 17. abstract와 interface 그리고 inner class

Chapter 18. 예외처리(Exception Handling)

Chapter 19. 자바의 메모리 모델과 Object 클래스

Chapter 20. 자바의 다양한 기본 클래스

Chapter 21. 제네릭(Generics)

Chapter 22. 컬렉션 프레임워크(Collection Framework)

Chapter 23. 쓰레드(Thread)와 동기화

Chapter 24. 파일과 I/O 스트림

Chapter 25. Swing 컴포넌트와 이벤트 핸들링

CC BY-NC-ND 2.0 KR

Related posts

Related posts

댓글 남기기 응답 취소