feat: Adapter,Bridge,Prototype,Singleton patterns

Author: boaglio

Patterns/AdapterPattern.java

@@ -0,0 +1,94 @@
+interface ILightningPhone {
+    void recharge();
+    void useLightning();
+}
+
+interface IMicroUsbPhone {
+    void recharge();
+    void useMicroUsb();
+}
+
+class Iphone implements ILightningPhone {
+    private boolean connector;
+
+    @Override
+    public void useLightning() {
+        connector = true;
+        System.out.println("Lightning connected");
+    }
+
+    @Override
+    public void recharge() {
+        if (connector) {
+            System.out.println("Recharge started");
+            System.out.println("Recharge finished");
+        } else {
+            System.out.println("Connect Lightning first");
+        }
+    }
+}
+
+class Android implements IMicroUsbPhone {
+    private boolean connector;
+
+    @Override
+    public void useMicroUsb() {
+        connector = true;
+        System.out.println("MicroUsb connected");
+    }
+
+    @Override
+    public void recharge() {
+        if (connector) {
+            System.out.println("Recharge started");
+            System.out.println("Recharge finished");
+        } else {
+            System.out.println("Connect MicroUsb first");
+        }
+    }
+}
+/* exposing the target interface while wrapping source object */
+class LightningToMicroUsbAdapter implements IMicroUsbPhone {
+    private final ILightningPhone lightningPhone;
+
+    public LightningToMicroUsbAdapter(ILightningPhone lightningPhone) {
+        this.lightningPhone = lightningPhone;
+    }
+
+    @Override
+    public void useMicroUsb() {
+        System.out.println("MicroUsb connected");
+        lightningPhone.useLightning();
+    }
+
+    @Override
+    public void recharge() {
+        lightningPhone.recharge();
+    }
+}
+
+public class AdapterPattern {
+    static void rechargeMicroUsbPhone(IMicroUsbPhone phone) {
+        phone.useMicroUsb();
+        phone.recharge();
+    }
+
+    static void rechargeLightningPhone(ILightningPhone phone) {
+        phone.useLightning();
+        phone.recharge();
+    }
+
+    public static void main(String[] args) {
+        Android android = new Android();
+        Iphone iPhone = new Iphone();
+
+        System.out.println("Recharging android with MicroUsb");
+        rechargeMicroUsbPhone(android);
+
+        System.out.println("Recharging iPhone with Lightning");
+        rechargeLightningPhone(iPhone);
+
+        System.out.println("Recharging iPhone with MicroUsb");
+        rechargeMicroUsbPhone(new LightningToMicroUsbAdapter (iPhone));
+    }
+}

Patterns/BridgePattern.java

@@ -0,0 +1,60 @@
+// Logger has two implementations: info and warning
+@FunctionalInterface
+interface Logger {
+    void log(String message);
+    
+    static Logger info() {
+        return message -> System.out.println("info: " + message);
+    }
+    static Logger warning() {
+        return message -> System.out.println("warning: " + message);
+    }
+}
+
+abstract class AbstractAccount {
+    private Logger logger = Logger.info();
+    
+    public void setLogger(Logger logger) {
+        this.logger = logger;
+    }
+    
+    // the logging part is delegated to the Logger implementation
+    protected void operate(String message, boolean result) {
+        logger.log(message + " result " + result);
+    }
+}
+
+class SimpleAccount extends AbstractAccount {
+    private int balance;
+    
+    public SimpleAccount(int balance) {
+        this.balance = balance;
+    }
+    
+    public boolean isBalanceLow() {
+        return balance < 50;
+    }
+    
+    public void withdraw(int amount) {
+        boolean shouldPerform = balance >= amount;
+        if (shouldPerform) {
+            balance -= amount;
+        }
+        operate("withdraw " + amount, shouldPerform);
+    }
+}
+
+public class BridgePattern {
+    public static void main(String[] args) {
+        SimpleAccount account = new SimpleAccount(100);
+        account.withdraw(75);
+        
+        if (account.isBalanceLow()) {
+            // you can also change the Logger implementation at runtime
+            account.setLogger(Logger.warning());
+        }
+        
+        account.withdraw(10);
+        account.withdraw(100);
+    }
+}

Patterns/PrototypePattern.java

@@ -0,0 +1,31 @@
+// Prototype pattern
+abstract class Prototype implements Cloneable {
+    public Prototype clone() throws CloneNotSupportedException{
+        return (Prototype) super.clone();
+    }
+}
+	
+class ConcretePrototype1 extends Prototype {
+    @Override
+    public Prototype clone() throws CloneNotSupportedException {
+        return (ConcretePrototype1)super.clone();
+    }
+}
+
+class ConcretePrototype2 extends Prototype {
+    @Override
+    public Prototype clone() throws CloneNotSupportedException {
+        return (ConcretePrototype2)super.clone();
+    }
+}
+
+public class PrototypePattern {
+
+    public static void main (String [] args) throws CloneNotSupportedException {
+       Prototype car1 = new ConcretePrototype1();
+       Prototype car2 = new ConcretePrototype2();
+       
+       Prototype anotherCar1 = car1.clone();
+       Prototype anotherCar2 = car2.clone();
+    }
+}

Patterns/Singleton.java

@@ -0,0 +1,35 @@
+class Coin {
+
+    private static final int ADD_MORE_COIN = 10;
+    private int coin;
+    private static Coin instance = new Coin(); // eagerly loads the singleton
+
+    private Coin() {
+        // private to prevent anyone else from instantiating
+    }
+
+    public static Coin getInstance() {
+        return instance;
+    }
+
+    public int getCoin() {
+        return coin;
+    }
+
+    public void addMoreCoin() {
+        coin += ADD_MORE_COIN;
+    }
+
+    public void deductCoin() {
+        coin--;
+    }
+}
+
+public class Singleton {
+
+    public static void main(String [] args) {
+           Coin coin = Coin.getInstance();
+           coin.addMoreCoin();
+    }
+
+}