优雅的创建实例
通过构造函数创建实例
通过多参数构造函数重载，提供多个实例化入口
class Demo {
Demo(){
this(0, 0);
}
Demo(int var){
this(var, 0);
}
Demo(int var1, int var2){
//implement logic
}
}
优点：
- 简单的实现了多个实例化入口，可以通过级联调用
缺点：
- 实例返回的对象无法子类化、无法单例化等，灵活性差
- 多实例参数时并且这些参数不确定需要时，需要提供大量构造重载入口，繁琐
通过静态工厂方法创建实例
通过静态方法提供多内容的实例化
class Demo {
private Demo() {}
public static Demo getInstance() {
return new Demo();
}
}
优点：
- 可以根据不同的实例用途进行方法命名，提高调用者的对不同实例入口的认知
- 可以根据业务需求和当前状态的选择是返回一个新的实例还是一个已缓存的类实例
- 返回类型可以是返回的具体实例的超类，该超类可以是一个协议接口，从而实现了返回值的子类化
缺点：
- 当工厂方法不在需要实例化的类中时，需要被实例化的类无法做到子类化
- 多实例参数并且这些参数不确定需要时，需要提供大量静态方法，繁琐
通过传入JavaBean创建实例
通过打包多个参数到一个JavaBean对象，来减少方法签名数
class DataBean {
int var1;
int var2;
int var3;
}
class Demo {
Demo(DataBean data){}
}
优点：
- 多参数的构造中，可以减少参数的传递，减少调用者的负担
缺点：
- 传入
JavaBean的方式是先传入JavaBean，再获取实例，而该JavaBean的内容是可变的，这给实例带来了不确定性。
通过Builder构建器创建实例
通过创建Builder构建器，从而创建对象
class Demo {
private int var1;
private String var2;
Demo(Builder builder) {
this.var1 = builder.var1;
this.var2 = builder.var2;
}
static class Builder {
private int var1;
private String var2;
public Builder setVar1(int var){
this.var1 = var;
return this;
}
public Builder setVar2(String var) {
this.var2 = var;
return this;
}
public build(){
//1. check the fileds in builder
return new Demo(this);
}
}
}
优点：
- 相比多个构造器，
Builder模式可以实现多参数的自由组合，也有利于后期多参数扩展，可维护性更好 - 相比
JavaBean，传入的参数是当前对象可控可检查的，入参非法则不允许创建对象，更加安全 - 链式调用，更符合函数式编程实现，对每个参数有强约束，更加易于阅读和操作
缺点：
- 多构造器模式更加冗长，适用于大于4个参数的情况
- 对性能开销有一定的负面影响
最优的单例实现方式
枚举单例和Atomic原子引用
//枚举法
public class EnumSingleton{
private EnumSingleton(){}
public static EnumSingleton getInstance(){
return Singleton.INSTANCE.getInstance();
}
private static enum Singleton{
INSTANCE;
private EnumSingleton singleton;
//JVM会保证此方法绝对只调用一次
private Singleton(){
singleton = new EnumSingleton();
}
public EnumSingleton getInstance(){
return singleton;
}
}
}
//原子操作 + 自旋锁（乐观锁）
public class AtomicSingleton {
private static AtomicReference<AtomicSingleton> INSTANCE = new AtomicReference<>();
private AtomicSingleton() {}
public static AtomicSingleton getInstace(){
while (true) {
AtomicSingleton current = INSTANCE.get();
if(current != null){ return current; }
current = new AtomicSingleton();
if(INSTANCE.compareAndSet(null, current)) { return current; }
}
}
}
优点：
- 多线程安全
- 枚举：延迟加载，原子操作：乐观锁，保证了性能的最优化
- 绝对的序列化安全和反射攻击安全
不可实例化类的声明
class Demo {
// 私有化缺省构造，让调用者无法实例化
private Demo(){
//若有反射攻击，抛出一个异常
throw new AssertionError();
}
}
避免创建不必要的对象
//code 1
String s1 = new String("str");
//code 2
String s2 = "str";
- code 1中，“str”已经为一个创建的实例，通过
String的构造器再创建一个对象，这是一个无意义的操作 - code2中，s2指向的不是一个
String对象，而是常量池中的一个String地址，若“str”在常量池中已经存在相同字面值的一份，则引用直接指向它，否则才创建，这个做法类似于基本类型的创建机制
public static void main(String[] args) {
Integer sum = 0;
for (int i = 0; i <= Integer.MAX_VALUE; i++) {
sum += i;
}
System.out.println(sum);
}
- 上述代码中，由于装箱的存在，创建了
个
Integer对象，大大浪费了性能，所以尽量使用基础类型，避免无意识的装箱操作 - 但不是说尽量避免创建对象，首先要保证业务的通畅和代码的可维护性、可阅读性。不要为了减少对象的创建，来做一些额外的操作（如维护对象池），若维护的对象是轻量级，这个操作反而降低了效率，并且增加了代码的复杂度。而对足够重量级的对象（如
JDBC）进行这种操作才能带来收益
