创建和销毁对象
什么是静态工厂方法
返回一个类的实例的静态方法
优势
- 不要用多态的方法创建构造器，可以选择不同命名的静态工厂方法来创建实例
- 在类里可以预先构建好实例或者将实例缓存起来，然后重复返回相同对象，不用每次都new一个对象
- 可以返回子类
多个构造器解决方案
假如有2个必选参数和4个可选参数，那么构造函数至少要有5种，而且，每一次选择构造函数的时候还需要注意参数顺序，看api的时候还要点进去看
方案1:一个空的构造函数，其余参数用set方法来进行赋值，但这个有个不好的地方是，不能保证一个事务
方案2:builder模式，不直接生成对象，先生成一个builder对象，然后再将builder对象生成目标对象，具体例子如下：
public class NutritionFacts {
private final int servingSize; //require
private final int servings; //require
private final int calories; //optional
private final int fat; //optional
private final int sodium; //optional
private final int carbohydrate; //optional
public static class Builder {
//对象的必选参数
private final int servingSize;
private final int servings;
//对象的可选参数的缺省值初始化
private int calories = 0;
private int fat = 0;
private int carbohydrate = 0;
private int sodium = 0;
//只用少数的必选参数作为构造器的函数参数
public Builder(int servingSize,int servings) {
this.servingSize = servingSize;
this.servings = servings;
}
public Builder calories(int val) {
calories = val;
return this;
}
public Builder fat(int val) {
fat = val;
return this;
}
public Builder carbohydrate(int val) {
carbohydrate = val;
return this;
}
public Builder sodium(int val) {
sodium = val;
return this;
}
public NutritionFacts build() {
return new NutritionFacts(this);
}
}
private NutritionFacts(Builder builder) {
servingSize = builder.servingSize;
servings = builder.servings;
calories = builder.calories;
fat = builder.fat;
sodium = builder.sodium;
carbohydrate = builder.carbohydrate;
}
}
//使用方式
public static void main(String[] args) {
NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8).calories(100)
.sodium(35).carbohydrate(27).build();
System.out.println(cocaCola);
}
单例模式
public class Elvis {
public static final Elvis INSTANCE = new Elvis();
private Elivs() { ... }
public static Elvis getInstance() {
return INSTANCE;
}
public void leaveTheBuilding() { ... }
}
避免创建不必要的对象
String s = new String("aaa");
String s = "aaa";
比较这两行代码，上面的语句每次执行的时候都会创建一个新的 String 实例，但是这些创建对象的动作全都是不必要的。而下面的语句只用了一个 String 实例，而不是每次执行的时候都创建一个新的实例。由于 String 被实现为不可变对象，JVM 底层将其实现为常量池，所有值等于"aaa"的对象实例共享同一对象地址，而且还可以保证，对于所有在同一 JVM 中运行的代码，只要他们包含相同的字符串字面常量，该对象就会被重用。
拓展：string、stringBuilder、stringBuffer的区别
String 字符串常量
(每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String)
StringBuffer 字符串变量（线程安全）对方法加了同步锁
public synchronized StringBuffer reverse() {
super.reverse();
return this;
}
public int indexOf(String str) {
return indexOf(str, 0); //存在 public synchronized int indexOf(String str, int fromIndex) 方法
}
*** synchronized的含义：
每一个类对象都对应一把锁，当某个线程A调用类对象O中的synchronized方法M时，必须获得对象O的锁才能够执行M方法，否则线程A阻塞。一旦线程A开始执行M方法，将独占对象O的锁。使得其它需要调用O对象的M方法的线程阻塞。只有线程A执行完毕，释放锁后。那些阻塞线程才有机会重新调用M方法。这就是解决线程同步问题的锁机制。 ***
StringBuilder 字符串变量（非线程安全）
总结
1.如果要操作少量的数据 <=> String
2.单线程操作字符串缓冲区 下操作大量数据 <=> StringBuilder
3.多线程操作字符串缓冲区 下操作大量数据 <=> StringBuffer
当一个类里面一些对象变量不会改变或者只需要初始化一遍时，可以进行如下操作，将变量初始化为final类型，并在static方法里面完成赋值，重用那些已知不会被修改的可变对象
public class Person {
private static final Date BOOM_START;
private static final Date BOOM_END;
static {
Calender c = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
c.set(1946,Calendar.JANUARY,1,0,0,0);
BOOM_START = c.getTime();
c.set(1965,Calendar.JANUARY,1,0,0,0);
BOOM_END = c.getTime();
}
public boolean isBabyBoomer() {
return birthDate.compareTo(BOOM_START) >= 0 && birthDate.compareTo(BOOM_END) < 0;
}
}
