java创建对象的五种方式

1.采用new的形式

这是我们最常见的也是最简单的创建对象的方式，通过这种方式我们还可以调用任意的构造函数（无参的和有参的）。 

2.通过反序列化的方式

     当我们反序列化一个对象，jvm会给我们创建一个单独的对象。在反序列化时，jvm创建对象并不会调用任何构造函数。 为了反序列化一个对象，我们需要让我们的类实现Serializable接口。

 

User.java的bean文件：

/**
 * @author zhangyu
 * @version V1.0
 * @ClassName: User
 * @Description: 测试user序列化与反序列化
 * @date 2019/3/5 19:25
 **/


public class User implements Serializable {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

序列化和反序列化文件 TestObjSerializeAndDeserialize.java

package serialize;

import java.io.*;

/**
 * @author zhangyu
 * @version V1.0
 * @ClassName: TestObjSerializeAndDeserialize
 * @Description: 测试序列化与反序列化
 * @date 2019/3/5 20:12
 **/


public class TestObjSerializeAndDeserialize  {
    public static void main(String[] args)throws Exception{
        SerializeUser();
        User  user=DeserializeUser();
        System.out.println();
        System.out.println(user.getAge()+user.getName());
    }
    private static void SerializeUser()throws FileNotFoundException,IOException{
        User user=new User();
        user.setName("zhangyu");
        user.setAge(18);

        // ObjectOutputStream对象输出流，将User对象存储到D盘
        ObjectOutputStream oo=new ObjectOutputStream(new FileOutputStream(new File("d:/user.txt")));
        oo.writeObject(user);
        System.out.println("user对象序列化");
        oo.close();
    }
    private static User DeserializeUser()throws Exception,IOException{
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new File("d:/user.txt")));
        User user=(User)ois.readObject();
        System.out.println("Person对象反序列化成功!");
        return user;
    }
}

3.通过克隆的方式

     无论何时我们调用一个对象的clone方法，jvm就会创建一个新的对象，将前面对象的内容全部拷贝进去。用clone方法创建对象并不会调用任何构造函数。 

package binarysearch;

/**
 * @author zhangyu
 * @version V1.0
 * @ClassName: CloneDemo
 * @Description: 测试序列化和反序列化的例子
 * @date 2019/3/5 16:48
 **/


public class CloneDemo implements Cloneable {
    // 定义一个bean
    private String name;

    public String getName() {
        return name;
    }

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

    public static void main(String[] args) {
        try {
            // 创建一个对象
            CloneDemo cloneTest = new CloneDemo();
            // 注入属性
            cloneTest.setName("zhangyu");
            // 复制一个属性
            CloneDemo copyClone = (CloneDemo) cloneTest.clone();
            System.out.println("newInstance:" + cloneTest.getName());
            System.out.println("copyInstance:" + copyClone.getName());
        } catch (Exception e) {
        }
    }
}

4.通过反射的方式

Constructor<Instance> constructor = Instance.class.getConstructor();
Instance instance= constructor.newInstance();

5.通过动态代理方式

    动态代理是spring中的概念，其实底层还是使用的反射机制。