在实际开发中，某些情况下，我们可能需要频繁去创建一些对象（new），下面介绍一种，我从书上看到的，可以提高效率的方法。
首先，对于将会频繁创建的对象，我们要让这个类实现Cloneable接口，因为这个优化的核心，就是利用clone。
clone的最大特点就是，不会去调用任何构造方法，所以，在我看来重点应该放在构造方法中。
废话少说，先上一个简单的测试代码吧：
package util;
public class Main {
public static void main(String[] args) {
long beginTime = System.currentTimeMillis();
for (int i = 0; i < 100; i++) {
Person.getOnePerson();
}
long endTime = System.currentTimeMillis();
System.out.println("采用clone的方法，一共花费的时间：" + (endTime - beginTime));
beginTime = System.currentTimeMillis();
for (int i = 0; i < 100; i++) {
new Person();
}
endTime = System.currentTimeMillis();
System.out.println("采用new的方法，一共花费的时间：" + (endTime - beginTime));
}
}
class TestA {
private String aa;
public TestA() {
// 模拟一下耗时操作
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public String getAa() {
return aa;
}
public void setAa(String aa) {
this.aa = aa;
}
}
class TestB extends TestA {
private String bb;
public TestB() {
// 模拟一下耗时操作
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public String getBb() {
return bb;
}
public void setBb(String bb) {
this.bb = bb;
}
}
class Person extends TestB implements Cloneable {
private String id;
private String name;
private static Person person = new Person();
private int[] temp = null;
// 这里理应设置为private的，但是为了在上面测试方便，这里就将其设置为public了
// 但是，在真正开发中时，为了避免误导开发人员，应该将构造函数私有化
public Person() {
};
public static Person getOnePerson() {
try {
return (Person) person.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
// 模拟有参构造方法
public static Person getOnePersonWithInitName(String name) {
try {
Person tempPerson = (Person) person.clone();
tempPerson.name = name;
return tempPerson;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int[] getTemp() {
return temp;
}
public void setTemp(int[] temp) {
this.temp = temp;
}
}
看一下，在我本机上的运行效果吧
可以很明显的看出，同样是循环100次，采用clone的方式要比new方式快得多得多。而且，从clone一共花费的时间，可以很轻松的看出并证实了我前面说的：“clone的最大特点就是，不会去调用任何构造方法“”。
2.简要说明
我来稍微说明一下，我上面的测试代码，为什么要这样写吧。
2.1.我之所以是创建TestA，TestB这两个看似毫无意义的类，并让TestB继承TestA，让Person继承TestB，主要是为了模拟构造函数递归调用的过程。各位应该也知道，当一个类存在继承关系时，你创建一个子类的对象时，如果在没有明确指定的情况下，子类是会隐式的去调用父类的无参构造的。假设，我们需要频繁创建的对象，是一个继承关系比较深的类的话，调用构造函数的开销不容小窥啊。
2.2.各位如果看一下我的测试代码的话，应该不难看出，我在TestA和TestB这两个类的构造函数中，都加了一个睡眠，用于模拟一些耗时操作。（当然，在实际开发中，耗时操作不一定是10毫秒，可能更高或者更低，这里主要是为了演示体现效果罢了）。如果当我们用new关键字去创建对象时，而这些对象的构造方法中，有可能会做某些事情，比如去初始化一些什么，或者准备一些什么等等。这些都是消耗不少时间的。如果一时间内，频繁创建某对象时，这些平时不显眼的消耗一叠加起来，就变得很客观了。但是，当我们使用clone的话，就可以避免这个问题。
3.个人一些看法和补充
3.1方法名字很重要
在实际开发中，我们需要的不仅仅是无参构造，还有可能是有参构造。但是，当我们屏蔽了构造函数之后，一个可以让我们获取这个类对象的方法的方法名，就显示尤为重要了：比如，我上面写到的getOnePerson()和getOnePersonWithInitName(String name)。
因为屏蔽了构造函数，上面这两个方法就充当了构造函数的角色。当名字起得不好的时候，入参的名字起得不好的时候，是很容易让别人困惑的。当
然，你说可以用注释嘛。但是，在我看来，真正好的代码，是应该具有自述性的。就是仅仅可以从方法名和入参名之间，就知道这个方法的意义和作用。虽然注释很有用，但是你要明白，注释和代码的更新，往往是不同步的啊。当代码和注释失配时，就很坑爹了！！而且，其实，让这些方法来充当构造函数时，无疑是在无形之间，增加了学习的成本。
3.2利用clone的这种创建对象的方式，和工厂模式很配哦~