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

독서평

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

nan_java

목차 및 내용정리

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

Chapter 01. Let’s Start JAVA!

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 01-1. 자바의 세계로 오신 여러분을 환영합니다.
01-2. 자바 프로그램의 이해와 실행의 원리
01-3. 첫 번째 자바 프로그램의 관찰과 응용
01-4. 컴파일의 대상에서 제외되는 주석!
[/symple_box]

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

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 02-1. 변수의 이해와 활용
02-2. 정수 표현방식의 이해
02-3. 실수 표현방식의 이해
02-4. 자료형의 이해
[/symple_box]
  • 실수표현
    • 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)

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 03-1. 자료형을 기반으로 표현이 되는 상수
03-2. 자료형의 변환
[/symple_box]
  • 상수도 메모리에 저장됨. 변수처럼 변경되지 않음. 상수=리터럴(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 접미)
  • 자동 형변환 (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)

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 04-1. 자바에서 제공하는 이항 연산자들
04-2. 자바에서 제공하는 단항 연산자들
04-3. 비트와 관련이 있는 연산자들
[/symple_box]
  • 이항 연산자 (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); // 연산은 되지만 나머지 연산에서 의미가 없다. 실수형 나머지를 허용하지 않는 언어도 있음.
  • Short-Circuit Evaluation (Lazy Evaluation)
    • 가장 빠르게 연산을 진행하기 위한 계산방식
    • false && XXXX : XXXX는 볼 필요 없음
    • true || XXXX : XXXX는 볼 필요 없음
    • XXXX 에서 대입이 일어나지 않아야 함

Chapter 05. 실행흐름의 컨트롤

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 05-1. if 그리고 else
05-2. switch와 break
05-3. for, while 그리고 do~while
05-4. continue & break
05-5. 반복문의 중첩
[/symple_box]
  • 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 ( ~ )를 빠져나감.
    }
    }
    

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

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 06-1. 메소드에 대한 이해와 메소드의 정의
06-2. 변수의 스코프
06-3. 메소드의 재귀호출
[/symple_box]

Chapter 07. 클래스와 인스턴스

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 07-1. 클래스의 정의와 인스턴스의 생성
07-2. 생성자(Constructor)
07-3. 자바의 이름 규칙(Naming Rule)
[/symple_box]
  • final : 상수화 시키는 키워드, 한번의 초기화 가능
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. 클래스 패스와 패키지

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 08-1. 클래스 패스(Class Path)의 지정
08-2. 패키지(Package)의 이해
[/symple_box]
  • 클래스 패스 : 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 파일을 다른 디렉토리에 생성 가능해짐

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

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 09-1. 정보은닉(Information Hiding)
09-2. 접근제어 지시자(Access Control Specifiers)
09-3. public 클래스와 default 클래스
09-4. 어떤 클래스를 public으로 선언할까요?
09-5. 캡슐화(Encapsulation)
[/symple_box]
  • 접근제어
    • 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; }
  • default 생성자는 클래스의 접근제어 지시자와 동일한 것으로 선언됨.

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

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 10-1. static 변수(클래스 변수)
10-2. static 메소드(클래스 메소드)
10-3. System.out.println & public static void main
[/symple_box]
  • 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();
        ~~~
    }
}

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

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 11-1. 메소드 오버로딩(Overloading)
11-2. String 클래스
11-3. API Document의 참조를 통한 String 클래스의 인스턴스 메소드 관찰
11-4. StringBuilder & StringBuffer 클래스
11-5. 단계별 프로젝트: 전화번호 관리 프로그램 01단계
[/symple_box]
  • 오버로딩 (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 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()할때 한번.
  • StringBuilder / StringBuffer는 사용법이 똑같다.
    • StringBuilder : thread-safe. JDK 1.5 이상
    • StringBuffer : thread-unsafe. JDK 1.0 이상

Chapter 12. 콘솔 입력과 출력

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 12-1. 콘솔 출력(Console Output)
12-2. 콘솔 입력(Console Input)
12-3. 단계별 프로젝트: 전화번호 관리 프로그램 02단계
[/symple_box]
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)

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 13-1. 배열이라는 존재가 필요한 이유
13-2. 1차원 배열의 이해와 활용
13-3. 다차원 배열의 이해와 활용
13-4. for-each
13-5. main 메소드로의 데이터 전달
13-6. 단계별 프로젝트: 전화번호 관리 프로그램 03단계
[/symple_box]
// 배열
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: 상속의 기본

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 14-1. 상속은 재활용 + 알파(α)
14-2. 상속의 기본문법 이해
14-3. 상속과 접근제어 지시자
14-4. static 변수(메소드)의 상속과 생성자의 상속에 대한 논의
[/symple_box]
  • 상속 이모저모
    • 객체지향 패러다임은 재활용 관점에서는 실패한 패러다임이다.
    • 재활용을 위해 상속을 사용하지 마라. (재활용하는 것이 새로 만드는 것보다 공수가 많음. 재활용을 위한 디자인은 어렵다)
    • 상속을 통해 일련의 클래스에 대한 공통 규약을 정의할 수 있다.
  • 용어 정리
    • 상속받은 클래스 : 하위 클래스 (sub class), 유도 클래스 (derived class)
    • 상속한 클래스 : 상위 클래스 (super class), 기초 클래스 (basic class)
  • super(…) : 상위 생성자 호출하여 초기화

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

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

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 15-1. 상속을 위한 관계
15-2. 하위 클래스에서 메소드를 다시 정의한다면?
15-3. 참조변수의 인스턴스 참조와 instanceof 연산자
[/symple_box]
  • Is-a 관계 : 무선전화기는 전화기이다.
  • Has-a 관계 : 경찰은 총을 가지고 있다.
    • 이 경우는 총을 경찰의 멤버로 가지는게 더 좋다.
    • 총없는 경찰을 위해 코드가 더 많이 생성된다.
    • 전기봉, 수갑 등을 가질 경우, 다중 상속해야 하는가?
  • 오버라이드 : 하위 클래스에서 상위 클래스 재정의 –> 상위 클래스 메소드는 하위 클래스 매소드에 “가려진다”
  • 상속 확인
