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

}

scanf(const char *TEMPLATE, ...)

scanf("%d %d %d \n", &array[0], &array[1], &array[2] );

register int  i,  j;   // 레지스터에  i, j 생성을 요청.     

void func()
{
    static int i = 0;    // 연이은 호출에도 처음 생성된 i가 사용됨.
    i++;
}

#include <stdio.h>
 
void swap(int , int);// 함수원형(프로토타입)   

int main() {
...
return 0;
}

void swap(int a, int b) {   // 함수의 정의         
...
}

#include <stdio.h>

main() {
    int a = 1, b = 5;
    swap(a, b);// 변수의 값을 전달함 
}

void swap(int a, int b)  {// main함수의 a, b는 변경되지 않음    
    int temp = a;
    a = b;
    b = temp      
}

import java.util.List;

public class PasswordUtils {
	
	@UseCase(id = 47, description = "passwords must contain at least one numeric")
	public boolean validatePassword(String password) {
		return (password.matches("\\w*\\d\\w*"));
	}
	
	@UseCase(id = 48)
	public String encryptPassword(String password) {
		return new StringBuilder(password).reverse().toString();
	}
	
	@UseCase(id = 49, description = "New passwords can't equal perviously used ones")
	public boolean checkForNewPassword(List prevPasswords, String password) {
		return !prevPasswords.contains(password);
	}
}

package net.atgame.annotation.usecase;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class UseCaseTracker {
	
	public static void trackUseCases(List useCases, Class cl) {
		for (Method m : cl.getDeclaredMethods()) {
			UseCase uc = m.getAnnotation(UseCase.class);
			if (uc != null) {
				System.out.println("Found Use Case:" + uc.id() + " " + uc.description());
				useCases.remove(new Integer(uc.id()));
			}
		}
		
		for (int i : useCases) {
			System.out.println("Warning: Missing use case~" + i);
		}
	}
	
	public static void main(String[] args) {
		List useCases = new ArrayList();
		Collections.addAll(useCases, 47, 48, 49, 50);
		trackUseCases(useCases, PasswordUtils.class);
	}
}

package net.atgame.annotation.database;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DBTable {
	public String name() default "";
}

package net.atgame.annotation.database;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SQLInteger {
	String name() default "";
	Constraints constraints() default @Constraints;
}

package net.atgame.annotation.database;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SQLString {
	int value() default 0;
	String name() default "";
	Constraints constraints() default @Constraints;
}

package net.atgame.annotation.database;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Constraints {
	boolean primaryKey() default false;
	boolean allowNull() default true;
	boolean unique() default false;
}

package net.atgame.annotation.database;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

public class TableCreator {
	
	public static void main(String[] args) throws Exception {
		if (args.length < 1) {
			System.out.println("arguments: annotated classes");
			System.exit(0);
		}
		// 모든 엔티티 클래스를 읽음 
		for (String className : args) {
			Class cl = Class.forName(className);
			// 클래스 어노테이션 가져오기 
			DBTable dbTable = cl.getAnnotation(DBTable.class);
			if (dbTable == null) {
				System.out.println("No DBTable annotations in class " + className);
				continue;
			}
			String tableName = dbTable.name();
			
			if (tableName.length() < 1) {
				tableName = cl.getName().toUpperCase();
			}
			List columnDefs = new ArrayList();
			
			/// 필드목록 조회 
			for (Field field : cl.getDeclaredFields()) {
				String columnName = null;
				Annotation[] anns = field.getDeclaredAnnotations();
				if (anns.length < 1) {
					continue;
				}
				if (anns[0] instanceof SQLInteger)  {
					SQLInteger sInt = (SQLInteger)anns[0];
					if (sInt.name().length() < 1) {
						columnName = field.getName().toUpperCase();
					} else {
						columnName = sInt.name();
					}
					columnDefs.add(columnName + " INT" + getConstraints(sInt.constraints()));
				}
				if (anns[0] instanceof SQLString) {
					SQLString sString = (SQLString)anns[0];
					if (sString.name().length() < 1) {
						columnName = field.getName().toUpperCase();
					} else {
						columnName = sString.name();
					}
					columnDefs.add(columnName + " VARCHAR(" + sString.value() + ")" + getConstraints(sString.constraints()));
				}
				
			}
			StringBuilder createCommand = new StringBuilder("CREATE TABLE " + tableName + " (");
			for (String columnDef : columnDefs) {
				createCommand.append("\n " + columnDef + ",");
			}
			// 마지막 쉼표제거 
			String tableCreate = createCommand.substring(0, createCommand.length()-1) + ");";
			System.out.println("Table Creation SQL for " + className + " is :\n" + tableCreate);
		}
		
	}
	
	private static String getConstraints(Constraints con) {
		String constraints = "";
		if (!con.allowNull()) {
			constraints += " NOT NULL";
		}
		if (con.primaryKey()) {
			constraints += " PRIMARY KEY";
		}
		if (con.unique()) {
			constraints += " UNIQUE";
		}
		return constraints;
	}
}

정의한 어노테이션을 다음과 같이 사용한다. 

단일 멤버를 갖을 경우에만 위와 같이 사용할 수 있다. 

3) 디폴트 값 설정하기 
 

디폴트값을 사용한 예는 다음과 같다. 

4) 메타-어노테이션

어노테이션에 사용되는 어노테이션으로 해당 어노테이션의 동작대상 및 보여타임을 결정한다. 

② @Retention 메타-어노테이션 

     자바컴파일러가 어노테이션을 다루는 방법과 관련이 있다.  소스파일, 클래스파일, 런타임 중 어느시점까지

    어노테이션을 보유하고 있을 것인지를 결정한다. 

위 세값 중 하나를 인자로 취해 다음과 같이 사용된다.