import java.util.*;

// 모든 Set 컬렉션은
// 중복 회피를 위해 equals()를 재정의 해야함
class SetType {
        int i;
        public SetType(int n) {
                i = n;
        }
        public boolean equals(Object o) {
                return o instanceof SetType && (i == ((SetType)o).i);
        }
        public String toString() {
                return Integer.toString(i);
        }
}

// HashSet 계열은 equals() 외에 hasCode()를 재정의 해야함
// 그렇지 않을 경우 equals()를 정의했어도, 데이터 중복이 발생
class HashType extends SetType {
        public HashType(int n) {
                super(n);
        }
        public int hashCode() {
                return i;
        }
}

// TreeSet 계열은 equals() 외에 compareTo()를 재정의 해야함
// compareTo()를 재정의 하지않으면 실행시 ClassCastException 발생
class TreeType extends SetType implements Comparable<treetype>
 {
        public TreeType(int n) {
                super(n);
        }
        public int compareTo(TreeType arg) {
                return (i > arg.i ? 1 : (i == arg.i) ? 0 : -1);
        }
}


public class TypesForSets {
        
        static <t> Set<t> fill(Set<t> set, Class<t> type) {
                try {
                        for (int i = 0; i < 10; i++) {
                                // int형 인자를 갖는 생성자를 얻어서, 객체 생성
                                set.add(type.getConstructor(int.class).newInstance(i));
                        }
                } catch(Exception e) {
                        throw new RuntimeException(e);
                }
                return set;
        }
        
        static <t> void test(Set<t> set, Class<t> type) {
                // 객체 중복저장 시도 - 셋의 특성을 알아보기 위함
                fill(set, type);
                fill(set, type);
                fill(set, type);
                System.out.println(set);
        }
        
        public static void main(String[] args) {
                // HashSet 계열은 equals() 와 hashCode()를 재정의 해야함
                test(new HashSet(), HashType.class);
                test(new LinkedHashSet(), HashType.class);
                // TreeSet 계열은 equals() 와 compareTo()를 재정의 해야함
                test(new TreeSet(), TreeType.class);
                
                // 아래메소드들은 각 Set 컬렉션의 특성이 파괴됨
                test(new HashSet(), SetType.class);
                test(new HashSet(), TreeType.class);
                test(new LinkedHashSet(), SetType.class);
                test(new LinkedHashSet(), TreeType.class);
                
                try {
                        test(new TreeSet(), SetType.class);
                } catch (Exception e) {
                        System.out.println(e.getMessage());
                }
                try {
                        test(new TreeSet(), HashType.class);
                } catch (Exception e) {
                        System.out.println(e.getMessage());
                }
        }
}

package com.tistory.hiddenviewer.reflection.executor;

import java.lang.reflect.Method;
import com.tistory.hiddenviewer.reflection.Board;

public class GetterSetterPrinter {

	public static void main(String[] args) {
		printGettersSetters(Board.class);
	}

	public static void printGettersSetters(Class aClass){
		Method[] methods = aClass.getMethods();

		for(Method method : methods){

			if(isGetter(method)) {
				System.out.println("getter: " + method);
			} 

			if(isSetter(method)) {
				System.out.println("setter: " + method);
			}
		} // for
	}
	

	public static boolean isGetter(Method method){
		// get 으로 시작하지 않으면 반환
		if(!method.getName().startsWith("get")) {
			return false;
		}
		// 파라미터가 있으면 반환 
		if(method.getParameterTypes().length != 0) {
			return false;  
		}
		// 반환값이 없으면 반환
		if(void.class.equals(method.getReturnType())) {
			return false;
		}
		return true;
	}
	public static boolean isSetter(Method method){
		// set 으로 시작하지 않으면 반환 
		if(!method.getName().startsWith("set")) {
			return false;
		}
		// 파라미터가 개수가 1이 아니면 반환 
		if(method.getParameterTypes().length != 1) {
			return false;
		}
		return true;
	}
}

// 생성자 목록 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Constructor[] constructors = aClass.getConstructors();

// 특정 파라미터를 갖는 생성자 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Constructor constructor =
        aClass.getConstructor(new Class[]{String.class});

// 생성자의 파라미터 타입목록 얻기
Class aClass = ... // 이전에 얻은 클래스 객체
Class[] parameterTypes = constructor.getParameterTypes();

// 하나의 String 파라미터를 갖는 생성자를 얻는다. 
Constructor constructor = MyObject.class.getConstructor(String.class);
// 생성 
MyObject myObject = (MyObject)constructor.newInstance("constructor-arg1");

// 클래스에 선언된 public 속성의 Field 객체얻기
Class aClass = ... // 이전에 얻은 클래스 객체
Field[] fields = aClass.getFields();

public class MyObject{
  public String someField = null;
}

// Field 이름 얻기
Field field = ... // Field 객체를 얻는다. 
String fieldName = field.getName();

// Field 타입 얻기 
Field field = aClass.getField("someField");
Object fieldType = field.getType();

// Field 값 설정하고 조회하기
Class  aClass = MyObject.class
Field field = aClass.getField("someField");
MyObject objectInstance = new MyObject();
Object value = field.get(objectInstance);
field.set(objetInstance, value);

Board board = new Board();
board.setContents("test contents...");
		
Field field = cls.getDeclaredField("contents");
field.setAccessible(true);
String contents = (String) field.get(board);
		
System.out.println("Private Contents Field: " + contents);

