½W¬ä¸€å¤§ä¼˜åŠ?- 他们有名¿U°ã€?/h4>

多个构造器只能通过匚w…å‚æ•°¾cÕdž‹çš„顺序不同来区分使用哪一个，˜q™æ ·å¸¸å¸¸ä¼šå¯¼è‡´ç”¨æˆ¯‚°ƒç”¨é”™è¯¯æž„造器åQŒè€Œé™æ€å·¥½E‹æ–¹æ³•åˆ™ä¸åŒåQŒå¯ä»¥é€šè¿‡æ–ÒŽ³•åæ¸…晰的指明用意ã€?/p>

//本例只用来说明第一大优势，请不要纠¾l“其它问é¢?/span> 
public class Foo {
         Set<Bar> bars;
         List<Car> cars;
         //构造器1
         private Foo(Set<Bar> bars) {
                 this.bars = bars;
         }
         //构造器2
         private Foo(List<Car> cars) {
                 this.cars = cars;
         }
         //构造器3
         private Foo(Set<Bar> bars, List<Car> cars) {
                 this.bars = bars;
                 this.cars = cars;
         }
         //静态工厂方�
         public static Foo newInstanceByBar(){
                 return new Foo(new HashSet<Bar>());
         }
         //静态工厂方�
         public static Foo newInstanceByCar(){
                 return new Foo(new ArrayList<Car>());
         }
         //静态工厂方�
         public static Foo newInstanceByAll(){
                 return new Foo(new HashSet<Bar>(),new ArrayList<Car>());
         }
         public static void main(String[] args) {
                 // 通过构造器创徏实例åQŒä¸å¥½åŒºåˆ†å®¹æ˜“ä‹É用错è¯?br />                 Foo fbar = new Foo(new HashSet<Bar>());
                 Foo fcar = new Foo(new ArrayList<Car>());
                 Foo fall = new Foo(new HashSet<Bar>(),new ArrayList<Car>());
                  // 通过静态工厂方法可以清晰的用方法名识别
                 Foo fbar_static = Foo.newInstanceByBar();
                 Foo fcar_static = Foo.newInstanceByCar();
                 Foo fall_static = Foo.newInstanceByAll();
         }
  }
  class Bar {}
  class Car {} 

对于GuavaåQŒåƈ没有提供创徏静态工厂方法的工具åQŒä½†æ•´ä¸ªGuava API到处都是静态方法的实现åQŒæˆ‘们以Guava Collections Framewrok举例说明ã€?/p>

Guava对于½W¬ä¸€å¤§ä¼˜åŠ¿æœ‰å¾ˆå¤šå®žçŽ°åQ?/p>

List<Type> exactly100 = Lists.newArrayListWithCapacity(100);
List<Type> approx100 = Lists.newArrayListWithExpectedSize(100); 
Set<Type> approx100Set = Sets.newHashSetWithExpectedSize(100);

½W¬äºŒå¤§ä¼˜åŠ?- 不必在每‹Æ¡è°ƒç”¨ä»–们的时候都创徏一个新对象ã€?/h4>

方便对象重用åQŒè¿˜å¯ä»¥¼‹®ä¿ä¸å¯å˜çš„不会存在两个相等的实例，如果a==b那么a.equals.(b)才会˜q”回true ,如果能保证这一点，ž®±å¯ä»¥ä‹Éç”?tt>==操作½W¦æ¥æ¯”较对象åQŒä¼šæœ‰å¾ˆå¤§çš„性能提升ã€?/p>

½W¬ä¸‰å¤§ä¼˜åŠ?- 他们可以˜q”回原返回类型的ä»ÖM½•å­ç±»åž‹çš„对象ã€?/h4>

˜q™æ˜¯ä¸€ä¸ªéžå¸¸å¼ºå¤§çš„ç‰ÒŽ€§ï¼Œ Effective Java中列举了API、SPI、服务提供框架的关系来说明：

API(Service Interface): 服务公共接口 SPI(Service Provider Interface)åQ?服务提供商接å?nbsp;SPF(Service Provider Framework): 服务提供框架

看例�

// 服务提供框架½Cºæ„æ¨¡åž‹ - 服务API 
public interface ServiceAPI {
         // ˜q™é‡Œæ˜¯æœåŠ¡æŒ‡å®šçš„æ–ÒŽ³•
 }
