第2章创建和销毁对象-优快云博客

本文探讨了对象的创建、管理和销毁策略，包括使用静态工厂方法代替构造器、构建器模式的运用、强化Singleton和不可实例化能力、避免创建不必要的对象、消除过期引用、以及避免使用终结方法。这些策略有助于提高代码质量和系统性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本章的主题是创建和销毁对象：何时以及如何创建对象，何时以及如何避免创建对象，如何确保它们能够适时地销毁，以及如何管理对象销毁之前必须进行的各种清理动作。 ###第1条：考虑用静态工厂方法代替构造器### 获取类的实例有两个方法，类提供一个公有的构造器和提供一个公有的只返回类的实例静态工厂方法(static factory method)。
例如将boolean基本类型值转换成一个Boolean对象引用：

public static Boolean valueOf(boolean b)
{
    return b ? Boolean.TRUE : Boolean.FALSE;
}

这里的静态工厂方法与设计模式中的工厂方法模式不同。
静态工厂方法比公有的构造器有几大优势：
1.它们有名称
如果构造器的参数本身没有确切的描述正被返回的对象那么具有适当名称的静态工厂方法会更容易使用。例如构造器BigInteger(int, int, Random)返回的BigInteger可能为素数，如果用名为BigInteger.probablePrime的静态工厂方法表示显然更清楚。
2.不必在每次调用它们的时候都创建一个新对象
这使得不可变类可以使用预先构建好的实例，或者将构建好的实例缓存起来进行重复利用，从而避免创建不必要的重复对象。
静态工厂方法能够为重复的调用返回相同对象，这样有助于类总能严格控制在某个时刻哪些实例应该存在。这种类被称作实例受控的类(instance-controlled)，实例受控使得类可以确保它是一个Singleton或者是不可实例化的。它还使得不可变的类可以确保不会存在两个相等的实例，即当且仅当a==b的时候才有a.equals(b)为true。如果可以保证这一点就可以使用==代替equals()方法，这样可以提升性能，枚举(enum)保证了这一点。
3.它们可以返回原返回类型的任何子类型对象
公有的静态工厂方法所返回的对象的类不仅可以是非公有的，而且该类还可以随着每次调用而发生变化，这取决于静态工厂方法的参数值。只要是已声明的返回类型的子类型，都是允许的。
例如java.util.enumSet没有公有构造器，只有静态工厂方法

    /**
     * Creates an empty enum set with the specified element type.
     *
     * @param elementType the class object of the element type for this enum
     *     set
     * @throws NullPointerException if <tt>elementType</tt> is null
     */
    public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {
        Enum[] universe = getUniverse(elementType);
        if (universe == null)
            throw new ClassCastException(elementType + " not an enum");

        if (universe.length <= 64)
            return new RegularEnumSet<>(elementType, universe);
        else
            return new JumboEnumSet<>(elementType, universe);
    }

它返回两种实现类之一，具体则取决于底层枚举类型的大小：如果它的元素有64个或者更小会返回一个RegularEnumSet实例否则返回JumboEnumSet实例。
静态工厂方法返回的对象所属的类在编写该静态工厂方法的类的时候可以不必存在，这种灵活的静态工厂方法构成了服务提供者框架（Service Provider Framework）（多个服务提供者实现一个服务，系统为服务提供者的客户端提供多个实现，并把他们从多个实现中解耦出来）的基础。
服务提供者框架中有三个重要的组件：服务接口（Service Interface），这是提供者实现的；提供者注册API（Provider Registration API），这是系统用来注册实现让客户端访问他们的；服务访问API（Service Access API），是客户端用来获取服务的实例的。第四个组件是可选的：服务提供者接口（Service Provider Interface），这些提供者负责创建其服务实现的实例。如果没有服务提供者接口，实现就按照类名称注册，并通过反射方式进行实例化。
对于JDBC来说，Connection就是它的服务接口，DriverManager.registerDriver是提供者注册API，DriverManager.getConnection是服务访问API，Driver就是服务提供者接口。
客户端调用的方式

Connection connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);

Connection是一个接口提供了操作数据库的各种方法：

public interface Connection extends Wrapper, AutoCloseable {
	public abstract Statement createStatement() throws SQLException;
	public abstract PreparedStatement prepareStatement(String s) throws SQLException;
	public abstract CallableStatement prepareCall(String s) throws SQLException;
	... ...
}

DriverManager的registerDriver方法如下：

