Facade Pattern

Pros

• Allows a client to work with a single class as a simplified interface to a complex system
• Decouples the client and underlying system

Cons

• Anything can have a facade between a client and its system but it might just be pointless complexity
• Could become a god class

Example Explanation

FacadeBattleSystem - The actual facade part of the pattern. It makes interacting with warrior and zombie simple so the Client does not need to understand how their individual complexities appropriately interact.

class Main {
  public static void main(String[] args) {

    FacadeBattleSystem fbs = new FacadeBattleSystem();

    fbs.playerAttackMonster();
    fbs.monsterAttackPlayer();
  }
}

class FacadeBattleSystem{

  private Entity player;
  private Entity monster;

  private DamageCalculation calc;

  public FacadeBattleSystem(){
    player = new Warrior(7);
    monster = new Zombie(9);
    calc = new DamageCalculation();
  }

  public void playerAttackMonster(){
    int dmg = calc.calculateDamage( player.getDamage(), monster.getArmor() );

    System.out.println(player.getName()+" attacks "+monster.getName()+" for "+dmg+" damage!");
  }

  public void monsterAttackPlayer(){
    int dmg = calc.calculateDamage( monster.getDamage(), player.getArmor() );

    System.out.println(monster.getName()+" attacks "+player.getName()+" for "+dmg+" damage!");
  }

}

class Zombie extends Entity{

  public Zombie(int level){
    super(new Attack(4, level), new Defense(3, level), level, "Zombie");
  }
}

class Warrior extends Entity{
  public Warrior(int level){
    super(new Attack(7, level), new Defense(1, level), level, "Warrior");
  }
}

abstract class Entity{
  private Attack attack;
  private Defense defense;
  protected String name;
  protected int level;
  public Entity(Attack attack, Defense defense, int level, String name){
    this.attack = attack;
    this.defense = defense;
    this.level = level;
    this.name = name;
  }
  public String toString(){
    return name+" [Attack: "+attack.getDamage()+", Defense: "+defense.getArmor()+"]";
  }
  public String getName(){
    return name;
  }
  public int getDamage(){
    return attack.getDamage();
  }
  public int getArmor(){
    return defense.getArmor();
  }
}

class Attack {
  private int damage;
  private int level;

  public Attack(int damage, int level){
    this.damage = damage;
    this.level = level;
  }

  public int getDamage(){
    return (int) (damage * getLevelMultiplier()) ;
  }
  private double getLevelMultiplier(){
    return 1 + level * 3.5;
  }
}

class Defense {

  private int armor;
  private int level;

  public Defense(int armor, int level){
    this.armor = armor;
  }

  public int getArmor(){
    return armor + level * 5;
  }
}

class DamageCalculation{

  public int calculateDamage(int damage, int armor){
    int totalDamage = damage - armor;

    return totalDamage > 0 ? totalDamage : 0;
  }
}

Extra Resources

https://www.geeksforgeeks.org/facade-design-pattern-introduction/

https://springframework.guru/gang-of-four-design-patterns/facade-pattern/