Design Patterns in Java: A Complete Exploration

public class Singleton { 

    private static Singleton instance; 

         // Private constructor to prevent instantiation from outside 

    private Singleton() { } 

         // Static method to get the Singleton instance 

    public static Singleton getInstance() { 

        if (instance == null) { 

            instance = new Singleton(); 

        } 

        return instance; 

    } 

        // Other methods and variables of the Singleton class can be added here 

} 

class Document: 

    def __init__(self): 

        self.content = [] 

     def add_content(self, content): 

        self.content.append(content) 

      def show_content(self): 

        for item in self.content: 

            print(item) 

      def create_document(self): 

        raise NotImplementedError("create_document() method is not implemented.") 

  class Resume(Document): 

    def create_document(self): 

        return Resume() 

  class Report(Document): 

    def create_document(self): 

        return Report() 

  class Letter(Document): 

    def create_document(self): 

        return Letter() 

class AbstractFactory: 

    def create_product_a(self): 

        pass 

         def create_product_b(self): 

        pass 

# Concrete factory 1 

class ConcreteFactory1(AbstractFactory): 

    def create_product_a(self): 

        return ProductA1() 

         def create_product_b(self): 

        return ProductB1() 

# Concrete factory 2 

class ConcreteFactory2(AbstractFactory): 

    def create_product_a(self): 

        return ProductA2() 

         def create_product_b(self): 

        return ProductB2() 

# Abstract product A 

class AbstractProductA: 

    def useful_function_a(self): 

        pass 

# Concrete product A1 

class ProductA1(AbstractProductA): 

    def useful_function_a(self): 

        return "The result of the product A1." 

# Concrete product A2 

class ProductA2(AbstractProductA): 

    def useful_function_a(self): 

        return "The result of the product A2." 

# Abstract product B 

class AbstractProductB: 

    def useful_function_b(self): 

        pass 

# Concrete product B1 

class ProductB1(AbstractProductB): 

    def useful_function_b(self): 

        return "The result of the product B1." 

# Concrete product B2 

class ProductB2(AbstractProductB): 

    def useful_function_b(self): 

        return "The result of the product B2." 

 public class Person { 

  private String firstName; 

  private String lastName; 

  private int age; 

   public Person(PersonBuilder builder) { 

    this.firstName = builder.firstName; 

    this.lastName = builder.lastName; 

    this.age = builder.age; 

  } 

    public static class PersonBuilder { 

    private String firstName; 

    private String lastName; 

    private int age; 

     public PersonBuilder() {} 

      public PersonBuilder firstName(String firstName) { 

      this.firstName = firstName; 

      return this; 

    } 

      public PersonBuilder lastName(String lastName) { 

      this.lastName = lastName; 

      return this; 

    } 

      public PersonBuilder age(int age) { 

      this.age = age; 

      return this; 

    } 

      public Person build() { 

      return new Person(this); 

    } 

  } 

   @Override 

  public String toString() { 

    return "Person{" + 

            "firstName='" + firstName + ''' + 

            ", lastName='" + lastName + ''' + 

            ", age=" + age + 

            '}'; 

  } 

} 

public abstract class Shape implements Cloneable { 

    private String type; 

       public String getType() { 

        return type; 

    } 

         public void setType(String type) { 

        this.type = type; 

    } 

         public abstract void draw(); 

        public Object clone() { 

        Object clone = null; 

                 try { 

            clone = super.clone(); 

        } catch (CloneNotSupportedException e) { 

            e.printStackTrace(); 

        } 

             return clone; 

    } 

} 

public class Circle extends Shape { 

    public Circle() { 

        setType("Circle"); 

    } 

         @Override 

