java基础与进阶首页投稿(暂停使用,暂停投稿)Java技术文章

《Effective Java》之 对象的创建和销毁

2016-03-09  本文已影响851人  溪沙Sean
图片来自网络

对象的创建和销毁

第一条 用静态工厂方法来代替构造器

类除了可以通过构造器来实例化之外,还可以通过静态的工厂方法(newInstance)

优势

1. 他们有名称

比如一个Apple类,你想获得一个红苹果和绿苹果的实例,Apple.newRedInstance()Apple.newGreenInstance()Apple(red)Apple(green)看上去要更能突出他们之间的区别

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

class Apple{
     private Apple apple;    
     private Apple();
    newInstance(){
           return apple ==null ?new Apple : apple;
    }
}

单例模式的简单写法,单例模式的有各种好处,比如不用重复创建对象,可以用==来代替equals方法等等之类的我就不多说神马了。

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

这种时候我们在返回对象的类时就有了更大的灵活性,甚至于我们在编写该静态方法的时候这个类是可以不存在的。书上管这个叫服务提供者框架(Service Provicer Framework)。 例如JDBC 的API就是一个很好的例子。Connection是他的服务接口,DriverManager.registerDriver 是提供者的API,DriverManager.getConnection是服务访问的API,Driver就是服务提供者接口。适配器模式也是这种框架的一种变体。

// 服务提供者框架简易Demo
// 服务类的接口
public interface Service{
    // 具体需要实现的服务方法
}
// 服务提供者的接口
public interface Provider{
    Service newService();
}
// Service 注册和调用的类
public class Services{
    private Services();    // 防止实例化
    // Service 名字跟服务的Map
    private static final Map<String,Provider> providers = new ConcurrentHashMap<String , Provider>( );
    public static final String DEFAULT_PROVIDER_NAME = "<dev>";
    // 服务提供者注册的API
    public static void registerDefaultProvider(Provider p){
         registerProvider(DEFAULT_PROVIDER_NAME ,p); 
    }
    public static void registerDefaultProvider(String name ,Provider p){
         providers.put(name ,p); 
    }
//  获取服务接口
public static Service newInstance(){
    return newInstance(DEFAULT_PROVIDER_NAME);
}
publicstatic Service newInstance(String name ){
    Provider p = providers.get(name);
    if(p== null)
            throw new IllegalArgumentException("这个服务者没有注册");
    return p.newService();
}

适配器模式的简单例子。

4. 实例化参数类型时更简单

比如

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

随着参数越来越长,越来越复杂,代码就越来越丑了。
这个时候如果有这个方法

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

那我们只要这样写就好了Map<String,List<String>> m = HshMap.newInstance();,代码就简洁了好多。目前(jdk 1.8.0_73)官方并没有实现这样的方法,可以放在自己的工具类中体现自己的逼格。

缺点

第二条 当构造方法有多个可选参数的时候考虑用构造器

当实例化一个类有很多可选参数的时候,有如下的几种方法

创建多个构造器

优点: 能用
缺点:写起来容易错,参数的顺序啊神马的记起来容易错

用JavaBean 的getter 和setter 模式

优点:写的时候不容易出错
缺点:线程不安全

使用构造器模式

优点:使代码简单好些,而且看上去很有逼格
缺点:增加了一些开销
拿一个苹果类举例

class Apple{
    private String color;
    private String size;
    private String weight;
    private String price;
    
    public static class Builder{
        private String color;
        private String size;
        private String weight;
        
        public Builder color(String color){
            this.color = color;
            return this;
        }
        public Builder size(String size){
            this.size = size;
            return this;
        }
        public Builder weight(String weight){
            this.weight = weight;
            return this;
        }
        public Apple bulid(){
            return new Apple(this);
        }
    }
    
    private Apple(Builder bulider){
        this.color = bulider.color;
        this.size = bulider.size;
        this.weight = bulider.weight;
    };
}

然后就可以通过下面的方式来实例化一个苹果

Apple apple = new Apple.Builder().color("red").size("100").weight("100").bulid(); 

这样逼格满满的代码就出来了。在可选参数很多的时候选择这种写法是种很不错的选择。

第三条 单例的三种写法和注意事项

原翻译 使用枚举增强类的单例属性

单例模式的各种好处就不说,这条讲了单例的三种写法和注意事项

写法一

class Apple{
    public static Apple INSTANCE = new Apple();
    // someThing
    private Apple(){
    };
} 

写法二

class Apple{
    private static Apple INSTANCE = new Apple();
    // someThing
    private Apple(){
    };
    public static Apple newInstance(){
        return INSTANCE;
    }
} 

*** 注意事项 ***

  1. AccessibleObject.setAccessible 可以通过反射调用私有的构造方法。在构造器加上第二次实例化抛异常的逻辑可以防范这种攻击。

  2. 如果单例的类为了可序列化而继承了 Serializable 接口,那么为了防止类在反序列化的时候被偷偷的实例化,可以在类中加入如下代码

    private Object readResolve() {
        return INSTANCE;
    } 

写法三 使用枚举实现单例

enum Apple{
    INSTANCE;
}

第4条 通过私有化构造器使单例类更加单例

有些工具类我们可能不希望它被实例化,可以使用如下代码

public class AppleUtils{
    private AppleUtils(){
        throw new AssertionError();
    }
} 

这样一来,AppleUtils(和他的子类)就不能被实例化了。

第5条 避免创建不必要的对象

对象么能少创建就少创建,这条主要讲了如何更少的创建对象

Long sum =0L;
for (int i = 0; i < Integer.MAX_VALUE; i++) {
sum +=i;
}
System.out.println(sum); 

这段代码在我机器上的运行时间为

Long 的运行时间

但是如果把Long sum 换成long sum

long 的运行时间

可以看到时间从6886ms变成了781ms,效率大大的优化了。

第六条 避免内存泄露的几点建议

原翻译:消除过期的对象引用

第七条 避免使用终结(finalizer)方法

总结

这一章主要讲了对象的创建和销毁时候需要注意的一些点。有些代码真的是使人豁然开朗,瞬间逼格满满。期待第二章的学习,Fighting~

上一篇下一篇

猜你喜欢

热点阅读