Java中创建对象的4种方法

最新推荐文章于 2022-04-27 00:39:47 发布
最新推荐文章于 2022-04-27 00:39:47 发布
阅读量842 收藏 9
点赞数 1
分类专栏： 笔记 文章标签： 反射 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46399870/article/details/105471782
版权

通过new创建对象

会创建几个完全不相同的对象
实体类：

package cn.xiaov.creatobject;

public class Person {
    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;
    }
}

测试类

package cn.xiaov.creatobject;
/**
 * @ClassName TestByNew
 * @Description:  测试通过new产生对象
 * @author: RiceBall
 * @date: 2020/4/12 17:04
 */
public class TestByNew {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
        System.out.println(p1==p2); //false
    }
}

通过克隆创建对象

浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制

实现clone方法的步骤
（1）克隆对象实现Cloneable接口
（2）重写Object类中的clone()方法，重写时需要定义成public
（3）在重写方法中，调用super.clone()

浅克隆

实体类：

package cn.xiaov.creatobject;

public class Person implements Cloneable {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

测试类：

package cn.xiaov.creatobject;
/**
 * @ClassName TestByShallowClone
 * @Description: 测试浅克隆产生新的对象 
 * @author: RiceBall
 * @date: 2020/4/12 17:13
 */
public class TestByShallowClone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p1 = new Person("张三", 12);

        Person p2 = (Person) p1.clone();
        System.out.println(p1 == p2);   //false
        System.out.println(p2);         //Person{name='张三', age=12}
        p2.setName("李四");
        System.out.println(p1);         //Person{name='张三', age=12}
        System.out.println(p2);         //Person{name='李四', age=12}
    }
}

但是这仅仅是局限于浅克隆，当条件改变时，比如Person类增加一个成员变量Car car

package cn.xiaov.creatobject;

public class Car implements Cloneable {
    private int high;
    private String name;

    public Car() {
    }
    public Car(int high, String name) {
        this.high = high;
        this.name = name;
    }

    public int getHigh() {
        return high;
    }

    public void setHigh(int high) {
        this.high = high;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Car{" +
                "hight=" + high +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

此时改造后的Person类如下：

package cn.xiaov.creatobject;

public class Person implements Cloneable {
    private String name;
    private int age;
    private Car car;

    public Person() {
    }

    public Person(String name, int age, Car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }

    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;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

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

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

测试类：

package cn.xiaov.creatobject;
/**
 * @ClassName TestByShallowClone
 * @Description: 测试浅克隆产生新的对象
 * @author: RiceBall
 * @date: 2020/4/12 17:13
 */
public class TestByShallowClone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Car car =new Car(120,"BYD");
        Person p1 = new Person("张三", 12,car);

        Person p2 = (Person) p1.clone();
        System.out.println(p1 == p2);   //false
        System.out.println(p2);         //Person{name='张三', age=12, car=Car{high=120, name='BYD'}}
        p2.getCar().setName("Bentley");
        System.out.println(p1);         //Person{name='张三', age=12, car=Car{high=120, name='Bentley'}}
        System.out.println(p2);         //Person{name='张三', age=12, car=Car{high=120, name='Bentley'}}
    }
}

惊讶的发现：虽然只改变了p2的carName，但是p1的也跟着改变了，这显然不是我们需要的。
从这里就可以引入深克隆了。

深克隆

需要解决上面的问题，必须使用深克隆。
我们只需要在Person中修改clone()就好了，修改成如下：

@Override
    public Object clone() throws CloneNotSupportedException {
        //return super.clone();
        Person obj = null;
        obj= (Person)super.clone();
        Car car = (Car)obj.getCar().clone();
        obj.setCar(car);
        return obj;
    }

测试类：

package cn.xiaov.creatobject;
/**
 * @ClassName TestByShallowClone
 * @Description: 测试浅克隆产生新的对象
 * @author: RiceBall
 * @date: 2020/4/12 17:13
 */
public class TestByShallowClone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Car car =new Car(120,"BYD");
        Person p1 = new Person("张三", 12,car);

        Person p2 = (Person) p1.clone();
        System.out.println(p1 == p2);   //false
        System.out.println(p2);         //Person{name='张三', age=12, car=Car{high=120, name='BYD'}}
        p2.getCar().setName("Bentley");
        System.out.println(p1);         //Person{name='张三', age=12, car=Car{high=120, name='BYD'}}
        System.out.println(p2);         //Person{name='张三', age=12, car=Car{high=120, name='Bentley'}}
    }
}

这样就是修改p2的car而不会改变p1的car了。

通过序列化和反序列化创建对象

对象必须实现Serializable接口，将对象以流的形式序列化存入文件中，然后反序列化读出，实现克隆对象。

实体类：

package cn.xiaov.creatobject;

import java.io.Serializable;

public class People implements Serializable {
    private static final long serialVersionUID = 1276556512891407167L;
    private String name;
    private Cat cat;

    public People() {
    }

    public People(String name, Cat cat) {
        this.name = name;
        this.cat = cat;
    }

