ความแตกต่างระหว่างรูปแบบคงที่และรูปแบบซิงเกิล?

อะไรคือความแตกต่างที่แท้จริง (เช่นในทางปฏิบัติ) ที่มีอยู่ระหว่างคลาสแบบสแตติกและรูปแบบซิงเกิล?

ทั้งสองสามารถถูกเรียกใช้โดยไม่มีการสร้างอินสแตนซ์ทั้งสองมีเพียง "อินสแตนซ์" หนึ่งรายการเท่านั้นและทั้งคู่ไม่มีความปลอดภัยต่อเธรด มีความแตกต่างอื่น ๆ อีกไหม?

อะไรทำให้คุณพูดว่าวิธีการแบบซิงเกิลหรือแบบสแตติกไม่ปลอดภัยต่อเธรด โดยปกติแล้วทั้งคู่ควรจะติดตั้งให้ปลอดภัยต่อเธรด

ความแตกต่างอย่างมากระหว่างซิงเกิลตันและเมธอดคงที่คือซิงเกิลตันสามารถใช้อินเทอร์เฟซ (หรือสืบทอดมาจากคลาสพื้นฐานที่มีประโยชน์แม้ว่ามันจะไม่ธรรมดาในประสบการณ์ของฉัน) ดังนั้นคุณสามารถผ่านรอบเดี่ยวได้ราวกับว่ามันเป็น "การใช้งาน

คำตอบที่แท้จริงคือโดยจอนสกีต, ฟอรั่มที่นี่อีก

ซิงเกิลตันอนุญาตให้เข้าถึงอินสแตนซ์ที่สร้างเดียว - อินสแตนซ์นั้น (หรือมากกว่านั้นการอ้างอิงถึงอินสแตนซ์นั้น) สามารถส่งผ่านเป็นพารามิเตอร์ไปยังวิธีการอื่น ๆ และถือว่าเป็นวัตถุปกติ

คลาสสแตติกอนุญาตให้ใช้วิธีสแตติกเท่านั้น

