devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java中的clone方法_java clone

作者：IT小白 | 2024-05-24 08:45:40

赞

踩

java clone

注解

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

注解的分类：

  1. 内置注解

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

  1. public class Animals {
  2.     public void run(){
  3.         System.out.println("动物跑");
  4.     }
  5. }
  1. public class Cat extends Animals{
  2.     @Override
  3.     public void run1() {
  4.         super.run();
  5.     }
  6. }

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

  1. public class Animals {
  2.     @Deprecated
  3.     public void run(){
  4.         System.out.println("动物跑");
  5.     }
  6. }

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

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

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

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

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

  1. public enum ElementType {
  2.     /** Class, interface (including annotation type), or enum declaration */
  3.     //可以应用于类的任何元素
  4.     TYPE,
  5.  
  6.     //可以用于字段或属性
  7.     /** Field declaration (includes enum constants) */
  8.     FIELD,
  9.  
  10.     //可以用于方法级注释
  11.     /** Method declaration */
  12.     METHOD,
  13.  
  14.     //可以用于方法的参数
  15.     /** Formal parameter declaration */
  16.     PARAMETER,
  17.  
  18.     //可以应用于构造函数
  19.     /** Constructor declaration */
  20.     CONSTRUCTOR,
  21.  
  22.     //可以用于局部变量
  23.     /** Local variable declaration */
  24.     LOCAL_VARIABLE,
  25.  
  26.     /** Annotation type declaration */
  27.     ANNOTATION_TYPE,
  28.  
  29.     //可以用于包声明
  30.     /** Package declaration */
  31.     PACKAGE,
  32.  
  33.     /**
  34.      * Type parameter declaration
  35.      *
  36.      * @since 1.8
  37.      */
  38.     TYPE_PARAMETER,
  39.  
  40.     /**
  41.      * Use of a type
  42.      *
  43.      * @since 1.8
  44.      */
  45.     TYPE_USE
  46. }

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

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

  1. public enum RetentionPolicy {
  2.     /**
  3.      * Annotations are to be discarded by the compiler.
  4.      */
  5.     SOURCE,//在源文件中有效（源文件保存）
  6.  
  7.     /**
  8.      * Annotations are to be recorded in the class file by the compiler
  9.      * but need not be retained by the VM at run time.  This is the default
  10.      * behavior.
  11.      */
  12.     CLASS,//在class文件中有效（class保存）
  13.  
  14.     /**
  15.      * Annotations are to be recorded in the class file by the compiler and
  16.      * retained by the VM at run time, so they may be read reflectively.
  17.      *
  18.      * @see java.lang.reflect.AnnotatedElement
  19.      */
  20.     RUNTIME//在运行时有效（运行时保留）
  21. }

  1. 自定义注解

注解类：

  1. @Target(ElementType.FIELD)//作用在类的属性上
  2. @Retention(RetentionPolicy.RUNTIME)//运行时生效
  3. public @interface NotNull {
  4.  
  5.     String message() default "";
  6.     
  7.     int length() default 0;
  8.     
  9.     String lengthmessage() default "";
  10. }

model类：

  1. public class User {
  2.     
  3.     private int num;
  4.  
  5.     @NotNull(message="姓名不能为空",length=3,lengthmessage="长度不能小于3")
  6.     private String name;
  7.  
  8.     public String getName() {
  9.         return name;
  10.     }
  11.  
  12.     public void setName(String name) {
  13.         this.name = name;
  14.     }
  15.  
  16.     public int getNum() {
  17.         return num;
  18.     }
  19.  
  20.     public void setNum(int num) {
  21.         this.num = num;
  22.     }
  23.  
  24. }

测试代码：

  1. public class Test {
  2.  
  3.       public static void main(String[] args) throws NoSuchMethodException, SecurityException, Exception {
  4.             User user=new User();
  5.           Field[] fields=user.getClass().getDeclaredFields();//将类中的字段存储在field数组中
  6.           //对数组中的字段进行强循环
  7.           for(Field filed:fields){
  8.               NotNull notNull=filed.getAnnotation(NotNull.class);//获取注释类型
  9.               if(notNull!=null){
  10.     Method method = user.getClass().getMethod("get" + getMethodName(filed.getName()));//获取方法对象
  11.            Object value = method.invoke(user);//调用类的实例对象
  12.              if(value==null){
  13.            System.err.println(filed.getName()+notNull.message());//打印输出相应的字段和注释信息
  14.                       throw new NullPointerException(notNull.message());//抛出异常信息
  15.                   }
  16.                   else if(String.valueOf(value).length()< notNull.length()){//判断字符串长度
  17.                       System.err.println(filed.getName()+notNull.lengthmessage());
  18.  
  19.                   }
  20.               }
  21.           }
  22.  
  23.        }
  24.  
  25.         /**
  26.          * 把一个字符串的第一个字母大写
  27.          */
  28.         private static String getMethodName(String fildeName) throws Exception {
  29.             byte[] items = fildeName.getBytes();
  30.             items[0] = (byte) ((char) items[0] - 'a' + 'A');
  31.             return new String(items);
  32.         }
  33. }

