1.1用静态方法代替构造器

1.1

​ 静态工厂方法与构造器不同的第一大优势在于，它们有名称。例如构造器BigIntger(int,int,Random)返回一个奇数。但是如果通过构造器创建的话，在使用次构造器的时候，是不知道它具体的作用的。但是如果采用了静态方法代替的话。如：BigIntger.probablePrime(int,int,Random)来表示，显示更为清晰，更利于后期维护和它人使用

1.1.2

​ 静态工厂方法与构造器不同的第二大优势在于，不必每次调用都创建一个新的对象。比如享元模式。享元模式就是对已经创建的对象进行重复利用，从而大幅度提高性能，减少内存的占用。

以下是享元模式的简介

//Shape.java
public interface Shape {
  void draw();
}

//Circle.java
public class Circle implements Shape {
  private String color;
  private int x;
  private int y;
  private int radius;

  public Circle(String color){
     this.color = color;     
  }

  public void setX(int x) {
     this.x = x;
  }

  public void setY(int y) {
     this.y = y;
  }

  public void setRadius(int radius) {
     this.radius = radius;
  }

  @Override
  public void draw() {
     System.out.println("Circle: Draw() [Color : " + color 
        +", x : " + x +", y :" + y +", radius :" + radius);
  }
}

//ShapeFactory.java
import java.util.HashMap;

public class ShapeFactory {
  private static final HashMap<String, Shape> circleMap = new HashMap<>();

  public static Shape getCircle(String color) {
     Circle circle = (Circle)circleMap.get(color);

     if(circle == null) {
        circle = new Circle(color);
        circleMap.put(color, circle);
        System.out.println("Creating circle of color : " + color);
     }
     return circle;
  }
}


//FlyweightPatternDemo.java
public class FlyweightPatternDemo {
  private static final String colors[] = 
     { "Red", "Green", "Blue", "White", "Black" };
  public static void main(String[] args) {

     for(int i=0; i < 20; ++i) {
        Circle circle = 
           (Circle)ShapeFactory.getCircle(getRandomColor());
        circle.setX(getRandomX());
        circle.setY(getRandomY());
        circle.setRadius(100);
        circle.draw();
     }
  }
  private static String getRandomColor() {
     return colors[(int)(Math.random()*colors.length)];
  }
  private static int getRandomX() {
     return (int)(Math.random()*100 );
  }
  private static int getRandomY() {
     return (int)(Math.random()*100);
  }
}
   ```

  **1.1.3**

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

 **1.1.4**

​       **静态工厂的第四大优势在于，所返回的对象的类可以随着每次调用而发生变化，这取决于静态工厂方法的参数值**。例如EnumSet没有公共的构造器，只有静态工厂方法。它有两个实现的类。RegularEnumSet和JumboEnumSet。静态工厂方法会根据传递过来的枚举类型包含的枚举值的数量而确定返回哪个实现类。如果少于等于64个的话，返回RegularEnumSet实现类。如果超过64个的话，返回JumboEnumSet实现类。这两个实现类的存在对于用户来讲是不可见无感知的。

以下是对EnumSet的介绍

```java
//Session.java 枚举类
public enum Session {
   
   A(1),
   B(2),
   C(3),
   D(4);

   private Integer value;
   Session(Integer value) {
       this.value = value;
   }

   public Integer getValue()
   {
       return value;
   }

}


// EnumSetTest.java
public class EnumSetTest {

   public static void main(String[] args) {
       //1.创建一个包含Session（枚举类）里所有枚举值的EnumSet集合
       EnumSet e1 = EnumSet.allOf(Session.class);
     
       //遍历集合，得到所有枚举对象
       e1.forEach(x->{
           System.out.println(x.getValue());
       });
   }
}

1.1.5

静态工厂的第五大优势在于，方法返回的类型可以在编写该静态工厂方法的时候，该返回类型是不存在的。

1.1.6

​ 总结：简而言之，静态工厂方法和公有构造器都各有用处，我们需要理解它们各自的长处。静态工厂经常更加合适，因此切忌第一反应就是提供公有的构造器，而不先考虑静态工厂。