1. วัตถุซิงเกิลถูกเก็บไว้ในกองแต่วัตถุคงถูกเก็บไว้ในสแต็ค
2. เราสามารถโคลน (ถ้าผู้ออกแบบไม่ได้ไม่อนุญาต) วัตถุเดี่ยว แต่เราไม่สามารถโคลนวัตถุคลาสคงที่
3. คลาส Singleton ปฏิบัติตามOOP (หลักการเชิงวัตถุ) คลาสแบบสแตติกไม่
4. เราสามารถใช้interfaceคลาสที่มี Singleton แต่วิธีการคงที่ของคลาส (หรือเช่น C # static class) ไม่สามารถทำได้

รูปแบบซิงเกิลมีข้อดีหลายประการมากกว่าคลาสสแตติก ก่อนอื่นซิงเกิลสามารถขยายคลาสและใช้อินเทอร์เฟซได้ในขณะที่คลาสสแตติกไม่สามารถ (มันสามารถขยายคลาสได้ แต่จะไม่สืบทอดสมาชิกอินสแตนซ์ของมัน) ซิงเกิลสามารถเริ่มต้นได้อย่างเกียจคร้านหรือแบบอะซิงโครนัสในขณะที่คลาสสแตติกจะเริ่มต้นได้เมื่อโหลดครั้งแรกซึ่งนำไปสู่ปัญหาตัวโหลดคลาสที่มีศักยภาพ อย่างไรก็ตามข้อได้เปรียบที่สำคัญที่สุดคือการที่สามารถจัดการ polymorphically ได้โดยไม่บังคับให้ผู้ใช้สันนิษฐานว่ามีเพียงอินสแตนซ์เดียวเท่านั้น

staticคลาสไม่ได้มีไว้สำหรับสิ่งใดที่ต้องการสถานะ มันมีประโยชน์สำหรับการรวมกลุ่มของฟังก์ชั่นเข้าด้วยกันเช่นMath(หรือUtilsในโครงการ) ดังนั้นชื่อชั้นจะให้เบาะแสแก่เราซึ่งเราสามารถหาฟังก์ชั่นและไม่มีอะไรเพิ่มเติม

Singletonเป็นรูปแบบที่ฉันโปรดปรานและฉันใช้มันเพื่อจัดการบางอย่างในจุดเดียว มีความยืดหยุ่นมากกว่าstaticคลาสและสามารถรักษาสถานะไว้ได้ สามารถใช้อินเตอร์เฟสรับมาจากคลาสอื่นและอนุญาตให้สืบทอด

กฎของฉันสำหรับการเลือกระหว่างstaticและsingleton:

หากมีฟังก์ชั่นมากมายที่ควรเก็บไว้ด้วยกันก็staticเป็นทางเลือก singletonสิ่งอื่นที่ต้องการเข้าถึงเดียวไปยังแหล่งข้อมูลบางอย่างอาจจะนำมาใช้เป็น

คลาสคงที่: -

1. คุณไม่สามารถสร้างอินสแตนซ์ของคลาสแบบคงที่

2. โหลดโดยอัตโนมัติโดย. NET Framework ภาษาทั่วไปรันไทม์ (CLR) เมื่อมีการโหลดโปรแกรมหรือ namespace ที่มีคลาส

3. คลาสคงที่ไม่สามารถมีตัวสร้าง

4. เราไม่สามารถส่งผ่านคลาสสแตติกไปยังเมธอด

5. เราไม่สามารถสืบทอดคลาสสแตติกไปยังคลาสสแตติกอื่นใน C #

6. ชั้นเรียนที่มีวิธีการคงที่ทั้งหมด

7. ประสิทธิภาพที่ดีขึ้น (วิธีคงที่จะถูกผูกมัดในเวลารวบรวม)

ซิงเกิล: -

1. คุณสามารถสร้างหนึ่งอินสแตนซ์ของวัตถุและนำมาใช้ใหม่

2. อินสแตนซ์ซิงเกิลถูกสร้างขึ้นเป็นครั้งแรกเมื่อผู้ใช้ร้องขอ

3. คลาส Singleton สามารถมี Constructor ได้

4. คุณสามารถสร้างวัตถุของคลาสซิงเกิลตันและส่งต่อไปยังเมธอด

5. คลาสซิงเกิลไม่ได้กล่าวถึงข้อ จำกัด ของการสืบทอด

6. เราสามารถกำจัดวัตถุของคลาสซิงเกิลตัน แต่ไม่ใช่คลาสสแตติก

7. สามารถแทนที่เมธอดได้

8. สามารถขี้เกียจโหลดได้เมื่อต้องการ (มีการโหลดคลาสแบบคงที่เสมอ)

9. เราสามารถใช้อินเตอร์เฟส (คลาสคงที่ไม่สามารถใช้อินเตอร์เฟส)

คลาสสแตติกเป็นคลาสที่มีเมธอดสแตติกเท่านั้นซึ่งคำที่ดีกว่าจะเป็น "ฟังก์ชัน" สไตล์การออกแบบเป็นตัวเป็นตนในระดับคงที่เป็นขั้นตอนอย่างหมดจด

ในทางกลับกัน Singleton เป็นรูปแบบเฉพาะสำหรับการออกแบบ OO มันเป็นตัวอย่างของวัตถุ (ด้วยความเป็นไปได้ทั้งหมดที่มีอยู่ในนั้นเช่นความหลากหลาย) ด้วยกระบวนการสร้างที่ทำให้มั่นใจได้ว่ามีเพียงตัวอย่างเดียวของบทบาทนั้นตลอดช่วงอายุการใช้งาน

ในรูปแบบซิงเกิลคุณสามารถสร้างซิงเกิลตันเป็นอินสแตนซ์ของชนิดที่ได้รับคุณไม่สามารถทำได้ด้วยคลาสแบบสแตติก

ตัวอย่างด่วน:

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

เพื่อขยายคำตอบของ Jon Skeet

ความแตกต่างอย่างมากระหว่างซิงเกิลตันและเมธอดคงที่คือซิงเกิลตันสามารถใช้อินเทอร์เฟซ (หรือสืบทอดมาจากคลาสพื้นฐานที่มีประโยชน์แม้ว่าจะเป็น IME ทั่วไปที่น้อยกว่า) ดังนั้นคุณสามารถผ่านรอบซิงเกิลตันราวกับว่ามันเป็น

Singletons ง่ายต่อการใช้งานเมื่อหน่วยทดสอบชั้นเรียน เมื่อใดก็ตามที่คุณผ่าน singletons เป็นพารามิเตอร์ (constructors, setters หรือ method) คุณสามารถแทนที่รุ่น singleton ที่เยาะเย้ยหรือ stubbed

นี่เป็นบทความที่ดี: 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");
      }
  }
  

