java创建对象时，new 出一个对象 和 = null的区别

Posted 2023-05-15

如果使用new，就会创建一个新的对象，并且占用空间。如果只是null，则不会创建对象，不会占用空间。
一般在初始化时，会使用null进行初始化，实际要使用到某个对象时，再进行创建。 参考技术A new 会创建空间，null不需要，只在用到时再创建

java设计模式——原型模式

一. 定义与类型

定义：指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。不需要知道任何创建的细节，不调用构造函数

类型：创建型

二.使用场景

类初始化消耗较多资源

new 产生的一个对象需要非常繁琐的过程(数据准备，访问权限等)

构造函数比较复杂

循环体中生产大量对象时

三.优缺点

优点：

　　原型模式性能比直接new一个对象性能高，简化创建过程

缺点：

　　必须配备克隆方法，

　　对克隆复杂对象或对克隆出的对象进行复杂改造时，容易引入风险

　　深拷贝，浅拷贝要运用得当

四. 扩展

深克隆：对于引用类型，如果需要指向不同的对象，而对于某个对象的引用类型的时候，必须要显式的去写对那个属性进行深克隆

浅克隆：

五. Coding

/**
 * @program: designModel
 * @description:
 * @author: YuKai Fan
 * @create: 2018-12-13 16:11
 **/
public class Mail implements Cloneable {
    private String name;
    private String emailAddress;
    private String content;
    public Mail() {
        System.out.println("Mail Class Constructor");
    }

    public String getName() {
        return name;
    }

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

    public String getEmailAddress() {
        return emailAddress;
    }

    public void setEmailAddress(String emailAddress) {
        this.emailAddress = emailAddress;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "Mail{" +
                "name=\'" + name + \'\\\'\' +
                ", emailAddress=\'" + emailAddress + \'\\\'\' +
                ", content=\'" + content + \'\\\'\' + super.toString() +
                \'}\';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        System.out.println("clone mail object");
        return super.clone();
    }
}

/**
 * @program: designModel
 * @description:
 * @author: YuKai Fan
 * @create: 2018-12-13 16:17
 **/
public class MailUtil {
    public static void sendMail(Mail mail) {
        String outputContent = "向{0}同学,邮件地址:{1},邮件内容:{2}发送成功";
        System.out.println(MessageFormat.format(outputContent,mail.getName(),mail.getEmailAddress(),mail.getContent()));
    }

    public static void saveOriginMailRecord(Mail mail) {
        System.out.println("存储originMail记录,originMail:" + mail.getContent());
    }
}

/**
 * @program: designModel
 * @description:
 * @author: YuKai Fan
 * @create: 2018-12-13 16:20
 **/
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Mail mail = new Mail();
        mail.setContent("初始化模板");
        System.out.println("初始化mail:" + mail);
        for (int i = 0; i < 10; i++) {
            //克隆的时候，并不会使用原对象的构造器
            Mail mailTemp = (Mail) mail.clone();
            mailTemp.setName("姓名" + i);
            mailTemp.setEmailAddress("姓名" + i + "@qq.com");
            mailTemp.setContent("恭喜您，中奖了");
            MailUtil.sendMail(mailTemp);
        }
        MailUtil.saveOriginMailRecord(mail);
    }
}

从上面的代码不难看出，其实原型模式就是实现了cloneable接口，在创建一个不同的对象，来完成邮件的发送，而保留了原来的邮件模板。由于clone不会，调用原对象的构造器，所以在效率上比直接new 对象要高。但是，因为在Mail类中的属性都是简单类型，所以在clone的时候，基本上不会出现上面问题。但是看下面一个实体：

/**
 * @program: designModel
 * @description:
 * @author: YuKai Fan
 * @create: 2018-12-13 16:33
 **/
public class Pig implements Cloneable {
    private String name;
    private Date birthDay;

    public Pig(String name, Date birthDay) {
        this.name = name;
        this.birthDay = birthDay;
    }

    public String getName() {
        return name;
    }

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

    public Date getBirthDay() {
        return birthDay;
    }

    public void setBirthDay(Date birthDay) {
        this.birthDay = birthDay;
    }

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

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

/**
 * @program: designModel
 * @description:
 * @author: YuKai Fan
 * @create: 2018-12-13 16:34
 **/
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Date birthDay = new Date(0L);
        Pig pig = new Pig("佩奇", birthDay);
        Pig pig1 = (Pig) pig.clone();
        System.out.println(pig);
        System.out.println(pig1);

        pig.getBirthDay().setTime(6666666666666L);
        /**
         * 通过上面对birthDay进行操作，如果是浅拷贝，那么pig与pig1的date对象都会改变：
         *  因为在浅拷贝的时候，两个对象中的引用对象date，都是引用同一个对象，所以改变了一个，那么两个都会改变
         *
         * 如果是深拷贝，那么pig与pig1引用的date对象就是不一样的，改变其中一个，对另一个并没有影响。
         *
         * 由于深克隆，浅克隆的关系，也算是原型模式的一个坑。(原则是，都会使用深克隆，不然就算是给项目埋坑)
         *
         */
        System.out.println(pig);
        System.out.println(pig1);
    }
}

输出结果为：

上面的注释和结果，其实也清楚的看到了。我只改变了pig对象中的birthDay，但是pig1中也改变了。如果clone的对象中存在引用类型的对象，那么如果是浅拷贝，拷贝与被拷贝出的对象的引用对象都是指向同一地址的，所以改变其中一个，另一个也会改变。这时候，如果根据需求就必须使用深拷贝。

也就是对于对象中的引用对象也要进行clone。看下面代码：

/**
 * @program: designModel
 * @description:
 * @author: YuKai Fan
 * @create: 2018-12-13 16:33
 **/
public class Pig implements Cloneable {
    private String name;
    private Date birthDay;

    public Pig(String name, Date birthDay) {
        this.name = name;
        this.birthDay = birthDay;
    }

    public String getName() {
        return name;
    }

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

    public Date getBirthDay() {
        return birthDay;
    }

    public void setBirthDay(Date birthDay) {
        this.birthDay = birthDay;
    }

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Pig pig = (Pig) super.clone();

        //深克隆
        pig.birthDay = (Date) pig.birthDay.clone();
        return pig;
    }
}

输出结果：

可以看到，Pig中重写了clone方法，对Date对象也进行了clone，从而使得，引用对象指向不同的地址。所以改变pig中的birthDay，对于pig1并没有影响。

由于clone方法，可以用原型模式拷贝来破坏单例模式：

/**
 * @program: designModel
 * @description:
 * @author: YuKai Fan
 * @create: 2018-12-13 16:34
 **/
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {

        /**
         * 使用原型模式，克隆破坏单例模式
         *
         * 这种情况的解决方式：
         * 要么单例模式类不去实现Cloneable接口，要么就重写clone方法，直接返回getInstance()方法，这个对象的实例
         */
        HungrySingleton hungrySingleton = HungrySingleton.getInstance();
        Method method = hungrySingleton.getClass().getDeclaredMethod("clone");
        method.setAccessible(true);
        HungrySingleton cloneHungrySingleton = (HungrySingleton) method.invoke(hungrySingleton);
        System.out.println(hungrySingleton);
        System.out.println(cloneHungrySingleton);
    }
}

六. 源码分析

基本上只要知道了哪些类使用了Cloneable就知道，原型模式如何使用。

比如ArrayList，HashMap类都重写了clone方法

Mybatis中的CacheKey类也重写了clone()方法