if(box instanceof GoldPaperBox) { ~~~ }

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

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 16-1. 개인정보 관리 프로그램
16-2. 모든 클래스가 상속하는 Object 클래스
16-3. final 클래스와 final 메소드
16-4. 단계별 프로젝트: 전화번호 관리 프로그램 04단계
[/symple_box]
  • 상속을 통해 연관된 일련의 클래스에 대한 “공통적인 규약”을 정의할 수 있다.
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

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 17-1. abstract 클래스
17-2. interface
17-3. Inner 클래스
17-4. Local 클래스와 Anonymous 클래스
17-5. 단계별 프로젝트: 전화번호 관리 프로그램 05단계
[/symple_box]
  • 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를 열거형 처럼 사용 (boolean이 없을때 사용하던 방법 같음)
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) { ~~ }
} 
  • 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 인스턴스 생성
}
  • 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();
}
  • 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();
}

Chapter 18. 예외처리(Exception Handling)

[symple_box color=”gray” fade_in=”false” float=”center” text_align=”left” width=””] 18-1. 예외처리에 대한 이해와 try~catch문의 기본
18-2. 프로그래머가 직접 정의하는 예외의 상황
18-3. 예외 클래스의 계층도
18-4. 단계별 프로젝트: 전화번호 관리 프로그램 06단계
[/symple_box]
  • try ~ catch
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이 처리한다. 메소드를 호출한 영역으로 예외를 던진다고 생각하면 됨
    }
}

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

[symple_box color="gray" fade_in="false" float="center" text_align="left" width=""] 19-1. 자바 가상머신의 메모리 모델
19-2. Object 클래스
[/symple_box]
  • java의 메모리 모델 = VM의 메모리 관리방식
    • 메소드 영역 : 메소드의 바이트코드 & Static 변수를 저장 ==> main도 메소드이므로 대부분의 프로그램 흐름이 들어간다)
    • 스택 영역 : 지역변수, 매개변수 저장 ==> 메소드 내에서만 유효한 것들
    • 힙 영역 : 인스턴스 ==> 스택영역의 참조변수가 이곳의 인스턴스를 참고함. 인스턴스 소멸은 VM이 담당한다(GC)
  • Object 클래스의 finalize()
    • protecte void finalize() throws Throwable
    • 인스턴스가 소멸되기 전에 반드시 호출됨
    • GC를 강제로 실행하기
    System.gc(); // 여기서 인스턴스 소멸이 유보되어 살아남는 놈도 있다.
    System.runFinalization();
    
  • 비교문
    • == : 참조변수의 참조값을 비교
    • equals : 인스턴스의 값을 비교
  • Object 클래스의 clone() 메소드
    • protecte void clone() throws CloneNotSupportException
    • 인스턴스의 복제
    • clonable 인터페이스를 구현해야 함
    • deep copy를 위해서는 clone 메소드를 오버라이딩하여 사용해야 함.
    • 단, String 인스턴스는 deep copy 하지 않아도 된다.

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

