blocks|key|1418202|text|与静态类相比，单例模式有几个优点。首先，单例可以扩展类和实现接口，而静态类不能(它可以扩展类，但不继承它们的实例成员)。单例可以延迟或异步初始化，而静态类通常在第一次加载时初始化，这会导致潜在的类加载器问题。然而，最重要的优点是，单例可以多态处理，而不会迫使用户假设只有一个实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1418203|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|$]]

The Singleton pattern has several advantages over static classes. First, a singleton can extend classes and implement interfaces, while a static class cannot (it can extend classes, but it does not inherit their instance members). A singleton can be initialized lazily or asynchronously while a static class is generally initialized when it is first loaded, leading to potential class loader issues. However the most important advantage, though, is that singletons can be handled polymorphically without forcing their users to assume that there is only one instance.

blocks|key|1633028|text|static类不适用于任何需要状态的东西。它对于把一堆函数放在一起很有用，比如Math+(或者项目中的Utils+)。因此，类名只是给我们提供了一个线索，我们可以在哪里找到函数，仅此而已。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1633029|Singleton是我最喜欢的模式，我使用它在单点进行管理。它比static类更灵活，可以维护它的状态。它可以实现接口，继承其他类，并允许继承。|1633030|我在static和singleton之间选择的规则|1633031|如果有一堆函数应该放在一起，那么static是最好的选择。任何其他需要对某些资源进行单一访问的东西，都可以作为singleton实现。|1633032|entityMap^0|0|6|13|4|1F|5|0|0|9|W|6|0|2|6|9|9|0|G|6|1J|9|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|M|$]]

<code>static</code> classes are not for anything that needs state. It is useful for putting a bunch of functions together i.e <code>Math</code> (or <code>Utils</code> in projects). So the class name just gives us a clue where we can find the functions and nothing more.

<code>Singleton</code> is my favorite pattern and I use it to manage something at a single point. It's more flexible than <code>static</code> classes and can maintain it's state. It can implement interfaces, inherit from other classes and allow inheritance.

My rule for choosing between <code>static</code> and <code>singleton</code>:

If there is a bunch of functions that should be kept together, then <code>static</code> is the choice.
Anything else which needs single access to some resources, could be implemented as a <code>singleton</code>.

blocks|key|1418301|text|静态类是只有静态方法的类，更好的说法是“函数”。静态类中体现的设计风格纯粹是过程化的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1418302|另一方面，Singleton是一种特定于OO设计的模式。它是一个对象的实例(具有其固有的所有可能性，例如多态性)，具有一个创建过程，该过程确保在该特定角色的整个生命周期中只有一个实例。|1418303|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

A static class is one that has only static methods, for which a better word would be "functions". The design style embodied in a static class is purely procedural.

Singleton, on the other hand, is a pattern specific to OO design. It is an instance of an object (with all the possibilities inherent in that, such as polymorphism), with a creation procedure that ensures that there is only ever one instance of that particular role over its entire lifetime.

blocks|key|1632792|text|在单例模式中，您可以将单例创建为派生类型的实例，但不能使用静态类执行此操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1632793|快速示例：|1632794|if(+useD3D+)
++++IRenderer::instance+=+new+D3DRenderer
else
++++IRenderer::instance+=+new+OpenGLRenderer|code-block|syntax|javascript|1632795|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In singleton pattern you can create the singleton as an instance of a derived type, you can't do that with a static class.

Quick Example:

<pre><code>if( useD3D )
 IRenderer::instance = new D3DRenderer
else
 IRenderer::instance = new OpenGLRenderer
</code></pre>

blocks|key|1633111|text|单例的另一个优点是它很容易被序列化，如果你需要将它的状态保存到磁盘上，或者将它远程发送到某个地方，这可能是必要的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633112|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|$]]

Another advantage of a singleton is that it can easily be serialized, which may be necessary if you need to save its state to disc, or send it somewhere remotely.