// 服务提供框架½Cºæ„æ¨¡åž‹ - 服务SPI 
public interface ServiceSPI {
         ServiceAPI newService();
 }  
// 服务提供框架½Cºæ„æ¨¡åž‹å®žçŽ° 
// 不可实例化的¾c»ï¼Œç”¨æ¥æ³¨å†Œåˆ›å¾å’Œæä¾›è®¿é—?/span> 
public class ServiceFramework {
         private ServiceFramework() {
         }// 强制防止实例化（规则4åQ?br />
         // 映射服务名到服务
         private static final ConcurrentMap<String, ServiceSPI> spis = new MapMaker().makeMap();//使用Guava创徏
         public static final String DEFAULT_SPI_NAME = "<def>";

         // 默认SPI注册API
         public static void registerDefaultSPI(ServiceSPI spi) {
                 registerSPI(DEFAULT_SPI_NAME, spi);
         }

         // 指定SPI注册API
         public static void registerSPI(String name, ServiceSPI spi) {
                 spis.put(name, spi);
         }

         // 服务讉K—®API
         public static ServiceAPI newInstance() {
                 return newInstance(DEFAULT_SPI_NAME);
         }
         public static ServiceAPI newInstance(String name) {
                 ServiceSPI spi = spis.get(name);
                 if(spi == null)
                         throw new IllegalArgumentException(
                                         "No provider registered with name: " + name);
                 return spi.newService();
         }
 }

Note	静态工½E‹æ–¹æ³•è¿”回的对象所属的¾c»ï¼Œåœ¨ç¼–写这个包含静态工厂方法的¾cÀL—¶å¯ä»¥ä¸å¿…存在。上面的例子在编写ServiceFramework¾cÀL—¶åQŒServiceAPI的实现类òq¶ä¸å­˜åœ¨ã€‚这大大增加了框架的灉|´»æ€§ã€?/strong>

现在¾~–写客户端测试程åº?/p>

// ½Ž€å•çš„服务提供框架‹¹‹è¯•½E‹åº 
public class Test {
         public static void main(String[] args) {
                 // 服务提供商执行下面的注册
                 ServiceFramework.registerDefaultSPI(DEFAULT_PROVIDER);
                 ServiceFramework.registerSPI("comp", COMP_PROVIDER);
                 ServiceFramework.registerSPI("armed", ARMED_PROVIDER);
                  // 客户端执行下面的创徏
                 ServiceAPI s1 = ServiceFramework.newInstance();
                 ServiceAPI s2 = ServiceFramework.newInstance("comp");
                 ServiceAPI s3 = ServiceFramework.newInstance("armed");
                 System.out.printf("%s, %s, %s%n", s1, s2, s3);
         }
          private static ServiceSPI DEFAULT_PROVIDER = new ServiceSPI() {
                 public ServiceAPI newService() {
                         return new ServiceAPI() {
                                 @Override
                                 public String toString() {
                                         return "默认服务";
                                 }
                         };
                 }
         };
          private static ServiceSPI COMP_PROVIDER = new ServiceSPI() {
                 public ServiceAPI newService() {
                         return new ServiceAPI() {
                                 @Override
                                 public String toString() {
                                         return "Complementary 服务";
                                 }
                         };
                 }
         };
          private static ServiceSPI ARMED_PROVIDER = new ServiceSPI() {
                 public ServiceAPI newService() {
                         return new ServiceAPI() {
                                 @Override
                                 public String toString() {
                                         return "Armed 服务";
                                 }
                         };
                 }
         };
 }
  
//输出如下 �/span>�/span>�/span>�/span>, Complementary �/span>�/span>, Armed �/span>�/span>

½W¬å››å¤§ä¼˜åŠ?- 在创建参数化¾cÕdž‹å®žä¾‹çš„时候，他们使代码变得更加简‹zã€?/h4>

在JDK7之前åQŒæˆ‘们创å»ÞZ¸€ä¸ªCollections大致是这么做的：

List<TypeThatsTooLongForItsOwnGood> list = new ArrayList<TypeThatsTooLongForItsOwnGood>();

JDK7发布以后åQŒæˆ‘们可以简化成˜q™æ ·åQ?/p>

List<TypeThatsTooLongForItsOwnGood> list = new ArrayList<>();

