개발자가 놓치기 쉬운 자바의 기본원리_Daum DNA

1 객체지향의 구멍 static

1.1 Java는 객체지향 언어이다?

1.2 전역변수

2 Java는 Pointer언어이다? (Java에는
Pointer밖에 없다?)

2.1 Java는 primitive형을 제외하곤
모두 Pointer이다

2.2 null은 객체인가?

2.3 String에 대하여

2.4 객체지향의 캡슐화 파괴 주의

2.5 배열에 대하여

2.5.1 배열은 object 인가?

2.5.2 배열의 length는 왜
field(member variable)인가?

2.5.3 final과 배열에
대하여…

2.5.4 “Java에서의 다차원 배열은
존재하지 않는다.”

2.6
인수(parameter/argument)전달의 개념

2.6.1 “Java에서
parameter(argument) 전달은 무조건 ‘call by value’ 이다”

2.6.2 “C와 같은 언어는
static linking이지만, Java는 dynamic linking이다.”

2.7 GC 에 대하여 잠깐!

2.7.1 “Garbage
Collection은 만능이 아니다.”

2.8 Java Pointer 결론

2.8.1 “결국 Java에는
pointer가 있는 것인가, 없는 것인가?”

3 상속과 interface의 문제점

3.1 상속

3.1.1 상속에 있어서의
생성자(constructor)

3.1.2 “down cast는
본질적으로 매우 위험하다”

3.1.3 “추상클래스에 final이
있으면 compile error이다”

3.2 interface

3.2.1 “interface는
interface일뿐 다중 상속의 대용품이 아니다.”

3.3 상속 제대로 사용하기

4 package와 access 제어에 관한 이해

4.1 package

4.1.1 “package는 ‘계층구조’
인가?”

4.1.2 “compiler 가 인식하는
class검색 순서(소스코드내 클래스가 발견될 경우 그 클래스의 위치를 찾는 순서)”

4.2 access 제어

4.2.1 “interfacde
member의 access 제어”

4.2.2 그렇다면 interface를
다른 package에 대하여 숨기고 싶으면 어떻게 하는가?

5 기타 Java 기능

5.1 Thread

5.1.1 “Multi Thread에서는
흐름은 복수이지만 data는 공유될 수 있다.”

5.1.2 “Thread는 객체와
직교하는 개념이다.”

5.1.3 “Synchronized 의
이해”

5.1.4 “Thread 사용법의
정석은?”

5.2 Exception

5.2.1 “finally 절은 반드시
어떠한 경우에도 실행되는가?”

5.2.2 “예외의 종류 3가지
(Error, RuntimeException, 그밖의 Exception)”

5.2.2.1 Error

5.2.2.2
RuntimeException

5.2.2.3 그밖의
Exception

5.2.3
“OutOfMemoryError는 어떻게 처리해야 하는가?”

5.3 Object Serialize

5.3.1 “Serialize를 위해서는
marker interface인 java.io.Serializable interface를 implements해야한다.”

5.3.2 “super class는
Serializable이 아닌데 sub class만 Serializable인 경우의 문제점”

5.3.3 “transient
field의 복원(?)관련”

5.3.4 “Stack Overflow에
주의하라!”

5.4 “nested class / inner
class / 중첩클래스”

5.4.1 “중첩클래스의 개념”

5.4.2 “내부클래스는 부모의 참조를
몰래 보유하고 있다.”

5.4.3 “local inner
class에 대하여”

5.4.4 “anonymous
class(무명클래스)에 대하여”

6 이래도 Java가 간단한가?

6.1 method overload 에서의 혼란?

6.1.1 “overload란 이름이
가고 인수가 다른 method에 compiler가 다른 이름을 붙이는 기능”

6.1.2 “그렇다면 overload에서
실제로 혼동되는 부분은 무엇인가?”

6.1.3 (참고) 또다른 혼동,
overload한 method를 override 하면?

6.2 상속/override/은폐 에서의 복잡함

6.2.1 “Java class의
member 4 종류”

6.2.2 “override시
method 이름에 대한 함정”

6.2.3 “또다른 나의(?) 실수 –
말도 안되는 오타”

6.2.4 “static member를
instance를 경유하여 참조해서는 안 된다.”

6.2.5 “super keyword는
부모의 this”

6.3 상속에 관한 또 다른 문제

6.4 그밖의 함정

6.4.1 “생성자에 void 를
붙인다면?”

6.4.2 “if / switch 의
함정”

7 Java 기능 적용 몇가지

7.1 대규모 개발에서 interface 분리하기

7.1.1 “interface 분리의
필요성”

7.2 Java에서의 열거형

7.3 Debug write

8 Java 5.0 Tiger 에 대하여

8.1 Working with
java.util.Arrays

8.2 Using java.util.Queue
interface

8.3 java.lang.StringBuilder
사용하기

8.4 Using Type-Safe Lists

8.5 Writing Generic Types

8.6 새로운 static final enum

8.7 Using java.util.EnumMap

8.8 Using java.util.EnumSet

8.9 Convert Primitives to
Wrapper Types

8.10 Method Overload
resolution in AutoBoxing

