Design patterns
ब्रिज पैटर्न

जावा में ब्रिज पैटर्न का कार्यान्वयन

ब्रिज पैटर्न कार्यान्वयन से अमूर्तता को कम करता है ताकि दोनों स्वतंत्र रूप से भिन्न हो सकें। यह विरासत के बजाय रचना के साथ हासिल किया गया है।

विकिपीडिया से ब्रिज यूएमएल आरेख:

इस पैटर्न में आपके चार घटक हैं।

Abstraction : यह एक इंटरफ़ेस को परिभाषित करता है

RefinedAbstraction : यह अमूर्तता को लागू करता है:

Implementor : यह कार्यान्वयन के लिए एक इंटरफ़ेस परिभाषित करता है

ConcreteImplementor : यह इंप्लायर इंटरफेस को लागू करता है।

The crux of Bridge pattern : दो ऑर्थोगोनल श्रेणी पदानुक्रमों का उपयोग करते हुए रचना (और कोई विरासत)। अमूर्त पदानुक्रम और कार्यान्वयन पदानुक्रम स्वतंत्र रूप से भिन्न हो सकते हैं। कार्यान्वयन कभी भी अमूर्तता को संदर्भित नहीं करता है। अमूर्त में एक सदस्य के रूप में कार्यान्वयन इंटरफ़ेस होता है (रचना के माध्यम से)। यह रचना वंशानुक्रम पदानुक्रम के एक और स्तर को कम करती है।

वास्तविक शब्द उपयोग मामला:

अलग-अलग वाहनों को मैनुअल और ऑटो गियर सिस्टम के दोनों संस्करणों के लिए सक्षम करें।

उदाहरण कोड:

/* Implementor interface*/
interface Gear{
    void handleGear();
}

/* Concrete Implementor - 1 */
class ManualGear implements Gear{
    public void handleGear(){
        System.out.println("Manual gear");
    }
}
/* Concrete Implementor - 2 */
class AutoGear implements Gear{
    public void handleGear(){
        System.out.println("Auto gear");
    }
}
/* Abstraction (abstract class) */
abstract class Vehicle {
    Gear gear;
    public Vehicle(Gear gear){
        this.gear = gear;
    }
    abstract void addGear();
}
/* RefinedAbstraction - 1*/
class Car extends Vehicle{
    public Car(Gear gear){
        super(gear);
        // initialize various other Car components to make the car
    }
    public void addGear(){
        System.out.print("Car handles ");
        gear.handleGear();
    }
}
/* RefinedAbstraction - 2 */
class Truck extends Vehicle{
    public Truck(Gear gear){
        super(gear);
        // initialize various other Truck components to make the car
    }
    public void addGear(){
        System.out.print("Truck handles " );
        gear.handleGear();
    }
}
/* Client program */
public class BridgeDemo {    
    public static void main(String args[]){
        Gear gear = new ManualGear();
        Vehicle vehicle = new Car(gear);
        vehicle.addGear();
        
        gear = new AutoGear();
        vehicle = new Car(gear);
        vehicle.addGear();
        
        gear = new ManualGear();
        vehicle = new Truck(gear);
        vehicle.addGear();
        
        gear = new AutoGear();
        vehicle = new Truck(gear);
        vehicle.addGear();
    }
}

उत्पादन:

Car handles Manual gear
Car handles Auto gear
Truck handles Manual gear
Truck handles Auto gear

स्पष्टीकरण:

1. Vehicle एक अमूर्तन है।
2. Car और Truck Vehicle दो ठोस कार्यान्वयन हैं।
3. Vehicle एक अमूर्त विधि को परिभाषित करता है: addGear() ।
4. Gear कार्यान्वयनकर्ता इंटरफ़ेस है
5. ManualGear और AutoGear Gear दो कार्यान्वयन हैं
6. Vehicle में इंटरफ़ेस implementor बजाय implementor इंटरफ़ेस शामिल है। Compositon implementor इंटरफ़ेस की इस पद्धति की जड़ है: यह स्वतंत्र रूप से भिन्न करने के लिए अमूर्त और कार्यान्वयन की अनुमति देता है।
7. Car और Truck एब्स्ट्रेक्शन के लिए कार्यान्वयन (पुनर्परिभाषित अमूर्तता) को परिभाषित करते हैं: addGear() : इसमें Gear - ई Manual या Auto

ब्रिज पैटर्न के लिए केस (एस) का उपयोग करें :

1. अमूर्तता और कार्यान्वयन एक दूसरे को स्वतंत्र रूप से बदल सकते हैं और वे संकलन समय पर बाध्य नहीं होते हैं
2. मानचित्र ऑर्थोगोनल पदानुक्रम - एक अमूर्त के लिए और एक कार्यान्वयन के लिए ।