Java中的clone方法

喜欢ヅ旅行 2023-10-04 21:06 44阅读 0赞

#### 注解 ####

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

**注解的分类**：

1.  **内置注解**

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

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

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

![d689d979799a6194c674bc05c0a338f1.png][]

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

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

![ed5a96f7dc5ae6eb9d374890fae56835.png][]

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

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

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

*  @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//在运行时有效（运行时保留）
    }

1.  **自定义注解**

注解类：

@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;
        }
    
        @Override
        protected Person clone() throws CloneNotSupportedException {
            Person person = (Person)super.clone();
           // person.address = (Address)address.clone();   //深度复制  联同person中关联的对象也一同克隆.
            return person;
        }
        @Override
        public 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;
        }
    
        @Override
        public String toString() {
            return "Address{" +
                    "address='" + address + '\'' +
                    '}';
        }
    
        @Override
        protected 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);
        }
    }

![4476f8475cc808cb493765ec4211dddb.png][]

![c504c839f56a6e93f9fa3a25068e8514.png][]

![5ad2177583bea12239e8776bf40bd3ad.png][]

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

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

![d9cf9f7213382fe2bcd4040e848dc188.png][]

引用类：

public class Address implements Cloneable{
    
         String  address;
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "Address{" +
                    "address='" + address + '\'' +
                    '}';
        }
    
        @Override
        protected 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;
        }
    
        @Override
        protected Person clone() throws CloneNotSupportedException {
            Person person = (Person)super.clone();
            person.address = (Address)address.clone();   //深度复制  联同person中关联的对象也一同克隆.
            return person;
        }
    
        @Override
        public 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);
        }
    }

![a897af016b64f7aa3c7277040f5e4a6b.png][]

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

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

引用类：

public class Address  implements Serializable {
    
         String  address;
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public 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;
              }
    
    
        @Override
        public 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);
    
    
        }
    }

[d689d979799a6194c674bc05c0a338f1.png]: https://img-blog.csdnimg.cn/img_convert/d689d979799a6194c674bc05c0a338f1.png
[ed5a96f7dc5ae6eb9d374890fae56835.png]: https://img-blog.csdnimg.cn/img_convert/ed5a96f7dc5ae6eb9d374890fae56835.png
[4476f8475cc808cb493765ec4211dddb.png]: https://img-blog.csdnimg.cn/img_convert/4476f8475cc808cb493765ec4211dddb.png
[c504c839f56a6e93f9fa3a25068e8514.png]: https://img-blog.csdnimg.cn/img_convert/c504c839f56a6e93f9fa3a25068e8514.png
[5ad2177583bea12239e8776bf40bd3ad.png]: https://img-blog.csdnimg.cn/img_convert/5ad2177583bea12239e8776bf40bd3ad.png
[d9cf9f7213382fe2bcd4040e848dc188.png]: https://img-blog.csdnimg.cn/img_convert/d9cf9f7213382fe2bcd4040e848dc188.png
[a897af016b64f7aa3c7277040f5e4a6b.png]: https://img-blog.csdnimg.cn/img_convert/a897af016b64f7aa3c7277040f5e4a6b.png