Effective Java读书笔记一

最新推荐文章于 2024-05-02 23:46:17 发布

原创最新推荐文章于 2024-05-02 23:46:17 发布 · 435 阅读

0 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

9 篇文章

订阅专栏

本文深入探讨了Effective Java中的静态工厂方法在对象管理中的应用，包括其优点与缺点，以及如何通过静态工厂方法实现对象的注册与实例化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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();

}

~~~