相关疑难解决方法(0)

我正在学习GoF Java设计模式,我想看看它们的一些真实例子.Java核心库中这些设计模式的一些很好的例子是什么？

今天我正在浏览这个网站上的一些问题,我发现提到了一个enum 单独使用模式的关于这种解决方案所谓的线程安全的好处.

我从来没有使用过enums,而且我已经用Java编程了好几年了.显然他们改变了很多.现在他们甚至在自己内部全力支持OOP.

现在为什么我应该在日常编程中使用枚举？

在JavaScript中实现单例模式的最简单/最简洁的方法是什么？

请澄清我对Singleton和Multithreading的疑问:

• 在多线程环境中,在Java中实现Singleton的最佳方法是什么？
• 当多个线程同时尝试访问getInstance() 方法时会发生什么？
• 我们可以制作单身人士getInstance() synchronized吗？
• 使用Singleton类时是否真的需要同步？

这是我的代码:

class A {
    static A obj = new A();
    static int num1;
    static int num2=0;

    private A() {
        num1++;
        num2++;
    }
    public static A getInstance() {
        return obj;
    }
}

public class Main{
    public static void main(String[] arg) {
        A obj = A.getInstance();
        System.out.println(obj.num1);
        System.out.println(obj.num2);
    }
}

输出是1 0,但我无法理解.

有人可以向我解释一下吗？

基于SO问题编写的最佳单例实现在Java中 - 即使用枚举创建单例 - 有什么区别/优点/缺点(构造函数省略)

public enum Elvis {
    INSTANCE;
    private int age;

    public int getAge() {
        return age;
    }
}

然后打电话 Elvis.INSTANCE.getAge()

和

public enum Elvis {
    INSTANCE;
    private int age;

    public static int getAge() {
        return INSTANCE.age;
    }
}

然后打电话 Elvis.getAge()

我写了一个下面的Singleton类.我不确定这是否是线程安全的单例类？

public class CassandraAstyanaxConnection {

    private static CassandraAstyanaxConnection _instance;
    private AstyanaxContext<Keyspace> context;
    private Keyspace keyspace;
    private ColumnFamily<String, String> emp_cf;



    public static synchronized CassandraAstyanaxConnection getInstance() {
        if (_instance == null) {
            _instance = new CassandraAstyanaxConnection();
        }
        return _instance;
    }

    /**
     * Creating Cassandra connection using Astyanax client
     *
     */
    private CassandraAstyanaxConnection() {

        context = new AstyanaxContext.Builder()
        .forCluster(ModelConstants.CLUSTER)
        .forKeyspace(ModelConstants.KEYSPACE)
        .withAstyanaxConfiguration(new AstyanaxConfigurationImpl()      
            .setDiscoveryType(NodeDiscoveryType.RING_DESCRIBE)
        )
        .withConnectionPoolConfiguration(new ConnectionPoolConfigurationImpl("MyConnectionPool")
            .setPort(9160)
            .setMaxConnsPerHost(1)
            .setSeeds("127.0.0.1:9160")
        )
        .withAstyanaxConfiguration(new AstyanaxConfigurationImpl()      
            .setCqlVersion("3.0.0")
            .setTargetCassandraVersion("1.2"))
        .withConnectionPoolMonitor(new CountingConnectionPoolMonitor())
        .buildKeyspace(ThriftFamilyFactory.getInstance());

        context.start();
        keyspace = context.getEntity();

        emp_cf = …

对实用程序类来说,常见的做法是为它们提供一个私有构造函数:

public final class UtilClass {
    private UtilClass() {}

    ...
}

但不幸的是,有些工具不喜欢私有构造函数.他们可能会警告它在类中没有被调用,它没有被测试覆盖,块不包含注释等.

如果您这样做,很多警告就会消失:

public enum UtilClass {;
    ...
}

我的问题是:除了对未来开发人员的无休止的仇恨之外,没有值的枚举和Java中的私有构造函数的类之间有什么重要的区别？

请注意,我并不是说Java枚举与具有公共静态最终字段的类相比有什么优势？.我不是在决定一系列事物应该是一堆常量还是一个枚举,我决定将一堆函数放在无构造函数的类或无值的枚举中.

另请注意,我实际上并不想这样做.我只想知道权衡作为一般语言知识的一部分.

例如,使用枚举会使用无用的方法污染自动完成UtilClass.values().还有哪些缺点？上升空间？

我知道在Java中,我们可以通过创建一个类的实例new,clone(),Reflection和serializing and de-serializing.

我创建了一个实现Singleton的简单类.

我需要一直停止创建我的类的实例.

public class Singleton implements Serializable{
    private static final long serialVersionUID = 3119105548371608200L;
    private static final Singleton singleton = new Singleton();
    private Singleton() { }
    public static Singleton getInstance(){
        return singleton;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException("Cloning of this class is not allowed"); 
    }
    protected Object readResolve() {
        return singleton;
    }
    //-----> This is my implementation to stop it but Its not working. …

我有一个特定的问题,如何在Android中运行类加载/垃圾收集.我们现在偶然发现了几次这个问题,据我所知,Android在这里与普通的JVM不同.

问题在于:我们目前正在尝试减少应用程序中的单例类,以支持单个根工厂单例,其唯一目的是管理其他管理器类.如果你愿意的话,是一名顶级经理.这使我们可以轻松地替换测试中的实现,而无需选择完整的DI解决方案,因为所有活动和服务共享对该根工厂的相同引用.

这是它的样子:

public class RootFactory {

    private static volatile RootFactory instance;

    @SuppressWarnings("unused")
    private Context context; // I'd like to keep this for now

    private volatile LanguageSupport languageSupport;
    private volatile Preferences preferences;
    private volatile LoginManager loginManager;
    private volatile TaskManager taskManager;
    private volatile PositionProvider positionManager;
    private volatile SimpleDataStorage simpleDataStorage;

    public static RootFactory initialize(Context context) {
        instance = new RootFactory(context);
        return instance;
    }

    private RootFactory(Context context) {
        this.context = context;
    }

    public static RootFactory getInstance() {
        return instance;
    }

    public LanguageSupport getLanguageSupport() …