Effective java 第一条

第一条.考虑用静态工厂方法代替构造器！

 

优势：

1.有名称。

BigInteger的probablePrime方法。

public static BigInteger probablePrime(int bitLength, Random rnd) { if (bitLength < 2) throw new ArithmeticException("bitLength < 2"); // The cutoff of 95 was chosen empirically for best performance return (bitLength < SMALL_PRIME_THRESHOLD ? smallPrime(bitLength, DEFAULT_PRIME_CERTAINTY, rnd) : largePrime(bitLength, DEFAULT_PRIME_CERTAINTY, rnd)); }

 

 

 

2.不必每次调用它们的时候都创建一个新对象。

例如BigInteger的valueOf(int i)，

public static BigInteger valueOf(long val) { // If -MAX_CONSTANT < val < MAX_CONSTANT, return stashed constant if (val == 0) return ZERO; if (val > 0 && val <= MAX_CONSTANT) return posConst[(int) val]; else if (val < 0 && val >= -MAX_CONSTANT) return negConst[(int) -val]; return new BigInteger(val); }

  

 更好的例子是Boolean的valueOf方法。因为Boolean只会有两个值。并且经常是数值判等。以下两种情况都可以判断相等。

Boolean b1 = Boolean.valueOf(true); Boolean b2 = Boolean.valueOf(true); if(b1.equals(b2)){ System.out.println("equals"); } if(b1==b2){ System.out.println("=="); }

 

 

 

3.可以返回任何子类型的对象。

例如Collections。

4.在创建参数化类型实例的时候，使得代码更简洁。这个还没有实现。但是想法很好！

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

可以写成

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

其静态工厂方法为:

public static <K, V>HashMap<K, V> newInstance(){

     return new HashMap<K, V>();

}

 

 

服务提供者框架是指这样一个系统：多个服务提供者实现一个服务，系统为服务提供者的客户端（在类的实现中使用了API的类被称为该API的客户端）提供多个实现，并把它们从多个实现中解耦出来。

服务提供者框架中有三个重要组件：服务接口（Service Interface），由服务提供者实现；提供者注册API（Provider Registration API），这是系统用来注册实现，让客户端访问他们的；服务访问API（Service Access API），是客户端用来获取服务的实例的。

服务提供者框架的第四个组件是可选的：服务提供者接口（Service Provider Interface），这些提供者负责创建其服务实现的实例。如果没有服务提供者接口，实现就按照类名称注册，并通过反射方式进行实例化。

// Service provider framework sketch // Service interface public interface Service{...} // Service provider interface public interface Provider{ Service new Service(); } // Noninstantiable class for service registration and access public class Services{ private Services(){} //禁止实例化 // Maps service names to services private static final Map<String, Provider> providers = new ConcurrentHashMap<String, Provider>(); public static final String DEFAULT_PROVIDER_NAME = "<def>"; // Provider registration API public static void registerDefaultProvider<Provider p>{ registerProvider(DEFAULT_PROVIDER_NAME, p); } public static void registerProvider(String name, Provider p){ providers.put(name, p); } // Service access API 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(); } }

 

对于JDBC来说，Connection就是他的服务接口，DriverManager.registerDriver是提供者注册API，DriverManager.getConnection是服务访问API，Driver就是服务提供者接口。

 

package ServiceProviderFramework;   
  
import java.util.Map;   
import java.util.concurrent.ConcurrentHashMap;   
  
public class Services {   
  
    private Services(){   
          
    }   
    private static final Map<String, Provider> providers = new ConcurrentHashMap<String, Provider>();   
    public static final String DEFAULT_PROVIDER = "<def>";   
       
    public static void registerDefaultProvider(Provider p){   
        registerProvider(DEFAULT_PROVIDER, p);   
    }   
    public static void registerProvider(String name, Provider p){   
        providers.put(name, p);   
    }   
       
    public static Service newInstance(){   
        return newInstance(DEFAULT_PROVIDER);   
    }   
       
    public static Service newInstance(String name){   
        Provider p = providers.get(name);   
        if(p==null)   
            throw new IllegalArgumentException("No provider");   
        return p.newService();   
    }   
}  

 

package ServiceProviderFramework;

public interface Service {
	public void service();
}

 

 

package ServiceProviderFramework;

public interface Provider {
	Service newService();
}

 

package ServiceProviderFramework; 

class Service1 implements Service{ 
	@Override public void service() { 
		// TODO Auto-generated method stub 
		System.out.println("Servide1 is running!");  
	} 
}

 

package ServiceProviderFramework; 

class Service2 implements Service{ 
	@Override public void service() { 
		// TODO Auto-generated method stub 
		System.out.println("Servide2 is running!");  
	} 
}

  

 

package ServiceProviderFramework;

class Provider1 implements Provider {
	private static final Service service = new Service1();

	@Override
	public Service newService() {
		// TODO Auto-generated method stub return service;
		return service;
	}
}

 

 

package ServiceProviderFramework;

class Provider1 implements Provider {
	private static final Service service = new Service1();

	@Override
	public Service newService() {
		// TODO Auto-generated method stub return service;
		return service;
	}
}

 

 

package ServiceProviderFramework;

class Provider2 implements Provider {
	private static final Service service = new Service2();

	@Override
	public Service newService() {
		// TODO Auto-generated method stub return service;
		return service;
	}
}

 

 

package ServiceProviderFramework;

public class Test {
	public static void main(String[] args) {
		Provider1 p1 = new Provider1();
		Provider2 p2 = new Provider2();
		Services.registerDefaultProvider(p1);
		Services.registerProvider("Provider2", p2);
		Service s1 = Services.newInstance();
		Service s2 =  Services.newInstance("Provider2");
		s1.service();
		s2.service();
	}
}