public static synchronized void registerDriver(Driver driver) throws SQLException
{
    if(driver != null)
        registeredDrivers.addIfAbsent(new DriverInfo(driver));
    else
        throw new NullPointerException();
    println((new StringBuilder()).append("registerDriver: ").append(driver).toString());
}

Driver是一个接口：

public interface Driver 
{
	public abstract Connection connect(String s, Properties properties) throws SQLException;
	public abstract boolean acceptsURL(String s) throws SQLException;
	public abstract DriverPropertyInfo[] getPropertyInfo(String s, Properties properties) throws SQLException;
	public abstract int getMajorVersion();
	public abstract int getMinorVersion();
	public abstract boolean jdbcCompliant();
	public abstract Logger getParentLogger() throws SQLFeatureNotSupportedException;
}

其中DriverManager.getConnection(String s, String s1, String s2)通过下面代码获得Connection

Connection connection = driverinfo.driver.connect(s, properties);

服务提供者框架模式有着无数种变体，例如服务访问API可以利用适配器（Adapter）模式返回比提供者需要的更丰富的服务接口。下面是一个简单实现：

// 服务接口
public interface Service
{
	...//服务操作的方法
}

// 服务提供者接口
public interface Provider
{
	Service newService();// 返回具体的服务实例
}

// 用于注册和访问服务的不可实例化的类
public class Services 
{
	// 构造函数声明为私有的不可实例化
	private Services()
	{
	}
	
	// 存储服务名字和对应的服务
	private static final Map<String, Provider> providers = new ConcurrentHashMap<String, Provider>();
	public static final String DEFAULT_PROVIDER_NAME = "<def>";
	
	// 提供注册接口
	public static void registerProvider(String name, Provider p)
	{
		providers.put(name, p);
	}
	
	// 服务访问接口
	public static Service newInstance()
	{
		return newInstance(DEFAULT_PROVIDER_NAME);
	}
	public static Service newInstance(String name)
	{
		Provider p = providers.get(name);
		if(p == null)
		{
			throw new IllegalArgumentException("No provider registered with name: " + name);
		}
		
		return p.newService();
	}
}

4.在创建参数化类型实例的时候它使代码更简洁在调用参数化类的构造器的时候通常要求提供两次类型参数，如果参数很多会比较冗长。通过静态工厂方法，编译器可以找到类型参数，这被称作类型推倒(type inference)，例如：

Map<String, List<String>> m = New HashMap<String, List<String>>();

假设HashMap提供了这个静态工厂：

public static <K, V> HashMap<K, V> newInstance()
{
	return new HashMap<K, V>();
}
Map<String, List<String>> m = HashMap.newInstance();

静态工厂方法也有缺点：
1.类如果不含有public或protected的构造器就不能被子类化。
但是也可以因祸得福，因为鼓励使用复合(composition)而不是继承。
2.它们与其他的静态方法实际上没有任何区别从而不容易知道如何实例化一个类。 ###第2条：遇到多个构造器参数时要考虑使用构建器### 静态工厂和构造器都不能很好的扩展到大量的可选参数，如果可选参数多的话通常有两种方式创建类的实例。
1.重载构造器
需要写太多个构造器而且客户端的代码也会很难编写
2.使用JavaBeans模式
调用一个无参的构造器创建对象然后调用setter方法来设置每个必要的参数以及相关的可选参数，这种方式弥补了重载构造器模式的不足代码读起来也容易。但是也有一些缺点，在构造过程中JavaBean可能处于不一致的状态，类无法仅仅通过检验构造器参数的有效性来保证一致性。例如new了一个类的两个实例，一个只set了A属性，一个只设置了B属性，这两个实例不一致，不能保证通过该类的同一个构造器构造出来的对象是属性相同的。另外，这样类就不是不可变类（不可变对象指对象一旦被创建，状态就不能再改变。任何修改都会创建一个新的对象，如 String、Integer及其它包装类）了，就需要付出额外的努力来确保它的线程安全。
3.Builder模式既能保证像重叠构造器模式那样的安全性也能保证像JavaBeans模式那么好的可读性。
例如：

public class TestBuilder 
{
	public static void main(String[] args) 
	{
		Student student = new Student.Builder("victor", 1).age(25).address("上海").Builder();
	}
}

/**
 * @author victor
 * 学生类。姓名和性别是必填参数，年龄和住址是可选的
 */
class Student 
{
	private String name;
	private int gender;
	private int age;
	private String address;
	
	public static class Builder
	{
		private String name;
		private int gender;
		// 初始化可选参数
		private int age = 12;
		private String address = "北京";
		
