Bridge Pattern with Abstract Factory Pattern Demo

[abhiraj2k]

package design_patterns.creational.bridge_pattern;

abstract class Variant {
    String type;

    Variant(String type) {
        this.type = type;
    }

    public String getType() {
        return this.type;
    }
}

class Modern extends Variant {
    public Modern() {
        super("Modern");
    }
}

class Victorian extends Variant {
    public Victorian() {
        super("Victorian");
    }
}

abstract class Product {
    Variant variant;
    String name;

    Product(Variant variant, String name) {
        this.variant = variant;
        this.name = name;
    }

    boolean hasLegs() {
        return !(this.variant.getType().equals("Modern"));
    }

    void displayLegsStatus() {
        System.out.print(this.variant.getType() + " " + this.name + " ");
        if (this.hasLegs()) {
            System.out.println("has legs.");
        } else {
            System.out.println("does not have legs");
        }
    }
}

class Chair extends Product {
    public Chair(Variant variant) {
        super(variant, "Chair");
    }

    void sitOn() {
        System.out.println("I am sitting on " + this.variant.getType() + " " + this.name);
    }
}

class Sofa extends Product {

    public Sofa(Variant variant) {
        super(variant, "Sofa");
    }

    void sitOn() {
        System.out.println("I am sitting on " + this.variant.getType() + " " + this.name);
    }

}

class CoffeeTable extends Product {

    public CoffeeTable(Variant variant) {
        super(variant, "Coffee Table");
    }

    void keepOn() {
        System.out.println(this.variant.getType() + " " + this.name + " is kept on  floor");
    }

}

class FurnitureFactory {
    Variant variant;

    FurnitureFactory(Variant variant) {
        this.variant = variant;
    }

    Chair createChair() {
        return new Chair(this.variant);
    }

    Sofa createSofa() {
        return new Sofa(this.variant);
    }

    CoffeeTable createCoffeeTable() {
        return new CoffeeTable(this.variant);
    }
}

class Client {
    private Chair chair;
    private Sofa sofa;
    private CoffeeTable coffeeTable;

    Client(FurnitureFactory factory) {
        this.chair = factory.createChair();
        this.sofa = factory.createSofa();
        this.coffeeTable = factory.createCoffeeTable();
    }

    void useFurniture() {
        this.chair.sitOn();
        this.sofa.sitOn();
        this.coffeeTable.keepOn();

        this.chair.displayLegsStatus();
        this.sofa.displayLegsStatus();
        this.coffeeTable.displayLegsStatus();
    }

}

public class BridgePatternEg {
    public static void main(String[] args) {
        Variant victorian = new Victorian();
        Variant modern = new Modern();

        FurnitureFactory modernFactory = new FurnitureFactory(modern);
        FurnitureFactory victorianFactory = new FurnitureFactory(victorian);

        Client client1 = new Client(modernFactory);
        Client client2 = new Client(victorianFactory);

        client1.useFurniture();
        System.out.println();
        client2.useFurniture();

    }
}

[preeti-max]

package BridgeWithAbstract;
//implementing bridge with abstract

abstract class Varient {
    abstract String getName();

}

class ModernFurniture extends Varient {

    public String getName() {
        return "Modern";
    }

}

class VictorianFurniture extends Varient {

    public String getName() {
        return "Victorian";
    }

}

abstract class Product {
    Varient varient;

    Product(Varient varient) {
        this.varient = varient;
    }

    boolean hasLegs() {
        return !(this.varient.getName().equals("Modern"));

    }

}

class Chair extends Product {
    Chair(Varient varient) {
        super(varient);

    }

    public void sitOn() {
        System.out.println("I am sat on a " + varient.getName() + " Chair");
    }
}

class Sofa extends Product {
    Sofa(Varient varient) {
        super(varient);

    }

    public void sitOn() {
        System.out.println("I am sat on a " + varient.getName() + " Sofa");
    }
}

class CoffeeTable extends Product {
    CoffeeTable(Varient varient) {
        super(varient);

    }

    public void keepOn() {
        System.out.println("I am sat on a " + varient.getName() + " Coffee Table");
    }
}

class FurnitureFactory {
    Varient varient;

    public FurnitureFactory(Varient varient) {
        this.varient = varient;
    }

    public Chair createChair() {
        return new Chair(varient);
    }

    public Sofa createSofa() {
        return new Sofa(varient);
    }

    public CoffeeTable createCoffeeTable() {
        return new CoffeeTable(varient);
    }

}

class Client {
    private Chair chair;
    private Sofa sofa;
    private CoffeeTable coffeeTable;

    Client(FurnitureFactory factory) { // abstract factory
        this.chair = factory.createChair();
        this.sofa = factory.createSofa();
        this.coffeeTable = factory.createCoffeeTable();
    }

    void useFurniture() {
        this.chair.sitOn();
        this.sofa.sitOn();
        this.coffeeTable.keepOn();
        System.out.println("Chair: " + this.chair.hasLegs());
        System.out.println("Sofa: " + this.sofa.hasLegs());
        System.out.println("Coffee Table: " + this.coffeeTable.hasLegs());

    }

}

public class BridgeWithAbstractFactoryDemo {
    public static void main(String[] args) {
        Varient modern = new ModernFurniture();
        Varient victorian = new VictorianFurniture();

        FurnitureFactory modernFactory = new FurnitureFactory(modern);
        FurnitureFactory victorianFactory = new FurnitureFactory(victorian);

        Client client = new Client(modernFactory);
        Client client1 = new Client(victorianFactory);

        client.useFurniture();
        client1.useFurniture();
    }
}