8.11 가변적인 argument 개수
…

8.12 The Three Standard
Annotation

8.13 Creating Custom
Annotation Types

9 The for/in Statement

9.1 for/in 의 자주 사용되는 형태

10 Static Import

10.1 static member/method
import

11 References

• 오해1. “객체지향에서는 객체끼리 서로 메세지를 주고 받으며 동작한다.” 라는 말을 듣고 다음과 같이 생각할 수 있다. “객체지향에서는
  객체가 각각 독립하여 움직인다는 것인가, 그러면 각 객체에 독립된 thread가 할당되어 있단 말인가?” 그렇지 않다. “메세지를 보낸다”라는
  것은 단순히 각 객체의 함수 호출에 불과하다.
• 오해2. “객체지향에서는 method가 class에 부속되어 있다”는 말을 듣고 다음과 같이 생각할 수 있다. “그러면
  instance별로 method의 실행코드가 복제되고 있는 것이 아닌가?” 물론 이것도 오해다. method의 실행코드는 종래의 함수와 동일한
  어딘가 다른곳(JVM의 class area)에 존재하며 그 첫번째 파라미터로 객체의 포인터 this가 건네질 뿐이다.
• 오해3. “그렇다면 각 instance가 method의 실행코드를 통째로 갖고 있지 않는 것은 확실하지만, method의 실행 코드의
  포인터는 각 instance별로 보관하고 있는것이 아닌가?” 이것은 약가 애매한 오해이긴 하다. JVM 스펙에서는 class영역에 실행코드를
  갖고 있으며, method 호출시 별도의 stack frame이 생성되어 실행되고 실행 완료시 복귀 주소를 전달한다.

• (참고) final 초기화에서의 주의점. 예를 들어 다음과 같은 코드를 보았을때 우려되는 점은 무엇인가?

public final static Color WHITE = new Color(255, 255, 255);

1. static field는 final의 경우와 달리 정말 “하나여도 되는지” 여부를 잘 생각해야 한다.
2. static method는 주저하지 말고 쓰되 다음 두가지의 경우 매우 활용적이다.
   1. 다른 많은 클래스에서 사용하는 Utility Method 군을 만드는 경우. (주로 Utility Class의 method)
   2. 클래스 안에서만 사용하는 “하청 메소드(private method)”. 이유를 예를 들어 설명하면, 아래와 같은 조금은 과장된 클래스가
      있다고 하자.

                public class T ..
                    private int a;
                    private int b;
                    private int c;
                    private int calc(){
                        c = a + b;
                        return c * c;
                    }
                    ....other method or getter/setter...

            private static int calc(int a, int b){
               int c = a + b;
               return c * c;
            }

• null object의 instance method 호출
• null object의 field(member variables)에 대한 액세스 또는 그 값의 변경
• null의 길이를 배열처럼 취득할 경우
• null의 slot을 배열처럼 액세스 또는 수정
• null을 Throwable처럼 throw 할 경우

위에서 null object라는 말이 등장하는데 이는
공참조에 객체가 붙어 있지 않은 것이 아니라 null을 가리키는 객체라고 볼수 있다. 즉, 공참조라는 것은 JVM에서 봤을때 아무것도 참조하지
않는것이 아니라 null이라고 하는 object를 참조하고 있는것이다. 그러나 JSL 4.3.1에서는 다음과 같이 나와있다.

            String str = "111222";
            String a = "111";
            String b = "222";
            String c = "111";
            String d = b;
            String t = str.substring(0,3);  //111

1. str == (a + b) ==> 이것은 두개의 참조와 하나의 참조를 비교했으므로 당연히 false이다.
2. a == b ==> 이것은 당연히 false
3. d == b ==> 이것은 동일한 reference이므로 true
4. a == t ==> a 와 t 는 둘다 값이 “111”이다. 하지만 이것은 서로 다른 참조를 가져 false이다. 그렇다면 다음
   5번도 false일까?
5. a == c ==> 이것은 true이다. 아.. 4번과 혼란스럽다. 이것이 참인 이유는? ==> 이것의 해답은 JSR
   3.10.5에 다음과 같이 나와 있기 때문이다.

“동일한 내용의 문자열 리터럴에 관해서는 인스턴스를 하나밖에
생성하지 않는다.”

        //(참고)Member에는 두개의 field(Identity Class 형의 ID와 Family Class 형의 family)가 있다. 
        /** shallow copy */
        Member shallowCopy(){
            Member newer = new Member();
            newer.id = this.id;
            newer.family = this.family;
            return newer;
        }     
        /** deep copy */
        Member deepCopy(){
            Member newer = new Member();
            newer.id = new Idetity(this.id.getId(), this.id.getName());
            newer.family = new Family(this.family.getFamilyName(), this.family.getFamilyInfo());
            return newer;
        }

1. 모든 field(member variable)를 생성자(constructor)를 이용하여 초기화 한다.
2. 모든 field는 private으로 선언하고, getter method는 만들되 setter는 기술하지 않는다.

즉, 값을 변경하기 위해서는 object를 다시 만들어야만 하는 불편은 있지만 안전하게 사용하려 할때 유용하다.

