ITSC 1213 - Introduction to CS 2 How to Design Programs with Object Oriented Programming

// Everything is scattered and global
class GameState {
  // Data just floating around
  static int playerHealth = 100;
  static int monsterHealth = 100;
  static int potionCount = 3;

  // Rules are separate from data
  static void healPlayer(int amount) {
    playerHealth += amount;    // Which player's health?
    potionCount--;            // Easy to forget this!
  }

  static void healMonster(int amount) {
    monsterHealth += amount;   // Copy-pasted code
  }

  public static void main(String[] args) {
    // Easy to make mistakes:
    playerHealth = -50;        // Negative health?
    potionCount = healPlayer(20);  // Wrong return type!
    healMonster(monsterHealth);    // Wrong parameter!
  }
}

      // Organize things into classes
      // We define our own data types
public class Player {
    private int health = 100;

    public void heal(int amount) {
        health += amount;  // This Player's health
    }
}

  // Organize things into classes
  // We have a separate class for running the program
  class GameState {
 
  public static void main(String[] args) {
    Player hero = new Player(20);
    Player villan = new Player(10);

   // Clear which player we're modifying
    hero.heal(20);
    villan.heal(5);
  }
}

Player hero = new Player(100, 50);

// During gameplay:
hero.health = -999;     // Player becomes invincible!
hero.gold = 1000000;    // Instant millionaire...
monster.health = 0;     // Kill without fighting

public class Restaurant {
    // Store kitchen details inside the class (encapsulation)
    private double grillTemp;   // Current temperature of grill
    private int burgerCount;    // How many burgers we can make
    private int grillSpace;     // How many burgers fit on grill
    
    // Simple interface for customers:
    public boolean orderCheeseburger() {
        // First check if we can make the burger
        if (burgerCount <= 0) {
            return false;    // Can't make burger - out of ingredients
        }
        
        // Complex steps hidden from customer:
        setGrillTemp(375);              // Heat the grill
        boolean success = cookPatty();   // Try to cook the burger
        
        if (success) {
            burgerCount = burgerCount - 1;  // Use up ingredients
            return true;                     // Burger ready!
        }
        return false;                        // Something went wrong
    }
    
    // Helper method - customers don't need to see this
    private boolean cookPatty() {
        if (grillSpace > 0) {           // If there's room on grill
            grillSpace = grillSpace - 1; // Take up one spot
            return true;                 // Cooking successful
        }
        return false;                    // Grill is full
    }
}

// Customer just needs to know:
Restaurant store = new Restaurant();
boolean gotBurger = store.orderCheeseburger();  // Don't care about the details!

public class Player {
    private int health;            // Encapsulation
    private double healBonus;      // (protect the data)

    public void heal(int amount) { // Abstraction
        // Complex healing logic hidden from users:
        applyHealingBuffs();
        checkStatusEffects();
        updateHealth(amount);      // Users don't see these steps
    }
}

class Player {
    private int health;
    public void takeDamage(int amount) { ... }
}

class Monster {
    private int health;
    public void takeDamage(int amount) { ... }
}

class Building {
    private int health;
    public void takeDamage(int amount) { ... }
}

public class BankAccount {
  // Step 1: Protect the data (Encapsulation)
  private double balance;
  private double interestRate;

  // Step 2: Control object creation
  public BankAccount(double initBalance) {
    if (initBalance < 0) {
      initBalance = 0;  // Start at 0 if negative
    }
    this.balance = initBalance;
    this.interestRate = 0.01;  // 1% interest
  }

  // Step 3: Simple interface, complex implementation (Abstraction)
  public boolean deposit(double amount) {
    // Validate input
    if (amount < 0) {
      return false;  // Can't deposit negative amounts
    }

    // Update balance
    balance += amount;
    return true; // success
  }

  public boolean withdraw(double amount) {
    // Validate input
    if (amount < 0 || amount > balance) {
      return false;  // Invalid amount
    }

    // Update balance
    balance -= amount;
    return true;
  }

  // Step 4: Safe way to check balance
  public double getBalance() {
    return balance;
  }

  // Step 5: Hidden interest calculation
  private void addInterest() {
    balance += balance * interestRate;
  }
}

BankAccount acct = new BankAccount(100);
acct.deposit(50);   // Simple to use!

// Design Recipe says: "health must be ≥ 0"
public class Player {
  private int health;   // Data definition + protection

  public void heal(int amt) {  // Methods enforce constraints
    if (amt < 0) return;     // No negative healing
    health = Math.min(100,   // Can't exceed max
             health + amt);
  }
}

Player hero = new Player(100);
Player backup = hero;
backup.health -= 50;  // Does this affect hero?