Java中的clone方法

注解

定义： 注解是一种注释机制，它可以注释包、类、方法、变量、参数，在编译器生成类文件时，标注可以被嵌入到字节码中。

注解的分类：

1. 内置注解

• Override :重写方法，引用时没有该方法时会编译错误

public class Animals {public void run(){System.out.println("动物跑");}
}

public class Cat extends Animals{@Overridepublic void run1() {super.run();}
}

• Deprecated :标记过时方法，会造成编译警告

public class Animals {@Deprecatedpublic void run(){System.out.println("动物跑");}
}

• SuppressWarnings :用于编译器去忽略注解中的声明报告

• FunctionalInterface ：用于指示被修饰的接口是函数式接口

2. 元注解(修饰注解的注解)

• @Retention -标记这个注解存储在哪里

• @Documented -标记这些注解是否包含在用户文档中

• @Target -标记这些注解时java哪种成员

public enum ElementType {/** Class, interface (including annotation type), or enum declaration *///可以应用于类的任何元素TYPE,//可以用于字段或属性/** Field declaration (includes enum constants) */FIELD,//可以用于方法级注释/** Method declaration */METHOD,//可以用于方法的参数/** Formal parameter declaration */PARAMETER,//可以应用于构造函数/** Constructor declaration */CONSTRUCTOR,//可以用于局部变量/** Local variable declaration */LOCAL_VARIABLE,/** Annotation type declaration */ANNOTATION_TYPE,//可以用于包声明/** Package declaration */PACKAGE,/*** Type parameter declaration** @since 1.8*/TYPE_PARAMETER,/*** Use of a type** @since 1.8*/TYPE_USE
}

• @Inherited -标记这个注解时继承于哪个类

• @Repeatable -标识某注解可以在同一个声明上使用多次

public enum RetentionPolicy {/*** Annotations are to be discarded by the compiler.*/SOURCE,//在源文件中有效（源文件保存）/*** Annotations are to be recorded in the class file by the compiler* but need not be retained by the VM at run time.  This is the default* behavior.*/CLASS,//在class文件中有效（class保存）/*** Annotations are to be recorded in the class file by the compiler and* retained by the VM at run time, so they may be read reflectively.** @see java.lang.reflect.AnnotatedElement*/RUNTIME//在运行时有效（运行时保留）
}

3. 自定义注解

注解类：

@Target(ElementType.FIELD)//作用在类的属性上
@Retention(RetentionPolicy.RUNTIME)//运行时生效
public @interface NotNull {String message() default "";int length() default 0;String lengthmessage() default "";
}

model类：

public class User {private int num;@NotNull(message="姓名不能为空",length=3,lengthmessage="长度不能小于3")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;}}

测试代码：