1. 상속에서는 슈퍼클래스가 허용하고 있는 조작을 서브클래스에서 모두 허용해야 하지만, composition과 delegation에서는 조작을
   제한할 수 있다.
2. 클래스는 결코 변경할 수 없지만, composition하고 있는 객체는 자유롭게 변경할 수 있다. 예를 들면 학생 클래스가 영원이 학생이
   아니라 나중에 취직을 하여 직장인 클래스가 될수 있다.

상속을 composition과 delegation으로 변경하는 요령은? 여기서
Shape를 상속한 Polyline과 Circle을 변경한다면 다음과 같다.

1. Shape(부모)의 공통된 내용을 구현한 구현 클래스(ShapeImpl)를 만든다.
2. Polyline과 Circle 클래스에서 ShapeImpl을 composition하고 부모와 공통되지 않는 method를 각각 위임
   받는다.
3. ShapeImpl 클래스의 method를 추출한 ShapeIF interface를 작성하고 Polyline과 Circle에서는
   implements 한다.

1. 그 class자신
2. 단일형식으로 임포트된 class
3. 동일한 패키지에 존재하는 다른 class
4. 온디멘드 형식(..* 형태) 임포트 선언된 class

1. Multi Thread에서는 Thread라는 처리 흐름이 2개 이상 존재할 수 있다.
2. 어떤 Thread에서 움직이기 시작한 method가 다른 method를 호출 했을때 호출된 측의 method는 호출한 측의 method와
   동일한 Thread에서 동작한다.
3. Thread의 경계와 객체의 경계는 전혀 관계가 없다. 즉, Thread와 객체는 직교하고 있다.

        synchronized void method1(){
            ...
        }
        void method2(){
            synchronized(this){
                ...
            }
        }

1. Runnable을 implements하고 Thread의 참조를 보유(composition) 하는 방법. 이경우는 단지 Runnable만
   implement함으로서 해결되는 경우가 대부분이긴 하지만, 그 class 내에서 해당 class의 Thread를 조작하게 된다면
   composition한 Thread 객체에 delegation하면 된기 때문이다.
2. Thread class를 상속하는 방법. JDK의 소스를 보면 Thread class에는 Runnable을 implements 하고
   있다. 그리고 run method는 native method이다. 따라서 Thread를 상속한 모든 클래스는 사실 Runnable을
   implements하고 있는 것이다. run method는 abstract가 아니므로 구현되어 있고 우리는 이를 오버라이드하여 사용하고 있다.
   이 방식을 사용하면 Thread의 method를 안팍으로 자유롭게 호출할 수 이지만, 이미 다른 class를 상속하고 있다면 이 방식을 사용할
   수는 없다.

JDK API Reference의 Runnable에 과한 설명중에 다음과 같은
내용이 있다.

        try{
            ...
            System.exit(1);
        }catch(...){
        }finally{
            ... //이 부분은 실행되지 않는다.
        }

private void writeObject(java.io.ObjectOutputStream out) throws IOException;
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException;

        private synchronized void writeObject(java.io.ObjectOutputStream s) throws IOException {
            s.defaultWrtieObject(); //이 코드는 무조건 들어가게 되는데 이곳 소스의 System.arraycopy()에서 overflow발생한다.
            s.writeInt(size);   //이부분이 실제 추가되어 Stack Overflow를 예방한다.
            for(Entry e = ...)
                s.writeObject(e.element);
            }
            ...
        }
        //readObject()도 이와 같은 개념으로 변경되어 있다.

        class Test{
            class InnerClass {
                int i;
                ...
            }
            public static void main(String[] args){
                InnerClass icls = new InnerClass();
                ...
            }
        }

        public class OuterClass {
            public int get(){
                int i = 9;
                int id = 99;
                int id2 = 99;
                final int id3 = 100000;
                class LocalInnerClass {
                    int id = 100;
                    LocalInnerClass(){
                        System.out.println("LocalInnerClass");   
                    }
                    int getId(){
                        return id3 + id;
                    }
                }   
                LocalInnerClass lic = new LocalInnerClass();
                return id + lic.getId();
            }   
            public static void main(String[] args){
                OuterClass outer = new OuterClass();
                System.out.println("id = " + outer.get());  
                //결과 값은 "100000(id3) + 100(LocalInnerClass.id) + 99(OuterClass.get())" 인 100199가 나온다.
            }
        }

        class AnonymousTest {
            private interface Printable {
                void print();
            }
            static void doPrint(Printable p){
                p.print();
            }
            public static void main(String[] args){
                doPrint( new Printable(){
                            public void print(){
                                System.out.println("this is new Printable print()");
                            }
                         });
            }
        }

        //IFS.java
        interface IFS {
            public String getName();
        }
        //Impl1.java
        class Impl1 implements IFS {
            public String getName(){
                return "Impl1";
            }
        }
        //Impl2.java
        class Impl2 implements IFS {
            public String getName(){
                return "Impl2";
            }
        }   
        //main이 있는 OverloadTest.java
        public class OverloadTest {
            static void pr(int i){
                System.out.println("pr_int : " + i);   
            }
            static void pr(String s){
                System.out.println("pr_string : " + s);   
            }
            static void pr(IFS ifs){
                System.out.println("pr_string : " + ifs.getName());
            }
            static void pr_run(Impl1 i1){
                System.out.println("pr_run : " + i1.getName());
            }
            static void pr_run(Impl2 i2){
                System.out.println("pr_run : " + i2.getName());
            }
            public static void main(String[] args){
                OverloadTest test = new OverloadTest();
                test.pr(10);
                test.pr("Jeid");   
                IFS ifs1 = new Impl1();
                test.pr(ifs1);
                IFS ifs2 = new Impl2();
                test.pr(ifs2);
                //pr_run(ifs1);
                //pr_run(ifs2);
            }
        }

        OverloadTest.java:36: cannot resolve symbol
        symbol  : method pr_run (IFS)
        location: class OverloadTest
                pr_run(ifs1);
                ^
        OverloadTest.java:37: cannot resolve symbol
        symbol  : method pr_run (IFS)
        location: class OverloadTest
                pr_run(ifs2);
                ^
        2 errors

        class OverloadTest2 {
            static int base(double a, double b){ ... }  //method A
            static int count(int a, int b){ ... }  //method B
            static int count(double a, double b){ ... }  //method C
            static int sum(int a, double b){ ... }  //method D
            static int sum(double a, int b){ ... }  //method E
        }

