Go语言视频零基础入门到精通

javalearner

于类而言，为了让客户端获取它自身的一个实例，最常用的方法就是提供一个公有的构造器。类也可以提供一个公有的静态工厂方法，它只是一个返回类的实例的静态方法。下面是一个来自Boolean的简单示例。  public static Boolean valueOf(boolean b) {
     return b ? Boolean.TRUE : Boolean.False;
}  (1)静态工厂方法与构造器不同的第一大优势在于，它们有名称
。
(2)静态工厂方法与构造器不同的第二大优势在于，不必在每次调

(3)用它们的时候都创建一个新对象。
静态工厂方法与构造器不同的第三大优势在于，它们可以返回原返回类型的任何子类型的对象。

(4) 静态工厂方法的第四大优势在于，在创建参数化类型实例的时候，它们使代码变得更加简洁。
   
  
   
   

     
   

     
   
  
静态工厂方法的主要缺点在于，类如果不含有公有的或受保护的构造器，就不能被子类化。
静态工厂方法的第二个缺点在于，它们与去他的静态方法实际上没有任何区别。 服务提供者框架：

1. public interface Service { //要提供的服务
   
2.     // Service-specific methods go here  
   
3. }
   
4. public interface Provider { //服务提供者要实现的接口
   
5.     Service newService();
   
6. }
   
7. import java.util.*;
   
8. import java.util.concurrent.*;
   
9. 
   
10. public class Services {
    
11.     private Services() { }  
    
12. 
    
13.     // Maps service names to services  
    
14.     private static final Map< String, Provider> providers =  new ConcurrentHashMap< String, Provider>();
    
15.     public static final String DEFAULT_PROVIDER_NAME = "< def>";
    
16. 
    
17.     // Provider registration API  
    
18.     public static void registerDefaultProvider(Provider p) {
    
19.         registerProvider(DEFAULT_PROVIDER_NAME, p);
    
20.     }
    
21.     public static void registerProvider(String name, Provider p){
    
22.         providers.put(name, p);
    
23.     }
    
24. 
    
25.     // Service access API  
    
26.     public static Service newInstance() {
    
27.         return newInstance(DEFAULT_PROVIDER_NAME);
    
28.     }
    
29.     public static Service newInstance(String name) {
    
30.         Provider p = providers.get(name);
    
31.         if (p == null)
    
32.             throw new IllegalArgumentException(
    
33.                 "No provider registered with name: " + name);
    
34.         return p.newService();
    
35.     }
    
36. }
    
37. 
    
38. public class Test {
    
39.     public static void main(String[] args) {
    
40.         // Providers would execute these lines  
    
41.         Services.registerDefaultProvider(DEFAULT_PROVIDER);
    
42.         Services.registerProvider("comp",  COMP_PROVIDER);
    
43.         Services.registerProvider("armed", ARMED_PROVIDER);
    
44. 
    
45.         // Clients would execute these lines  
    
46.         Service s1 = Services.newInstance();
    
47.         Service s2 = Services.newInstance("comp");
    
48.         Service s3 = Services.newInstance("armed");
    
49.         System.out.printf("%s, %s, %s%n", s1, s2, s3);
    
50.     }
    
51. 
    
52.     private static Provider DEFAULT_PROVIDER = new Provider() {
    
53.         public Service newService() {
    
54.             return new Service() {
    
55.                 @Override public String toString() {
    
56.                     return "Default service";
    
57.                 }
    
58.             };
    
59.         }
    
60.     };
    
61. 
    
62.     private static Provider COMP_PROVIDER = new Provider() {
    
63.         public Service newService() {
    
64.             return new Service() {
    
65.                 @Override public String toString() {
    
66.                     return "Complementary service";
    
67.                 }
    
68.             };
    
69.         }
    
70.     };
    
71. 
    
72.     private static Provider ARMED_PROVIDER = new Provider() {
    
73.         public Service newService() {
    
74.             return new Service() {
    
75.                 @Override public String toString() {
    
76.                     return "Armed service";
    
77.                 }
    
78.             };
    
79.         }
    
80.     };
    
81. }
    
82. 
    

复制代码

运行：
C:ex>java Test
Default service, Complementary service, Armed service




  
  
   
   

     
   

     
   
  

复制代码