对象克隆

原因：new出来的对象属性都是初始化的值，不能保存当前对象“状态”，clone解决了这个问题

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

如何实现克隆

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

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

model类：

  1. public class Person implements  Cloneable{
  2.  
  3.      int num;
  4.      String name;
  5.      Address address;
  6.  
  7.     public Person() {
  8.     }
  9.  
  10.     public Person(int num, String name) {
  11.         this.num = num;
  12.         this.name = name;
  13.     }
  14.  
  15.     public int getNum() {
  16.         return num;
  17.     }
  18.  
  19.     public void setNum(int num) {
  20.         this.num = num;
  21.     }
  22.  
  23.     public String getName() {
  24.         return name;
  25.     }
  26.  
  27.     public void setName(String name) {
  28.         this.name = name;
  29.     }
  30.  
  31.     public Address getAddress() {
  32.         return address;
  33.     }
  34.  
  35.     public void setAddress(Address address) {
  36.         this.address = address;
  37.     }
  38.  
  39.     @Override
  40.     protected Person clone() throws CloneNotSupportedException {
  41.         Person person = (Person)super.clone();
  42.        // person.address = (Address)address.clone();   //深度复制  联同person中关联的对象也一同克隆.
  43.         return person;
  44.     }
  45.     @Override
  46.     public String toString() {
  47.         return "Person{" +
  48.                 "num=" + num +
  49.                 ", name='" + name + '\'' +
  50.                 ", address=" + address +
  51.                 '}';
  52.     }
  53. }

引用类：

  1. public class Address {
  2.  
  3.      String  address;
  4.  
  5.     public String getAddress() {
  6.         return address;
  7.     }
  8.  
  9.     public void setAddress(String address) {
  10.         this.address = address;
  11.     }
  12.  
  13.     @Override
  14.     public String toString() {
  15.         return "Address{" +
  16.                 "address='" + address + '\'' +
  17.                 '}';
  18.     }
  19.  
  20.     @Override
  21.     protected Address clone() throws CloneNotSupportedException {
  22.         return (Address)super.clone();
  23.     }
  24. }

测试类：

  1. public class Test {
  2.  
  3.     public static void main(String[] args) throws CloneNotSupportedException {
  4.  
  5.         Address address = new Address();
  6.                 address.setAddress("汉中");
  7.  
  8.         Person p1 = new  Person(100,"jim");
  9.                p1.setAddress(address);
  10.  
  11.         Person p2 =p1.clone();
  12.                p2.setName("tom");
  13.                address.setAddress("西安");//
  14.         System.out.println(p1);
  15.     }
  16. }

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

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

引用类：

  1. public class Address implements Cloneable{
  2.  
  3.      String  address;
  4.  
  5.     public String getAddress() {
  6.         return address;
  7.     }
  8.  
  9.     public void setAddress(String address) {
  10.         this.address = address;
  11.     }
  12.  
  13.     @Override
  14.     public String toString() {
  15.         return "Address{" +
  16.                 "address='" + address + '\'' +
  17.                 '}';
  18.     }
  19.  
  20.     @Override
  21.     protected Address clone() throws CloneNotSupportedException {
  22.         return (Address)super.clone();
  23.     }
  24. }