• base(3,4) 를 호출했을때 수행되는 method는? => 당연히 method A (3과 4는 정수라도 double이 되므로
  정상적으로 수행됨)
• count(3,4) 를 호출했을때 수행되는 method는? => B와 C중 갈등이 생긴다. 이럴경우 JVM은 가장 한정적(more
  specific)한 method를 찾는다. 여기서 3과 4는 정수형에 가까우므로 method B 가 호출된다.
• count(3, 4.0) 을 호출했을때 수행되는 method는? => 이것은 4.0 이 double이므로 method C 가 더
  한정적이므로 method C 가 호출된다.

• sum(3,4.0) 을 호출했을때 수행되는 method는? => 이것은 당연히 type이 일치하는 method D.
• sum(3,4) 를 호출했을때 수행되는 method는?? => 이런 코드가 소스내에 있으면 다음과 같은 compile 오류를
  표출한다.

             OverloadTest.java:48: reference to sum is ambiguous, both method sum(int,double)
               in OverloadTest and method sum(double,int) in OverloadTest match
                    System.out.println("sum(3,4) = " + sum(3,4));
                                                       ^
             1 error

1. instance field
2. instance method
3. static field
4. static method

여기서 상속을 하였을 경우 runtime시 객체의 형식에 따라 선택되는 것은? 2번
instance method 뿐이다. 즉, 동명의 member를 sub class에서 선언했을 때 instance method만 override
되고 나머지는 완전 별개의 member가 된다. 따라서 위의 1,3,4는 sub class에서 동일하게 선언했을 경우 별개의 것으로 인식되며
compile시에 무엇을 access 할지 결정된다.

        public class Member {
            private int memberNo;
            public int getMemberNo(){
                return this.memberNo;
            }
            public void setMemberNo(int menberNo){
                this.memberNo = memberNo;
            }
            ......
        }

        ClassA a = new ClassA(); 
        int i = a.AA;       //instance를 경유하여 접근
        int j = ClassA.AA;  //올바르게 접근

        public class ConstructorTest{
            void ConstructorTest(){
                System.out.println("Constuctor");
            }
            .....
        }

        ....
        if( a < 5 )
            b = 3;
            c = 10;   //이부분은 나중에 추가된 라인이다.
        if( isStudent )
            if( isFemale )
                sayHello("Hi~~");
        else
            sayHello("Hello Professor~");

        public static final int LEFT = 0;
        public static final int CENTER = 1;
        public static final int RIGHT = 2;
        ...
        label.setAlignment(Label.CENTER);
        ...

        //LabelAlignment.java
        public class LabelAlignment {
            private LabelAlignment() {} //이는 생성자를 private으로 하여 다른데서는 만들지 못하도록 하기위함이다.
            public static final LabelAlignment LEFT = new LabelAlignment():
            public static final LabelAlignment CENTER = new LabelAlignment():
            public static final LabelAlignment RIGHT = new LabelAlignment():
        }
        //변형된 Label.java 의 일부..
        public synchronized void setAlignment(LabelAlignment alignment){
            if( alignment == LabelAlignment.LEFT ){
                ...//왼쪽으로 맞추기..
            }else if( ...
                ...
            }
        }
        ...

        //LabelAlignment.java
        public class LabelAlignment {
            private int flag;
            private LabelAlignment(int flag){
                this.flag = flag;
            } 
            public static final LabelAlignment LEFT = new LabelAlignment(0):
            public static final LabelAlignment CENTER = new LabelAlignment(1):
            public static final LabelAlignment RIGHT = new LabelAlignment(2):
            public boolean equals(Object obj){
                return ((LabelAlignment)obj).flag == this.flag;
            }
        }
        //변형된 Label.java 의 일부..
        public synchronized void setAlignment(LabelAlignment alignment){
            if( LabelAlignment.LEFT.equals(alignment) ){
                ...//왼쪽으로 맞추기..
            }else if( ...
                ...
            }
        }
        ...

        #ifdef DEBUG
            fprintf(stderr, "error...%d\n", error);
        #endif /* DEBUG */

        if( Debug.isDebug ){
            System.out.println("error..." + error);
        }

        // 1. GetCallerSecurityManager.java
        public final class GetCallerSecurityManager extends SecurityManager {
            public Class[] getStackTrace(){
                return this.getClassContext();   
            }
        }
        // 2. GetCallerClass.java
        public final class GetCallerClass {
            private static GetCallerSecurityManager mgr;
            static{
                mgr = new GetCallerSecurityManager();
                System.setSecurityManager(mgr);
            }
            public static void writeCaller(String str){
                Class[] stk = mgr.getStackTrace();
                int size = stk.length;
                for(int i = 0; i < size; i++){
                    System.out.println("stk[" + i + "] = " + stk[i]);   
                }   
                String className = stk[2].getName();
                System.out.println("className is " + className + " : " + str);
            }
        }
        // 3. GetCallerClassMain1 : 호출하는 클래스 예제 1
        public class GetCallerClassMain1 {
            public static void main(String[] args){
                GetCallerClass.writeCaller(", real is 1.");
            }
        }
        // 4. GetCallerClassMain1 : 호출하는 클래스 예제 2
        public class GetCallerClassMain2 {
            public static void main(String[] args){
                GetCallerClass.writeCaller(", real is 2.");
            }
        }

    className is GetCallerClassMain1 : , real is 1.
    className is GetCallerClassMain2 : , real is 2.