ซิงเกิล

• วัตถุที่สามารถ instantiated ครั้งเดียว
• เมธอดสามารถแทนที่ได้ ( ทำไม Java ไม่อนุญาตให้แทนที่เมธอดสแตติก? )
• ง่ายต่อการเยาะเย้ยแล้ววิธีคงที่
• ดีกว่าในการรักษาสถานะ

โดยสรุปฉันจะใช้คลาสแบบคงที่เท่านั้นสำหรับวิธีการเก็บแบบ util และใช้ Singleton สำหรับทุกอย่างอื่น

การแก้ไข

• คลาสแบบคงที่ถูกโหลดแบบขี้เกียจเช่นกัน ขอบคุณ @jmoreno (การเริ่มต้นคลาสคงที่เกิดขึ้นเมื่อไร )

• วิธีซ่อนสำหรับคลาสแบบคงที่ ขอบคุณ @ MaxPeng

ข้อดีอีกอย่างของซิงเกิลตันคือสามารถทำให้เป็นอนุกรมได้ง่ายซึ่งอาจจำเป็นถ้าคุณต้องการบันทึกสถานะไว้ในแผ่นดิสก์หรือส่งไปที่อื่นจากระยะไกล

ฉันไม่ใช่นักทฤษฎี OO ที่ยอดเยี่ยม แต่จากสิ่งที่ฉันรู้ฉันคิดว่าคุณสมบัติ OO เดียวที่คลาสแบบสแตติกขาดเมื่อเทียบกับ Singletons คือ polymorphism แต่ถ้าคุณไม่ต้องการใช้คลาสแบบคงที่คุณสามารถมีการสืบทอด (ไม่แน่ใจเกี่ยวกับการใช้อินเตอร์เฟส) และการห่อหุ้มข้อมูลและฟังก์ชั่น

ความคิดเห็นของ Morendil "สไตล์การออกแบบเป็นตัวเป็นตนในคลาสแบบคงที่เป็นขั้นตอนอย่างหมดจด" ฉันอาจจะผิด แต่ฉันไม่เห็นด้วย ในวิธีการแบบคงที่คุณสามารถเข้าถึงสมาชิกแบบคงที่ซึ่งจะเหมือนกับวิธีการแบบซิงเกิลที่เข้าถึงสมาชิกอินสแตนซ์เดียวของพวกเขา

แก้ไข:
จริง ๆ แล้วฉันคิดว่าตอนนี้ความแตกต่างอีกอย่างหนึ่งคือคลาสแบบคงที่ถูกสร้างอินสแตนซ์เมื่อเริ่มต้นโปรแกรม * และใช้ชีวิตตลอดช่วงชีวิตทั้งหมดของโปรแกรมในขณะที่ซิงเกิลตันถูกสร้างอินสแตนซ์ชัดเจน

* หรือฉันอาจใช้อินสแตนซ์เมื่อใช้ครั้งแรกขึ้นอยู่กับภาษาที่ฉันใช้

เพื่อแสดงให้เห็นถึงจุดของจอนสิ่งที่แสดงด้านล่างไม่สามารถทำได้ถ้า 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: "วิธีการที่ไม่สามารถเข้าถึงข้อมูลอินสแตนซ์หรือวิธีการโทรสามารถทำเครื่องหมายเป็นแบบคงที่ (แชร์ใน VB) หลังจากทำเช่นนั้นคอมไพเลอร์จะส่งไซต์โทรที่ไม่ใช่เสมือนไปยังสมาชิกเหล่านี้ ตรวจสอบรันไทม์สำหรับการโทรแต่ละครั้งที่มั่นใจว่าตัวชี้วัตถุปัจจุบันไม่เป็นโมฆะซึ่งอาจส่งผลให้ได้รับประสิทธิภาพที่วัดได้สำหรับโค้ดที่ไวต่อประสิทธิภาพในบางกรณีความล้มเหลวในการเข้าถึงอินสแตนซ์วัตถุปัจจุบันแสดงถึงปัญหาความถูกต้อง
ฉันไม่รู้จริง ๆ ว่าสิ่งนี้ใช้ได้กับเมธอดสแตติกในคลาสแบบคงที่หรือไม่

Singleton's นั้นอินสแตนซ์มันมีเพียงอินสแตนซ์เดียวเท่านั้นที่อินสแตนซ์ที่เคยดังนั้นซิงเกิลใน Singleton

