《Effective Java》读书笔记（一）

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

静态工厂含义：静态工厂方法指的是在类中提供一个公有的静态方法，返回类的一个实例。

对于类而言，为了让客户端获取它自身的一个实例，最常用的方法就是提供一个共有的构造器；还有一种方法：类可以提供一个公有的静态工厂方法，它只是一个返回类的实例的静态方法；书中用了一个来自Boolean的简单示例，它的静态工厂方法是：

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

我们可以用静态工厂的方法代替构造器产生一个Boolean实例：

//构造器产生
Boolean a = new Boolean(true);
//静态工厂方法产生
Boolean b = Boolean.valueOf(true);

使用静态工厂方法而不是构造器，这样的优势是：

1. 静态工厂方法与构造器不同的第一大优势在于，它们有名称。

一个类只能有一个带有指定签名的构造器（方法签名：方法的名称+参数类型），当一个类需要多个带有相同签名的构造器时，我们就会非常混乱，究竟要用哪个呢？这时候，带有名称的静态工厂方法就派上用场了。

public class User {
    
    private int age;
    private String username;

    public User(int age,String username) {
        this.age = age;
        this.username = username;
    }

    //相同签名
    public User(String username, int age) {
        this.age = age;
        this.username = username;
    }

    //静态工厂方法 有名字
    public static User getNewInstance(String username, int age) {
        return new User(age,username);
    }

}

• 静态工厂方法与构造器不同的第二大优势在于，不必在每次调用它们的时候都创建一个新对象

这使得不可变类可以使用预先构造好的实例，或者将构造好的实例缓存起来，进行重复利用，从而避免创建不必要的重复对象。

不可变类 是指创建该类的实例后，该实例的实例变量是不可改变的。Java中已有类例如Double和String等。
如果需要创建自定义的不可变类，遵守如下规则：

• 使用private和final修饰符来修饰该类的成员变量；
• 提供带参数的构造器，根据传入的参数来初始化类里的成员变量；
• 仅为该类的成员变量提供getter方法，不要提供setter方法，因为普通方法无法修改final修饰的成员变量；
• 如果有必要，重写Object类的hascode()和equals()方法。equals方法根据关键成员变量来作为两个对象是否相等的标准，除此之外，还应该保证两个用equals方法判断为相等的对象的hashCode()也相等。

这里借鉴一下这篇文章，详细介绍了不可变类：

https://blog.csdn.net/mashaokang1314/article/details/83247147?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1

试着写一个不可变类：

public class Position{
	//私有类型封装
    private final int x;
    private final int y;
    private static Position ORIGIN = new Position(0,0);
    private Position(int x, int y){
        this.x = x;
        this.y = y;
    }
	//静态工厂方法 返回类的一个实例
    public static Position getORIGIN(){
        return ORIGIN;
    }
    //只有get 没有set
    public int getX(){
        return x;
    }
    
    public int getY(){
        return y;
    }
}

不可变类可以使用预先构造好的实例，这句话怎么理解呢，我们看回Boolean不可变类的例子：

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

看一看包装类Boolean的源码中，已经有事先构造好的实例：

public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);

就不用再一次次使用如下代码构建，创建对象的代价很高。

Boolean a = new Boolean(true);

或者将构造好的实例缓存起来，进行重复利用，从而避免创建不必要的重复对象，这句话我们也来举一个例子，这里我们用不可变类Integer为例：

//生成新的integer对象
Integer i1 = new Integer(6);
 //直接从缓存中取出已缓存的对象来使用
Integer i12 = Integer.valueOf(6);

valueOf()是怎么实现缓存的呢？

 public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

可以看到，如果传进来的数是-128～127,则从缓存数组中返回，如果不是在这个范围呢，则直接返回一个新的对象，我们再点进去看看IntegerCache缓存是怎么做的：

 private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

原来它已经事先给我们构建好了Integer范围内的实例并缓存起来，方便我们进行重复利用，但要注意的是：如果程序需要经常请求相同对象的时候，这项技术才可以提高性能，如果只是用一次，或重复概率不大的类，缓存实例就是弊大于利，所以不能盲目使用缓存实例。

静态工厂方法与构造器不同的第三大优势在于，它们可以返回原返回类型的任何子类型的对象。

这句话看起来有点难以理解，看一个小示例：

public class Person {
    public static Person getInstance(){
        //项目中主类不应该依赖子类 仅示范
        return new Student();
    }
}
class Student extends Person {

}

我们再看看书上解释的这句：静态工厂方法返回的对象所属的类，在编写包含该静态工厂方法的类是可以不必存在，这种灵活的静态工厂方法构成了服务提供者框架，例如JDBC API；服务者提供框架是指这样一个系统：多个服务提供者实现一个服务，系统为服务提供者的客户端提供多个实现，并把它们从多个实现中解耦出来。

服务提供者框架中有三个重要的组件与一个可选的组件：

• 服务接口(Service Interface)：这是提供者实现的
• 提供者注册API(Provider Registration API)：这是系统用来注册实现，让客户端访问它们的
• 服务访问API(Service Access API)：是客户端用来获取服务的实例的
• (可选)服务提供者接口(Service Provider Interface)：这些提供者负责创建其服务

