Java 中创建一个对象的 6 种方式

最新推荐文章于 2024-07-27 09:41:54 发布
最新推荐文章于 2024-07-27 09:41:54 发布
阅读量1k 收藏
点赞数
分类专栏： Java 文章标签： java Java创建对象的几种方式 Java创建对象 Java创建对象的6种方式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daidaineteasy/article/details/114288768
版权

文章目录


为了方便后边的代码展示，我们先提前定义一个演示类： 

@Data
public class User {

    private String userName;
    private short age;

    public User() {
        System.out.println("------ 调用无参构造方法 ------");
    }

    public User(String userName, short age) {
        this.userName = userName;
        this.age = age;

        System.out.println(String.format("------ 调用有参构造方法：userName[%s], age[%d] ------", userName, age));
    }
}
1、使用 new 关键字创建对象

这是最常见也是最简单的创建对象的方式。通过这种方式，我们可以调用定义的构造函数(无参的和带参数的)来创建对象。
如：

public static void main(String[] args) {
	User user1 = new User();
	User user2 = new User("Lucy", (short) 18);

	System.out.println(user1);
	System.out.println(user2);
}

输出：

------ 调用无参构造方法 ------
------ 调用有参构造方法：userName[Lucy], age[18] ------
User(userName=null, age=0)
User(userName=Lucy, age=18)

2、使用 Constructor 类的 newInstance 方法

通过 Class 类对象的 getConstructor() 或 getDeclaredConstructor() 方法获得构造器（Constructor）对象，并调用其 newInstance() 方法创建对象，适用于无参和有参构造方法。
如：

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException,
		InvocationTargetException, InstantiationException {

	// 获取 User 的无参构造函数，并创建对象
	User user1 = User.class.getDeclaredConstructor().newInstance();
	// 获取 User 的第一个参数是String， 第二个参数是short的构造函数，并创建对象
	User user2 = User.class.getDeclaredConstructor(String.class, short.class).newInstance("Lili", (short)17);

	System.out.println(user1);
	System.out.println(user2);
}

输出：

------ 调用无参构造方法 ------
------ 调用有参构造方法：userName[Lili], age[17] ------
User(userName=null, age=0)
User(userName=Lili, age=17)

这是通过反射创建对象的一种方式，这里 getConstructor() 和 getDeclaredConstructor() 区别是：

  • getConstructor ： 构造函数的访问权限必须是 public
  • getDeclaredConstructor ： 构造函数可以是任意访问权限

通过这种方式可以调用类私有的构造方法，但需要禁用构造器对象的安全检查。
如：

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException,
		InvocationTargetException, InstantiationException {

	Constructor<User> constructor = User.class.getDeclaredConstructor();
	// 禁用 constructor 构造器对象的安全检查
	constructor.setAccessible(true);

	User user = constructor.newInstance();

	System.out.println(user);
}

禁用安全检查后，就可以通过私有的构造方法创建新对象了。

3、使用 Class 类的 newInstance 方法

这种方式跟上边第 2 种方式差不多，都是通过反射来创建对象。内部其实也是先获取到 Constructor 构造器对象，然后再使用 Constructor 类的 newInstance 方法创建对象。不过通过这种方式创建对象，调用的是无参构造方法，并且此无参构造方法不能是 private （Class 类的 newInstance 方法中做了访问类型校验）。
如：

public static void main(String[] args) throws IllegalAccessException, InstantiationException {

	User user = User.class.newInstance();

	System.out.println(user);

}

输出：

------ 调用无参构造方法 ------
User(userName=null, age=0)

4、使用 clone 方法

想要通过 clone 方式创建对象，则需要对 User 类做一些改动：

  1. User 类实现 Cloneable 接口；
  2. User 类中，重写 Object 类中的 clone() 方法。

这里有个有意思的地方，查看 Cloneable 接口源码，我们可以看到，这个接口中一个方法也没有。重写的 clone() 方法是 Object 这个超级父类中的。

那这里的 Cloneable 接口有什么用呢？

其实，这里的 Cloneable 接口起到的是一个标记的作用，在JVM中，具有这个标记的对象才有可能被拷贝。那怎么才能从“有可能被拷贝” 转换为 “可以被拷贝” 呢？ 那就是重写 Object 类的 clone() 方法。

改动后的 User 类如下：

@Data
public class User implements Cloneable{

    private String userName;
    private short age;

