一、静态方法替代构造器

对应获取一个类的对象，我们常用的方法就是通过构造器去new一个对象出来！但是我们也可以考虑通过一个静态方法来获取一个类的对象：

这样做的好处

1. 这样的方法具体名称，可读性强
   

   @Test
       public void test17() {
           //这样通过方法名很直观的获取我们想要的对象，很方便
           //取得一个A212的对象,属性name="A"的
           A212 a=A212.getInstance_name_A();
           //取得一个A212的对象,属性name="B"的
           A212 a2=A212.getInstance_name_B();
       }
   
   
   class A212{
       private static String name;
       private A212(){}
       public static A212 getInstance_name_A(){
           A212 a=new A212();
           a.name="A";
           return a;
       }
       public static  A212 getInstance_name_B(){
           A212 a=new A212();
           a.name="B";
           return a;
       }
       
   }

2. 很简单的就做到每一次调用方法得到的对象都是同一个，可以使用"=="代替equals()方法来判断两个对象是否相等，提高效率
   

   @Test
       public void test20() {
           A211 a1=A211.getA211();
           A211 a2=A211.getA211();
           System.out.println(a1==a2);
       }
   
   class A211{
       private static A211 a=new A211();
       public static A211 getA211(){
           return a;
       }
   }

3. 可以返回除本身以外的任何子类对象，甚至可以不用保证对象的类是公有的
   

   @Test
       public void test16() {
           A213 a=A213.getA214();
           a.hello();//A214
       }
   
   class A213{
   
       public static A213 getA214(){
           return new A214();
       }
       
       private static class A214 extends A213{//继承A213，且是private对外不公开
           public  void hello(){
               System.out.println("A214");
           }
       }
   
       public  void hello(){
           System.out.println("A213");
       }
   }

4. 在创建参数化类型时，更代码变得更简洁
   

   @Test
       public void test15() {
           //传统方法,不过现在的jdk是可以Map<Map<String,String>,Map<String,String>> map=new HashMap<>();
           Map<Map<String,String>,Map<String,String>> map=new HashMap<Map<String,String>,Map<String,String>>();
           //使用静态方法
           Map<Map<String,String>,Map<String,String>> map2=getMap();
       }
       public static <T,K> Map<T,K> getMap(){
           return new HashMap<T,K>();
       }

这样做的坏处：

• 当构造器私有化后的类，不能被扩展了