		public Builder(String name, int gender)
		{
			this.name = name;
			this.gender = gender;
		}
		
		public Builder age(int age)
		{
			this.age = age;
			return this;
		}
		public Builder address(String address)
		{
			this.address = address;
			return this;
		}
		
		public Student Builder()
		{
			return new Student(this);
		}
	}
	
	private Student(Builder builder)
	{
		this.name = builder.name;
		this.gender = builder.gender;
		this.age = builder.age;
		this.address = builder.address;
	}
}

如果类的构造器或者静态工厂中具有多个参数可以思考一下是否用Builder模式更适合。 ###第3条：用私有构造器或者枚举类型强化Singleton属性### Singleton指仅仅被实例化一次的类。
在Java 1.5之前实现Singleton有两种方法，这两种方法都要把构造器保持为私有的并导出公有的静态成员。
第一种方法：

public class Singleton 
{
	public static final Singleton INSTANCE = new Singleton();
	
	private Singleton()
	{
		
	}
}

私有构造器仅被调用一次，用来实例化公有的静态final域，保证了Singleton的全局唯一性。但是享有特权的客户端可以通过反射机制调用私有构造器，如果需要抵御这种攻击，可以修改构造器在创建第二个实例的时候抛出异常。
第二种方法：
公有的成员是个静态工厂方法

public class Singleton 
{
	private static final Singleton INSTANCE = new Singleton();
	
	private Singleton()
	{
		
	}
	
	public static Singleton getInstance()
	{
		return INSTANCE;
	}
}

第一种公有域的方法主要好处在于组成类的成员的声明很清楚的表明了这个类是一个Singleton:公有的静态域是final的，所以该域总是包含相同的对象引用。公有域方法在性能上不再有任何优势：现代的JVM实现几乎都能够将静态工厂方法的调用内联化。
第二种工厂方法的优势之一在于，它提供了灵活性：在不改变其API的前提下，我们可以改变该类是否应该为Singleton的想法。第二个优势与泛型有关。
使用其中一种方法实现的Singleton类变成可序列化（Serializable）仅仅在声明中加上"implement Serializable"是不够的。为了维护并保证Singleton，必须声明所有实例域都是瞬时（transient）的，并提供一个readResolve方法。否则，每次反序列化一个序列化的实例时都会创建一个新的实例。
从Java 1.5版本起实现Singleton还有第三种方法。只需编写一个包含单个元素的枚举类型：

public enum People 
{
	INSTANCE;
	public void speak()
	{
		System.out.println(this + " is speaking! ");
	}
}
public class Singleton 
{
	public static void main(String[] args)
	{
		People s1 = People.INSTANCE;
	    s1.speak();
	    People s2 = People.INSTANCE;
	    s2.speak();
	    System.out.println(s1 == s2);
	}
}

运行结果：

INSTANCE is speaking! 
INSTANCE is speaking! 
true

这种方法在功能上与公有域方法相近，但是更加简洁并且无偿的提供了序列化机制，绝对防止多次实例化，即使是在面对复杂的序列化或者反射攻击的时候。单元素的枚举类型已经成为实现Singleton的最佳方法。 ###第4条：通过私有构造器强化不可实例化的能力### 有一些工具类不希望被实例化，实例对它没有任何意义。由于只有当类不包含显示的构造器时，编译器才会生成缺省的构造器，因此只要让这个类包含私有构造器就不能被实例化了。

public class UtilityClass 
{
	// Suppress default constructor for non-instantiability
	private UtilityClass()
	{
		throw new AssertionError();
	}
}

副作用就是使得该类不能被子类化，因为所有的构造器都必须显示或隐式的调用超类构造器，在这种情形下，子类就没有可访问的超类构造器可调用了。 ###第5条：避免创建不必要的对象### 一般来说，最好能重用对象而不是在每次需要的时候就创建一个相同功能的新对象。重用方式既快速，又流行。如果对象是不可变（immutable）的它始终可以被重用。
一个极端的例子：String s = new String("stringette");
"stringette"本身就是一个String实例，功能方面等同于构造器创建的所有对象。
改进后的版本：String s = "stringette";可以保证对于所有在同一台虚拟机中运行的代码，只要它们包含相同的字符串字面常量该对象就会被重用。
对于同时提供了静态工厂方法和构造器的不可变类，通常可以使用静态工厂方法而不是构造器以避免创建不必要的对象。例如，静态工厂方法Boolean.valueOf(String)总是优于构造器Boolean(String)。构造器在每次被调用的时候都会创建一个新的对象，而静态工厂方法则从来不要求这样做。
除了重用不可变的对象之外也可以重用那些已知不会被修改的可变对象，下面是一个常见的反例，检验一个人是否出生于1946年至1964年期间：

