jdk1.5新特性一 共享设计模式

一、静态导入

为什么要搞个静态导入呢？

目的： 为了减少字符输入量，提高代码的可阅读性，以便更好地理解程序。

但不可滥用，滥用时会造成代码可阅读性不高，若代码出错要调试时，由于去掉了类名修饰，还需要猜测此方法哪个类的。

可以遵循以下两个规则：

1>不使用*（星号）通配符，除非是导入静态常量类（只包含常量的类或接口）。

2>方法名是具有明确、清晰表象意义的工具类。

如下面的代码：

package com.enhance;
import static java.lang.Math.max;  //静态导入
public class StaticImport {
	public static void main(String[] args){
		
		int x = 4 , y = 5;
		int z = max(x,y);
		
		System.out.println(z);  // 静态导入了某个类中所有静态方法，见import static，最后不要使用*的。
	}
}

二、可变参数

可变参数的由来，要从函数的重载说起了，当函数具有相同的功能描述，但由于参数个数不同时。可以使用函数重载来实现。

若参数个数不是固定，可以使用参数类型数组来实现。但依然需要在调用此方法之前，new一个数组。

为了简化代码和减少代码输入量，从jdk1.5引入了可变参数。使得当参数个数不确定时，不用再new数组传入了，依然可以直接把参数扔入此方法中。

可变参数的具有如下两个特点：
1> 只能出现在参数列表中的最后一个参数中。
2> 编译器是把可变参数当成一个数组来处理的。

小发现，可变参数的三个.，...可以在两个出现空格也可以不出现空格。

如下面的代码：

package com.enhance;

public class VariableChangable {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int sum = sum(3,4);
		System.out.println(sum);
		sum = sum(3,4,5);
		System.out.println(sum);
		
	}
	
	/**
	 可变参数的特点：
	 1> 只能出现在参数列表中的最后一个参数中。
	 2> 编译器是把可变参数当成一个数组来处理的。
	
	 
	 * */
	public static int sum(int x , int... args){
		int sum = x;
		/**
		 * 增强的for循环，特点：
		 * for(Type 变量名 : 可迭代的集合)
		 * Type前可加final来修饰
		 * 
		 */
		for(int arg : args){
			
			sum += arg ;
		}
		
		return sum;
	}

}

三、增加for循环
它的出现，使得在打印输出或仅对数组或实现了Iterable集合中，取出元素的处理不用再用数组角标或hasNext,next之类繁重的代码输入量了。使得代码更短小精简。

那么使用增加for循环(foreach)必须要满足以下条件之一：

1> 是数组

2> 是集合且实现了Iterable接口

如上的例子。

格式是 for(TYPE 变量名 ： 数组或可迭代的集合) 且TYPE类型前面可以加final修饰的。

当然对集合实现Iterable接口，此接口仅一个方法iterator()返回Iterator接口。但不可在foreach中，使用remove等方法。

四、基本数据类型的自动装箱与拆箱

在jdk1.5之前，若需要创建如Integer实例，则必须new一个出来或使用Integer等相关类的方法来获得一个Integer实例。

1.5之后，对于此应用可以更简单了，因为支持了自动装箱。

如以下：

Integer a = 123 ; //装箱

int b = a -10 ; //拆箱

具体示例代码如下：

package com.enhance;

public class AutoBinning {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Integer x = 120 ;
		Integer y = 120;
		System.out.println("x==y::"+(x==y));//为true
		x = 128;
		y = 128;
		System.out.println("x==y::"+(x==y));  //为false
		//因为自动装箱中，Integer有byte范围 -128~127之间都有缓存的，也只是这个范围内只new一个对象。
		
		Integer a = Integer.valueOf(3);
		Integer b = Integer.valueOf(3);
		System.out.println("a==b::"+(a==b));  //为true
		
		 a = Integer.valueOf(128);
		 b = Integer.valueOf(128);
		System.out.println("a==b::"+(a==b)); //为false
	}

}

从上发现一个现象，即当Integer值的范围是-128~127之前时， new 出来或装箱出来的同一值时，产生的对象是同一个。这里来到了缓存池的概念，

即当取值是一个byte表示的范围时，会缓存此值在缓冲池中，下次再来一个byte范围的值时会在缓冲池中找是否存在，存在则不再创建新的对象了。这个处理方法的原则其实也就是享元设计模式了。

享元设计模式概念：

简单的说是：运用共享技术有效的支持大量细粒子对象。

利用共享来避免大量具有相同内容的开销，这种开销最常见及最常观的就是内存的开销。

Flyweight模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度.应用场合很多:比如你要从一个数据库中读取一系列字符串,这些字符串中有许多是重复的,那么我们可以将这些字符串储存在Flyweight池(pool)中.

具体的示例代码如下：

package com.pattern.flyweight;

import java.util.HashMap;

public class Client {

	public static void main(String[] args){
		int innr = 22 ;
		FlyweightFactory factory = new FlyweightFactory();
		Flyweight xf = factory.getFlyweight("x");
		xf.operation(--innr);
		
		Flyweight yf = factory.getFlyweight("y");
		yf.operation(--innr);
		
		Flyweight xxf = factory.getFlyweight("x");
		xxf.operation(--innr);
		
		int extr = 22 ;
		UnsharedConcreteFlyweight uf = new UnsharedConcreteFlyweight();
		uf.operation(--extr);
		
		System.out.println("count:"+factory.getStanceCount());
	}
}

class FlyweightFactory{
	//常用Map 来缓存具体相同对象的实例
	private HashMap<String,Flyweight> map = new HashMap<String,Flyweight>();
	
	
	public Flyweight getFlyweight(String key){
		Flyweight f ;
		if(null==map.get(key)){
			f = new ConcreteFlyweight();
			map.put(key, f);
		}else{
			f = map.get(key);
		}
		return f ;
	}
	
	public int getStanceCount(){
		return map.size();
	}
}

abstract class Flyweight{
	
	public abstract void operation(int innr);
}

class ConcreteFlyweight extends Flyweight{

	public void operation(int innr) {
		System.out.println("具体的flyweight:"+innr);
	}
}

class UnsharedConcreteFlyweight extends Flyweight{
	public void operation(int extr){
		System.out.println("具体的不flyweight:"+extr);
	}
}