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

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

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

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

Большая разница между синглтоном и кучей статических методов заключается в том, что синглтоны могут реализовывать интерфейсы (или получать полезные базовые классы, хотя, по моему опыту, это менее распространено), так что вы можете обойти синглтон, как если бы он был «просто другим». " реализация.

Правильный ответ - Джон Скит, на другом форуме здесь .

Синглтон обеспечивает доступ к одному созданному экземпляру - этот экземпляр (или, скорее, ссылка на этот экземпляр) может быть передан в качестве параметра другим методам и рассматриваться как обычный объект.

Статический класс допускает только статические методы.

1. Объекты Singleton хранятся в Heap , но статические объекты хранятся в стеке .
2. Мы можем клонировать (если дизайнер не запретил это) одноэлементный объект, но мы не можем клонировать статический объект класса.
3. Синглтон-классы следуют ООП (объектно-ориентированные принципы), а статические классы - нет.
4. Мы можем реализовать interfaceкласс с классом Singleton, но статические методы класса (или, например, C # static class) не могут.

Шаблон Singleton имеет несколько преимуществ по сравнению со статическими классами. Во-первых, синглтон может расширять классы и реализовывать интерфейсы, в то время как статический класс не может (он может расширять классы, но он не наследует членов их экземпляров). Синглтон может быть инициализирован лениво или асинхронно, в то время как статический класс обычно инициализируется при первой загрузке, что приводит к потенциальным проблемам с загрузчиком классов. Однако самое важное преимущество заключается в том, что синглетами можно обрабатывать полиморфно, не заставляя пользователей предполагать, что существует только один экземпляр.

staticзанятия не для чего то нужного государства. Это полезно для объединения нескольких функций, т.е. Math(или Utilsв проектах). Таким образом, имя класса просто дает нам подсказку, где мы можем найти функции и ничего более.

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

Мое правило выбора между staticиsingleton :

Если есть множество функций, которые должны храниться вместе, то staticэто выбор. Все, что требует единого доступа к некоторым ресурсам, может быть реализовано как singleton.

Статический класс: -

1. Вы не можете создать экземпляр статического класса.

2. Загружается автоматически общеязыковой средой .NET Framework (CLR) при загрузке программы или пространства имен, содержащих класс.

3. Статический класс не может иметь конструктора.

4. Мы не можем передать статический класс методу.

5. Мы не можем наследовать статический класс другому статическому классу в C #.

6. Класс, имеющий все статические методы.

7. Лучшая производительность (статические методы связаны во время компиляции)

Singleton: -

1. Вы можете создать один экземпляр объекта и использовать его повторно.

2. Экземпляр Singleton создается впервые по запросу пользователя.

3. Класс Singleton может иметь конструктор.

4. Вы можете создать объект синглтон-класса и передать его методу.

5. Класс Singleton не говорит о каких-либо ограничениях наследования.

6. Мы можем располагать объекты одноэлементного класса, но не статического класса.

7. Методы могут быть переопределены.

8. Может быть лениво загружаться при необходимости (статические классы всегда загружаются).

9. Мы можем реализовать интерфейс (статический класс не может реализовать интерфейс).

Статический класс - это класс, в котором есть только статические методы, для которых более подходящим словом будут «функции». Стиль дизайна, воплощенный в статическом классе, является чисто процедурным.

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

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

Быстрый пример:

if( useD3D )
    IRenderer::instance = new D3DRenderer
else
    IRenderer::instance = new OpenGLRenderer

Расширить ответ Джона Скита

Большая разница между одноэлементным и кучей статических методов заключается в том, что синглтоны могут реализовывать интерфейсы (или наследовать полезные базовые классы, хотя это не так часто встречается в IME), поэтому вы можете передавать одиночный код, как если бы это была «просто другая» реализация.

С синглетами легче работать при модульном тестировании класса. Где бы вы ни передавали синглтоны в качестве параметра (конструкторы, сеттеры или методы), вы можете вместо этого заменять имитированную или заглушенную версию синглтона.

Вот хорошая статья: http://javarevisited.blogspot.com.au/2013/03/difference-between-singleton-pattern-vs-static-class-java.html

Статические классы

• класс, имеющий все статические методы .
• лучшая производительность (статические методы связаны во время компиляции)

• не может переопределить методы, но может использовать скрытие методов. ( Что такое метод, скрывающийся в Java? Даже объяснение JavaDoc сбивает с толку )

  public class Animal {
      public static void foo() {
          System.out.println("Animal");
      }
  }
  
  public class Cat extends Animal {
      public static void foo() {  // hides Animal.foo()
          System.out.println("Cat");
      }
  }
  

одиночка

• объект который может быть только один раз.
• методы могут быть переопределены ( Почему Java не позволяет переопределять статические методы? )
• легче издеваться, чем статические методы
• лучше поддерживать состояние

Таким образом, я бы использовал статические классы только для хранения утилит, а для всего остального - синглтон.

Правки

• статические классы также загружаются лениво. Спасибо @jmoreno ( Когда происходит инициализация статического класса? )

• скрытие метода для статических классов. Спасибо @MaxPeng.

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

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

Комментарий Морендила: «Стиль дизайна, воплощенный в статическом классе, является чисто процедурным» Я могу ошибаться, но я не согласен. В статических методах вы можете получить доступ к статическим элементам, которые будут точно такими же, как одноэлементные методы для доступа к их отдельным элементам экземпляра.

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

* или он может быть создан при первом использовании, я думаю, в зависимости от языка.

Чтобы проиллюстрировать точку зрения Джона, то, что показано ниже, невозможно, если Logger был статическим классом. Класс SomeClassожидает, что экземпляр ILoggerреализации будет передан в его конструктор.

Класс Singleton важен для внедрения зависимости.

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

Хорошо, синглтон - это просто нормальный класс, который создается, но только один раз и косвенно из клиентского кода. Статический класс не создан. Насколько я знаю, статические методы (статический класс должен иметь статические методы) работают быстрее, чем нестатические.

Редактировать:
Описание правила производительности FxCop: «Методы, которые не обращаются к данным экземпляра или методы экземпляра вызова, могут быть помечены как статические (Shared в VB). После этого компилятор будет генерировать не виртуальные сайты вызовов для этих членов, что предотвратит проверка во время выполнения для каждого вызова, который гарантирует, что текущий указатель объекта не равен нулю. Это может привести к ощутимому приросту производительности для чувствительного к производительности кода. В некоторых случаях невозможность доступа к текущему экземпляру объекта представляет проблему правильности ».
Я на самом деле не знаю, относится ли это также к статическим методам в статических классах.

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

Статический класс не может быть создан чем-либо, кроме самого себя.

Основные отличия:

• У Singleton есть экземпляр / объект, в то время как статический класс - это набор статических методов
• Синглтон может быть расширен, например, через интерфейс, в то время как статический класс не может быть.
• Синглтон может быть унаследован, что поддерживает принципы открытия / закрытия в принципах SOLID, с другой стороны, статический класс не может быть унаследован, и нам нужно вносить изменения в себя.
• Объект Singleton может быть передан в методы, в то время как статический класс, так как у него нет экземпляра, не может быть передан в качестве параметров

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

В приведенном ниже примере я проиллюстрирую это. Предположим, у вас есть метод isGoodPrice (), который использует метод getPrice (), и вы реализуете getPrice () как метод в одиночном коде.

синглтон, обеспечивающий функциональность getPrice:

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

Использование getPrice:

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

Окончательная реализация Singleton:

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

тестовый класс:

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

    }

}