// Method 객체목록 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Method[] methods = aClass.getMethods();

// 파라미터를 갖는 메소드의 Method 객체 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Method method = aClass.getMethod("doSomething", new Class[]{String.class});

// 파라미터가 없는 메서드의 Method 객체 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Method method = aClass.getMethod("doSomething", null);

// 메서드의 파라미터 타입목록 얻기 
Method method = ... //
Class[] parameterTypes = method.getParameterTypes();

// 메서드의 반환값 타입 얻기 
Method method = ... //
Class returnType = method.getReturnType();

// 메서드 호출 
Method method = MyObject.class.getMethod("doSomething", String.class);
Object returnValue = method.invoke(null, "parameter-value1");

ClassName
Class Modifiers (public, private, synchronized 등)
Package Info
Superclass
Implemented Interfaces
Constructors
Methods
Fields
Annotations

 Class myObjectClass = MyObject.class

String className =  ... // 클래스 풀네임 
Class myObjectClass = Class.forName(className); 

// 클래스 풀네임 
Class aClass = ... // 이전에 얻은 클래스 객체 
String className = aClass.getName();

// 클래스 심플 네임 
Class  aClass = ... // 이전에 얻은 클래스 객체
String simpleClassName = aClass.getSimpleName();

// 변경자 얻기 
Class  aClass = ... // 이전에 얻은 클래스 객체
int modifiers = aClass.getModifiers();

 

// 변경자 플래그 확인 메소드들
 Modifier.isAbstract(int modifiers)
 Modifier.isFinal(int modifiers)
 Modifier.isInterface(int modifiers)
 Modifier.isNative(int modifiers)
 Modifier.isPrivate(int modifiers)
 Modifier.isProtected(int modifiers)
 Modifier.isPublic(int modifiers)
 Modifier.isStatic(int modifiers)
 Modifier.isStrict(int modifiers)
 Modifier.isSynchronized(int modifiers)
 Modifier.isTransient(int modifiers)
 Modifier.isVolatile(int modifiers)

// 패키지 정보 얻기
Class  aClass = ... // 이전에 얻은 클래스 객체
Package package = aClass.getPackage();

// 수퍼 클래스의 class 객체 얻기 
Class superclass = aClass.getSuperclass();

// 구현한 인터페이스 목록 얻기 
Class  aClass = ... // 이전에 얻은 클래스 객체
Class[] interfaces = aClass.getInterfaces();

// 클래스 생성자 목록 얻기 
Constructor[] constructors = aClass.getConstructors();

// 메소드 목록 얻기 
Method[] methods = aClass.getMethods();

// 필드 목록 얻기 
 Field[] fields = aClass.getFields();

// 어노테이션 목록 얻기
Annotation[] annotations = aClass.getAnnotations();

package com.tistory.hiddenviewer.reflection;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class Board implements ActionListener{

	public final static String boardName = "MyBoard"; 
	public ArrayList boardList;
	
	public int seq;
	protected String title;
	private String contents;
	
	public Board() {
		this(10);
	}
	
	public Board(int count) {
		this.boardList = new ArrayList(count);
	}
	
	
	public int getSeq() {
		return seq;
	}

	public void setSeq(int seq) {
		this.seq = seq;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getContents() {
		return contents;
	}

	public void setContents(String contents) {
		this.contents = contents;
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		
	}

}

package com.tistory.hiddenviewer.reflection.executor;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class BoardReflectionExecutor {


	public static void main(String[] args) throws IOException, ClassNotFoundException {
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		System.out.print("생성할 클래스 이름을 입력하세요(패키지 포함): ");
		String className = br.readLine();
		
		Class cls = Class.forName(className);
		
		// 클래스 이름얻기 
		String classFullName = cls.getName();
		String classSimpleName = cls.getSimpleName();
		
		System.out.println("class full name: " + classFullName);
		System.out.println("class simple name: " + classSimpleName);
		
		// 변경자 얻기 
		int modifiers = cls.getModifiers();
		
		if (Modifier.isPublic(modifiers)) {
			System.out.println("class is public class");
		} 
		if (Modifier.isFinal(modifiers)) {
			System.out.println("class is final class");
		}

		// 패키지 얻기 
		Package pkg = cls.getPackage();
		System.out.println("package name: " + pkg.getName());
		
		
		// 수퍼클래스 얻기 
		Class superCls = cls.getSuperclass();
		System.out.println("super class name :" + superCls.getName());
		
		
		// 구현 인터페이스 목록 얻기 
		Class[] interfaces = cls.getInterfaces();
		for (Class cs : interfaces) {
			System.out.println("this class implements " + cs.getName() + " interface");
		}
		
		// 생성자 목록 얻기 
		Constructor[] conturctors = cls.getConstructors();
		for (Constructor constructor : conturctors) {
			System.out.println("Constructor: " + constructor.getName());
		}
		
		// 메서드 목록 얻기 
		Method[] methods = cls.getMethods();
		for (Method method : methods) {
			System.out.println(method.getReturnType() + " " + method.getName() + "(...)");
		}
		
		
		// 프로퍼티 목록 얻기 
		Field[] fields = cls.getFields();
		for (Field field : fields) {
			System.out.println(field.getType() + " " + field.getName());
		}
		
	
		// 어노테이션 얻기 
		Annotation[] annotations = cls.getAnnotations();
		for (Annotation annotation : annotations) {
			System.out.println(annotation.toString());
		}
		
	}

}