【Java基础】创建和销毁对象
Num1：考虑用静态工厂方法代替构造器
对于类而言，常见的方法是提供一个公有的构造器，但其实还有一种方法叫做静态工厂方法(static factory method)，它只是一个返回类的实例静态方法。
目前比较流行的规范是把静态工厂方法命名为valueOf或者getInstance。
valueOf：该方法返回的实例与它的参数具有同样的值，例如：
Integer a=Integer.valueOf(100); //返回取值为100的Integer对象
从上面代码可以看出，valueOf()方法能执行类型转换操作，在本例中，把int类型的基本数据转换为Integer对象。
getInstance：返回的实例与参数匹配，例如：
Calendar cal=Calendar.getInstance(Locale.CHINA); //返回符合中国标准的日历
优势：
- 静态工厂方法与构造器不同的第一大优势在于，他们有名称，更有可读性。
- 静态工厂方法与构造器不同的第二大优势在于，不必每次调用它们的时候都创建一个新对象。
- 静态工厂方法与构造器不同的第三大优势在于，它们可以返回原返回类型的任何子类型的对象。
- 静态工厂方法与构造器不同的第四大优势在于，在创建参数化实例的时候，它们使代码变得更加简洁。
缺点：
- 类如果不含公有的或者受保护的构造器，就不能被子类化。
- 它们与其他的静态方法实际上没有任何区别。
Num2：遇到多个构造器参数时要考虑用构造器
一般有以下三种构造器的方式
- 重叠构造器模式
- JavaBeans模式
- Builder模式
重叠构造器模式
public class NutritionFacts {
private final int servingSize; // (mL) required
private final int servings; // (per container) required
private final int calories; // optional
private final int fat; // (g) optional
private final int sodium; // (mg) optional
private final int carbohydrate; // (g) optional
public NutritionFacts(int servingSize, int servings) {
this(servingSize, servings, 0);
}
public NutritionFacts(int servingSize, int servings, int calories) {
this(servingSize, servings, calories, 0);
}
public NutritionFacts(int servingSize, int servings, int calories, int fat) {
this(servingSize, servings, calories, fat, 0);
}
public NutritionFacts(int servingSize, int servings, int calories, int fat,
int sodium) {
this(servingSize, servings, calories, fat, sodium, 0);
}
public NutritionFacts(int servingSize, int servings, int calories, int fat,
int sodium, int carbohydrate) {
this.servingSize = servingSize;
this.servings = servings;
this.calories = calories;
this.fat = fat;
this.sodium = sodium;
this.carbohydrate = carbohydrate;
}
public static void main(String[] args) {
NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);
}
}
JavaBeans模式
在这种模式下，调用一个无参构造器来创建对象，然后调用setter方法来设置每个必要的参数。如下：
public class NutritionFacts {
// Parameters initialized to default values (if any)
private int servingSize = -1; // Required; no default value
private int servings = -1; // " " " "
private int calories = 0;
private int fat = 0;
private int sodium = 0;
private int carbohydrate = 0;
public NutritionFacts() {
}
// Setters
public void setServingSize(int val) {
servingSize = val;
}
public void setServings(int val) {
servings = val;
}
public void setCalories(int val) {
calories = val;
}
public void setFat(int val) {
fat = val;
}
public void setSodium(int val) {
sodium = val;
}
public void setCarbohydrate(int val) {
carbohydrate = val;
}
public static void main(String[] args) {
NutritionFacts cocaCola = new NutritionFacts();
cocaCola.setServingSize(240);
cocaCola.setServings(8);
cocaCola.setCalories(100);
cocaCola.setSodium(35);
cocaCola.setCarbohydrate(27);
}
}
Builder模式
不直接生成想要的对象，而是让调用者利用所有必要的参数调用构造器，得到一个builder对象，然后客户端在builder对象上调用类似于setter的方法，来设置每个相关的可选参数，最后客户端调用无参的build方法来生成一个不可变的对象。
public class NutritionFacts {
private final int servingSize;
private final int servings;
private final int calories;
private final int fat;
private final int sodium;
private final int carbohydrate;
public static class Builder {
// Required parameters
private final int servingSize;
private final int servings;
// Optional parameters - initialized to default values
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();
}
}
小结####
与构造器相比，builder模式的优势在于，builder可以有多个可变的参数，构造器就像方法一样，只能有一个可变参数。总之，如果类的构造器或静态工厂中具有多个参数，设计这种类的时候，builder模式就是一种不错的选择。
Num3：用私有构造器或者枚举类型强化Singleton属性
Singleton简单的说就是仅仅被实例化一次的类。实现Singleton有三种方式。
Field方式
public class Elvis {
public static final Elvis INSTANCE = new Elvis();
private Elvis() {
}
public void leaveTheBuilding() {
System.out.println("Whoa baby, I'm outta here!");
}
// This code would normally appear outside the class!
public static void main(String[] args) {
Elvis elvis = Elvis.INSTANCE;
elvis.leaveTheBuilding();
}
}
Method方式
public class Elvis {
private static final Elvis INSTANCE = new Elvis();
private Elvis() {
}
public static Elvis getInstance() {
return INSTANCE;
}
public void leaveTheBuilding() {
System.out.println("Whoa baby, I'm outta here!");
}
// This code would normally appear outside the class!
public static void main(String[] args) {
Elvis elvis = Elvis.getInstance();
elvis.leaveTheBuilding();
}
}
特别要说明下，如果要使得类支持可序列化，仅仅加上implements Serializable是不够的，需要在方法里加上这么一个方法。
private Object readResolve() {
// Return the one true Elvis and let the garbage collector
// take care of the Elvis impersonator.
return INSTANCE;
}
枚举类方式
public enum Elvis {
INSTANCE;
public void leaveTheBuilding() {
System.out.println("Whoa baby, I'm outta here!");
}
// This code would normally appear outside the class!
public static void main(String[] args) {
Elvis elvis = Elvis.INSTANCE;
elvis.leaveTheBuilding();
}
}
Num4：消除过期的对象引用
所谓过期引用：是指永远也不会再被解除的引用。在支持垃圾回收的语言中，内存泄露是很隐蔽的，如果一个对象引用被这个对象无意识地保留起来，那么，垃圾回收机制不仅不会处理这个对象，而且也不会处理被这个对象所引用的所有其他对象，从而对性能造成潜在的重大影响。
那么该如何修复呢，很简单：一旦对象引用已经过期了，只需要清空这些引用即可。
public Object pop() {
if (size == 0)
throw new EmptyStackException();
Object result = elements[--size];
elements[size] = null;
return result;
}
一般而言，只要类是自己管理内存，程序员就应该警惕内存泄露问题。
内存泄露的另一个常见问题是缓存，所以一般可以弱引用weak reference代表缓存，当缓存过期后，它们会自动被删除，记住缓存项的生命周期是外部引用而不是值引用的。
内存泄露的第三个常见来源是监听器和其他回调。如果你实现了一个API，客户端在这个API中注册回调，却没有显式地取消注册，那么除非采取某些动作，否则就会积聚，确保回调立即被当作垃圾回收的最佳方法是只保存它们的弱引用。
