A Very Big Branch Answer Key - Fill Online, Printable, Fillable ... - Free Printable

It looks like you've uploaded a page from a textbook or educational material that contains two problems related to object-oriented programming (OOP) concepts, specifically focusing on inheritance, polymorphism, and design patterns. However, the actual image content is not visible to me — I can only read the text you've provided.

Let’s analyze the two problems presented in your text and solve them step-by-step with explanations.

---

🔹 Problem 1: Very Big Branch

> We’ve Got a Job to Do
> You are given an application that is very similar to the one described in Figure 8.3 of the book. The problem is that the code for each type of employee is duplicated across several classes. Your job is to refactor this code using inheritance and polymorphism.

#### 📌 Problem Summary:
- There are different types of employees: `HourlyEmployee`, `SalariedEmployee`, etc.
- Each has its own `calculatePay()` method.
- This leads to code duplication and violates DRY (Don't Repeat Yourself) principle.
- Goal: Use inheritance and polymorphism to eliminate duplication.

---

#### ✔ Solution:

We should create a base class (`Employee`) with common properties and methods, then use inheritance to define specific employee types.

```java
// Base class
abstract class Employee {
protected String name;
protected int id;

public Employee(String name, int id) {
this.name = name;
this.id = id;
}

// Abstract method - forces subclasses to implement
public abstract double calculatePay();
}

// Subclass: Hourly Employee
class HourlyEmployee extends Employee {
private double hourlyRate;
private int hoursWorked;

public HourlyEmployee(String name, int id, double hourlyRate, int hoursWorked) {
super(name, id);
this.hourlyRate = hourlyRate;
this.hoursWorked = hoursWorked;
}

@Override
public double calculatePay() {
return hourlyRate * hoursWorked;
}
}

// Subclass: Salaried Employee
class SalariedEmployee extends Employee {
private double annualSalary;

public SalariedEmployee(String name, int id, double annualSalary) {
super(name, id);
this.annualSalary = annualSalary;
}

@Override
public double calculatePay() {
return annualSalary / 52; // Weekly pay
}
}
```

#### 💡 Explanation:
- Inheritance: All employees share common attributes (`name`, `id`), so they inherit from `Employee`.
- Polymorphism: The `calculatePay()` method is overridden in each subclass. When calling it via a reference to `Employee`, the correct version runs based on the actual object type.
- Encapsulation: Data is protected, and behavior is encapsulated within classes.

This design allows for easy extension (e.g., adding `CommissionEmployee`) without modifying existing code.

---

🔹 Problem 2: Carrying Out Laws Enforcement

> Write down a way to "carry out" a law. That depends on the kind of law that needs to be enforced. Some laws require hiring agents and sending them to locations where violations occur. Others may involve monitoring systems or issuing fines.

#### 📌 Problem Summary:
- Different enforcement strategies depend on the type of law.
- Need a flexible system that supports various enforcement methods.
- Likely involves strategy pattern or polymorphism.

---

#### ✔ Solution Using Strategy Pattern:

We’ll model this using polymorphism and possibly the Strategy Design Pattern.

```java
// Interface defining the enforcement strategy
interface LawEnforcementStrategy {
void enforce(Law law);
}

// Concrete strategy: Hire agents
class AgentBasedEnforcement implements LawEnforcementStrategy {
@Override
public void enforce(Law law) {
System.out.println("Hiring agents to enforce " + law.getName());
}
}

// Concrete strategy: Monitor systems
class MonitoringEnforcement implements LawEnforcementStrategy {
@Override
public void enforce(Law law) {
System.out.println("Monitoring systems to enforce " + law.getName());
}
}

// Concrete strategy: Issue fines
class FineEnforcement implements LawEnforcementStrategy {
@Override
public void enforce(Law law) {
System.out.println("Issuing fines for violation of " + law.getName());
}
}

// Law class
class Law {
private String name;
private LawEnforcementStrategy strategy;

public Law(String name, LawEnforcementStrategy strategy) {
this.name = name;
this.strategy = strategy;
}

public void enforce() {
strategy.enforce(this);
}

public String getName() { return name; }
}
```

#### Usage Example:
```java
public class Main {
public static void main(String[] args) {
Law trafficViolation = new Law("Speeding", new AgentBasedEnforcement());
Law dataPrivacy = new Law("Data Protection", new MonitoringEnforcement());

trafficViolation.enforce(); // Output: Hiring agents to enforce Speeding
dataPrivacy.enforce(); // Output: Monitoring systems to enforce Data Protection
}
}
```

#### 💡 Explanation:
- Strategy Pattern: Allows changing the enforcement behavior at runtime.
- Polymorphism: Each `Law` uses a different strategy depending on its nature.
- Extensibility: Adding new enforcement methods (e.g., “Public Awareness Campaign”) is simple — just add a new class implementing `LawEnforcementStrategy`.

---

✔ Final Answer Summary

| Problem | Key Concept Used | Solution |
|--------|------------------|---------|
| Very Big Branch | Inheritance + Polymorphism | Create base `Employee` class with abstract `calculatePay()`. Subclasses override it. Eliminates duplication. |
| Carrying Out Laws Enforcement | Strategy Pattern | Define `LawEnforcementStrategy` interface. Implement different behaviors (agent-based, monitoring, fines). Assign strategy per law. |

These solutions follow OOP principles:
- Encapsulation
- Inheritance
- Polymorphism
- Open/Closed Principle (extendable without modifying existing code)

---

If you have a specific diagram or additional details (like Figure 8.3 mentioned), feel free to describe it, and I can tailor the solution further!