package com.jeid.tiger;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class ArraysTester {
	private int[] arr;
	private String[] strs;
	public ArraysTester(int size) {
		arr = new int[size];
		strs = new String[size];
		for (int i = 0; i < size; i++) {
			if (i < 10) {
				arr[i] = 100 + i;
			} else if (i < 20) {
				arr[i] = 1000 - i;
			} else {
				arr[i] = i;
			}
			strs[i] = "str" + arr[i];
		}
	}
	public int[] getArr() {
		return this.arr;
	}
	public String[] getStrs() {
		return this.strs;
	}
	public static void main(String[] args) {
		int size = 50;
		ArraysTester tester = new ArraysTester(size);
		int[] testerArr = tester.getArr();
		int[] cloneArr = tester.getArr().clone();
		String[] testerStrs = tester.getStrs();
		String[] cloneStrs = tester.getStrs().clone();
		// clone test
		if (Arrays.equals(cloneArr, testerArr)) {
			System.out.println("clonse int array is same.");
		} else {
			System.out.println("clonse int array is NOT same.");
		}
		if (Arrays.equals(cloneStrs, testerStrs)) {
			System.out.println("clonse String array is same.");
		} else {
			System.out.println("clonse String array is NOT same.");
		}
		// 2부터 10까지 값 셋팅
		Arrays.fill(cloneArr, 2, 10, new Double(Math.PI).intValue());
		testerArr[10] = 98;
		testerStrs[10] = "corea";
		testerStrs[11] = null;
		List<String> listTest = Arrays.asList(testerStrs);
		System.out.println("listTest[10] = " + listTest.get(10));
		System.out.println("------- unsorted arr -------");
		System.out.println("Arrays.toString(int[]) = " + Arrays.toString(testerArr));
		System.out.println("Arrays.toString(String[]) = " + Arrays.toString(testerStrs));
		Arrays.sort(testerArr);
		// Arrays.sort(testerStrs); //NullPointerException in sort method..(null이 없더라도 길이에 대한 크기 체크는 못함)
		Arrays.sort(testerStrs, new Comparator<String>() {
			public int compare(String s1, String s2) {
				if (s1 == null && s2 == null) {
					return 0;
				} else if (s1 == null && s2 != null) {
					return -1;
				} else if (s1 != null && s2 == null) {
					return 1;
				} else if (s1.length() < s2.length()) {
					return -1;
				} else if (s1.length() > s2.length()) {
					return 1;
				} else if (s1.length() == s2.length()) {
					return 0;
				} else {
					return s1.compareTo(s2);
				}
			}
		});
		System.out.println("------- sorted arr -------");
		System.out.println("Arrays.toString(int[]) = " + Arrays.toString(testerArr));
		System.out.println("Arrays.toString(String[]) = " + Arrays.toString(testerStrs));
		System.out.println("------------------------------------------------");
		String[][] mstrs1 = { { "A", "B" }, { "C", "D" } };
		String[][] mstrs2 = { { "a", "b" }, { "c", "d" } };
		String[][] mstrs3 = { { "A", "B" }, { "C", "D" } };
		System.out.println("Arrays.deepToString(mstrs1) = " + Arrays.deepToString(mstrs1));
		System.out.println("Arrays.deepToString(mstrs2) = " + Arrays.deepToString(mstrs2));
		System.out.println("Arrays.deepToString(mstrs3) = " + Arrays.deepToString(mstrs3));
		if( Arrays.deepEquals(mstrs1, mstrs2)) {
			System.out.println("mstrs1 is same the mstrs2.");
		}else {
			System.out.println("mstrs1 is NOT same the mstrs2.");
		}
		if( Arrays.deepEquals(mstrs1, mstrs3)) {
			System.out.println("mstrs1 is same the mstrs3.");
		}else {
			System.out.println("mstrs1 is NOT same the mstrs3.");
		}
		System.out.println("mstrs1's hashCode = " + Arrays.deepHashCode(mstrs1));
		System.out.println("mstrs2's hashCode = " + Arrays.deepHashCode(mstrs2));
		System.out.println("mstrs3's hashCode = " + Arrays.deepHashCode(mstrs3));
	}
}