blocks|key|1418750|text|为了说明Jon的观点，如果Logger是一个静态class.The类，则不能执行下面所示的操作。SomeClass希望将ILogger实现的实例传递给它的构造函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1418751|单例类对于依赖注入是很重要的。|1418752|using+System;
using+System.Collections.Generic;
using+System.Linq;
using+System.Text;

namespace+ConsoleApplication2
{
++++class+Program
++++{
++++++++static+void+Main(string[]+args)
++++++++{

++++++++++++var+someClass+=+new+SomeClass(Logger.GetLogger());
++++++++}


++++}

++++public+class+SomeClass+
++++{
++++++++public+SomeClass(ILogger+MyLogger)
++++++++{

++++++++}
++++}

++++public+class+Logger+:+ILogger
++++{
++++++++private+static+Logger+_logger;
++++++++private+Logger()+{+}

++++++++public+static+Logger+GetLogger()
++++++++{
++++++++++++if+(_logger==null)
++++++++++++{
++++++++++++++++_logger+=+new+Logger();
++++++++++++}

++++++++++++return+_logger;
++++++++}

++++++++public+void+Log()
++++++++{

++++++++}

++++}


++++public+interface+ILogger
++++{
+++++++++void+Log();
++++}
}|code-block|syntax|javascript|1418753|entityMap^0|1C|9|1O|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

To illustrate Jon's point what's shown below cannot be done if Logger was a static class.The class <code>SomeClass</code> expects an instance of <code>ILogger</code> implementation to be passed into its constructor. 

Singleton class is important for dependency injection to be possible.

<pre><code>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
 class Program
 {
 static void Main(string[] args)
 {

 var someClass = new SomeClass(Logger.GetLogger());
 }


 }

 public class SomeClass 
 {
 public SomeClass(ILogger MyLogger)
 {

 }
 }

 public class Logger : ILogger
 {
 private static Logger _logger;
 private Logger() { }

 public static Logger GetLogger()
 {
 if (_logger==null)
 {
 _logger = new Logger();
 }

 return _logger;
 }

 public void Log()
 {

 }

 }


 public interface ILogger
 {
 void Log();
 }
}
</code></pre>

blocks|key|1632953|text|单例只是一个普通的类，它是从客户端代码间接实例化的，但只有一次。未实例化静态类。据我所知，静态方法(静态类必须有静态方法)比非静态方法更快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1632954|编辑：|1632955|FxCop性能规则描述：“不访问实例数据或调用实例方法的方法可以标记为静态(在VB中是共享的)。这样做之后，编译器将向这些成员发出非虚拟调用点，这将防止在运行时检查确保当前对象指针为非空的每个调用。这可以为性能敏感的代码带来可测量的性能增益。在某些情况下，无法访问当前对象实例表示正确性问题。”|1632956|我不知道这是否也适用于静态类中的静态方法。|1632957|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|$]]

Well a singleton is just a normal class that IS instantiated but just once and indirectly from the client code. Static class is not instantiated.
As far as I know static methods (static class must have static methods) are faster than non-static. 

Edit: 
FxCop Performance rule description:
"Methods which do not access instance data or call instance methods can be marked as static (Shared in VB). After doing so, the compiler will emit non-virtual call sites to these members which will prevent a check at runtime for each call that insures the current object pointer is non-null. This can result in a measurable performance gain for performance-sensitive code. In some cases, the failure to access the current object instance represents a correctness issue." 
I don't actually know if this applies also to static methods in static classes.

