第二章：创建和销毁对象

太过爱你忘了你带给我的痛 2022-04-24 09:52 329阅读 0赞

### 第1条： 用静态工厂方法替换构造器 ###

基本类型boolean的装箱类Boolean的例子：

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

1.  静态工厂方法与构造器不同的第一大优势在于，他们有名称。通过适当的名称，使用者会更容易使用。
2.  静态工厂方法与构造器不同的第二大优势在于，不必在每次调用它们的时候都创建一个新对象。
3.  静态工厂方法与构造器不同的第三大优势在于，它们可以返回原返回类型的任何子类型的对象。
4.  静态工厂的第四大优势在于，所返回的对象的类可以随着每次调用而发生变化，这取决于静态工厂方法的参数值。
5.  静态工厂的第五大优势在于，方法返回的对象所属的类，在编写包含该静态工厂方法的类市客运不存在。
6.  静态工厂方法的主要缺点在于，类如果不含公有的或者受保护的构造器，就不能被子类化
7.  静态工厂方法的第二个缺点在于，程序员很难发现它们。

### 第2条: 遇到多个构造器参数时要考虑使用构建器 ###

静态方法和构造器有个共同的局限性：它们都不能很好地扩展到大量的可选参数。

当遇到有大量可选参数时 程序员一向习惯采用重叠构造器模式。  
简而言之，重叠构造器模式可行，但是当有许多参数的时候，客户端代码会很难编写，并且仍然较难以阅读。

遇到有大量可选参数时，还有第二种代换方法，即JavaBeans模式，在这种模式下，先调用无参，再调用settter方法。但再构造过程中JavaBean可能处于不一致的状态。JavaBeans模式使得把类做成不可变的可能性不复存在。

幸运的是，还有第三种替代方法，它既能保证像重叠构造器模式的安全性，也能保证像JavaBean模式那么好的可读性。这就是建造者（Builder）模式的一种形式。 它不直接生成想要的对象，而是让客户端利用所有必要的参数调用构造器，得到一个builder对象。再调用类似setter方法，最后生成通常是不可变的对象。  
例如:

// 其中姓名和年龄是必须填写的 父亲母亲是可选的
    User user = new User("张三",22).father("张一").mother("小李").build();

简而言之，如果类的构造器或者静态工厂中具有多个参数，设计这种类市，Builder模式就是一种不错的选择。

### 第3条：用私有构造器或者枚举类型强化Singleton属性 ###

Singleton是指仅仅被实例化一次的类。使类成为Singleton会使它的客户端测试变得十分困难，因为不能给Singleton替换模拟实现。  
实现Singleton有两种常见的方法。  
第一种方法中，公有静态成员是一个final域：

//Singleton with public final field
    public class Elvis { 
    	public static final Elvis INSTANCE = new Elvis();
    	private Elvis() { ...}
    	public void leaveTheBuilding() { ...}
    	
    }

第二种方法中，共有的成员是个静态工厂方法：

//Singleton with static factory
    public class Elvis { 
    	public static final Elvis INSTANCE = new Elvis();
    	private Elvis() { ...}
    	public static Elvis getInstance() { return INSTANCE;}
    	public void leaveTheBuilding() { ...}	
    }

第三种方法是声明一个包含单个元素的枚举类型：

//Singleton with static factory
    public enum Elvis { 
    	INSTANCE;
    	public void leaveTheBuilding() { ...}	
    }

这种方法在功能上与公有域方法相似，但更加简洁，无偿提供了 序列化机制，绝对防止多次实例化。  
虽然这种方法还没有广泛采用，但是单元素的枚举经常成为实现Singleton的最佳方法。

### 第4条：通过私有构造器强化不可实例化的能力 ###

企图通过将类做成抽象类来强制该类不可被实例化是行不通的。该类可以被子类化，并且该子类也可以被实例化。  
只要让这个类包含一个私有构造器，它就不能被实例化：

public calss UtilityClass { 
    	private UtilityClass() { 
    		throw new AssertionError();
    	}
    }

### 第5条：优先考虑依赖注入来引用资源 ###

最简单的模式：当创建一个新的实例时，就将该资源传到构造器中。

### 第6条：避免创建不必要的对象 ###

反例：

String s = new String("bikini");

该语句每次被执行的时候都创建一个新的String实例。  
改进：

String s = "bikini";

假如想要编写一个方法，用它确定一个字符串是否为一个有效的罗马数字。下面介绍一种最容易的方法，使用一个正则表达式:

//不好的方法
    	public boolean isRomanNumeral(String s) { 
    		return s.matches("^(?=.)M*(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");
    	}

这个实现的问题在于它依赖String.matches方法。虽然String.matches方法最易于查看一个字符串是否与正则表达式相匹配，但并不适合在注重性能的情形中重复使用。问题在于，他在内部为正则表达式创建一个Pattern实例，却只用一次，之后就可以进行垃圾回收了。创建Pattern实例的成本很多，因为需要将正则表达式编译成一个有限状态机。  
为了提升性能，应该显式地将正则表达式编译成一个Pattern实例（不可变），让它成为类初始化的一部分，并将它缓存起来，每当调用isRomanNumeral方法的时候就重用同一个实例：