    protected User() {
        System.out.println("------ 调用无参构造方法 ------");
    }

    public User(String userName, short age) {
        this.userName = userName;
        this.age = age;

        System.out.println(String.format("------ 调用有参构造方法：userName[%s], age[%d] ------", userName, age));
    }

    @Override
    protected User clone() throws CloneNotSupportedException {
        System.out.println("------ 调用 clone 方法 ------");
        return (User)super.clone();
    }
}

接下来试下通过 clone 创建对象：

public static void main(String[] args) throws CloneNotSupportedException {

	User user = new User("Lilei", (short) 20);
	// 通过 clone 方式创建对象
	User cloneUser = user.clone();

	System.out.println(user);
	System.out.println(cloneUser);
	
	// 看下对象是否是同一个对象
	System.out.println(user == cloneUser);

}

输出：

------ 调用有参构造方法：userName[Lilei], age[20] ------
------ 调用 clone 方法 ------
User(userName=Lilei, age=20)
User(userName=Lilei, age=20)
false

通过 clone 方式创建对象，并不会调用任何构造函数，而是直接在内存中对二进制流的拷贝，要比直接 new 一个对象性能好很多。

注意：在使用 clone 方式创建对象时，需要注意深拷贝和浅拷贝的不同，不了解的可以百度下，这里就不进行扩展了。

5、使用 Serializable 反序列化方式

想要通过 Serializable 反序列化方式创建对象，则类需要实现 Serializable 接口。这里 Serializable 接口也是一个标记的作用，当我们让实体类实现 Serializable 接口时，其实是在告诉JVM此类可被默认的序列化机制序列化。

改动后的 User 类如下：

@Data
public class User implements Serializable {

    private static final long serialVersionUID = 7330451128451152699L;
    
    private String userName;
    private short age;

    protected User() {
        System.out.println("------ 调用无参构造方法 ------");
    }

    public User(String userName, short age) {
        this.userName = userName;
        this.age = age;

        System.out.println(String.format("------ 调用有参构造方法：userName[%s], age[%d] ------", userName, age));
    }

}

接下来试下通过反序列化方式创建对象：

public static void main(String[] args) throws IOException, ClassNotFoundException {

	User user = new User("Hanmeimei", (short) 18);

	// 通过 ObjectOutputStream 对象输出流，将 user 对象序列化写入到 user.txt 文件中
	ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:\\user.txt"));
	out.writeObject(user);
	out.close();

	// 通过 ObjectInputStream 对象输入流，将 user.txt 文件中内容反序列化，创建一个 User 对象
	ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:\\user.txt"));
	User user_1 = (User)in.readObject();

	// 再次通过 ObjectInputStream 对象输入流，将 user.txt 文件中内容反序列化，创建一个 User 对象
	in = new ObjectInputStream(new FileInputStream("D:\\user.txt"));
	User user_2 = (User)in.readObject();

	System.out.println(user);
	System.out.println(user_1);
	System.out.println(user_2);

	// 判断两次反序列化创建的对象是否是同一个对象
	System.out.println(user_1 == user_2);

}

输出：

------ 调用有参构造方法：userName[Hanmeimei], age[18] ------
User(userName=Hanmeimei, age=18)
User(userName=Hanmeimei, age=18)
User(userName=Hanmeimei, age=18)
false

通过 Serializable 反序列化方式创建对象，也不会调用任何构造函数。如果想控制哪个字段属性不被序列化和反序列化，可以通过 transient 关键字，将属性指定为瞬时态。

上边是使用的JVM默认的序列化和反序列化逻辑，如果想要使用自定义的序列化和反序列化，需要添加两个方法 private void writeObject(ObjectOutputStream out) 和 private void readObject(ObjectInputStream in)

改动后的 User 类如下：

@Data
public class User implements Serializable {

    private static final long serialVersionUID = 7330451128451152699L;

    private String userName;
    private short age;

    public User() {
        System.out.println("------ 调用无参构造方法 ------");
    }

    public User(String userName, short age) {
        this.userName = userName;
        this.age = age;

        System.out.println(String.format("------ 调用有参构造方法：userName[%s], age[%d] ------", userName, age));
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.writeShort(age); // 序列化时，只写入 age 的值（哪些序列化哪些不序列化，都由我们自己控制）
        System.out.println("------ 调用 writeObject 方法 ------");
    }