    public String getName() {
        return name;
    }

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

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

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

package cn.xiaov.creatobject;

import java.io.Serializable;

public class Cat implements Serializable {
    private static final long serialVersionUID = -3714996400599377283L;

    private int height;
    private String name;

    public Cat() {
    }

    public Cat(int height, String name) {
        this.height = height;
        this.name = name;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

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

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

SerializableUtil工具类：

package cn.xiaov.creatobject;

import java.io.*;

/**
 * @ClassName SerializableUtil
 * @Description: 序列化和反序列化产生对象的工具类
 * @author: RiceBall
 * @date: 2020/4/12 18:15
 */
public class SerializableUtil {

    private SerializableUtil() {
        throw new AssertionError();
    }

    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T clone(T obj) throws Exception {
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bout);
        oos.writeObject(obj);
        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bin);
        return (T) ois.readObject();
    }
}

测试类：

package cn.xiaov.creatobject;

public class TestBySerializable {
    public static void main(String[] args) throws Exception {
        Cat cat = new Cat(12, "小花");
        People p1 = new People("张三", cat);

        People p2 = SerializableUtil.clone(p1);
        System.out.println(p1==p2);     //false
        System.out.println(p2);         //People{name='张三', cat=Cat{height=12, name='小花'}}
        p2.getCat().setName("小红");
        System.out.println(p1);         //People{name='张三', cat=Cat{height=12, name='小花'}}
        System.out.println(p2);         //People{name='张三', cat=Cat{height=12, name='小红'}}
    }
}

通过反射产生对象

实体类使用上面的People和Cat
测试类如下：

package cn.xiaov.creatobject;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @ClassName TestByReflection
 * @Description: 测试通过反射创建对象
 * @author: RiceBall
 * @date: 2020/4/12 19:42
 */
public class TestByReflection {
    public static void main(String[] args) throws ClassNotFoundException,
            IllegalAccessException, InstantiationException, NoSuchMethodException,
            InvocationTargetException {
        Cat cat = new Cat(12, "小花");
        Class<?> c = Class.forName("cn.xiaov.creatobject.People");

        //直接使用newInstance()方法创建对象 调用无参构造
        People p1 = (People) c.getDeclaredConstructor().newInstance();
        //p1.setName("张三");
        //p1.setCat(cat);
        //通过反射调用普通方法
        Method setName = c.getDeclaredMethod("setName", String.class);
        Method setCat = c.getDeclaredMethod("setCat", Cat.class);
        setName.invoke(p1, "王五");
        setCat.invoke(p1, cat);
        System.out.println(p1);     //People{name='王五', cat=Cat{height=12, name='小花'}}

        //通过有参构造器创建对象
        Constructor<?> constructor = c.getDeclaredConstructor(String.class, Cat.class);
        People p2 = (People) constructor.newInstance("李四", cat);
        System.out.println(p2);     //People{name='李四', cat=Cat{height=12, name='小花'}}
    }
}

备注：
Java9之后，newInstance()方法过时，改用：

//被废弃的方法
//aClass.newInstance()
//更新后的使用
aClass.getDeclaredConstructor().newInstance();
7仔要加油
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【java】Java中创建对象有哪些方式？
DreamSun的博客
04-26 4702
本文介绍了Java中六种常见的创建对象的方式，分别是使用new关键字、Class的newInstance()方法、Constructor的newInstance()方法、clone()方法、反序列化、工厂模式等。在实际开发中，可以根据具体的业务场景选择不同的创建方式。
【小家java】Java中5种创建对象的方法，你知道几种？
架构师：通透，才能写出好代码！
07-18 953
作为一个Java开发者，一种面向对象的语言，我们每天都创建很多对象。但后续我们开发中，采用了spring的依赖管理系统，我们就很少自己去创建对象了，全部交给容器去托管，那么本篇文章回源塑本，讲述一下java中能够创建一个对象的5中方法。 本文最大的特色是，我不仅给出案例，还给出对应的字节码解释，从底层来解释现象 1.使用new关键字 这是最常见也是最简单的创建对象的方式了。通过这种方...
Java创建对象的5种方法
smiling
04-27 2814
使用new关键字 通过使用此方法，我们可以调用要调用的任何构造函数，即可以调用无参数的构造函数也可以调用有参数的构造函数。 User user = new User(); User user = new User(1,”admin”,19); 使用Class类的newInstance()方法 例如： User user = Class.forName(“com.smile.entity.User”).newInstance()...
redis笔记-共享对象
无
09-09 632
000
java创建对象的过程
caoPengFlying的博客
07-12 830
代码： public class A { private String name = &quot;A&quot;; A(){ System.out.println(name); } } public class B extends A { private String name = &quot;B&quot;; B(){ System.out.println(name); ...
Java创建对象的几种方法
08-31
这里我们将探讨三种常见的Java创建对象的方法：使用`new`关键字、使用`Object.clone()`以及通过反序列化。 1. **使用`new`关键字创建对象** 这是最常见也是最直接的方法。当类的实例需要被创建时，我们可以通过`...
JAVA创建和销毁对象的方法
08-31
本文将深入探讨Java中创建对象的几种方法以及对象的销毁。 首先，我们来看看创建对象的基本方式——构造器。构造器是每个类都具有的特殊方法，用于初始化新创建的对象。当你使用`new`关键字调用构造器时，一个新的...
java创建对象的五种方法demo
12-27
下面将详细讲解Java中创建对象的五种方法，并通过实际示例进行演示。 1. **使用`new`关键字构造器创建对象** 这是最常见、最直接的方法。每个类都有一个构造器，用于初始化新创建的对象。例如，假设我们有一个名为...
Java中创建对象的5种方式总结
08-31
本文将详细介绍Java中创建对象的五种方式，以及每种方式的特点和适用场景。 1. **使用`new`关键字** 这是最常见也是最直接的创建对象的方式。通过`new`关键字，我们可以调用类的构造函数来初始化新创建的对象。...
java实体对象_Java中的实体对象
weixin_35085438的博客
02-18 725
一、PO :(persistant object )，持久对象可以看成是与数据库中的表相映射的java对象。使用Hibernate来生成PO是不错的选择。二、VO :(value object) ，值对象通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可以和表对应,也可以不,这根据业务的需要.PO只能用在数据层，VO用在商务逻辑层和表示层。各层操作属于该层自己...
Java中创建对象的六个步骤 细分后（new关键字）对象头详细介绍
qq_43012792的博客
07-16 8537
要看的懂对象的创建过程，首先你得有对Java虚拟机和Java基础以及JUC很是熟悉，比如类的加载过程，CAS、多线程、JVM的GC等等 首先好看一个图，我大概会根据图中的内容来分享这六个步骤（其实几个步骤不重要，只要包括的内容都在就行）： 可以看完这个图就懵了，以下是创建对象的六个步骤： 1、判断是否能在常量池中能找到类符号引用，并检查是否已被加载、解析、初始化（即判断类元信息是否存在） 如果没有则在双亲委派模式下，使用当前类加载器以ClassLoader + 包名 + 类名为Key进行查找对应的.cl.
java创建对象的5种方式
sunzhicehng的博客
04-26 1364
1.new 2.使用反射Class.forName(“com.cn.mybatisDemo.util.Student”).newInstance()或Student.class.newInstance(); 3.使用构造器 Constructor constructor=Student.class.getConstructor(); Student newInstance =
图解java对象的创建过程
白子安
09-11 691
注：摘抄自https://www.cnblogs.com/chenyangyao/p/5296807.html 需提前掌握： java中类加载与静态变量、静态方法与静态代码块详解与初始化序：https://blog.csdn.net/qq_36522306/article/details/80584595 类加载过程：https://blog.csdn.net/cnahyz/arti...
Java中创建对象的5种方式，你都知道几种？【享学Java】
架构师：通透，才能写出好代码！
06-30 1265
前言 说起Java创建的对象一共有多少种方式这个问题，还是曾经有一次面试的时候被问起的。作为java开发者，我们每天创建很多对象，但是我们通常使用依赖注入的方式管理系统，比如：创建对象的工作交给Spring。 那么连使用new关键字创建对象都离我们渐行渐远的今天，你是否知道Java中创建对象有哪些种方式呢？ 本文将介绍5种方式来创建一个java对象： new关键字 Class.newInstan...
java对象的创建
love_QJP的博客
09-17 191
java对象的创建 在语言层面上，创建对象（例如克隆、发序列化）通常仅仅是一个new关键字而已。 类加载过程 而虚拟机遇到一个new指令时,首先去检查这个指令的参数是否能在常量池中定义一个定位到一个类的引用，并检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有，那必须先执行相应的类加载过程。 在类加载检查通过后，接下来虚拟机要为新生对象分配内存。对象所需的内存大小在类加...
JAVA基础（创建对象的步骤）
Cricket_7的博客
06-13 2961
1，创建对象给成员变量赋值的两种方式的区别： p1 = new Person("张天一",23); 每次new相当于重新创建一个对象 Person p2 = new Person();//空参构造创建对象 构造方法： 给属性进行初始化 setXxx方法 修改属性值 这两种方式,在开发中用setXxx更多一些,因为...
Java实体类的构建与使用
AUK016的博客
05-29 6180
构造方法： 与实体类同名的方法，用于创建实体类对象。 set方法： 为实体类对象中的属性赋值 get方法： 从实体类对象中获取属性值 构造方法所带参数不同，则创建的对象“长相”也不同。 一个实体类可以有很多个，“长相”不同的对象。 package com.auko.test.entity; /** * 实体类Student,包含属性stu_name,class_no,stu_no,tel_no,math_grade,chinese_grade * */ public class Student {.
Java类与对象：构造方法和对象创建
总结来说，类和对象构成了Java面向对象编程的基础，通过定义类来描述现实世界的实体，通过创建对象来实例化这些类，并通过属性和方法来表示实体的特征和行为。构造方法和方法的重载是Java中实现对象初始化和功能多样...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值