书上服务提供者框架示例：

//服务接口
public interface Service{
  ...//some methods 
}
//服务提供者接口
public interface Provider{
  Service newService();
}

public class Services{
  private Services(){}
  private static final Map<String,Provider> providers=new ConcurrentHashMap<>();
  public static final String DEFAULT_PROVIDER_NAME="<def>"
  //提供者注册API
  public static void registerDefaultProvider(Provider p){
    registerProvider(DEFAULT_PROVIDER_NAME,p);
  }

 public static void registerProvider(String name,Provider p){
    providers.put(name,p);
  }
  
  //服务访问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();
  }  
}
}

这样看可能还是有点模糊，这里借鉴一个大佬的图与代码，非常简洁明了：

引用图文地址：https://www.jianshu.com/p/4d7a0cd36a82

//服务接口
interface MusicApp {
    void play();
}
//服务提供者接口
interface MusicProvider {
    MusicApp getMusicApp();
}

class AppStore {
    private AppStore() {}
    
    private static final Map<String, MusicProvider> providers = new ConcurrentHashMap<String, MusicProvider>();
    //服务注册API
    public static void registerProvider(String name, MusicProvider p) {
        providers.put(name, p);
    }
    //服务访问API
    public static MusicApp installApp(String name) {
        MusicProvider p = providers.get(name);
        if (p==null) {
            throw new IllegalArgumentException("No provider registerd with name:" + name);
        }
        return p.getMusicApp();
    }
}

实现类：

//网易云音乐移动端实现
class NetEaseMusicApp implements MusicApp {
    @Override
    public void play() {
        System.out.println("网易云音乐，听见好时光~来自Android客户端");
    }
}
//网易云音乐PC端实现
class NetEaseMusicPC implements MusicApp {
    @Override
    public void play() {
        System.out.println("网易云音乐，听见好时光~来自PC客户端");
    }
}
//网易云音乐服务提供者实现
class NetEaseMusicProvider implements MusicProvider {
    @Override
    public MusicApp getMusicApp() {
        boolean isDeviceAndroid = true;
        if (isDeviceAndroid) {
            return new NetEaseMusicApp();
        }
        else {
            return new NetEaseMusicPC();
        }
    }
}

主函数：

public static void main(String[] args) {
    AppStore.registerProvider("NetEase", new NetEaseMusicProvider());
    //以下为用户的操作
    MusicApp musicApp = AppStore.installApp("NetEase");
    musicApp.play();

个人理解：这个框架灵活之处在哪里呢？

首先在

 //服务访问API
    public static MusicApp installApp(String name) {
        MusicProvider p = providers.get(name);
        if (p==null) {
            throw new IllegalArgumentException("No provider registerd with name:" + name);
        }
        return p.getMusicApp();
    }

这一段中，我们可以通过传入不同的name，即App的名字来拿到不同的MusicApp，我们又可以自定义不同的MusicApp的实现类，比如上代码所说的NetEaseMusic-PC端跟NetEaseMusic-安卓端，或者定义其他MusicApp的实现类:class QQMusic implements MusicApp{}…然后上面代码返回的是MusicApp，实质上可以返回它的各种子类型对象，比如QQMusic等。
因为 服务提供者接口 => 服务接口

  // public static void registerProvider(String name, MusicProvider p) 
  // 与MusicProvider与MusicApp一一对应
  AppStore.registerProvider("NetEase", new NetEaseMusicProvider());
  AppStore.registerProvider("QQ", new QQMusicProvider());
  AppStore.registerProvider("Apple", new AppleMusicProvider());

相对应这里可以跟以上定义的不同MusicApp,通过实现MusicProvider接口传入不同MusicProvider的实现类，使用者不需要知道具体是怎么实现，只需要传入所需的服务名字即可；就像我们使用JDBC：

Class.forName("com.mysql.jdbc.Driver");   
DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","root");  

我们只需填入不同的Driver以及Url，就能轻松切换数据库。

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

调用参数化构造器的时候，通常要两次提供类型参数：

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

使用静态工厂方法后，可以把这个当成工具类使用，使重复调用时非常方便：

public static <K, V>HashMap<K, V> newInstance( ) {
	return new HashMap<K, V>();
}

当然静态工厂方法也有缺点：

• 类如果不含公有的或者受保护的构造器，就不能被子类化。什么意思呢？就是说如果类没有public或者protected修饰的构造器，那么就不能被另外一个类所继承，也就是所谓的子类化。
• 它们与其他的静态公有方法实际上没有任何区别。
  在API文档中，它们没有像构造器那样在API文档中被明确标识出来，因此，对于提供了静态工厂方法而不是构造器的类来说，要想查明如何实例化一个类，是非常困难的。

书上还列举了一些静态工厂方法的惯用名称：

• valueOf 该方法返回的实例与参数具有相同的值，实际是类型转换方法。
• of valueOf的一种替代。
• getInstance Singleton单例模式，返回唯一的实例。
• newInstance 返回的实例是一个新的实例，与之前返回的都不相同。
• getType 与getInstance一样，但是在工厂方法处于不同的类时候使用。
• newType 与getInstance一样，但是在工厂方法处于不同的类时候使用。