面试题Java对象创建的几种方式对比总结，非常详细的总结

本章讲了场景对象的几种方法，主要有new、反射、克隆、反序列化

新的

这种方法是最常见的。 通过调用构造函数创建一个对象，如new(“hello”)。 该方法必须知道要创建的具体类型。 比如要创建，就new(); 并且它不能是接口或抽象类。 有人说这是错误的，下面的方法可以是new一个接口，也可以是抽象类，其实这就是所谓的匿名类。很多时候我们并不知道对象的具体类型，比如泛型和泛型中间件

      new Comparable(){
            @Override
            public int compareTo(Integer o) {
                return 0;
            }
        };

public class GenericBean {
    
    public T newInstance(){
        // 编译报错
         return new T(); 
    }
    
}

反射

调用Class.()创建一个对象。 这种方法在一些框架中很常见。 比如在boot流行之前，采用xml配置的方式。 相信你不会忘记，你经常需要配置某个类的完整路径。

此方法有一个限制，即必须有默认的无参数构造方法。 下面的类代码会抛出异常n: com..study...()，那些添加了带参数的构造方法，但没有提供无参构造方法的同学注意了。

public class Student {
    private String name ;
    private int age;
    
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public static void main(String[] args) {
        Class clazz = Student.class;
        try {
            clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

克隆

克隆需要实现接口（没有实现可以尝试抛出异常），克隆的对象与原对象不是同一个对象，克隆的对象有浅拷贝和深拷贝之分

浅拷贝修改对象属性会影响原始对象

深拷贝则不然，记住深拷贝实现中的口头禅，属性也克隆了。

此处仅粘贴深复制代码

public class CloneBean  implements Cloneable {
    private int[] arr;
    public CloneBean( int[] arr) {
        this.arr = arr;
    }
    public void setArr(int[] arr) {
        this.arr = arr;
    }
    @Override
    protected CloneBean clone() throws CloneNotSupportedException {
        CloneBean cloneBean =  (CloneBean)super.clone();
        cloneBean.setArr(arr.clone());
        return cloneBean;
    }
    @Override
    public String toString() {
        return "CloneBean{" +
                ", arr=" + Arrays.toString(arr) +
                '}';
    }
    public static void main(String[] args) throws CloneNotSupportedException {
        int arr[] = new int[]{1,2,3};
        CloneBean cloneBean1 = new CloneBean(arr);
        CloneBean cloneBean2 = cloneBean1.clone();
        System.out.println(cloneBean2  == cloneBean1);
        System.out.println("cloneBean1" + cloneBean1);
        System.out.println("cloneBean2" + cloneBean2);
        arr[1] = 1000;
        System.out.println("cloneBean1" + cloneBean1);
        System.out.println("cloneBean2" + cloneBean2);
    }
}

反序列化

对象序列化需要实现接口，序列化就是.()反序列化。 .在网络传输中比较常见。 笔者第一次接触它是在大学的一个大型作业网络白板中

public class ExampleBean implements Serializable {
    private String name ;
    public ExampleBean(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "ExampleBean{" +
                "name='" + name + '\'' +
                '}';
    }
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ExampleBean exampleBean = new ExampleBean("hello");
        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(byteOut);
        out.writeObject(exampleBean);
        out.close();
        ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(byteOut.toByteArray()));
        ExampleBean exampleBean2 =  (ExampleBean)in.readObject();
        in.close();
        System.out.println(exampleBean2);
    }
}

还有其他创建对象的方式吗，欢迎交流