[symple_box color="gray" fade_in="false" float="center" text_align="left" width=""] 20-1. Wrapper 클래스
20-2. BigInteger 클래스와 BigDecimal 클래스
20-3. Math 클래스와 난수의 생성, 그리고 문자열 토큰(Token)의 구분
[/symple_box]
  • 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
  • 매우 큰수 표현
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 정확하다.
  • Math 클래스 : static 멤버로만 구성.
  • 난수
Random r = new Random(); // seed를 생략하면 생성시마다 다른 seed가 적용됨
  • StringTokenizer
StringTokenizer st = new StringTokenizer("11:22:33", ":");\
while(st.hasMoretoken())
    System.out.println(st.nextToken());

Chapter 21. 제네릭(Generics)

[symple_box color="gray" fade_in="false" float="center" text_align="left" width=""] 21-1. 제네릭 클래스의 이해와 설계
21-2. 제네릭을 구성하는 다양한 문법적 요소
[/symple_box]
  • 제네릭 : 자료형의 일반화
// T가 매개변수화된 자료형임을 나타냄
class FruitBox
{
    T item;
    public void store(T item) { this.item = item; }
    public T pullOut { return item; }
}

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

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

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

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

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

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

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

[symple_box color="gray" fade_in="false" float="center" text_align="left" width=""] 22-1. 컬렉션 프레임워크의 이해
22-2. Collection 인터페이스를 구현하는 제네릭 클래스들
22-3. Set 인터페이스를 구현하는 컬렉션 클래스들
22-4. Map 인터페이스를 구현하는 컬렉션 클래스들
22-5. 단계별 프로젝트: 전화번호 관리 프로그램 07단계
[/symple_box]
  • 프레임워크 : 골격. 설계의 원칙과 구조가 정의됨(라이브러리와의 차이점)
  • 컬렉션 : 자료구조 & 알고리즘
    • 자료구조 : 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)와 동기화

[symple_box color="gray" fade_in="false" float="center" text_align="left" width=""] 23-1. 쓰레드의 이해와 생성
23-2. 쓰레드의 특성
23-3. 동기화(Synchronization)
23-4. 새로운 동기화 방식
[/symple_box]
  • 쓰레드 생성 #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가 종료되어야 프로그램이 종료된다.
    }
}
  • 쓰레드 생성 #2 : 다른 클래스를 상속받아야 하면, 다중 상속을 위해 Runable 인터페이스를 구현
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++; }
  • 동기화 #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;
}
  • thread 실행 순서 제어
    • wait() : 누군가 깨워주기 기다림
    • notify() : 하나의 쓰레드 깨움
    • 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 entLock = new ReentrantLock();
private final Condition cond1 = entLock.newCondigion();

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

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

[symple_box color="gray" fade_in="false" float="center" text_align="left" width=""] 24-1. File I/O에 대한 소개
24-2. 필터 스트림의 이해와 활용
24-3. 문자 스트림의 이해와 활용
24-4. 스트림을 통한 인스턴스의 저장
24-5. Random Access 파일과 FILE 클래스
24-6. 단계별 프로젝트: 전화번호 관리 프로그램 08단계
[/symple_box]
  • 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로 쓴다. 
  • 버퍼링 기능 제공하는 필터 스트림

    • 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만 닫으면 연결된 스트림들은 차례로 종료된다.
  • 문자 스트림

    • 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 컴포넌트와 이벤트 핸들링

[symple_box color="gray" fade_in="false" float="center" text_align="left" width=""] 25-1. Swing을 시작하기에 앞서
25-2. Swing 컴포넌트와 이벤트 핸들링
25-3. 레이아웃 매니저(Layout Manager)
25-4. 이벤트와 이벤트 리스너(Event Listener)
25-5. 다양한 Swing 컴포넌트
25-6. 단계별 프로젝트: 전화번호 관리 프로그램 09단계
[/symple_box]
  • AWT : 초기 GUI는 AWT 패키지를 사용 - OS 종속적
  • Swing : GUI를 순수 자바로 구현 - OS 비종속적
  • SWT : 이클립스에서 개발

Notice

  • 이 저작물은 크리에이티브 커먼즈 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용할 수 있습니다. 크리에이티브 커먼즈 라이선스
  • 저작권과 관련된 파일요청 및 작업요청을 받지 않습니다.
  • 댓글에 대한 답변은 늦을 수도 있습니다.
  • 답글 남기기

    이메일 주소를 발행하지 않을 것입니다. 필수 항목은 *(으)로 표시합니다