package com.jeid.tiger;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
public class QueueTester {
	public static void main(String[] args) {
		System.out.println("---------- testFIFO ----------");
		testFIFO();
		System.out.println("---------- testOrdering ----------");
		testOrdering();
	}
	private static void testFIFO() {
		Queue<String> q = new LinkedList<String>();
		q.add("First");
		q.add("Second");
		q.add("Third");
		String str;
		while ((str = q.poll()) != null) {
			System.out.println(str);
		}
	}
	private static void testOrdering() {
		int size = 10;
		Queue<Integer> qi = new PriorityQueue<Integer>(size);
		Queue<String> qs = new PriorityQueue<String>(size);
		for (int i = 0; i < size; i++) {
			qi.offer(10 - i);
			qs.offer("str" + (10 - i));
		}
		for (int i = 0; i < size; i++) {
			System.out.println("qi[" + i + "] = " + qi.poll() + ", qs[" + i + "] = " + qs.poll());
		}
	}
}

package com.jeid.tiger;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class StringBuilderTester {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("str1");
		list.add("str2");
		list.add("str3");
		String ret = appendItems(list);
		System.out.println("ret = " + ret);
	}
	private static String appendItems(List<String> list) {
		StringBuilder sb = new StringBuilder();
		for (Iterator<String> iter = list.iterator(); iter.hasNext();) {
			sb.append(iter.next()).append(" ");
		}
		return sb.toString();
	}
}

package com.jeid.tiger;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class ListTester {
	public static void main(String[] args) {
		List<String> list = new LinkedList<String>();
		list.add("str1");
		list.add("str2");
		list.add(new Integer(123));  // <-- String이 아니므로 compile error!!
		//Iterator에 String type을 명시하므로 정삭작동됨.
		for (Iterator<String> iter = list.iterator(); iter.hasNext();) {
			String str = iter.next();
			System.out.println("srt = " + str);
		}
		//Iterator에 String type을 명시하지 않았으므로 아래 A 부분에서 compile 오류 발생!!
		for (Iterator iter = list.iterator(); iter.hasNext();) {
			String str = iter.next(); //A
			System.out.println("srt = " + str);
		}
		//byte, short, int, long, double, float 동시 사용
		List<Number> lstNum = new LinkedList<Number>();
		lstNum.add(1);
		lstNum.add(1.2);
		for (Iterator<Number> iter = lstNum.iterator(); iter.hasNext();) {
			Number num = iter.next();
			System.out.println("num = " + num);
		}
	}
}

class AnyTypeList<T> {
//class AnyTypeList<T extends Number> {  // <-- 이는 Number를 상속한 type은 허용하겠다는 의미.
	private List<T> list;
	//private static List<T> list;  // <-- 이는 정적이므로 compile error 발생!!! 
	public AnyTypeList(){
		list = new LinkedList<T>();
	}
	public boolean isEmpty(){
		return list == null || list.size() == 0;
	}
	public void add(T t){
		list.add(t);
	}
	public T grap(){
		if (!isEmpty() ) {
			return list.get(0);
		} else {
			return null;
		}
	}
}

