public class EqualsBuilder {
 
    private boolean isEquals;
 
    public EqualsBuilder() {
        super();
        isEquals = true;
    }
 
    public static boolean reflectionEquals(Object lhs, Object rhs) {
        return reflectionEquals(lhs, rhs, false);
    }
 
    public static boolean reflectionEquals(Object lhs, Object rhs, 
            boolean testTransients) {
        if (lhs == rhs) {
            return true;
        }
        if (lhs == null || rhs == null) {
            return false;
        }
        Class c1 = lhs.getClass();
        if (!c1.isInstance(rhs)) {
            return false;
        }
        Field[] fields = c1.getDeclaredFields();
        Field.setAccessible(fields, true);
        EqualsBuilder equalsBuilder = new EqualsBuilder();
        for (int i = 0; i < fields.length && equalsBuilder.isEquals; ++i) {
            Field f = fields[i];
            if (testTransients || !Modifier.isTransient(f.getModifiers())) {
                if (!Modifier.isStatic(f.getModifiers())) {
                    try {
                        equalsBuilder.append(f.get(lhs), f.get(rhs));
                    } catch (IllegalAccessException e) {
                        //this can't happen. Would get a Security exception instead
                        //throw a runtime exception in case the impossible happens.
                        throw new InternalError("Unexpected IllegalAccessException");
                    }
                }
            }
        }
        return equalsBuilder.isEquals();
    }
 
    public EqualsBuilder append(Object lhs, Object rhs) {
        if (isEquals == false) {
            return this;
        }
        if (lhs == rhs) {
            return this;
        }
        if (lhs == null || rhs == null) {
            isEquals = false;
            return this;
        }
        Class lhsClass = lhs.getClass();
        if (!lhsClass.isArray()) {
            //the simple case, not an array, just test the element 
            isEquals = lhs.equals(rhs);
        } else {
            //'Switch' on type of array, to dispatch to the correct handler
            // This handles multi dimensional arrays
            if (lhs instanceof long[]) {
                append((long[]) lhs, (long[]) rhs);
            } else if (lhs instanceof int[]) {
                append((int[]) lhs, (int[]) rhs);
            } else if (lhs instanceof short[]) {
                append((short[]) lhs, (short[]) rhs);
            } else if (lhs instanceof char[]) {
                append((char[]) lhs, (char[]) rhs);
            } else if (lhs instanceof byte[]) {
                append((byte[]) lhs, (byte[]) rhs);
            } else if (lhs instanceof double[]) {
                append((double[]) lhs, (double[]) rhs);
            } else if (lhs instanceof float[]) {
                append((float[]) lhs, (float[]) rhs);
            } else if (lhs instanceof boolean[]) {
                append((boolean[]) lhs, (boolean[]) rhs);
            } else {
                // Not an array of primitives
                append((Object[]) lhs, (Object[]) rhs);
            }
        }
        return this;
    }
 
}

    public EqualsBuilder append(long lhs, long rhs) {
        if (isEquals == false) {
            return this;
        }
        isEquals = (lhs == rhs);
        return this;
    }

public class CompareToBuilder {
 
    private int comparison;
 
    public CompareToBuilder() {
        super();
        comparison = 0;
    }
 
 
    public static int reflectionCompare(Object lhs, Object rhs) {
        return reflectionCompare(lhs, rhs, false);
    }
 