[SrideviYamala]

package patterns;

abstract class Variant {
    String varientName;

    Variant(String varientName) {
        this.varientName = varientName;
    }
}

class Victorian extends Variant {
    public Victorian() {
        super("Victorian");
    }
}

class Modern extends Variant {
    public Modern() {
        super("Modern");
    }
}

abstract class Product {
    Variant varient;
    String productName;

    Product(Variant varient, String productName) {
        this.varient = varient;
        this.productName = productName;
    }

    boolean hasLegs() {
        return (this.varient.varientName.equals("Victorian"));
    }

    void displayHasLegs() {
        System.out.print(this.varient.varientName + " " + productName);
        if (hasLegs())
            System.out.println(" has legs!");
        else
            System.out.println(" has no legs!");
    }

}

class Chair extends Product {

    public Chair(Variant varient) {
        super(varient, "Chair");
    }

    void sitOn() {
        System.out.println("I sat on a " + this.varient.varientName + " " + this.productName);
    }
}

class Sofa extends Product {

    public Sofa(Variant varient) {
        super(varient, "Sofa");
    }

    void sitOn() {
        System.out.println("I sat on a " + this.varient.varientName + " " + this.productName);
    }
}

class CoffeeTable extends Product {

    public CoffeeTable(Variant varient) {
        super(varient, "CoffeeTable");
    }

    void keepOn() {
        System.out.println("I kept coffee on a " + this.varient.varientName + " " + this.productName);
    }
}

class FurnitureFactory {
    Variant varient;

    FurnitureFactory(Variant varient) {
        this.varient = varient;
    }

    Chair createChair() {
        return new Chair(this.varient);
    }

    Sofa createSofa() {
        return new Sofa(this.varient);
    }

    CoffeeTable createCoffeeTable() {
        return new CoffeeTable(this.varient);
    }
}

class Client {
    private Chair chair;
    private Sofa sofa;
    private CoffeeTable coffeeTable;

    Client(FurnitureFactory factory) {
        this.chair = factory.createChair();
        this.sofa = factory.createSofa();
        this.coffeeTable = factory.createCoffeeTable();
    }

    void useFurniture() {
        this.chair.sitOn();
        this.sofa.sitOn();
        this.coffeeTable.keepOn();

        this.chair.displayHasLegs();
        this.sofa.displayHasLegs();
        this.coffeeTable.displayHasLegs();
    }

}

public class BridgePattern {
    public static void main(String[] args) {
        FurnitureFactory modernFactory = new FurnitureFactory(new Modern());
        FurnitureFactory victorianFactory = new FurnitureFactory(new Victorian());

        Client client1 = new Client(modernFactory);
        client1.useFurniture();

        Client client2 = new Client(victorianFactory);
        client2.useFurniture();
    }
}

[Shubhi27]

interface Variant {
    String getProductName();
}

class ModernFurniture implements Variant {

    @Override
    public String getProductName() {
        return "Modern";
    }

}

class VictorianFurniture implements Variant {

    public String getProductName() {
        return "Victorian";
    }

}

abstract class Product {
    Variant variant;

    Product(Variant variant) {
        this.variant = variant;
    }

    boolean hasLegs() {
        return (this.variant.getProductName().equals("Victorian"));

    }

}

class Chair extends Product {
    Chair(Variant variant) {
        super(variant);

    }

    public void sitOn() {
        System.out.println("I am sat on a " + variant.getProductName() + " Chair");
    }
}

class Sofa extends Product {
    Sofa(Variant Variant) {
        super(Variant);

    }

    public void sitOn() {
        System.out.println("I am sat on a " + variant.getProductName() + " Sofa");
    }
}

class CoffeeTable extends Product {
    CoffeeTable(Variant variant) {
        super(variant);

    }

    public void keepOn() {
        System.out.println("I am sat on a " + variant.getProductName() + " Coffee Table");
    }
}

class FurnitureFactory {
    Variant variant;

    public FurnitureFactory(Variant variant) {
        this.variant = variant;
    }

    public Chair createChair() {
        return new Chair(variant);
    }

    public Sofa createSofa() {
        return new Sofa(variant);
    }

    public CoffeeTable createCoffeeTable() {
        return new CoffeeTable(variant);
    }

}

class Client {
    private Chair chair;
    private Sofa sofa;
    private CoffeeTable coffeeTable;

    // Abstract Factory Pattern
    Client(FurnitureFactory factory) {
        this.chair = factory.createChair();
        this.sofa = factory.createSofa();
        this.coffeeTable = factory.createCoffeeTable();
    }

    void useFurniture() {
        this.chair.sitOn();
        this.sofa.sitOn();
        this.coffeeTable.keepOn();
        System.out.println("Chair has: " + this.chair.hasLegs());
        System.out.println("Sofa has: " + this.sofa.hasLegs());
        System.out.println("Coffee Table has: " + this.coffeeTable.hasLegs());

    }

}

public class BridgeAbstract {
    public static void main(String[] args) {
        Variant modern = new ModernFurniture();
        Variant victorian = new VictorianFurniture();

        FurnitureFactory modernFactory = new FurnitureFactory(modern);
        FurnitureFactory victorianFactory = new FurnitureFactory(victorian);

        Client client1 = new Client(modernFactory);
        Client client2 = new Client(victorianFactory);

        client1.useFurniture();
        client2.useFurniture();
    }
}