但是Guava˜q˜æ˜¯å®æ„¿ä½¿ç”¨é™æ€å·¥½E‹æ–¹æ³•ï¼Œå› äؓ真的非常方便åQ?/p>

Set<Type> copySet = Sets.newHashSet(elements); 
List<String> theseElements = Lists.newArrayList("alpha", "beta", "gamma");

静态工½E‹æ–¹æ³•çš„¾~ºç‚¹

既然Effective Javaå’ŒGuava都诞生于GoogleåQŒé‚£ä¹ˆå½“他们盔R‡ä¼šä»€ä¹ˆæ ·å‘¢ï¼Œä¸ºæ­¤æˆ‘决定重温Effective Java˜q™éƒ¨è‘—作åQŒåƈ针对每一条规则寻找Guava¾l™å‡ºçš„解å†Ïx–¹æ¡ˆï¼Œå¸Œæœ›èƒ½æ›´æ·±å…¥çš„掌握Javaã€?/p>

Effective Java½W?0条规则： å§‹ç»ˆè¦è¦†ç›?/strong>toStringæ–ÒŽ³•

Effective Java里指出，"å»ø™®®æ‰€æœ‰çš„子类都覆盖这ä¸?tt>toStringæ–ÒŽ³•"åQŒè¿™æ ·å¯ä»¥ä‹É¾cȝ”¨èµäh¥æ›´åŠ èˆ’适。最重要的是˜q™æ ·çš„做法对调试非常有帮助，Guava通过 Objects.toStringHelper为我们提供了方便创徏toString的方法。看下面的样例：

// Returns "ClassName{x=1}"
   Objects.toStringHelper(this)
       .add("x", 1)
       .toString();

   // Returns "MyObject{x=1}"
   Objects.toStringHelper("MyObject")
       .add("x", 1)
       .toString();

Guava关于toString的文档连接： https://code.google.com/p/guava-libraries/wiki/CommonObjectUtilitiesExplained

下面我把Effective Java的样例代码列出，òq¶ç”¨Guava重新äº?tt>toStringæ–ÒŽ³•

// 重写PhoneNumberçš„toStringæ–ÒŽ³• - Effective Java中文½W¬äºŒç‰ˆç¬¬44™å?/span>
package org.effectivejava.examples.chapter03.item10;

import java.util.HashMap;
import java.util.Map;

import com.google.common.base.Objects;

public final class PhoneNumber {
        private final short areaCode;
        private final short prefix;
        private final short lineNumber;

        public PhoneNumber(int areaCode, int prefix, int lineNumber) {
                rangeCheck(areaCode, 999, "area code");
                rangeCheck(prefix, 999, "prefix");
                rangeCheck(lineNumber, 9999, "line number");
                this.areaCode = (short) areaCode;
                this.prefix = (short) prefix;
                this.lineNumber = (short) lineNumber;
        }

        private static void rangeCheck(int arg, int max, String name) {
                if (arg < 0 || arg > max)
                        throw new IllegalArgumentException(name + ": " + arg);
        }

        @Override
        public boolean equals(Object o) {
                if (o == this)
                        return true;
                if (!(o instanceof PhoneNumber))
                        return false;
                PhoneNumber pn = (PhoneNumber) o;
                return pn.lineNumber == lineNumber && pn.prefix == prefix
                                && pn.areaCode == areaCode;
        }

        @Override
        public int hashCode() {
                int result = 17;
                result = 31 * result + areaCode;
                result = 31 * result + prefix;
                result = 31 * result + lineNumber;
                return result;
        }

    //Effective Java原有的toStringæ–ÒŽ³•
        /*
         * @Override public String toString() { return
         * String.format("(%03d) %03d-%04d", areaCode, prefix, lineNumber); }
         */

        /**
         * 采用Guava实现的toString
         *
         */
        @Override
        public String toString() {
                return Objects.toStringHelper(this)
                                .addValue(String.format("(%03d) %03d-%04d", areaCode, prefix,lineNumber))
                                .add("areaCode", areaCode)
                                .add("prefix", prefix)
                                .add("lineNumber", lineNumber)
                                .toString();
        }

        public static void main(String[] args) {
                Map<PhoneNumber, String> m = new HashMap<PhoneNumber, String>();
                m.put(new PhoneNumber(707, 867, 5309), "Jenny");

                System.out.println(m);
        }
}

输出å¯ÒŽ¯”