    public void draw() { 

        System.out.println("Drawing a circle."); 

    } 

} 

  public class Rectangle extends Shape { 

    public Rectangle() { 

        setType("Rectangle"); 

    } 

      @Override 

    public void draw() { 

        System.out.println("Drawing a rectangle."); 

    } 

} 

  public class PrototypePatternExample { 

    public static void main(String[] args) { 

        Circle circle = new Circle(); 

        Circle clonedCircle = (Circle) circle.clone(); 

         Rectangle rectangle = new Rectangle(); 

        Rectangle clonedRectangle = (Rectangle) rectangle.clone(); 

         System.out.println("Original Circle Type: " + circle.getType()); 

        System.out.println("Cloned Circle Type: " + clonedCircle.getType()); 

        System.out.println("Original Rectangle Type: " + rectangle.getType()); 

        System.out.println("Cloned Rectangle Type: " + clonedRectangle.getType()); 

    } 

} 

public interface MediaPlayer { 

    public void play(String audioType, String fileName); 

} 

  public interface AdvancedMediaPlayer {     

    public void playVlc(String fileName); 

    public void playMp4(String fileName); 

} 

  public class VlcPlayer implements AdvancedMediaPlayer{ 

    @Override 

    public void playVlc(String fileName) { 

        System.out.println("Playing vlc file. Name: "+ fileName);         

    } 

      @Override 

    public void playMp4(String fileName) { 

        // Do nothing 

    } 

} 

  public class Mp4Player implements AdvancedMediaPlayer{ 

      @Override 

    public void playVlc(String fileName) { 

        // Do nothing 

    } 

      @Override 

    public void playMp4(String fileName) { 

        System.out.println("Playing mp4 file. Name: "+ fileName);         

    } 

} 

  public class MediaAdapter implements MediaPlayer { 

      AdvancedMediaPlayer advancedMusicPlayer; 

      public MediaAdapter(String audioType){ 

        if(audioType.equalsIgnoreCase("vlc") ){ 

            advancedMusicPlayer = new VlcPlayer();            

        } else if (audioType.equalsIgnoreCase("mp4")){ 

            advancedMusicPlayer = new Mp4Player(); 

        }   

    } 

      @Override 

    public void play(String audioType, String fileName) { 

          if(audioType.equalsIgnoreCase("vlc")){ 

            advancedMusicPlayer.playVlc(fileName); 

        } 

        else if(audioType.equalsIgnoreCase("mp4")){ 

            advancedMusicPlayer.playMp4(fileName); 

        } 

    } 

} 

  public class AudioPlayer implements MediaPlayer { 

    MediaAdapter mediaAdapter;  

      @Override 

    public void play(String audioType, String fileName) { 

          // Inbuilt support to play mp3 music files 

        if(audioType.equalsIgnoreCase("mp3")){ 

            System.out.println("Playing mp3 file. Name: " + fileName);             

        }  

        // mediaAdapter is providing support to play other file formats 

        else if(audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){ 

            mediaAdapter = new MediaAdapter(audioType); 

            mediaAdapter.play(audioType, fileName); 

        } 

        else{ 

            System.out.println("Invalid media. " + audioType + " format not supported"); 

        } 

    }    

} 

public interface Shape { 

    void draw(); 

} 

  public class Circle implements Shape { 

    private final Color color; 

      public Circle(Color color) { 

        this.color = color; 

    } 

      @Override 

    public void draw() { 

        System.out.println("Drawing a " + color.getColor() + " circle."); 

    } 

} 

  public interface Color { 

    String getColor(); 

} 

  public class RedColor implements Color { 

    @Override 

    public String getColor() { 

        return "red"; 

    } 

} 

  public class BlueColor implements Color { 

    @Override 

    public String getColor() { 

        return "blue"; 

    } 

} 

  public class Main { 

    public static void main(String[] args) { 

        Shape redCircle = new Circle(new RedColor()); 

        Shape blueCircle = new Circle(new BlueColor()); 

          redCircle.draw(); 

        blueCircle.draw(); 

    } 

} 

public interface Component { 

    void operation(); 

} 

 public class Leaf implements Component { 

    public void operation() { 

        System.out.println("Leaf operation"); 

    } 

} 

  public class Composite implements Component { 

    private List children = new ArrayList<>(); 

      public void add(Component component) { 

        children.add(component); 

    } 

      public void remove(Component component) { 

        children.remove(component); 

    } 

      public void operation() { 

        System.out.println("Composite operation"); 

        for (Component child : children) { 

            child.operation(); 

        } 

    } 

} 

