Java注解和对象克隆

注解

什么是注解？

Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。
Java 语言中的类、方法、变量、参数和包等都可以被标注。和 Javadoc 不同， Java 标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌 入到字节码中。Java 虚拟机可以保留标注内容，在运行时可以获取到标注内容 。 当然它也支持自定义 Java 标注。

内置的注解

@Override - 检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有 该方法时，会报编译错误。
@Deprecated - 标记过时方法。如果使用该方法，会报编译警告。
@SuppressWarnings - 指示编译器去忽略注解中声明的警告
作用在其他注解的注解(或者说 元注解)是:
@Retention - 标识这个注解怎么保存，是只在代码中，还是编入 class 文件中，或者是在 运行时可以通过反射访问。
@Documented - 标记这些注解是否包含在用户文档中。
@Target - 标记这个注解应该是哪种 Java 成员。
@Inherited - 标记这个注解是继承于哪个注解类(默认 注解并没有继承于任何子类)
@SafeVarargs - Java 7 开始支持，忽略任何使用参数为泛型变量的方法或构造函数调用产 生的警告。
@FunctionalInterface - Java 8 开始支持，标识一个匿名函数或函数式接口。
@Repeatable - Java 8 开始支持，标识某注解可以在同一个声明上使用多次。

重点

@Target： 用于描述注解的使用范围（即：被描述的注解可以用在什么地方
ElementType.TYPE 可以应用于类的任何元素。
ElementType.CONSTRUCTOR 可以应用于构造函数。
ElementType.FIELD 可以应用于字段或属性。
ElementType.LOCAL_VARIABLE 可以应用于局部变量。
ElementType.METHOD 可以应用于方法级注释。
ElementType.PACKAGE 可以应用于包声明。
ElementType.PARAMETER 可以应用于方法的参数。
@Retention：@Retention 定义了该注解被保留的时间长短：某些注解仅出现在源代码中， 而被编译器丢弃；而另一些却被编译在 class 文件中；编译在 class 文件中的注解可能会被 虚拟机忽略，而另一些在 class 被装载时将被读取（请注意并不影响 class 的执行，因为注 解与 class 在使用上是被分离的）。使用这个 meta-Annotation 可以对注解的“生命周期” 限制。作用：表示需要在什么级别保存该注释信息，用于描述注解的生命周期（即：被描述 的注解在什么范围内有效） 取值（RetentionPoicy）有：

1. SOURCE:在源文件中有效（即源文件保留）
2. CLASS:在 class 文件中有效（即 class 保留）
3. RUNTIME:在运行时有效（即运行时保留）

自定义注解

自定义注解

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 NotNull {

	String message() default "";
	
	int length() default 0;
	
	String lengthmessage() default "";
}

public class User {
	
	private int num;

	@NotNull(message="姓名不能为空",length=4,lengthmessage="长度不能小于4")
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

}

测试

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test {

	  public static void main(String[] args) throws NoSuchMethodException, SecurityException, Exception {
		  User user = new User();
		      user.setName("赵佳辉");
		      //通过反射拿到User类中的所有属性
		  Field[] fields = user.getClass().getDeclaredFields();
		  for (Field field : fields) {
	            NotNull notNull = field.getAnnotation(NotNull.class);
	            if (notNull != null) {
	            	//通过反射拿到User类中的get方法
	                Method m = user.getClass().getMethod("get" + getMethodName(field.getName()));
	                //执行get方法
	                Object obj=m.invoke(user);
	                if (obj==null) {
	                    System.err.println(field.getName() +notNull.message());
	                    throw new NullPointerException(notNull.message());
	                }else{
	                	if(String.valueOf(obj).length()<(notNull.length())){
	                		 System.err.println(field.getName() +notNull.lengthmessage());
	                	}
	                }
	            }
	        }
	   }

		/**
		 * 把一个字符串的第一个字母大写
		 */
	    private static String getMethodName(String fildeName) throws Exception {
	        byte[] items = fildeName.getBytes();
	        items[0] = (byte) ((char) items[0] - 'a' + 'A');
	        return new String(items);
	    }
}

对象克隆

为什么要克隆？

大家先思考一个问题，为什么需要克隆对象？直接 new 一个对象不行吗？

克隆的对象可能包含一些已经修改过的属性，而 new 出来的对象的属性都还 是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠 clone 方法了。那么我把这个对象的临时属性一个一个的赋值给我新 new 的对 象不也行嘛？可以是可以，但是一来麻烦不说，二来，大家通过上面的源码都发 现了 clone 是一个 native 方法，就是快啊，在底层实现的。
误区：
我们常见的

Student stu1 = new Student (); 
Student stu2 = stu1 ;

这种形式的代码复制的是引用，即对象在内存中的地址，a 和 b 对象仍然指向了 同一个对象。这种只能称为引用复制,两个引用指向的还是同一个对象.

如何实现克隆？
先介绍一下两种不同的克隆方法，浅克隆(ShallowClone)和深克隆(DeepClone)。
在 Java 语言中，数据类型分为值类型（基本数据类型）和引用类型，值类型包 括 int、double、byte、boolean、char 等简单数据类型，引用类型包括类、 接口、数组等复杂类型。基本类型的值可以直接复制,引用类型只能复制引用地 址。所以浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制。

浅克隆和深克隆

1、浅克隆
在浅克隆中，如果原型对象的成员变量是值类型，将复制一份给克隆对象；如果 原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也 就是说原型对象和克隆对象的成员变量指向相同的内存地址。 简单来说，在浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成 员变量，而引用类型的成员对象并没有复制。

实现方式：
1.在 Java 语言中，通过覆盖 Object 类的 clone()方法可以实现浅克隆。
2.在 spring 框架中提供 BeanUtils.copyProperties(source,target);
2、深克隆
在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给 克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对象。
简单来说，在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量也 将复制。
在 Java 语言中，如果需要实现深克隆，可以通过覆盖 Object 类的 clone()方法 实现，也可以通过序列化(Serialization)等方式来实现。
序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个拷贝，而原 对象仍然存在于内存中。通过序列化实现的拷贝不仅可以复制对象本身，而且可 以复制其引用的成员对象，因此通过序列化将对象写到一个流中，再从流里将其 读出来，可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现 Serializable 接口，否则无法实现序列化操作。

解决多层克隆问题

如果引用类型里面还包含很多引用类型，或者内层引用类型的类里面又包含引用 类型，使用 clone 方法就会很麻烦。这时我们可以用序列化的方式来实现对象的 深克隆。