public class Person 
{
	private final Date birthDate = null;
	
	public boolean isBabyBoomer()
	{
		Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
		gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);
		Date boomStart = gmtCal.getTime();
		gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);
		Date boomEnd = gmtCal.getTime();
		return birthDate.compareTo(boomStart) >= 0 && birthDate.compareTo(boomEnd) < 0;
	}
}

isBabyBoomer每次被调用的时候都会新建一个Calendar、一个TimeZone和两个Date实例，这是不必要的。改进后代码的如下：

public class Person 
{
	private final Date birthDate = null;
	private static final Date BOOM_START;
	private static final Date BOOM_END;
	
	static
	{
		Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
		gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);
		BOOM_START = gmtCal.getTime();
		gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);
		BOOM_END = gmtCal.getTime();
	}
	
	public boolean isBabyBoomer()
	{
		return birthDate.compareTo(BOOM_START) >= 0 && birthDate.compareTo(BOOM_END) < 0;
	}
}

在Java1.5之后有一种创建多余对象的新方法称作自动装箱（autoboxing），它允许程序员将基本类型和装箱基本类型混用，按需要自动装箱和拆箱。
例如如下程序计算所有int正值的总和：

public static void main(String[] args)
{
		Long sum = 0L;
		for(long i = 0; i < Integer.MAX_VALUE; i++)
		{
			sum += i;
		}
		System.out.println(sum);
}

sum声明为Long而不是long程序就会构造大约2^31个多余的Long实例。
优先使用基本类型而不是装箱基本类型，要当心无意识的自动装箱。
###第6条：消除过期的对象引用### 虽然Java具有自动垃圾回收机制，但是也需要考虑内存管理的事情。
例如如下代码：

public class Stack 
{
	private Object[] elements;
	private int size = 0;
	private static final int DEFAULT_INITIAL_CAPACITY = 16;
	
	public Stack()
	{
		elements = new Object[DEFAULT_INITIAL_CAPACITY];
	}
	
	public void push(Object e)
	{
		ensureCapacity();
		elements[size++] = e;
	}
	
	public Object pop()
	{
		if(size == 0)
		{
			throw new EmptyStackException();
		}
		
		return elements[--size];
	}
	
	private void ensureCapacity()
	{
		if(elements.length == size)
		{
			elements = Arrays.copyOf(elements, 2*size + 1);
		}
	}
}

这是一个栈先增长然后再收缩，但是从栈中弹出来的对象将不会被当作垃圾回收，即使使用栈的程序不再引用这些对象。这是因为栈内部维护着对这些对象的过期引用，所谓的过期引用是指永远也不会再被解除的引用。在上述程序中凡是在数组活动部分之外的任何引用都是过期的，活动部分是指elements中下标小鱼size的那些元素。
pop方法的修复版本如下：

public Object pop()
{
	if(size == 0)
	{
		throw new EmptyStackException();
	}
		
	Object result = elements[--size];
	elements[size] = null;
	return result;
}

只要类是自己管理内存，就应该警惕内存泄露的问题。 ###第7条：避免使用终结方法### 终结方法（finalizer）通常是不可预测的也是很危险的，一般情况下是不可预测的。
终结方法的缺点在于不能保证会被及时地执行，从一个对象变得不可到达开始，到它的终结方法被执行所花费的这段时间是任意长的。Java语言规范不仅不保证终结方法会被即使地执行而且根本就不保证它们会被执行。
不应该依赖终结方法来更新重要的持久状态。例如，依赖终结方法来释放共享资源（例如数据库）上的永久锁很容易让整个分布式系统垮掉。
另外，如果在终结方法之中发生了异常则该异常不会使线程终止也不能打印出栈轨迹，不利于问题定位分析。
始终终结方法有一个非常严重的性能损失，用终结方法创建和销毁对象非常慢。
如果类的对象中封装的资源（例如文件或者线程）确实需要终止只需提供一个显示的终止方法，例如InputStream、OutputStream和java.sql.Connection上的close方法以及java.util.Timer上的cancel方法。显示的终止方法通常与try-finally结构结合起来使用，以保证及时执行。

转载于:https://my.oschina.net/u/1415012/blog/626886