// The interface for the component we want to decorate 

interface Pizza { 

    String getDescription(); 

    double getCost(); 

} 

  // The concrete implementation of the Pizza interface 

class PlainPizza implements Pizza { 

    @Override 

    public String getDescription() { 

        return "Plain pizza"; 

    } 

      @Override 

    public double getCost() { 

        return 5.0; 

    } 

} 

  // The decorator abstract class that implements the Pizza interface and holds a reference to a Pizza object 

abstract class PizzaDecorator implements Pizza { 

    protected Pizza pizza; 

      public PizzaDecorator(Pizza pizza) { 

        this.pizza = pizza; 

    } 

      @Override 

    public String getDescription() { 

        return pizza.getDescription(); 

    } 

      @Override 

    public double getCost() { 

        return pizza.getCost(); 

    } 

} 

  // The concrete decorator that adds toppings to the pizza 

class ToppingDecorator extends PizzaDecorator { 

    public ToppingDecorator(Pizza pizza) { 

        super(pizza); 

    } 

      @Override 

    public String getDescription() { 

        return pizza.getDescription() + ", with toppings"; 

    } 

      @Override 

    public double getCost() { 

        return pizza.getCost() + 2.0; 

    } 

} 

  // Client code that uses the decorator pattern to create and decorate pizzas 

public class PizzaClient { 

    public static void main(String[] args) { 

        Pizza plainPizza = new PlainPizza(); 

        Pizza pizzaWithToppings = new ToppingDecorator(plainPizza); 

          System.out.println(plainPizza.getDescription() + " costs $" + plainPizza.getCost()); 

        System.out.println(pizzaWithToppings.getDescription() + " costs $" + pizzaWithToppings.getCost()); 

    } 

} 

public class Facade { 

    public void operation() { 

        System.out.println("Facade is performing operation."); 

    } 

} 

  public class Main { 

    public static void main(String[] args) { 

        Facade facade = new Facade(); 

        facade.operation(); // Facade is performing operation. 

    } 

} 

import java.util.HashMap; 

import java.util.Map; 

public class FlyweightFactory { 

    private Map flyweights = new HashMap<>(); 

      public Flyweight getFlyweight(String key) { 

        if (flyweights.containsKey(key)) { 

            return flyweights.get(key); 

        } else { 

            Flyweight flyweight = new ConcreteFlyweight(key); 

            flyweights.put(key, flyweight); 

            return flyweight; 

        } 

    } 

} 

public interface Flyweight { 

    void operation(); 

} 

public class ConcreteFlyweight implements Flyweight { 

    private String key; 

    public ConcreteFlyweight(String key) { 

        this.key = key; 

    } 

    public void operation() { 

        System.out.println("ConcreteFlyweight with key " + key + " is doing operation."); 

    } 

}  

public class Client { 

    public static void main(String[] args) { 

        FlyweightFactory factory = new FlyweightFactory(); 

        Flyweight flyweight1 = factory.getFlyweight("key1"); 

        Flyweight flyweight2 = factory.getFlyweight("key1"); 

        flyweight1.operation(); 

        flyweight2.operation(); 

        System.out.println(flyweight1 == flyweight2); 

    } 

}

public interface Internet { 

    void connectTo(String serverHost); 

} 

public class RealInternet implements Internet { 

    @Override 

    public void connectTo(String serverHost) { 

        System.out.println("Connecting to " + serverHost); 

    } 

} 

public class ProxyInternet implements Internet { 

    private Internet internet = new RealInternet(); 

    private List bannedServers = new ArrayList<>(); 

    public void banServer(String serverHost) { 

        bannedServers.add(serverHost); 

    } 

    @Override 

    public void connectTo(String serverHost) { 

        if (bannedServers.contains(serverHost)) { 

            System.out.println("Access denied to " + serverHost); 

            return; 

        } 

        internet.connectTo(serverHost); 

    } 
}