    private void readObject(ObjectInputStream in) throws IOException,
            ClassNotFoundException {
        age = in.readShort(); // 反序列化时，只读取 age 的值，这个顺序需要跟写入顺序一致
        System.out.println("------ 调用 readObject 方法 ------");
    }

}

再来试下反序列化方式创建对象：

public static void main(String[] args) throws IOException, ClassNotFoundException {

	User user = new User("Hanmeimei", (short) 18);

	// 通过 ObjectOutputStream 对象输出流，将 user 对象序列化写入到 user.txt 文件中
	ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:\\user.txt"));
	out.writeObject(user);
	out.close();

	// 通过 ObjectInputStream 对象输入流，将 user.txt 文件中内容反序列化，创建一个 User 对象
	ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:\\user.txt"));
	User user_1 = (User)in.readObject();

	System.out.println(user);
	System.out.println(user_1);

}

输出：

------ 调用有参构造方法：userName[Hanmeimei], age[18] ------
------ 调用 writeObject 方法 ------
------ 调用 readObject 方法 ------
User(userName=Hanmeimei, age=18)
User(userName=null, age=18)

这里为什么加上 writeObject 和 readObject 方法后，就可以实现自定义的序列化和反序列化呢？这是因为 ObjectOutputStream 和 ObjectInputStream 使用反射来寻找是否声明了这两个方法。如果声明了这俩方法，并且访问类型是私有的，则使用这两个方法来进行序列化和反序列化。

注意1：使用自定义序列化和反序列化时，可以序列化和反序列化瞬态变量，因此 transient 没有效果。

注意2：serialVersionUID 用来表明实现序列化类的不同版本间的兼容性。如果类内容没有修改，或者修改后的类兼容之前的类，请不要修改此值，否则之前序列化的类在反序列化时会报错。

6、使用 Externalizable 反序列化方式

Externalizable 是 Serializable 接口的子接口，它也允许我们控制整个序列化过程。通过这种方式反序列化创建对象时，会先调用默认的无参构造函数创建对象（访问类型必须是 public ），然后再将反序列化读取到的值填充到对象中。

使用 Externalizable 方式，需要实现 writeExternal(ObjectOutput out) 和 readExternal(ObjectInput in) 方法的逻辑。

我们来看下 User 改动后：

@Data
public class User implements Externalizable {

    private static final long serialVersionUID = 7330451128451152697L;

    private String userName;
    private short age;

    public User() {
        System.out.println("------ 调用无参构造方法 ------");
    }

    public User(String userName, short age) {
        this.userName = userName;
        this.age = age;

        System.out.println(String.format("------ 调用有参构造方法：userName[%s], age[%d] ------", userName, age));
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeShort(age); // 序列化时，只写入 age 的值（哪些序列化哪些不序列化，都由我们自己控制）
        System.out.println("------ 调用 writeExternal 方法 ------");
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        age = in.readShort(); // 反序列化时，只读取 age 的值，这个顺序需要跟写入顺序一致
        System.out.println("------ 调用 readExternal 方法 ------");
    }
}

接下来试下通过反序列化方式创建对象：

public static void main(String[] args) throws IOException, ClassNotFoundException {

	User user = new User("Hanmeimei", (short) 18);

	// 通过 ObjectOutputStream 对象输出流，将 user 对象序列化写入到 user.txt 文件中
	ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:\\user.txt"));
	out.writeObject(user);
	out.close();
	
	// 通过 ObjectInputStream 对象输入流，将 user.txt 文件中内容反序列化，创建一个 User 对象
	ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:\\user.txt"));
	User user_1 = (User)in.readObject();
	
	System.out.println(user);
	System.out.println(user_1);
	
}

输出：

------ 调用有参构造方法：userName[Hanmeimei], age[18] ------
------ 调用 writeExternal 方法 ------
------ 调用无参构造方法 ------
------ 调用 readExternal 方法 ------
User(userName=Hanmeimei, age=18)
User(userName=null, age=18)

注意1：使用 Externalizable，可以序列化/反序列化瞬态变量，因此 transient 没有效果。

注意2：serialVersionUID 用来表明实现序列化类的不同版本间的兼容性。如果类内容没有修改，或者修改后的类兼容之前的类，请不要修改此值，否则之前序列化的类在反序列化时会报错。

6种创建对象方式的总结

最后，我们来看下6种创建对象方式的区别：

