java手动销毁对象_【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中注册回调，却没有显式地取消注册，那么除非采取某些动作，否则就会积聚，确保回调立即被当作垃圾回收的最佳方法是只保存它们的弱引用。