คลาสสแตติกไม่สามารถสร้างอินสแตนซ์ได้โดยสิ่งอื่นนอกจากตัวเอง

ความแตกต่างที่สำคัญคือ:

• Singleton มีอินสแตนซ์ / วัตถุในขณะที่คลาสสแตติกเป็นพวงของวิธีการสแตติก
• Singleton สามารถขยายได้เช่นผ่านส่วนติดต่อในขณะที่คลาสแบบสแตติกไม่สามารถทำได้
• 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 () คุณสามารถเยาะเย้ยแบบคงที่ด้วยการเยาะเย้ยพลังงาน แต่ผลิตภัณฑ์บางอย่างไม่สามารถใช้งานได้

ฉันเห็นด้วยกับคำจำกัดความนี้:

คำว่า " เดี่ยว " หมายถึงวัตถุเดียวตลอดวงจรชีวิตของแอปพลิเคชันดังนั้นขอบเขตอยู่ที่ระดับแอปพลิเคชัน

สแตติกไม่มีตัวชี้วัตถุใด ๆ ดังนั้นขอบเขตอยู่ที่ระดับ App Domain

นอกจากนี้ทั้งสองควรถูกนำมาใช้เพื่อให้ปลอดภัยต่อเธรด

คุณสามารถค้นหาความแตกต่างอื่น ๆ ที่น่าสนใจเกี่ยวกับ: Singleton Pattern Versus Static Class

ความแตกต่างที่โดดเด่นอย่างหนึ่งคือการสร้างอินสแตนซ์ที่แตกต่างที่มาพร้อมกับซิงเกิลตัน

ด้วยคลาสสแตติกมันถูกสร้างโดย CLR และเราไม่ได้ควบคุมมัน ด้วย singletons วัตถุจะถูกสร้างอินสแตนซ์บนอินสแตนซ์แรกที่พยายามเข้าถึง

ในหลายกรณีทั้งสองนี้ไม่มีความแตกต่างในทางปฏิบัติโดยเฉพาะอย่างยิ่งหากอินสแตนซ์ซิงเกิลไม่เคยเปลี่ยนแปลงหรือเปลี่ยนแปลงช้ามากเช่นการกำหนดค่า

ฉันจะบอกว่าความแตกต่างที่ใหญ่ที่สุดคือซิงเกิลตันยังคงเป็น Java Bean ปกติตรงข้ามกับคลาส Java เฉพาะแบบคงที่เท่านั้น และด้วยเหตุนี้จึงมีการยอมรับซิงเกิลตันในหลาย ๆ สถานการณ์ อันที่จริงแล้วเป็นกลยุทธ์เริ่มต้นการเริ่มต้นของ Spring Framework ผู้บริโภคอาจทราบหรือไม่ว่ามันเป็นซิงเกิลตันที่ถูกส่งผ่านไปมันแค่ปฏิบัติต่อมันเหมือนกับ Java bean ปกติ หากความต้องการเปลี่ยนแปลงและซิงเกิลตันต้องกลายเป็นต้นแบบแทนดังที่เรามักจะเห็นใน Spring มันสามารถทำได้อย่างสมบูรณ์โดยไม่ต้องเปลี่ยนรหัสผู้บริโภค

มีคนอื่นพูดถึงก่อนหน้านี้ว่าคลาสสแตติกควรเป็นขั้นตอนอย่างหมดจดเช่น java.lang.Math ในความคิดของฉันคลาสนี้ไม่ควรผ่านไปมาและพวกเขาไม่ควรถือสิ่งอื่นใดนอกจากสถิตสุดท้ายเป็นคุณลักษณะ สำหรับทุกสิ่งทุกอย่างให้ใช้ซิงเกิลตันเนื่องจากมีความยืดหยุ่นและบำรุงรักษาได้ง่ายกว่ามาก

เรามีเฟรมเวิร์ก DB ของเราที่ทำให้การเชื่อมต่อไปยัง Back end เพื่อหลีกเลี่ยงการอ่านสกปรกในผู้ใช้หลายคนเราได้ใช้รูปแบบซิงเกิลเพื่อให้แน่ใจว่าเรามีอินสแตนซ์เดียวที่สามารถใช้ได้ทุกเวลา