    public static int reflectionCompare(Object lhs, Object rhs, 
            boolean testTransients) {
        //判断是否相等
        if (lhs == rhs) {
            return 0;
        }
        //是否有空指针
        if (lhs == null || rhs == null) {
            throw new NullPointerException();
        }
        //类型是否一致
        Class c1 = lhs.getClass();
        if (!c1.isInstance(rhs)) {
            throw new ClassCastException();
        }
        Field[] fields = c1.getDeclaredFields();
        //修改属性的可见性
        Field.setAccessible(fields, true);
        //内部创建一个CompareToBuilder对象，构成链式结构
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        //只有当当前的两个属性相等时候（comparison == 0），才继续往下比较
        for (int i = 0; i < fields.length && compareToBuilder.comparison == 0; ++i) {
            Field f = fields[i];
            //是否是临时属性
            if (testTransients || !Modifier.isTransient(f.getModifiers())) {
            	//是否是静态属性
                if (!Modifier.isStatic(f.getModifiers())) {
                    try {
                        compareToBuilder.append(f.get(lhs), f.get(rhs));
                    } catch (IllegalAccessException e) {
                        //this can't happen. Would get a Security exception instead
                        //throw a runtime exception in case the impossible happens.
                        throw new InternalError("Unexpected IllegalAccessException");
                    }
                }
            }
        }
        return compareToBuilder.toComparison();
    }
 
    public CompareToBuilder append(Object lhs, Object rhs) {
        if (comparison != 0) {
            return this;
        }
        if (lhs == rhs) {
            return this;
        }
        if (lhs == null || rhs == null) {
            throw new NullPointerException();
        }
        Class lhsClass = lhs.getClass();
        if (!lhsClass.isArray()) {
            //the simple case, not an array, just test the element 
            comparison = ((Comparable) lhs).compareTo(rhs);
        } else {
            //'Switch' on type of array, to dispatch to the correct handler
            // This handles multi dimensional arrays
            if (lhs instanceof long[]) {
                append((long[]) lhs, (long[]) rhs);
            } else if (lhs instanceof int[]) {
                append((int[]) lhs, (int[]) rhs);
            } else if (lhs instanceof short[]) {
                append((short[]) lhs, (short[]) rhs);
            } else if (lhs instanceof char[]) {
                append((char[]) lhs, (char[]) rhs);
            } else if (lhs instanceof byte[]) {
                append((byte[]) lhs, (byte[]) rhs);
            } else if (lhs instanceof double[]) {
                append((double[]) lhs, (double[]) rhs);
            } else if (lhs instanceof float[]) {
                append((float[]) lhs, (float[]) rhs);
            } else if (lhs instanceof boolean[]) {
                append((boolean[]) lhs, (boolean[]) rhs);
            } else {
                // Not an array of primitives
                append((Object[]) lhs, (Object[]) rhs);
            }
        }
        return this;
    }
}

public int comapareTo(Object o) {
     MyClass rhs = (MyClass) o;
     return new CompareToBuilder()
                  .append(field1, rhs.field1)
                  .append(field2, rhs.field2)
                  .appendb(field3, rhs.field3)
                  .toComparison();
}

 public int compareTo(Object o) {
    return CompareToBuilder.reflectionCompare(this, obj);
 }

package com.javachen.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 用户自定义标签,带有成员变量的MyTag
 */
@Documented //将注释包含在JavaDoc中
@Inherited //允许子类继承父类中的注释。
@Target(value = {ElementType.METHOD,ElementType.CONSTRUCTOR})//标注这个注释使用的范围
@Retention(value = RetentionPolicy.RUNTIME)//要想使用反射得到注释信息，这个注释必须使用
public @interface MyTag {
	String name()  default "javachen";//给自定义注释类的成员加上默认值
	int age()  default 24;
}

package com.javachen.annotation;
 
import java.lang.annotation.Annotation;
 
public class TagTest {
	@MyTag(name = "MyTag", age = 1)
	public void test() {
	}
 
	@Override //可以保证编译时候Override函数的声明正确性
	public String toString() {
		return super.toString();
	}
 
	@Deprecated //对不应再使用的方法进行注解
	public String notToUse() {
		return super.toString();
	}
 
	public static void main(String[] args) {
		TagTest tt = new TagTest();
		try {
			Annotation[] annotation = tt.getClass().getMethod("test")
					.getAnnotations();
			for (Annotation tag : annotation) {
				System.out.println("Tag is:" + tag);
				System.out.println("tag.name()" + ((MyTag) tag).name());
				System.out.println("tag.age()" + ((MyTag) (tag)).age());
			}
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		}
	}
}