public class Test {public static void main(String[] args) throws NoSuchMethodException, SecurityException, Exception {User user=new User();Field[] fields=user.getClass().getDeclaredFields();//将类中的字段存储在field数组中//对数组中的字段进行强循环for(Field filed:fields){NotNull notNull=filed.getAnnotation(NotNull.class);//获取注释类型if(notNull!=null){Method method = user.getClass().getMethod("get" + getMethodName(filed.getName()));//获取方法对象Object value = method.invoke(user);//调用类的实例对象if(value==null){System.err.println(filed.getName()+notNull.message());//打印输出相应的字段和注释信息throw new NullPointerException(notNull.message());//抛出异常信息}else if(String.valueOf(value).length()< notNull.length()){//判断字符串长度System.err.println(filed.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出来的对象属性都是初始化的值，不能保存当前对象“状态”，clone解决了这个问题

//这种形式的代码复制的是引用，即对象在内存中的地址，car1和car2指向同一个对象
Car car1=new Car();
Car car2=car1;

如何实现克隆

克隆分为浅克隆和深克隆，下面就简单的介绍它们之前的区别：

• 浅克隆（值类型克隆值，引用类型传递地址）

model类：

public class Person implements  Cloneable{int num;String name;Address address;public Person() {}public Person(int num, String name) {this.num = num;this.name = name;}public int getNum() {return num;}public void setNum(int num) {this.num = num;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Address getAddress() {return address;}public void setAddress(Address address) {this.address = address;}@Overrideprotected Person clone() throws CloneNotSupportedException {Person person = (Person)super.clone();// person.address = (Address)address.clone();   //深度复制  联同person中关联的对象也一同克隆.return person;}@Overridepublic String toString() {return "Person{" +"num=" + num +", name='" + name + '\'' +", address=" + address +'}';}
}

引用类：

public class Address {String  address;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}@Overridepublic String toString() {return "Address{" +"address='" + address + '\'' +'}';}@Overrideprotected Address clone() throws CloneNotSupportedException {return (Address)super.clone();}
}

测试类：

public class Test {public static void main(String[] args) throws CloneNotSupportedException {Address address = new Address();address.setAddress("汉中");Person p1 = new  Person(100,"jim");p1.setAddress(address);Person p2 =p1.clone();p2.setName("tom");address.setAddress("西安");//System.out.println(p1);}
}

浅克隆中引用对象进行的是引用地址传递，原引用对象和克隆对象指向同一个引用地址

强克隆（值类型克隆值，引用类型克隆一个带有原数据的新的地址）

引用类：

public class Address implements Cloneable{String  address;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}@Overridepublic String toString() {return "Address{" +"address='" + address + '\'' +'}';}@Overrideprotected Address clone() throws CloneNotSupportedException {return (Address)super.clone();}
}

model类：

public class Person implements  Cloneable{int num;String name;Address address;public Person() {}public Person(int num, String name) {this.num = num;this.name = name;}public int getNum() {return num;}public void setNum(int num) {this.num = num;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Address getAddress() {return address;}public void setAddress(Address address) {this.address = address;}@Overrideprotected Person clone() throws CloneNotSupportedException {Person person = (Person)super.clone();person.address = (Address)address.clone();   //深度复制  联同person中关联的对象也一同克隆.return person;}@Overridepublic String toString() {return "Person{" +"num=" + num +", name='" + name + '\'' +", address=" + address +'}';}
}

测试：

public class Test {public static void main(String[] args) throws CloneNotSupportedException {Address address = new Address();address.setAddress("汉中");Person p1 = new  Person(100,"jim");p1.setAddress(address);Person p2 =p1.clone();p2.setName("tom");address.setAddress("西安");System.out.println(p1);System.out.println(p2);}
}

强克隆中的引用类型新创建的地址赋给克隆对象引用类型

我们也可以通过序列化的方式对对象进行克隆，代码如下：

引用类：

public class Address  implements Serializable {String  address;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}@Overridepublic String toString() {return "Address{" +"address='" + address + '\'' +'}';}}

model类：

public class Person implements Serializable {int num;String name;Address address;public Person() {}public Person(int num, String name) {this.num = num;this.name = name;}public int getNum() {return num;}public void setNum(int num) {this.num = num;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Address getAddress() {return address;}public void setAddress(Address address) {this.address = address;}/*** 自定义克隆方法* @return*/public Person myclone() {Person person = null;try { // 将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝ByteArrayOutputStream baos = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(baos);oos.writeObject(this);// 将流序列化成对象ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());ObjectInputStream ois = new ObjectInputStream(bais);person = (Person) ois.readObject();} catch (IOException e) {e.printStackTrace();} catch (ClassNotFoundException e) {e.printStackTrace();}return person;}@Overridepublic String toString() {return "Person{" +"num=" + num +", name='" + name + '\'' +", address=" + address +'}';}
}

测试类：

public class Test {public static void main(String[] args) throws CloneNotSupportedException {Address address = new Address();address.setAddress("汉中");Person p1 = new  Person(100,"jim");p1.setAddress(address);Person p2 =p1.myclone();p2.setName("tom");address.setAddress("西安");System.out.println(p1);System.out.println(p2);}
}