创建对象四种方式JAVA

面试题经常见到，就顺带整理下，创建对象的四种方式：

1.使用new创建对象

2.使用反射创建对象

3.使用clone创建对象

4.使用序列化反序列化创建对象

代码如下：

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/**
 * @Author: zhangximing
 * @Email: 530659058@qq.com
 * @Date: 2023/9/11 17:47
 * @Description: 创建对象四种方式
 */
public class CreateObject {

    public static void main(String[] args) throws Exception {
        //1、new创建对象
        createByNew();

        //2、反射创建对象
        createByReflect("com.zhangximing.springbootinterceptor.object.MyObject");

        //3、clone创建对象（浅复制）
        createByClone();

        //4、序列化创建对象
        createBySer();
    }

    /**
     * new创建对象
     */
    public static void createByNew(){
        MyObject myObject = new MyObject();
        myObject.create("new创建对象");
    }

    /**
     * 反射创建对象
     * @param classPathName
     * @throws Exception
     */
    public static void createByReflect(String classPathName) throws Exception {
        Class c = Class.forName(classPathName);
        //无参构造方法创建对象
        Object object = c.newInstance();
//        //有参构造器创建对象
//        Constructor privateCon = c.getConstructor(String.class,MyObjectT.class);
//        Object object1 = privateCon.newInstance("测试",new MyObjectT());
        //方法一：强转为指定对象调用方法
        MyObject myObject = (MyObject) object;
        String msg = "反射创建对象";
        myObject.create(msg);
        //方法二：指定方法以及参数进行调用
        Method executeMethod = c.getMethod("createT",String.class,Integer.class);
        Object result = executeMethod.invoke(object,msg,1);
        System.out.println("返回结果："+result);
    }

    /**
     * clone创建对象（注意对应类需要实现Cloneable）
     */
    public static void createByClone(){
        MyObject myObject = new MyObject();
//        MyObjectT myObjectT = new MyObjectT();
//        myObjectT.setName("测试1");
//        myObject.setMyObjectT(myObjectT);
        //浅拷贝：只拷贝对象本身，不拷贝引用对象
        MyObject myObjectClone = (MyObject) myObject.clone();
        myObjectClone.create("clone创建对象");
    }

    /**
     * 序列化创建对象（注意对应类需要实现Serializable）
     * 序列化：把Java对象转换为字节序列的过程。
     * 反序列化：把字节序列恢复为Java对象的过程。
     * @throws Exception
     */
    public static void createBySer() throws Exception {
        File file = new File("myObject.txt");
        //序列化持久化对象
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
        MyObject myObject = new MyObject("测试序列化",new MyObjectT("被引用对象"));
        out.writeObject(myObject);
        out.close();

        //反序列化，并得到对象
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
        // 没有强制转换类型
        Object object = in.readObject();
        in.close();
        System.out.println(object);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

import java.io.Serializable;

/**
 * @Author: zhangximing
 * @Email: 530659058@qq.com
 * @Description: 对象
 */
public class MyObject implements Cloneable, Serializable {

    private String name;

    private MyObjectT myObjectT;

    public MyObject(){}

    public MyObject(String name, MyObjectT myObjectT) {
        this.name = name;
        this.myObjectT = myObjectT;
    }

    public String getName() {
        return name;
    }

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

    public MyObjectT getMyObjectT() {
        return myObjectT;
    }

    public void setMyObjectT(MyObjectT myObjectT) {
        this.myObjectT = myObjectT;
    }

    public void create(String msg){
        System.out.println(msg);
    }

    public String createT(String msg,Integer i){
        return "已处理"+i+"，"+msg;
    }

    @Override
    public MyObject clone() {
        //浅拷贝
        try {
            MyObject clone = (MyObject) super.clone();
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new InternalError(e);
        }
    }

    @Override
    public String toString() {
        return "MyObject{" +
                "name='" + name + '\'' +
                ", myObjectT=" + myObjectT +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

import java.io.Serializable;

/**
 * @Author: zhangximing
 * @Email: 530659058@qq.com
 * @Description: 被引用对象（用于验证浅复制）
 */
public class MyObjectT implements Serializable {

    private String name;

    public MyObjectT(){}

    public MyObjectT(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "MyObjectT{" +
                "name='" + name + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32