model类：

  1. public class Person implements  Cloneable{
  2.  
  3.      int num;
  4.      String name;
  5.      Address address;
  6.  
  7.     public Person() {
  8.     }
  9.  
  10.     public Person(int num, String name) {
  11.         this.num = num;
  12.         this.name = name;
  13.     }
  14.  
  15.     public int getNum() {
  16.         return num;
  17.     }
  18.  
  19.     public void setNum(int num) {
  20.         this.num = num;
  21.     }
  22.  
  23.     public String getName() {
  24.         return name;
  25.     }
  26.  
  27.     public void setName(String name) {
  28.         this.name = name;
  29.     }
  30.  
  31.     public Address getAddress() {
  32.         return address;
  33.     }
  34.  
  35.     public void setAddress(Address address) {
  36.         this.address = address;
  37.     }
  38.  
  39.     @Override
  40.     protected Person clone() throws CloneNotSupportedException {
  41.         Person person = (Person)super.clone();
  42.         person.address = (Address)address.clone();   //深度复制  联同person中关联的对象也一同克隆.
  43.         return person;
  44.     }
  45.  
  46.     @Override
  47.     public String toString() {
  48.         return "Person{" +
  49.                 "num=" + num +
  50.                 ", name='" + name + '\'' +
  51.                 ", address=" + address +
  52.                 '}';
  53.     }
  54. }

测试：

  1. public class Test {
  2.  
  3.     public static void main(String[] args) throws CloneNotSupportedException {
  4.  
  5.         Address address = new Address();
  6.                 address.setAddress("汉中");
  7.  
  8.         Person p1 = new  Person(100,"jim");
  9.                p1.setAddress(address);
  10.  
  11.         Person p2 =p1.clone();
  12.                p2.setName("tom");
  13.                address.setAddress("西安");
  14.         System.out.println(p1);
  15.         System.out.println(p2);
  16.     }
  17. }

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

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

引用类：

  1. public class Address  implements Serializable {
  2.  
  3.      String  address;
  4.  
  5.     public String getAddress() {
  6.         return address;
  7.     }
  8.  
  9.     public void setAddress(String address) {
  10.         this.address = address;
  11.     }
  12.  
  13.     @Override
  14.     public String toString() {
  15.         return "Address{" +
  16.                 "address='" + address + '\'' +
  17.                 '}';
  18.     }
  19.  
  20. }

model类：

  1.  
  2. public class Person implements Serializable {
  3.  
  4.      int num;
  5.      String name;
  6.      Address address;
  7.  
  8.     public Person() {
  9.     }
  10.  
  11.     public Person(int num, String name) {
  12.         this.num = num;
  13.         this.name = name;
  14.     }
  15.  
  16.     public int getNum() {
  17.         return num;
  18.     }
  19.  
  20.     public void setNum(int num) {
  21.         this.num = num;
  22.     }
  23.  
  24.     public String getName() {
  25.         return name;
  26.     }
  27.  
  28.     public void setName(String name) {
  29.         this.name = name;
  30.     }
  31.  
  32.     public Address getAddress() {
  33.         return address;
  34.     }
  35.  
  36.     public void setAddress(Address address) {
  37.         this.address = address;
  38.     }
  39.  
  40.     /**
  41.      * 自定义克隆方法
  42.      * @return
  43.      */
  44.     public Person myclone() {
  45.             Person person = null;
  46.               try { // 将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
  47.                      ByteArrayOutputStream baos = new ByteArrayOutputStream();
  48.                       ObjectOutputStream oos = new ObjectOutputStream(baos);
  49.                       oos.writeObject(this);
  50.             // 将流序列化成对象
  51.                     ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
  52.                      ObjectInputStream ois = new ObjectInputStream(bais);
  53.                      person = (Person) ois.readObject();
  54.                   } catch (IOException e) {
  55.                      e.printStackTrace();
  56.                   } catch (ClassNotFoundException e) {
  57.                      e.printStackTrace();
  58.                  }
  59.              return person;
  60.           }
  61.  
  62.  
  63.     @Override
  64.     public String toString() {
  65.         return "Person{" +
  66.                 "num=" + num +
  67.                 ", name='" + name + '\'' +
  68.                 ", address=" + address +
  69.                 '}';
  70.     }
  71. }

测试类：

  1. public class Test {
  2.  
  3.     public static void main(String[] args) throws CloneNotSupportedException {
  4.  
  5.         Address address = new Address();
  6.                 address.setAddress("汉中");
  7.  
  8.         Person p1 = new  Person(100,"jim");
  9.         p1.setAddress(address);
  10.  
  11.         Person p2 =p1.myclone();
  12.                p2.setName("tom");
  13.                address.setAddress("西安");
  14.  
  15.         System.out.println(p1);
  16.         System.out.println(p2);
  17.  
  18.  
  19.     }
  20. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/616672
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号