Разница между статическим классом и одноэлементным шаблоном?

Question

Какая реальная (то есть практическая) разница существует между статическим классом и одноэлементным шаблоном?

Оба могут быть вызваны без создания экземпляров, оба предоставляют только один «Экземпляр», и ни один из них не является поточно-ориентированным. Есть ли другая разница?

Answer 1

Как я понимаю разницу между классом Static и классом Non-Static Singleton, static - это просто неинстанцированный «тип» в C #, где Singleton является истинным «объектом». Другими словами, все статические члены в статическом классе присваиваются типу, но в Singleton размещаются под объектом. Но имейте в виду, что статический класс по-прежнему ведет себя как ссылочный тип, так как он не является типом значения, как Struct.

Это означает, что при создании Singleton, поскольку сам класс не является статическим, но его член имеет преимущество, преимущество заключается в том, что статический член внутри Singleton, который ссылается на себя, связан с фактическим «объектом», а не с пустым «типом» о себе. Такого рода теперь проясняется разница между статическим и нестатическим синглтоном за пределами его других функций и использования памяти, что меня смущает.

Оба используют статические элементы, которые являются единичными копиями элемента, но Singleton оборачивает указанный элемент вокруг истинного экземпляра "объекта", адрес которого существует в дополнение к его статическому элементу. Этот объект сам обладает свойствами, в которых можно передавать и ссылаться на него, добавляя ценность. Класс Static - это просто тип, поэтому он не существует, кроме как для указания на его статические члены. Эта концепция как бы скрепила назначение Синглтона против Статического Класса помимо наследования и других вопросов.

Answer 2

Когда я хочу класс с полной функциональностью, например Есть много методов и переменных, я использую синглтон;

Если я хочу, чтобы класс содержал только один или два метода, например Класс MailService, который имеет только 1 метод SendMail () Я использую статический класс и метод.

Answer 3

Пример со статическим классом

public class Any {

    private static Any instance = new Any();

    private Singleton() {
        System.out.println("creating");
    }
}

с одноэлементными шаблонами существует только один экземпляр:

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 ");
        }
    }
}

Answer 4

Одно главное преимущество для Синглтона: полиморфизм Например: создайте экземпляр, используя фабрику классов (скажем, на основе некоторой конфигурации), и мы хотим, чтобы этот объект был действительно одноэлементным.

Answer 5

Я постараюсь подняться над ответами WTMI и WTL; DR.

Синглтоны являются экземпляром объекта ... полная остановка

Ваш вопрос в основном спрашивает о разнице между классом и экземпляром этого класса. Я думаю, что это довольно ясно и не требует каких-либо разработок.

Класс синглтона обычно предпринимает шаги для обеспечения построения одного экземпляра; это умно, но это не обязательно.

Пример: var connection = Connection.Instance;

Скажите, что это класс Connection:

public sealed class Connection 
{
    static readonly Connection _instance = new Connection();

    private Connection() 
    {
    }

    public static Connection Instance
    {
        get
        {
           return _instance;
        }
    } 
}

Обратите внимание, что вы можете добавить интерфейс к этому классу и смоделировать его для целей тестирования, чего нельзя сделать с помощью статического класса.

Answer 6

Оба могут быть вызваны без создания экземпляров, оба предоставляют только один «Экземпляр», и ни один из них не является поточно-ориентированным. Есть ли другая разница?

Вопрос неправильный, оба его утверждения. Обратите внимание: под статическим классом здесь подразумевается вложенный статический класс, а не класс с только статическими методами.

Я предполагаю (т. Е. Статический класс означает вложенный статический класс, а не класс только с статическими членами), потому что, если я вижу наиболее популярную реализацию Singleton, то есть способ DCL, это не что иное, как статическое объявление экземпляра и статический метод для получить экземпляр Singleton. Его одна реализация. Так что в этом случае какая разница между синглтоном и классом только со статическими членами? Хотя возможны и другие реализации, подобные Enum.

Позвольте мне исправить утверждения:

1. Класс Singleton может иметь один экземпляр для всего приложения. Вложенный статический класс может иметь несколько экземпляров (см. Код ниже в качестве доказательства). Прочитайте основы вложенного класса здесь .

2. Ни один класс не является поточно-ориентированным по своей природе, его нужно сделать поточно-программным. Это можно сделать как для вложенного статического класса, так и для Singleton.

Ниже приведены еще несколько разрушителей мифов (в большинстве ответов на этот вопрос эти высказывания были даны так, что было бы неплохо программно доказать это):

1. Вложенный статический класс может реализовывать интерфейс как любой другой класс.
2. Вложенный статический класс может расширять другой не финальный класс.
3. Вложенный статический класс может иметь переменные экземпляра.
4. Вложенный статический класс может иметь параметризованный конструктор (ы).

В приведенном ниже коде вы можете видеть, что вложенный статический класс NestedStaticClass реализует интерфейс, расширяет другой класс, имеет переменную экземпляра и параметризованный конструктор.

 package com.demo.core;

    public class NestedStaticClassTest
    {
        public static void main(String[] args)
        {
            OuterClass.NestedStaticClass obj1 = new OuterClass.NestedStaticClass();
            OuterClass.NestedStaticClass obj2 = new OuterClass.NestedStaticClass();

            if(obj1 == obj2)
            {
                System.out.println("Both nested static objects are equal....");
            }
            else
            {
                System.out.println("NOT EQUAL......");
            }

            System.out.println(OuterClass.NestedStaticClass.d);

            obj1.setD(5);

            System.out.println(OuterClass.NestedStaticClass.d);

            System.out.println(obj1.sum());
        }
    }

    class OuterClass
    {
        int a =1;
        static int b = 2;

        static class NestedStaticClass extends OneClass implements Sample
        {
            int c = 3;
            static int d = 4;

            public NestedStaticClass()
            {
            }

            //Parameterized constructor
            public NestedStaticClass(int z)
            {
                c = z;
            }

            public int sum()
            {
                int sum = 0;
                sum = b + c + d + getE();
                return sum;
            }

            public static int staticSum()
            {
                int sum = 0;
                sum = b + d;
                return sum;
            }

            public int getC()
            {
                return c;
            }
            public void setC(int c)
            {
                this.c = c;
            }
            public static int getD()
            {
                return d;
            }
            public static void setD(int d)
            {
                NestedStaticClass.d = d;
            }
        }
    }

    interface Sample
    {

    }

    class OneClass
    {
        int e = 10;
        static int f = 11;

        public int getE()
        {
            return e;
        }
        public void setE(int e)
        {
            this.e = e;
        }
        public static int getF()
        {
            return f;
        }
        public static void setF(int f)
        {
            OneClass.f = f;
        }

    }