В случае, если мы воспользуемся альтернативой использования статического метода для реализации getPrice (), было сложно смоделировать getPrice (). Вы можете издеваться над статическим электричеством, но не все продукты могут его использовать.

Я согласен с этим определением:

Слово " холост » означает один объект в жизненном цикле приложения, поэтому область действия находится на уровне приложения.

статическими не имеет указателя на объект, так что область находится на уровне приложения домена.

Более того, оба должны быть реализованы, чтобы быть потокобезопасными.

Вы можете найти интересные другие отличия о: шаблон Singleton и статический класс

Одним заметным отличием является различная реализация, которая идет с синглетонами.

Со статическими классами он создается CLR, и мы не можем его контролировать. с одиночными объектами объект создается в первом экземпляре, к которому пытаются получить доступ.

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

Я бы сказал, что самая большая разница в том, что синглтон по-прежнему является обычным Java Bean-компонентом, а не специализированным классом Java, предназначенным только для статических вычислений. И из-за этого синглтон принимается во многих других ситуациях; на самом деле это стратегия реализации Spring Framework по умолчанию. Потребитель может знать, а может и не знать, что это передаваемый синглтон, он просто обращается с ним как с обычным Java-бином. Если требования изменяются, а синглтон должен стать вместо этого прототипом, как мы часто видим в Spring, это может быть сделано полностью без каких-либо изменений кода для потребителя.

