Endless Endeavor

• 오해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 할 경우

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는 기술하지 않는다.

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

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를 상속하고 있다면 이 방식을 사용할 수는 없다.
    

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
    

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(...);