blocks|key|1633591|text|从测试的角度来看，单例是更好的方法。与静态类不同，单例可以实现接口，您可以使用模拟实例并注入它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633592|在下面的示例中，我将对此进行说明。假设您有一个使用getPrice()方法的isGoodPrice()方法，并且您将getPrice()实现为单例中的一个方法。|1633593|提供getPrice功能单例：|1633594|public+class+SupportedVersionSingelton+{

++++private+static+ICalculator+instance+=+null;

++++private+SupportedVersionSingelton(){

++++}

++++public+static+ICalculator+getInstance(){
++++++++if(instance+==+null){
++++++++++++instance+=+new+SupportedVersionSingelton();
++++++++}

++++++++return+instance;
++++}

++++@Override
++++public+int+getPrice()+{
++++++++//+calculate+price+logic+here
++++++++return+0;
++++}
}|code-block|syntax|javascript|1633595|getPrice的使用：|1633596|public+class+Advisor+{

++++public+boolean+isGoodDeal(){

++++++++boolean+isGoodDeal+=+false;
++++++++ICalculator+supportedVersion+=+SupportedVersionSingelton.getInstance();
++++++++int+price+=+supportedVersion.getPrice();

++++++++//+logic+to+determine+if+price+is+a+good+deal.
++++++++if(price+<+5){
++++++++++++isGoodDeal+=+true;
++++++++}

++++++++return+isGoodDeal;
++++}
}


In+case+you+would+like+to+test+the+method+isGoodPrice+,+with+mocking+the+getPrice()+method+you+could+do+it+by:
Make+your+singleton+implement+an+interface+and+inject+it.+



++public+interface+ICalculator+{
++++++++int+getPrice();
++++}|1633597|最终的单例实现：|1633598|public+class+SupportedVersionSingelton+implements+ICalculator+{

++++private+static+ICalculator+instance+=+null;

++++private+SupportedVersionSingelton(){

++++}

++++public+static+ICalculator+getInstance(){
++++++++if(instance+==+null){
++++++++++++instance+=+new+SupportedVersionSingelton();
++++++++}

++++++++return+instance;
++++}

++++@Override
++++public+int+getPrice()+{
++++++++return+0;
++++}

++++//+for+testing+purpose
++++public+static+void+setInstance(ICalculator+mockObject){
++++++++if(instance+!=+null+){
instance+=+mockObject;
++++}|1633599|测试类：|1633600|public+class+TestCalculation+{

++++class+SupportedVersionDouble+implements+ICalculator{
++++++++@Override
++++++++public+int+getPrice()+{+
++++++++++++return+1;
++++++++}+++
++++}
++++@Before
++++public+void+setUp()+throws+Exception+{
++++++++ICalculator+supportedVersionDouble+=+new+SupportedVersionDouble();
++++++++SupportedVersionSingelton.setInstance(supportedVersionDouble);

++++}

++++@Test
++++public+void+test()+{
++++++++++Advisor+advidor+=+new+Advisor();
++++++++++boolean+isGoodDeal+=+advidor.isGoodDeal();
++++++++++Assert.assertEquals(isGoodDeal,+true);

++++}

}|1633601|如果我们选择使用静态方法来实现getPrice()，则很难模拟getPrice()。你可以用power+mock模拟静态，但并不是所有的产品都能使用它。|1633602|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|15|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|H|7|19|8|@]|9|@]|A|$I|J]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

Singleton is better approach from testing perspective.
Unlike static classes , singleton could implement interfaces and you can use mock instance and inject them.

In the example below I will illustrate this.
Suppose you have a method isGoodPrice() which uses a method getPrice() and you implement getPrice() as a method in a singleton.

singleton that’s provide getPrice functionality:

<pre><code>public class SupportedVersionSingelton {

 private static ICalculator instance = null;

 private SupportedVersionSingelton(){

 }

 public static ICalculator getInstance(){
 if(instance == null){
 instance = new SupportedVersionSingelton();
 }

 return instance;
 }

 @Override
 public int getPrice() {
 // calculate price logic here
 return 0;
 }
}
</code></pre>

Use of getPrice:

<pre><code>public class Advisor {

 public boolean isGoodDeal(){

 boolean isGoodDeal = false;
 ICalculator supportedVersion = SupportedVersionSingelton.getInstance();
 int price = supportedVersion.getPrice();

 // logic to determine if price is a good deal.
 if(price &lt; 5){
 isGoodDeal = true;
 }

 return isGoodDeal;
 }
}


In case you would like to test the method isGoodPrice , with mocking the getPrice() method you could do it by:
Make your singleton implement an interface and inject it. 



 public interface ICalculator {
 int getPrice();
 }
</code></pre>

Final Singleton implementation:

<pre><code>public class SupportedVersionSingelton implements ICalculator {

 private static ICalculator instance = null;

 private SupportedVersionSingelton(){

 }

 public static ICalculator getInstance(){
 if(instance == null){
 instance = new SupportedVersionSingelton();
 }

 return instance;
 }

 @Override
 public int getPrice() {
 return 0;
 }

 // for testing purpose
 public static void setInstance(ICalculator mockObject){
 if(instance != null ){
instance = mockObject;
 }
</code></pre>

test class:

<pre><code>public class TestCalculation {

 class SupportedVersionDouble implements ICalculator{
 @Override
 public int getPrice() { 
 return 1;
 } 
 }
 @Before
 public void setUp() throws Exception {
 ICalculator supportedVersionDouble = new SupportedVersionDouble();
 SupportedVersionSingelton.setInstance(supportedVersionDouble);

 }

 @Test
 public void test() {
 Advisor advidor = new Advisor();
 boolean isGoodDeal = advidor.isGoodDeal();
 Assert.assertEquals(isGoodDeal, true);

 }

}
</code></pre>

In case we take the alternative of using static method for implementing getPrice() , it was difficult to the mock getPrice().
You could mock static with power mock, yet not all product could use it.

blocks|key|1418678|text|一个值得注意的区别是单例附带的不同实例化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1418679|对于静态类，它是由CLR创建的，我们无法控制它。对于单例，对象在第一次尝试访问时被实例化。|1418680|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

One notable difference is differed instantiation that comes with Singletons.

With static classes, it gets created by the CLR and we have not control on it.
with singletons, the object gets instantiated on the first instance it's tried to be accessed.

blocks|key|1418600|text|在许多情况下，这两个没有实际区别，特别是如果单例实例从不更改或更改非常慢，例如持有配置。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1418601|我想说，最大的区别是单例仍然是一个普通的Java+Bean，而不是专门的只有静态的Java类。正因为如此，单例在更多的情况下被接受；它实际上是默认的Spring+Framework的实例化策略。使用者可能知道也可能不知道它是一个被传递的单例，它只是把它当作一个普通的Java+bean来对待。如果需求发生变化，单例需要成为原型，就像我们在Spring中经常看到的那样，它可以完全无缝地完成，而不需要对消费者进行一行代码更改。|1418602|其他人早些时候已经提到，静态类应该是纯粹的过程性的，例如java.lang.Math。在我看来，这样的类永远不应该被传递，它们永远不应该拥有除了静态final之外的任何东西作为属性。对于其他任何事情，使用单例，因为它更灵活，更容易维护。|1418603|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

In many cases, these two have no practical difference, especially if the singleton instance never changes or changes very slowly e.g. holding configurations. 

I'd say the biggest difference is a singleton is still a normal Java Bean as oppose to a specialized static-only Java class. And because of this, a singleton is accepted in many more situations; it is in fact the default Spring Framework's instantiation strategy. The consumer may or may not know it's a singleton being passed around, it just treat it like a normal Java bean. If requirement changes and a singleton needs to become a prototype instead, as we often see in Spring, it can be done totally seamlessly without a line of code change to the consumer.

Someone else has mentioned earlier that a static class should be purely procedural e.g. java.lang.Math. In my mind, such a class should never be passed around and they should never hold anything other than static final as attributes. For everything else, use a singleton since it's much more flexible and easier to maintain.

blocks|key|1633314|text|我们有我们的DB框架，可以连接到Back+end.To，避免跨多个用户的脏读，我们使用单例模式来确保我们在任何时候都有一个实例可用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633315|在c#中，静态类不能实现接口。当单个实例类需要为业务契约或IoC实现接口时，这就是我使用不带静态类的单例模式的地方|1633316|Singleton提供了一种在无状态场景中维护状态的方法|1633317|希望这对你有帮助..|1633318|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|$]]

We have our DB framework that makes connections to Back end.To Avoid Dirty reads across Multiple users we have used singleton pattern to ensure we have single instance available at any point of time.

In c# a static class cannot implement an interface. When a single instance class needs to implement an interface for a business contracts or IoC purposes, this is where I use the Singleton pattern without a static class

Singleton provides a way to maintain state in stateless scenarios

Hope that helps you..

blocks|key|1418786|text|a.序列化-静态成员属于类，因此不能序列化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1418787|b.虽然我们已经将构造函数设为私有的，但静态成员变量仍将被带入子类。|1418788|c.我们不能做惰性初始化，因为所有的东西都只在类加载时加载。|1418789|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

a. Serialization - Static members belong to the class and hence can't be serialized.

b. Though we have made the constructor private, static member variables still will be carried to subclass.

c. We can't do lazy initialization as everything will be loaded upon class loading only.

blocks|key|1633749|text|从客户端的角度来看，静态行为对客户端是已知的，但是单例行为可以对客户端隐藏完成。客户可能永远不会知道，他一次又一次地使用的只有一个实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633750|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|$]]