ใน c # คลาสสแตติกไม่สามารถใช้อินเตอร์เฟสได้ เมื่อคลาสอินสแตนซ์เดียวจำเป็นต้องใช้อินเทอร์เฟซสำหรับสัญญาธุรกิจหรือวัตถุประสงค์ IoC นี่คือที่ฉันใช้รูปแบบ Singleton โดยไม่มีคลาสแบบสแตติก

Singleton จัดให้มีวิธีการรักษาสถานะในสถานการณ์ไร้สัญชาติ

หวังว่าจะช่วยคุณ ..

1. ขี้เกียจโหลด
2. การสนับสนุนอินเทอร์เฟซเพื่อให้สามารถดำเนินการแยกต่างหาก
3. ความสามารถในการส่งคืนชนิดที่ได้รับ (เป็นการรวมกันของ lazyloading และการใช้อินเตอร์เฟส)

การทำให้เป็นอนุกรม - สมาชิกแบบสแตติกอยู่ในคลาสและดังนั้นจึงไม่สามารถทำให้เป็นอนุกรมได้

ข แม้ว่าเราจะกำหนดให้ constructor เป็นส่วนตัว แต่ตัวแปรสมาชิกแบบสแตติกจะยังคงถูกนำไปใช้ในคลาสย่อย

ค. เราไม่สามารถเริ่มต้นขี้เกียจได้เพราะทุกอย่างจะถูกโหลดเมื่อโหลดคลาสเท่านั้น

จากมุมมองของลูกค้าพฤติกรรมแบบคงที่เป็นที่รู้จักกับลูกค้า แต่พฤติกรรม Singleton สามารถเสร็จสมบูรณ์ซ่อนจากลูกค้า ลูกค้าอาจไม่เคยรู้เลยว่ามีเพียงหนึ่งอินสแตนซ์เดียวที่เขาเล่นด้วยซ้ำแล้วซ้ำอีก

ฉันอ่านข้อความต่อไปนี้และคิดว่ามันสมเหตุสมผลด้วย:

ดูแลกิจการ

โปรดจำไว้ว่าหนึ่งในกฎ OO ที่สำคัญที่สุดคือวัตถุรับผิดชอบตัวเอง ซึ่งหมายความว่าปัญหาเกี่ยวกับวงจรชีวิตของคลาสควรได้รับการจัดการในชั้นเรียนไม่ได้รับมอบหมายให้สร้างโครงสร้างภาษาเช่นสแตติกและอื่น ๆ

จากกระบวนการคิดเชิงวัตถุเล่มที่ 4 เอ็ด

ในบทความที่ฉันเขียนฉันได้อธิบายมุมมองของฉันเกี่ยวกับสาเหตุที่ซิงเกิลดีกว่าคลาสแบบคงที่:

1. คลาสแบบสแตติกไม่ใช่คลาสแบบบัญญัติซึ่งเป็นเนมสเปซที่มีฟังก์ชันและตัวแปร
2. การใช้คลาสคงที่ไม่ใช่วิธีปฏิบัติที่ดีเนื่องจากการทำลายหลักการการเขียนโปรแกรมเชิงวัตถุ
3. คลาสแบบสแตติกไม่สามารถส่งผ่านเป็นพารามิเตอร์สำหรับตัวอื่นได้
4. คลาสสแตติกไม่เหมาะสำหรับการเริ่มต้น“ ขี้เกียจ”
5. การกำหนดค่าเริ่มต้นและการใช้คลาสแบบคงที่มักจะถูกติดตามอย่างหนัก
6. การนำการจัดการเธรดมาใช้นั้นทำได้ยาก

1. เราสามารถสร้างวัตถุของคลาสซิงเกิลและส่งผ่านไปยังเมธอด

2. คลาสซิงเกิลไม่ จำกัด การสืบทอด

3. เราไม่สามารถกำจัดวัตถุของคลาสสแตติก แต่สามารถคลาสเดี่ยว

ความแตกต่างจากคลาสสแตติก

JDK มีตัวอย่างของทั้งแบบซิงเกิลและแบบคงที่ในอีกด้านหนึ่งjava.lang.Mathเป็นคลาสสุดท้ายที่มีวิธีแบบคงที่ในทางกลับกันjava.lang.Runtimeเป็นคลาสแบบซิงเกิล

ข้อดีของซิงเกิลตัน