//改进后的方法
    	public class RomanNumerals { 
    		private static final Pattern ROMAN = Pattern.compile(
    				"^(?=.)M*(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");
    		
    		static boolean isRomanNumeral(String s) { 
    			return ROMAN.matcher(s).matches();
    		}	
    	}

改进后的isRomanNumeral方法如果被频繁地调用，会显示明显的性能优势。

另一种创建多余对象的方法，称作自动装箱，它允许程序员将基本类型和装箱基本类型混用，按需要自动装箱和拆箱。自动装箱使得基本类型和装箱基本类型之间的差别变得模糊起来，但是并没有完全消除。

//改进后的方法
    	private static long sum() { 
    		Long sum = 0L;
    		for (long i = 0; i <= Interger.MAX_VALUE; i++) { 
    			sum += i;
    			
    		return sum;
    		}
    	}

这段程序算出的答案是正确的，但是比实际情况要更新一些，只因为你打错了一个字符。变量sum被声明成Long而不是long，意味着程序构造了很多大个多余的Long。将sum的声明从Long改成long，在我的机器上市运行时间从6.3秒减少到0.59秒。结论很明显：要优先使用基本类型而不是装箱基本类型，要当心无意识的自动装箱。

### 第7条：消除过期对象引用 ###

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 Object 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); 	
    		}
    	}

程序中哪里发生了内存泄漏呢，如果一个栈先是增长，然后再收缩，那么，从栈中弹出来的对象将不会被当做垃圾回收，即使使用栈的程序不再引用引用这些对象，它们也不会被回收。这是因为栈内部维护着这些对象的过期引用。所谓的过期引用，是指永远也不会再被解除的引用。

这类问题的修复方法很简单：一旦对象引用已经过期，只需清空这些引用即可。

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

内存泄漏的另一个常见来源是缓存。  
内存泄漏的第三个常见来源是监听器和其他回调。 weakHashMap可处理

### 第8条：避免使用终结方法和清除方法 ###

终结方法(finalizer)通常是不可预测的，也是很危险的，一般情况下是不必要的。  
清除方法没有终结方法那么危险，但任然是不可预测、运行缓慢，一般情况下也是不必要的。

终结方法和清除方法的缺点在于不能保证会被及时执行。从一个对象变得不可到达开始，到它的终结方法被执行，所花费的这段时间是任意长的。这意味着，注重时间（time-critical）的任务不应该有终结方法或者清楚方法来完成、例如：用这些方法来关闭打开的文件，就是一个严重的错误，如果系统不能及时运行终结 就回导致大量的文件任然保留打开状态。

永远不应该依赖终结方法或者清除方法来更新重要的持久状态。例如：依赖终结方法或者清除方法来释放共享资源上的永久锁，这很容易让整个分布式系统垮掉。 未完。。

### 第9条：try-with-resources优先于try-finally ###

static viod copy(String srcm String dst) throws IOException { 
    	InputStream in = new FileInputStream(src);
    	try { 
    		OutputStream out = new FileOutputStream(dst);
    		try { 
    			byte[] buf = new btype[SIZE];
    			int n;
    			while ((n = in.read(buf)) >= 0)
    				out.write(buf, 0, n);
    		} finally { 
    			out.close();
    		}
    	} finally { 
    		in.close();
    	}
    }

在try块和finally块中的代码，都会抛出异常。 有些情况下第二个异常完全抹除了第一个异常。在异常堆栈轨迹中，完全没有关于第一个异常的记录，这在现实的系统中会导致调试变得非常复杂。

使用try-with-resources语句时，就解决了。必须权限实现AtuoCloseable接口，包括单个返回void的close方法。

static viod copy(String srcm String dst) throws IOException { 
    	try (InputStream in = new FileInputStream(src);
    		OutputStream out = new FileOutputStream(dst)) { 		
    		byte[] buf = new btype[SIZE];
    		int n;
    			while ((n = in.read(buf)) >= 0)
    				out.write(buf, 0, n);
    	}
    }

在使用try-with-resources语句的时候，异常可能发生在try语句中，也可能发生在释放资源时。如果资源初始化时或try语句中出现异常，而释放资源的操作正常执行，try语句中的异常会被抛出。如果try语句和释放资源都出现了异常，那么最终抛出的异常是try语句中出现的异常，在释放资源时出现的异常会作为被抑制的异常添加进去，即通过Throwable.addSuppressed方法来实现。

能够被try语句所管理的资源需要满足一个条件，那就是其java类要实现java.lang.AutoCloseable接口，否则会出现在编译错误。当需要释放资源的时候，该接口的close方法会被自动调用。