blocks|key|2683555|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2683556|但是，这个类在整个程序中应该只在一个指定的位置使用一次|blockquote|2683557|2683558|2683559|我不认为创建单例会阻止人们在多个地方使用它，因为通常单例是全局状态。|2683560|在您的例子中，我可能只会将工厂类放在需要使用它的类的内部。或者简单地使用访问修饰符，以确保它不会在其他地方使用(包私有或受保护可能是您正在寻找的)。|2683561|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|L|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|M|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|N|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|O|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|P|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|Q|7|@]|8|@]|9|$]]|$1|J|3|-4|4|5|6|R|7|@]|8|@]|9|$]]]|K|$]]

<blockquote>
 however this class should only used once throughout the program in once specifix place
</blockquote>

I don't think making a singleton would prevent someone to use it in more than one place, since usually singletons are global state.

In your case I would probably just make the factory class internal to the class which needs to use it. Or simply use access modifiers to ensure its not used anywhere else (package-private or protected might be what you're looking for).

blocks|key|2683597|text|问题是，如果将来有人决定在程序的不同部分中使用这个类，它应该如何工作？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2683598|答:没问题，随他们去吧。它不会影响它的其他用途。(不要使用单例。)|2683599|B.如果有很好的理由，那很好，但它会在第一次使用时搞砸(由于共享资源或其他原因)，所以他们必须使用在其他地方使用的相同实例。(使用单例。)|2683600|您说它应该在整个程序中只使用一次，并在一个特定的地方使用。如果由于技术限制，这是真的，那就让它成为单例。如果这是真的，因为这就是您对设计的看法，但没有技术原因将限制放在适当的地方，那么就不要让它成为单例。|2683601|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

The question is - if sometime in the future someone decides to use this class in a different part of the program, how should it work?

A. That's fine, let them. It won't impact the other use of it. (Don't use a singleton.)

B. If there's a good reason for it, that's fine, but it's going to mess up the first use of it (due to shared resources or whatever) so they have to use the same instance that's being used elsewhere. (Use a singleton.)

You say that it should only be used once throughout the program and in one specific place. If that's true because of a technical restriction, make it a singleton. If it's true because that's what your view of the design is, but there's no technical reason to put the restriction in place, then don't make it a singleton.

blocks|key|616847|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|616848|我有一个类，它通常只生成工厂对象，但是这个类在整个程序中只能在一个指定的地方使用一次。在这种情况下，最好的设计模式是什么？|blockquote|616849|616850|616851|如果它应该只使用一次，那么只调用一次。如果您希望强制只在代码中的那个位置调用它，您可以通过将它设置为包含调用的类的私有内部类来完全控制它。|616852|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|J|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|K|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|L|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|M|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|N|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|O|7|@]|8|@]|9|$]]]|I|$]]

<blockquote>
 I have a class that would normally just generate factory objects, however this class should only used once throughout the program in once specifix place. What is the best design pattern to use in this instance?
</blockquote>

If it should only be used once, only call it once. If you wish to enforce that it can be called only at that place in the code, you can control that completely by making it a private inner class of the class containing the call.

blocks|key|616864|text|与其添加最后一个静态字段=+new+SingletonClass()并将ctor设为私有，为什么不在将其作为参数传递给所有需要复制的内容时自己控制创建。这就是依赖注入的全部要点，类不需要调用静态字段来获取单例，而是在ctor或setter中接收所需的实例作为参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|616865|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Instead of adding a final static field = new SingletonClass() and making the ctor private, why not control the creation yourself when you pass it as a parameter to all the stuff that needs a copy. This is the entire point of dependency injection, classes dont need to call static fields to get a singleton, they instead receive the instance they need as a parameter in the ctor or setter.

I have a class that would normally just generate factory objects, however this class should only used once throughout the program in once specifix place. What is the best design pattern to use in this instance?

I throught that having a modified singleton design which only allows one reference to instance throughout the program would be the correct way to go. So only the first call to getInstance() returns the factory library.

Is this a good or bad idea? Have I missed out another fundermental design pattern for solving this problem?

Thanks for your help.

Should I use a modified singleton design pattern that only allows one reference to its instance?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个通常只生成工厂对象的类，但是这个类在整个程序中应该只在一个指定的地方使用一次。在这种情况下，最好的设计模式是什么？我认为在整个程序中只允许一次引用实例的修改后的单例设计将是正确的方法。因此，只有对getInstance()的第一次调用才会返回工厂库。这是个好主意还是坏主意？我是不是错过了另一个解决这个问题的基础...

问我是否应该使用修改后的单例设计模式，只允许对其实例的一个引用？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我是否应该使用修改后的单例设计模式，只允许对其实例的一个引用？EN