• หากคุณต้องการรักษาสถานะมากกว่ารูปแบบซิงเกิลเป็นตัวเลือกที่ดีกว่าคลาสสแตติกเนื่องจากการรักษาสถานะในคลาสสแตติกจะนำไปสู่ข้อบกพร่องโดยเฉพาะอย่างยิ่งในสภาพแวดล้อมพร้อมกันที่อาจนำไปสู่สภาวะการแข่งขัน

• Singleton class สามารถขี้เกียจได้ถ้ามันเป็นวัตถุที่หนัก แต่คลาส static นั้นไม่มีข้อดีดังกล่าวและมักจะโหลดอย่างกระตือรือร้น

• ด้วย singleton คุณสามารถใช้การสืบทอดและ polymorphism เพื่อขยายคลาสฐานใช้อินเทอร์เฟซและให้การใช้งานที่แตกต่างกัน

• เนื่องจากวิธีการคงที่ใน Java ไม่สามารถแทนที่ได้จึงนำไปสู่การไม่ยืดหยุ่น ในอีกทางหนึ่งคุณสามารถแทนที่วิธีการที่กำหนดในชั้นเรียนเดี่ยวโดยการขยายมัน

ข้อเสียของการเรียนแบบคงที่

• เป็นการง่ายกว่าที่จะเขียนการทดสอบหน่วยสำหรับซิงเกิลตันมากกว่าคลาสสแตติกเนื่องจากคุณสามารถผ่านวัตถุจำลองเมื่อใดก็ตามที่คาดว่าจะเป็นซิงเกิล

ข้อดีของการเรียนแบบคงที่

• คลาสสแตติกให้ประสิทธิภาพที่ดีกว่าซิงเกิลเนื่องจากเมธอดแบบสแตติกถูกผูกมัดกับเวลาคอมไพล์

รูปแบบซิงเกิลแต่ละอันมีข้อดีและข้อเสียแตกต่างกันไป

• กระตือรือร้นโหลดซิงเกิลตัน
• ล็อคเดี่ยวที่ตรวจสอบสองครั้ง
• สำนวนการเริ่มต้นตามความต้องการเจ้าของ
• ซิงเกิลอิง enum

คำอธิบายโดยละเอียดแต่ละคนนั้นละเอียดเกินไปดังนั้นฉันแค่ใส่ลิงค์ไปยังบทความที่ดี - สิ่งที่คุณอยากรู้เกี่ยวกับ Singleton

มีความแตกต่างอย่างมากระหว่างอินสแตนซ์คลาสแบบสแตติกเดี่ยว (นั่นคืออินสแตนซ์เดียวของคลาสซึ่งเกิดขึ้นเป็นตัวแปรแบบสแตติกหรือส่วนกลาง) และตัวชี้แบบสแตติกเดี่ยวไปยังอินสแตนซ์ของคลาสบนฮีป:

เมื่อแอปพลิเคชันของคุณออกตัวทำลายของอินสแตนซ์คลาสแบบสแตติกจะถูกเรียกใช้ นั่นหมายความว่าถ้าคุณใช้อินสแตนซ์แบบคงที่นั้นเป็นซิงเกิลซิงเกิลของคุณหยุดทำงานอย่างถูกต้อง หากยังคงมีการเรียกใช้รหัสที่ใช้ซิงเกิลตันนั้นตัวอย่างเช่นในเธรดอื่นรหัสนั้นมีแนวโน้มว่าจะผิดพลาด

ความแตกต่างในหัวของฉันคือการใช้การเขียนโปรแกรมเชิงวัตถุ (Singleton / Prototype) หรือการเขียนโปรแกรมฟังก์ชั่น (คงที่)

เราให้ความสำคัญกับจำนวนของวัตถุที่สร้างขึ้นโดยรูปแบบซิงเกิลมากขึ้นเมื่อสิ่งที่เราควรให้ความสำคัญคือในที่สุดเราก็ถือวัตถุ เช่นเดียวกับที่คนอื่นพูดไปแล้วมันสามารถขยายได้ส่งผ่านเป็นพารามิเตอร์ แต่ที่สำคัญที่สุดคือมันเป็นสถานะเต็ม

ในทางกลับกันคงที่จะใช้ในการใช้การเขียนโปรแกรมการทำงาน สมาชิกแบบคงที่อยู่ในชั้นเรียน พวกเขาไร้สัญชาติ

คุณทราบได้อย่างไรว่าคุณสามารถสร้างคลาสแบบคงที่แบบซิงเกิลตัน :)