package com.jeid.tiger;
import com.jeid.BaseObject;
import com.jeid.MyLevel;
public class EnumTester extends BaseObject {
	private static long start = System.currentTimeMillis();
	public static void main(String[] args) {
		try {
			test();
			enum1();
		} catch (Exception e) {
			e.printStackTrace();
		}
		printEllapseTime();
	}
	private static void test() throws Exception {
		byte[] b = new byte[0];
		System.out.println(b.length);
	}
	private static void enum1() {
		//enum TestEnum { A, B };  //enum cannot be local!!!
		for(MyVO.TestEnum te: MyVO.TestEnum.values()){
			System.out.println("Allow TestEnum value : " + te);
		}
		System.out.println("---------------------------------------");
		MyVO vo = new MyVO();
		vo.setName("enum1");
		vo.setLevel(MyLevel.A);
		System.out.println(vo);
		System.out.println("isA = " + vo.isA() + ", isGradeA = " + vo.isLevelA()+ ", isValueOfA = " + vo.isValueOfA());
		System.out.println("getLevelInKorean = " + vo.getLevelInKorean());
	}
	private static void printEllapseTime() {
		System.out.println("==> ellapseTime is " + (System.currentTimeMillis() - start) + " ms.");
	}
}
package com.jeid.tiger;
import com.jeid.BaseObject;
import com.jeid.MyLevel;
public class MyVO extends BaseObject {
	enum TestEnum {
		A, B
	}; // this is same public static final
	private int id;
	private String name;
	private MyLevel grade;
	// private List<T> list;
	public MyLevel getLevel() {
		return grade;
	}
	public void setLevel(MyLevel grade) {
		this.grade = grade;
	}
	public boolean isA() {
		return "A".equals(this.grade);
	}
	public boolean isValueOfA() {
		return MyLevel.valueOf("A").equals(grade);
	}
	public boolean isLevelA() {
		return MyLevel.A.equals(this.grade);
	}
	//A,B,C..대신 0,1,2... 도 동일함.
	public String getLevelInKorean() {
		switch(this.grade){
		case A:
			return "수";
		case B:
			return "우";
		case C:
			return "미";
		case D:
			return "양";
		case E:
			return "가";
		default:
			return "없음";
		}
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

package com.jeid.tiger;
import java.util.EnumMap;
public class EnumMapTester {
	private enum MyEnum {
		A, B, C
	}; // this is same the static final..
	public static void main(String[] args) {
		MyEnum[] enums = MyEnum.values();
		System.out.println("MyEnum is " + enums[0] + ", " + enums[1] + ", " + enums[2]);
		EnumMap<MyEnum, String> em = new EnumMap<MyEnum, String>(MyEnum.class);
		em.put(MyEnum.A, "수");
		em.put(MyEnum.B, "우");
		em.put(MyEnum.C, "미");
		em.put(MyEnum.B, "가"); //key 중복은 HashMap과 동일하게 overwrite임.
		for (MyEnum myEnum : MyEnum.values()) {
			System.out.println(myEnum + " => " + em.get(myEnum));
		}
	}
}

package com.jeid.tiger;
import java.util.EnumSet;
public class EnumSetTester {
	private enum MyEnum {
		A, B, C, a, b, c
	}; // this is same the static final..
	public static void main(String[] args) {
		MyEnum[] enums = MyEnum.values();
		System.out.println("MyEnum is " + enums[0] + ", " + enums[1] + ", " + enums[2]);
		EnumSet<MyEnum> es1 = EnumSet.of(MyEnum.A, MyEnum.B, MyEnum.C);
		EnumSet<MyEnum> es2 = EnumSet.of(MyEnum.a, MyEnum.b, MyEnum.c);
		EnumSet<MyEnum> es3 = EnumSet.range(MyEnum.a, MyEnum.c);
		if (es2.equals(es3)) {
			System.out.println("e2 is same e3.");
		}
		for (MyEnum myEnum : MyEnum.values()) {
			System.out.println(myEnum + " contains => " + es1.contains(myEnum));
		}
	}
}

package com.jeid.tiger;
public class AutoBoxingTester {
	public static void main(String[] args) {
		int i = 0;
		Integer ii = i; // boxing. JDK 1.4에서는 incompatible type error가 발생 했었으나 Tiger에서는 괜찮다.
		int j = ii; // unboxing
		for (ii = 0; ii < 5; ii++) { // Integer인데도 ++ 연산자 지원.
		}
		i = 129;
		ii = 129;
		if (ii == i) {
			System.out.println("i is same ii.");
		}
		// -128 ~ 127 사이의 수는 unboxing이 되어 == 연산이 허용되지만,
		// 그 범위 외의 경우 Integer로 boxing된 상태므로 equals를 이용해야함.
		// 이는 버그가 발생했을 경우 찾기 쉽지 않은 단점도 내포하고 있다.!!
		checkIntegerSame(127, 127); // same
		checkIntegerSame(128, 128); // Not same
		checkIntegerEquals(128, 128); // equals
		checkIntegerSame(-128, -128); // same
		checkIntegerSame(-129, -129); // Not same
		checkIntegerEquals(-129, -129); // equals
		System.out.println("--------------------------------------------");
		Boolean arriving = false;
		Boolean late = true;
		String ret = arriving ? (late ? "도착했지만 늦었네요." : "제시간에 잘 도착했군요.") : 
								(late ? "도착도 못하고 늦었군요." : "도착은 못했지만 늦진 않았군요.");
		System.out.println(ret);
		StringBuilder sb = new StringBuilder();
		sb.append("appended String");
		String str = "just String";
		boolean mutable = true;
		CharSequence chSeq = mutable ? sb : str;
		System.out.println(chSeq);
	}
	private static void checkIntegerSame(Integer ii, Integer jj) {
		if (ii == jj) {
			System.out.println("ii = " + ii + ", jj = " + jj + " ==> jj is same ii.");
		} else {
			System.out.println("ii = " + ii + ", jj = " + jj + " ==> jj is NOT same ii!!");
		}
	}
	private static void checkIntegerEquals(Integer ii, Integer jj) {
		if (ii.equals(jj)) {
			System.out.println("ii = " + ii + ", jj = " + jj + " ==> jj is equals ii.");
		} else {
			System.out.println("ii = " + ii + ", jj = " + jj + " ==> jj is NOT equals ii!!");
		}
	}
}

package com.jeid.tiger;
public class OverloadTester {
	public static void main(String[] args) {
		double d = 10;
		Integer ii = new Integer(10);
		doSomething(10);
		doSomething(1000);
		doSomething(ii);
		doSomething(d);
	}
	private static void doSomething(Integer ii) {
		System.out.println("This is doSomething(Integer)");
	}
	private static void doSomething(double d) {
		System.out.println("This is doSomething(double)");
	}
}

package com.jeid.tiger;
public class VarArgsTester {
	public static void main(String[] args) {
		setNumbers(1, 2);
		setNumbers(1, 2, 3, 4);
		setNumbers(1);
		// setNumbers(); //해당 되는 method가 없어 compile error!!
		System.out.println("==============================================");
		setNumbers2(1, 2, 3, 4);
		setNumbers2(1);
		setNumbers2();
	}
	// this is same setNumbers(int first, int[] others)
	private static void setNumbers(int first, int... others) {
		System.out.println("-----------setNumbers()----------- : " + first);
		for (int i : others) {
			System.out.println("i = " + i);
		}
	}
	// this is same setNumbers(int[] others)
	private static void setNumbers2(int... others) {
		System.out.println("-----------setNumbers2()----------- : "
				+ (others != null && others.length > 0 ? others[0] : "null"));
		for (int i : others) {
			System.out.println("i = " + i);
		}
	}
}

    //정상적인 사용
    @Override
    public int hashCode(){
        return toString().hashCode();
    }
    //스펠링이 틀려 compile error!!
    @Override
    public int hasCode(){   //misspelled => method does not override a method from its superclass error!!
        return toString().hashCode();
    }

package com.jeid.tiger;
public class AnnotationDeprecateTester {
	public static void main(String[] args){
		DeprecatedClass dep = new DeprecatedTester();
		dep.doSomething(10);    //deprecated
	}
}
class DeprecatedClass {
	@Deprecated
	public void doSomething(int ii){    //deprecated
		System.out.println("This is DeprecatedClass's doSomething(int)");
	}
	public void doSomethingElse(int ii){
		System.out.println("This is DeprecatedClass's doSomethingElse(int)");
	}
}
class DeprecatedTester extends DeprecatedClass {
	@Override
	public void doSomething(int ii){
		System.out.println("This is DeprecatedTester's doSomething(int)");
	}
}

package com.jeid.tiger;
import java.util.ArrayList;
import java.util.List;
public class AnnotationSuppressWarningsTester {
	@SuppressWarnings({"unchecked", "fallthrough"} )
	private static void test1(){
		List list = new ArrayList();
		list.add("aaaaaa");
	}
	@SuppressWarnings("unchecked")
	private static void test2(){
		List list = new ArrayList();
		list.add("aaaaaa");
	}
	//warning이 없는 소스.
	private static void test3(){
		List<String> list = new ArrayList<String>();
		list.add("aaaaaa");
	}
}

package com.jeid.tiger;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Documented
@Target( { ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
	String columnName();
	String methodName() default "";
}
//사용하는 쪽..
public class AnnotationTester {
	@MyAnnotation(columnName = "test", methodName = "setTest")
	private String test;
	@MyAnnotation(columnName = "grpid")
	public String grpid;
    ....
}
//위의 test 멤버의 경우 다음과 같이 접근 가능하다.
Field testField = cls.getDeclaredField("test");
if (testField.isAnnotationPresent(MyAnnotation.class)) {
    Annotatioin anno = testField.getAnnotation(MyAnnotation.class);
    System.out.println(anno.columnName() + ", method = " + anno.methodName());
}

//1. 가장 단순한 형태인 배열(array)
String[] strs = { "aaa", "bbb", "ccc" };
for (String str : strs) {
    System.out.println(str);
}
//2. List by using Iterator
List<Number> lstNum = new LinkedList<Number>();
lstNum.add(1);
lstNum.add(1.2);
for (Iterator<Number> iter = lstNum.iterator(); iter.hasNext();) {
	Number num = iter.next();
	System.out.println("num = " + num);
}
//3. List를 바로 사용
List<String> lst = new LinkedList<String>();
lst.add("aaaaa");
lst.add("bbbbb");
lst.add("ccccc");
lst.add("ddddd");
for (String str : lst) {
	System.out.println("str = " + str);
}
// 4. List of List
List[] lists = { lst, lst };
for (List<String> l : lists) {
	for (String str : l) {
		System.out.println("str = " + str);
	}
}

//예를 들어 System.out.println() 이라는 것을 사용하기 위해서는 다음의 import 문이 필요하다.
import java.lang.System;   //물론 java.lang 이기에 import 문이 필요없지만 예를 들자면 그렇다는 것이다.&^^
//허나, Tiger에서는 다음과 같이 사용할수 있다.
import static java.lang.System.out;
...
out.println(...);
// method를 import 한다면..
import static java.lang.System.out.println;
...
println(...);

• http://java.sun.com/j2se/1.4.2/docs/index.html
• http://java.sun.com/j2se/1.5.0/docs/index.html
• SUN의 JLS
• http://java.sun.com/docs/books/jls/html/index.html
• Java 핵심원리 – 마에바시 가즈야 저 – 영진닷컴
• Java 1.5 Tiger – Brett McLaughlin 저 – O’Reilly