Кто-то еще упоминал ранее, что статический класс должен быть чисто процедурным, например, java.lang.Math. На мой взгляд, такой класс никогда не должен передаваться, и они никогда не должны содержать ничего, кроме static final, в качестве атрибутов. Для всего остального используйте синглтон, так как он намного гибче и проще в обслуживании.

У нас есть база БД, которая устанавливает соединения с Back-end. Чтобы избежать грязного чтения среди нескольких пользователей, мы использовали одноэлементный шаблон, чтобы обеспечить доступность одного экземпляра в любой момент времени.

В c # статический класс не может реализовать интерфейс. Когда одному классу экземпляра необходимо реализовать интерфейс для бизнес-контрактов или целей IoC, здесь я использую шаблон Singleton без статического класса.

Синглтон обеспечивает способ поддерживать состояние в сценариях без сохранения состояния

Надеюсь, что это поможет вам ..

Отличие от статического класса

В JDK есть примеры как singleton, так и static, с одной стороны java.lang.Math, это финальный класс со статическими методами, с другойjava.lang.Runtime - синглтон-класс.

Преимущества синглтона

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

• Класс Singleton может быть загружен с отложенной загрузкой, если он тяжелый объект, но статический класс не имеет таких преимуществ и всегда загружен с нетерпением.

• С помощью singleton вы можете использовать наследование и полиморфизм для расширения базового класса, реализации интерфейса и предоставления различных реализаций.

• Поскольку статические методы в Java не могут быть переопределены, они ведут к негибкости. С другой стороны, вы можете переопределить методы, определенные в одноэлементном классе, расширив его.

Недостатки статического класса

• Легче написать модульный тест для синглтона, чем статический класс, потому что вы можете передать фиктивный объект, когда ожидается синглтон.

Преимущества статического класса

• Статический класс обеспечивает лучшую производительность, чем синглтон, потому что статические методы связаны во время компиляции.

Существует несколько реализаций синглтон-паттернов, каждый из которых имеет свои преимущества и недостатки.

• Стремительная загрузка синглтона
• Двойная проверка блокировки синглтона
• Идиома держателя инициализации по требованию
• Синглтон на основе перечисления

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

1. Ленивая Загрузка
2. Поддержка интерфейсов, так что можно обеспечить отдельную реализацию
3. Возможность возврата производного типа (как комбинация отложенной загрузки и реализации интерфейса)

а. Сериализация - Статические члены принадлежат классу и, следовательно, не могут быть сериализованы.

б. Хотя мы сделали конструктор закрытым, статические переменные-члены все равно будут перенесены в подкласс.

с. Мы не можем выполнить отложенную инициализацию, поскольку все будет загружено только при загрузке класса.

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

Я прочитал следующее и думаю, что это тоже имеет смысл:

Забота о бизнесе

Помните, одно из самых важных правил ОО состоит в том, что объект отвечает за себя. Это означает, что вопросы, касающиеся жизненного цикла класса, должны обрабатываться в классе, а не делегироваться таким языковым конструкциям, как static и т. Д.

из книги «Объектно-ориентированный мыслительный процесс», 4-е изд.

В статье, которую я написал, я описал свою точку зрения о том, почему синглтон намного лучше, чем статический класс:

1. Статический класс на самом деле не канонический класс - это пространство имен с функциями и переменными
2. Использование статического класса не является хорошей практикой из-за нарушения принципов объектно-ориентированного программирования
3. Статический класс не может быть передан в качестве параметра для других
4. Статический класс не подходит для «ленивой» инициализации
5. Инициализация и использование статического класса всегда отслеживаются
6. Реализовать управление потоками сложно

1. Мы можем создать объект синглтон-класса и передать его методу.

2. Класс Singleton не ограничивает наследование.

3. Мы не можем распоряжаться объектами статического класса, но можем использовать одноэлементный класс.

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

Когда ваше приложение завершается, вызывается деструктор экземпляра статического класса. Это означает, что если вы использовали этот статический экземпляр как синглтон, ваш синглтон перестал работать правильно. Если все еще выполняется код, который использует этот синглтон, например, в другом потоке, этот код, скорее всего, потерпит крах.

Разница в моей голове заключается в реализации объектно-ориентированного программирования (Singleton / Prototype) или функционального программирования (Static).

Мы слишком сосредоточены на количестве объектов, созданных с помощью одноэлементного шаблона, когда нам нужно сосредоточиться на том, чтобы в конце мы удерживали объект. Как уже говорили другие, он может быть расширен, передан в качестве параметра, но самое главное, он заполнен государством.

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

Кстати, вы знали, что можете создавать одноэлементные статические классы :)