संरचनात्मक पैटर्न में से एक का उद्देश्य समान वस्तुओं के साथ जितना संभव हो उतना डेटा साझा करके मेमोरी उपयोग को कम करना है।
यह विशेष रूप से बड़ी संख्या में समान वस्तुओं से निपटने में उपयोगी है, जहां प्रत्येक ऑब्जेक्ट के लिए एक नया उदाहरण बनाना मेमोरी खपत के मामले में महंगा होगा।
महत्वपूर्ण अवधारणाएं:
आंतरिक स्थिति: कई वस्तुओं के बीच साझा की जाने वाली स्थिति संदर्भ से स्वतंत्र होती है और विभिन्न वस्तुओं में समान रहती है।
बाहरी स्थिति: वह स्थिति जो प्रत्येक ऑब्जेक्ट के लिए अद्वितीय होती है और क्लाइंट से पारित होती है। यह स्थिति अलग-अलग हो सकती है और फ़्लाईवेट ऑब्जेक्ट में संग्रहीत नहीं है

मुख्य प्रतिभागी:

फ्लाईवेट: इंटरफ़ेस जो फ्लाईवेट ऑब्जेक्ट को बाहरी स्थिति प्राप्त करने और उसका उपयोग करने की अनुमति देता है।
कंक्रीटफ्लाईवेट: फ्लाईवेट को लागू करता है और आंतरिक स्थिति को संग्रहीत करता है।
फ्लाईवेटफैक्ट्री: फ्लाईवेट ऑब्जेक्ट्स को प्रबंधित करता है और इंटरफेस के साझाकरण को सुनिश्चित करता है, यह मौजूदा फ्लाईवेट को लौटाता है यदि यह पहले से मौजूद है।

क्लाइंट (मुख्य वर्ग की तरह): फ्लाईवेट का संदर्भ बनाए रखता है और जब उसे फ्लाईवेट ऑब्जेक्ट के साथ इंटरैक्ट करने की आवश्यकता होती है तो बाहरी स्थिति प्रदान करता है।

आइए चरित्र की फ्लाईवेट वस्तु का एक उदाहरण लें
मान लीजिए कि हमारे पास एक टेक्स्ट एडिटर है जिसे बड़ी मात्रा में टेक्स्ट प्रस्तुत करने की आवश्यकता है। प्रत्येक चरित्र को एक वस्तु के रूप में दर्शाया जा सकता है, लेकिन प्रत्येक चरित्र के लिए एक अलग वस्तु होने से बहुत सारी मेमोरी बर्बाद हो जाएगी। इसके बजाय, हम प्रत्येक अक्षर का प्रतिनिधित्व करने वाले चरित्र ऑब्जेक्ट को साझा करने के लिए फ्लाईवेट का उपयोग कर सकते हैं, और बाहरी स्थिति जैसे स्थिति या स्वरूपण को बाहर संग्रहीत कर सकते हैं

फ्लाईवेट

public interface Flyweight {
    public void display(int x, int y);//x, y are the extrinsic state of the Flyweight object
}

कंक्रीटफ्लाईवेट

public class CharacterFlyweight implements Flyweight {
    private char ch;
    public CharacterFlyweight(char c){
        this.ch  = c;
    }
    @Override
    public void display(int x ,int y){
        System.out.println("[drawing character: " this.ch " at co-ordinates:(" x "," y ")]");
    }

}

फ्लाईवेटफैक्ट्री

public class FlyweightFactory {
    private static HashMap flyweights = new HashMap();
    public static Flyweight getFlyweight(char c){
        Flyweight flyweight = flyweights.getOrDefault(c,null);
        if(null==flyweight){
            flyweight = new CharacterFlyweight(c);
            flyweights.put(c,flyweight);
        }
        return flyweight;
    }
}

मुख्य

public class Main {
    public static void main(String args[]){
        Flyweight flyweight1 = FlyweightFactory.getFlyweight('a');
        Flyweight flyweight2 = FlyweightFactory.getFlyweight('b');
        Flyweight flyweight3 = FlyweightFactory.getFlyweight('a');// will use the same object that is referenced by flyweight1

        flyweight1.display(1, 2);//'a' displayed at 1,2
        flyweight2.display(3, 4);//'b' displayed at 3,4
        flyweight3.display(5, 7); // 'a'(shared) displayed at 5,7
    }
}

आउटपुट:

[drawing character: a at co-ordinates:(1,2)]
[drawing character: b at co-ordinates:(3,4)]
[drawing character: a at co-ordinates:(5,7)]

प्रमुख बिंदु

• मेमोरी दक्षता: वस्तुओं को साझा करके मेमोरी के उपयोग को कम करता है, खासकर जब आंतरिक स्थिति बड़ी हो या कई ऑब्जेक्ट हों।
• प्रदर्शन में सुधार: बनाई गई वस्तुओं की संख्या को कम करके, यह बड़ी संख्या में वस्तुओं का प्रबंधन करते समय एप्लिकेशन के प्रदर्शन में सुधार कर सकता है।

नुकसान
जटिलता: पैटर्न कोड में जटिलता जोड़ सकता है, विशेष रूप से बाहरी और आंतरिक राज्यों को अलग-अलग प्रबंधित करने में।
ओवरहेड: यदि साझा करने के लिए कुछ वस्तुएं हैं, तो फ्लाईवेट पैटर्न महत्वपूर्ण मेमोरी बचत के बिना अनावश्यक जटिलता पेश कर सकता है।