Effective Java读书笔记一

Effective Java 读书笔记

package com.lcj;

public class Main {



    /**
     * #考虑使用静态工厂方法来替换构造器
     * 优点
     * 1，每个对象都有名字。
     * 2，不必每次都 new 出一个对象。
     * 3，多态的方式存在，返回的都是对象的子类。
     * 缺点
     * 1，类如果存在公有或则保护的构造器，就不能被子类化了（对象注册器中的构造器私有需私有化）。
     * 2，跟其它的静态方法并没有什么区别。
     * 
     * 总结：算是一种管理对象的方式，别每次需要到对象的时候都是new。
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("sss");

        Services.regsiterDefaultProvider(DEFAULT_PROVIDER);
        Services.registerProvider("comp", COMP_PROVIDER);
        Services.registerProvider("armed", ARMED_PROVIDER);

        Service s1 = Services.newInstance();
        Service s2 = Services.newInstance("comp");
        Service s3 = Services.newInstance("armed");

        System.out.printf("%s, %s, %s%n", s1, s2, s3);

    }

    //初始化三个对象
    private static Provider DEFAULT_PROVIDER = new Provider(){

        @Override
        public Service newService() {
            //返回一个Service 的子类对象
            return new Service(){

                @Override
                public String toString() {

                    return "Default service";
                }
            };
        }

    };

    private static Provider COMP_PROVIDER = new Provider(){

        @Override
        public Service newService() {
            //返回一个Service 的子类对象
            return new Service(){

                @Override
                public String toString() {

                    return "Complementary service";
                }
            };
        }

    };

    private static Provider ARMED_PROVIDER = new Provider(){

        @Override
        public Service newService() {
            //返回一个Service 的子类对象
            return new Service(){

                @Override
                public String toString() {

                    return "Armed service";
                }
            };
        }

    };
}

package com.lcj;

public interface Service {

}

package com.lcj;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Services {

    private Services() {

    }

    private static final Map<String, Provider> providers = new ConcurrentHashMap<String, Provider>();

    public static final String DEFAULT_PROVIDER = "<def>";

    public static void regsiterDefaultProvider(Provider p) {
        registerProvider(DEFAULT_PROVIDER, p);

    }

    public static void registerProvider(String name, Provider p) {
        providers.put(name, p);

    }
    //与单例设计模式中getInstance一样，但是能根据不同的名称返回不同的对象。
    public static Service newInstance() {
        return newInstance(DEFAULT_PROVIDER);
    }

    public static Service newInstance(String name) {
        Provider p = providers.get(name);
        if (p == null) {
            throw new IllegalArgumentException("No provider registered name"
                    + name);
        }
        return p.newService();
    }
}

package com.lcj;

public interface Provider {
    Service newService();

}