方式是否用到构造函数特点
使用 new 关键字是简单
使用 Constructor 类的 newInstance是可以使用任何访问类型的构造函数
使用 Class 类的 newInstance是只能使用非私有的无参构造函数
使用 clone 方法否直接在内存中对二进制流的拷贝，性能好
使用 Serializable 反序列化否
使用 Externalizable 反序列化是相比 Serializable ，可以实现构造方法的初始化过程（必须是 public 的无参构造方法）
晓呆同学
关注
专栏目录
深入理解Java虚拟机之创建对象，即创建一个类的过程
striveb的博客
11-08 761
一.对象的创建 1.类加载检查和分配内存 虚拟机遇到一条new指令时，首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已被加载、 解析和初始化过。 如果没有，那必须先执行相应的类加载过程。 在类加载检查通过后，接下来虚拟机将为新生对象分配内存。 对象所需内存的大小在类加载完成后便可完全确定，为对象分配空间的任务等同于把一块确定大小的内存从Ja...
java中创建对象4种方式
weixin_51994092的博客
08-18 3421
java中创建对象4种方式
java怎么定义_java怎么定义一个对象？
weixin_39979332的博客
02-12 864
展开全部你应该问怎么实例化一个类生成一个对象java 是先定义一e69da5e887aa62616964757a686964616f31333335346161个类 ，然后new 这个类，然后生成对象的Java编程中类和对象的定义1，什么是类？答：类是客观存在的，抽象的，概念的东西。2，什么事对象？答：对象是具体的，实际的，代表一个事物。例如：车是一个类，汽车，自行车就是他的对象。关于类与对象的描...
java中创建对象地方式有哪几种？（面试高频）
最新发布
qa3629723的博客
07-27 765
在Java中，这通常是通过实现`java.io.Serializable`接口（或`java.io.Externalizable`接口，但后者需要更复杂的实现）来完成的。虽然直接回答无法详尽到3000字，但我可以概述几种常见的创建对象的方法，并给出代码示例及注释，同时简要讨论一些高级话题如工厂模式、单例模式等，以便你能更全面地理解对象创建的方式。在Java中，序列化和反序列化是对象持久化的一种方式，它们分别用于将对象的状态保存到一系列字节中（序列化），以及从字节序列中恢复对象（反序列化）。
JVM-创建对象的步骤
kk阿彬
10-06 204
对象创建的方式 和 步骤 对象创建方式 new：最常见的方式、单例类中调用getInstance的静态类方法，XXXFactory的静态方法 Class的newInstance方法：在JDK9里面被标记为过时的方法，因为只能调用空参构造器，访问修饰符只能是public Constructor的newInstance(XXX)：反射的方式，可以调用空参的，或者带参的构造器，没有访问修饰符限制。所以取代了Class的newInstance方法 使用clone()：不调用任何构造器，要求当前的类
Java对象的创建
qq_41134990的博客
08-01 2131
应用：Java 中创建对象的 5 种方式！ - SegmentFault 思否1、使用new关键字这是最常见也是最简单的创建对象的方式了。通过这种方式，我们可以调用任意的构造函数(无参的和带参数的)。 Employee emp1 = new Employee(); 0: new           #19          // class org/programm
java创建静态对象_java - 以静态方式创建对象
weixin_36106506的博客
03-08 2076
初始化操作的一般顺序是(在加载类之后和首次使用之前)：静态(类)代码块按顺序出现在代码中，对象代码块按顺序出现在代码中(初始化块和赋值)。构造函数当然我不会将构造函数和函数体引用为上面的代码块。我不知道怎么样final static字段。 看起来它们遵循final static字段的规则，并且在声明之前它们不能被引用，尽管先前的注释它们在编译步骤初始化。 如果在编译错误之前引用它们：Example...
java 创建对象 设置属性_详解Java的对象创建
weixin_42548874的博客
02-13 4268
1. 前言在《还不清楚怎样面向对象？》和《面向对象再探究》两篇文章中，都介绍了关于面向对象程序设计的概念和特点。其中也涉及到了许多代码，比如：Dog dog = new Dog();这篇文章就主要来谈谈创建对象时的具体操作。2. 引入例子下面是一个Dog类：/*** @author Xing Xiaoguan (xingrenguanxue)*/public class Dog {private ...
java 之创建对象
qq_53096613的博客
03-02 3669
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 这是我学习过程中做的总结，如有不对见谅。 创建对象 我们用Demo类来创建一个对象。 Demo demo=new Demo(); 这一条语句，其实包括了四个动作： 1）右边的“new Demo”，是以Demo类为模板，在堆空间里创建一个Demo对象。 2）末尾的()意味着，在对
Java 中String 创建对象
李某的博客
04-22 1570
文章目录String创建对象的两种方式两种创建String对象的区别例1例2例3例4总结 String创建对象的两种方式 （1）方式一：直接赋值 String s1 = "hello"; (2) 方式二 调用构造器 String s2 = new String("hello"); 两种创建String对象的区别 方式一：先从常量池查看是否有"hello"的数据空间，如果有，直接指向其数据空间，如果没有，则重新创建，然后指向s1。s1最终指向的是常量池空间地址。 方式二：先再堆中创建空间，里面维护了va
Java对象的创建（1）
明天的你会感谢今天的自己
12-18 655
String str=new String("abc")
Java创建对象的方式
袁的博客
02-18 3701
Java创建对象的五种方式！！！
创建一个对象可以有几种方法
qq_41648092的博客
03-31 937
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title></title> <script type="text/javascript"> /** * 创建一个对象 * */ // var obj={ ...
Java中一个对象的创建过程
m0_52276165的博客
11-11 1445
Java中一个对象的创建过程 step1：检查该类是否被加载 当JVM执行一条new指令时，首先要去常量池中查找该类的符号引用。 当在常量池中查找到该类的符号引用，就说明该类已经被类加载（方法区保存了该类的类加载信息），就可以继续执行后续操作。 当在常量池中查找不到该类的符号引用，说明该类还没有被类加载，因此就要用类加载器执行该类的类加载过程。类加载完毕后执行后续操作。 step2：为对象分配内存 类加载之后，就要为新生对象分配内存空间。对象的大小在类加载的过程中就已经确定。分配空间有两种方式：1.指针碰撞
java对象的创建过程
热门推荐
fly_rice的博客
09-03 1万+
大家都知道，java使用new 关键字进行对象的创建，但这只是从语言层次上理解了对象的创建，下边我们从jvm的角度来看看，对象是怎么被创建出来的，即对象的创建过程。 对象的创建大概分为以下几步： 1：检查类是否已经被加载； 2：为对象分配内存空间； 3：为对象字段设置零值； 4：设置对象头； 5：执行构造方法。 第一步，当程序遇到new 关键字时，首先会去运行时常量池中查找该引用所指...
Java中创建一个对象的步骤
weixin_43502415的博客
04-18 2034
A:画图演示 画图说明一个对象的创建过程做了哪些事情? Student s = new Student(); 1,Student.class加载进内存 2,声明一个Student类型引用s 3,在堆内存创建对象, 4,给对象中属性默认初始化值（基本数据类型为0，引用数据类型为null） 5,属性进行显示初始化 6,构造方法进栈,对对象中的属性赋值,构造方法弹栈 7,将对象的地址值赋值给s ...
创建对象的四种方式
weixin_45151960的博客
10-25 3832
创建的对象的四种方式 使用new创建对象 使用new关键字创建对象应该是最常见的一种方式，但我们应该知道，使用new创建对象会增加耦合度。无论使用什么框架，都要减少new的使用以降低耦合度。 使用反射的机制创建对象 使用Class类的newInstance方法 使用Constructor类的newInstance方法 采用clone clone时，需要已经有一个分配了内存的源对象，创建...
java创建对象的详细步骤
weixin_44568697的博客
09-24 665
java创建对象一共分为六个步骤： 1.判断对象对应的类是否加载、链接（链接又分为校验、准备、解析）、初始化。 2.为对象分配内存： （1）如果内存规整——指针碰撞（假设java堆中内存是绝对规整的，所有用过的内存放一边，未使用过的放一边，中间有一个指针作为临界点，如果新创建了一个对象则是把指针往未分配的内存挪动与对象内存大小相同距离，这个称为指针碰撞。）。 （2）如果内存不规整——虚拟机维护一个列表、然后通过空闲列表分配内存。 3.处理并发安全问题。 4.初始化分配到的空间——给所有属..
java创建对象的三种方式
09-09
在Java中，创建对象有三种方式。第一种是显式创建对象，可以使用关键字new来创建对象，例如：ClassName obj = new ClassName();这种方式是最常见和简单的创建对象的方式。 第二种方式是使用java.lang.Class类的new...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

晓呆同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值