在实际开发中，某些情况下，我们可能需要频繁去创建一些对象（new），下面介绍一种，我从书上看到的，可以提高效率的方法。

首先，对于将会频繁创建的对象，我们要让这个类实现Cloneable接口，因为这个优化的核心，就是利用clone。

clone的最大特点就是，不会去调用任何构造方法，所以，在我看来重点应该放在构造方法中。

1.先写一个实体类：

在此实体类中写一个getInstance()，其中就是返回clone()。

import java.io.Serializable;


/**
* @ClassName: 生产单ERP
* @author hanwl
* @Description: TODO
*/

public class ErpProduct implements Serializable,Cloneable{
    private static final long serialVersionUID = 1L;
    private static ErpProduct erpProduct = new ErpProduct();
    
    private String topicNum;//选题号 选填
    private String compName;//部件名 必填 (多个部件以 ','分隔   封面,正文)
    private String printShop;//印厂名 必填 
    private String printUser; //分发人 必填 
    private String reback;//是否撤回 必填  0 默认分发  1撤回分发
    private String printNum;//印数 （选填）
    
    public ErpProduct() {
        super();
    }

    /**
     * 调用对象创建优化
     * 
     * @return
     */
    public static ErpProduct getInstance(){
        try {
            return (ErpProduct) erpProduct.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return new ErpProduct();
    }
    
    public String getTopicNum() {
        return topicNum;
    }
    public void setTopicNum(String topicNum) {
        this.topicNum = topicNum;
    }
    public String getCompName() {
        return compName;
    }
    public void setCompName(String compName) {
        this.compName = compName;
    }
    public String getPrintShop() {
        return printShop;
    }
    public void setPrintShop(String printShop) {
        this.printShop = printShop;
    }
    public String getPrintUser() {
        return printUser;
    }
    public void setPrintUser(String printUser) {
        this.printUser = printUser;
    }
    public String getPrintNum() {
        return printNum;
    }
    public void setPrintNum(String printNum) {
        this.printNum = printNum;
    }
    public String getReback() {
        return reback;
    }
    public void setReback(String reback) {
        this.reback = reback;
    }
    
}

2.在主方法中调用的时候直接getInstance()就可以。

public static void main(String[] args) {
        long beginTime = System.currentTimeMillis();
 
        for (int i = 0; i < 100; i++) {
            ErpProduct.getInstance();
        }
 
        long endTime = System.currentTimeMillis();
        System.out.println("采用clone的方法，一共花费的时间：" + (endTime - beginTime));
 
        beginTime = System.currentTimeMillis();
 
        for (int i = 0; i < 100; i++) {
            new ErpProduct();
        }
 
        endTime = System.currentTimeMillis();
        System.out.println("采用new的方法，一共花费的时间：" + (endTime - beginTime));
    }

当一个类存在继承关系时，你创建一个子类的对象时，如果在没有明确指定的情况下，子类是会隐式的去调用父类的无参构造的。假设，我们需要频繁创建的对象，是一个继承关系比较深的类的话，调用构造函数的开销不容小窥。

如果一时间内，频繁创建某对象时，这些平时不显眼的消耗一叠加起来，就变得很客观了。但是，当我们使用clone的话，就可以避免这个问题。