From a client perspective, static behavior is known to the client but Singleton behavior can be completed hidden from a client. Client may never know that there only one single instance he's playing around with again and again.

blocks|key|1633911|text|我脑海中的区别是实现面向对象编程(Singleton/Prototype)还是函数式编程(静态)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633912|我们太关注单例模式创建的对象的数量，而我们应该关注的是，最终我们持有一个对象。就像其他人已经说过的，它可以被扩展，作为一个参数传递，但最重要的是它是全状态的。|1633913|另一方面，使用静态来实现函数式编程。静态成员属于一个类。它们是无状态的。|1633914|顺便问一下，您是否知道可以创建单例静态类:)|1633915|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 difference in my head is implementing object oriented programming (Singleton/Prototype) or functional programming(Static).

We are too focused on the number of objects created by singleton pattern when what we should focus on is that in the end we hold an object. Like others have already said, it can be extended, passed as a parameter but most importantly it is state-full.

On the other hand static is used to implement functional programming. The static members belongs to a class. They are stateless.

By the way did you know that you can create singleton static classes :)

blocks|key|1633188|text|当我想要功能齐全的类时，比如有很多方法和变量，我会使用单例；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633189|如果我想要只有一个或两个方法的类，例如只有一个方法SendMail()的MailService类，我会使用静态类和方法。|1633190|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

When I want class with full functionality, e.g. there are many methods and variables, I use singleton;

If I want class with only one or two methods in it, e.g. MailService class, which has only 1 method SendMail() I use static class and method.

blocks|key|1633853|text|据我所知，静态类和非静态单例类之间的区别在于，在C#中，静态类只是一个未实例化的“类型”，而单例类是一个真正的“对象”。换句话说，静态类中的所有静态成员都被分配给该类型，但在Singleton中，这些静态成员都位于对象之下。但请记住，静态类的行为仍然像引用类型一样，因为它不是像Struct那样的值类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633854|这意味着当你创建一个Singleton时，因为类本身不是静态的，但是它的成员是静态的，所以它的优点是引用它自己的静态成员连接到一个实际的“对象”，而不是它自己的一个空的“类型”。这在某种程度上澄清了静态和非静态单例之间的区别，超出了它的其他功能和内存使用，这让我感到困惑。|1633855|两者都使用静态成员，这是成员的单个副本，但Singleton将被引用的成员包装在一个真正实例化的“对象”周围，该对象的地址除了其静态成员之外还存在。该对象本身具有属性，其中可以传递和引用，从而增加价值。静态类只是一个类型，所以除了指向它的静态成员之外，它并不存在。这个概念在某种程度上巩固了Singleton与Static类的目的，超越了继承和其他问题。|1633856|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

As I understand the difference between a Static class and non-Static Singleton class, the static is simply a non-instantiated "type" in C#, where the Singleton is a true "object". In other words, all the static members in a static class are assigned to the type but in the Singleton are housed under the object. But keep in mind, a static class still behaves like a reference type as its not a value type like a Struct.

That means when you create a Singleton, because the class itself isnt static but its member is, the advantage is the static member inside the Singleton that refers to itself is connected to an actual "object" rather than a hollow "type" of itself. That sort of clarifies now the difference between a Static and a Non-Static Singleton beyond its other features and memory usage, which is confusing for me.

Both use static members which are single copies of a member, but the Singleton wraps the referenced member around a true instantiated "object" who's address exists in addition to its static member. That object itself has properties wherein in can be passed around and referenced, adding value. The Static class is just a type so it doesn't exist except to point to its static members. That concept sort of cemented the purpose of the Singleton vs Static Class beyond the inheritance and other issues.

blocks|key|1633977|text|具有静态类的示例|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633978|public+class+Any+{

++++private+static+Any+instance+=+new+Any();

++++private+Singleton()+{
++++++++System.out.println("creating");
++++}
}|code-block|syntax|javascript|1633979|对于单例模式，只存在一个实例：|1633980|public+class+Singleton+{

++++private+static+Singleton+instance+=+new+Singleton();

++++private+Singleton()+{
++++++++System.out.println("creating");
++++++++if+(instance+!=+null)+{
++++++++++++throw+new+RuntimeException("Imposible+create+a+new+instance+");
++++++++}
++++}
}|1633981|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Example with a static class

<pre><code>public class Any {

 private static Any instance = new Any();

 private Singleton() {
 System.out.println("creating");
 }
}
</code></pre>

with singleton patterns only exist one instance:

<pre><code>public class Singleton {

 private static Singleton instance = new Singleton();

 private Singleton() {
 System.out.println("creating");
 if (instance != null) {
 throw new RuntimeException("Imposible create a new instance ");
 }
 }
}
</code></pre>

blocks|key|1419272|text|静态类通常用于库，如果我只需要一个特定类的实例，则使用单例。从内存的角度来看，有一些不同之处:通常在堆中只分配对象，唯一分配的方法是当前运行的方法。静态类的所有方法都是静态的，而且从begin开始就会在堆中，所以通常静态类会消耗更多的内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419273|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|$]]

static classes usually are used for libraries, singletons are used if I need only one instance of a particular class.
From the point of view of memory there are some differences though: usually in the heap there are allocated only objects, the only methods allocated are methods that are current running. a static class has all methods static too and that will be in the heap from begin, so in general the static class consume more memory.

blocks|key|1418720|text|单例的一个主要优点是:多态性，例如:使用类工厂创建实例(比如基于某种配置)，我们希望这个对象是真正的单例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1418721|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|$]]

One main advantage for Singleton : Polymorphism 
Eg : create instance using a Class factory( Say based on some configuration), and we want this object to be really singleton.

What real (i.e. practical) difference exists between a static class and a singleton pattern?

Both can be invoked without instantiation, both provide only one "Instance" and neither of them is thread-safe. Is there any other difference?

Difference between static class and singleton pattern?

静态类和单例模式之间有什么真正的(即实用的)区别？两者都可以在不实例化的情况下调用，它们都只提供一个“实例”，而且它们都不是线程安全的。还有其他区别吗？

问静态类和单例模式的区别？
EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问静态类和单例模式的区别？EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问静态类和单例模式的区别？
EN