"There is no good or bad code . But how you write it… that makes all the difference.”-- Master Shifu
The sun had just touched the tips of the Valley of Peace. Birds chirped, the wind whispered tales of warriors, and Po—the Dragon Warrior—was busy trying to write some Java code. Yes, you read that right.
Master Shifu stood behind him, watching, amused and concerned.
Po (scratching his head): “Master Shifu, I’m trying to make this app where each Kung Fu move is chosen based on the enemy. But the code is… bloated. Classes everywhere. If OOP was noodles, this is a full buffet.”
Shifu (calmly sipping tea): “Ah, the classic Strategy Pattern. But there’s a better way, Po… a functional way. Let me show you the path.”
The Traditional (OOP) Strategy Pattern – Heavy Like Po’s Lunch
Po wants to choose a fighting strategy based on his opponent.
// Strategy Interface
interface FightStrategy {
void fight();
}
// Concrete Strategies
class TigerFightStrategy implements FightStrategy {
public void fight() {
System.out.println("Attack with swift tiger strikes!");
}
}
class MonkeyFightStrategy implements FightStrategy {
public void fight() {
System.out.println("Use agile monkey flips!");
}
}
// Context
class Warrior {
private FightStrategy strategy;
public Warrior(FightStrategy strategy) {
this.strategy = strategy;
}
public void fight() {
strategy.fight();
}
public void setStrategy(FightStrategy strategy) {
this.strategy = strategy;
}
}Usage
Warrior po = new Warrior(new TigerFightStrategy());
po.fight(); // Output: Attack with swift tiger strikes!
po.setStrategy(new MonkeyFightStrategy());
po.fight(); // Output: Use agile monkey flips!Why This Is a Problem (and Why Po Is Annoyed)
Po: “So many files, interfaces, boilerplate! All I want is to change moves easily. This feels like trying to meditate with a noodle cart passing by!”
Indeed, OOP Strategy pattern works, but it's verbose, rigid, and unnecessarily class-heavy. It violates the spirit of quick Kung Fu adaptability!
Enter Functional Programming – The Way of Inner Simplicity
Shifu (nodding): “Po, what if I told you… that functions themselves can be passed around like scrolls of wisdom?”
Po: “Whoa... like… JScrolls?
Shifu: “No, Po. Java lambdas.”
In functional programming, functions are first-class citizens. You don’t need classes to wrap behavior. You can pass behavior directly.
Higher-Order Functions – functions that take other functions as parameters or return them.
Po, In Java8 onwards , now we can do that easily with the help of lambda, lambda can wrap the functionality and can be pass to another method as a parameter.
Strategy Pattern – The Functional Way in Java
import java.util.function.Consumer;
class Warrior {
private Consumer<Void> strategy;
public Warrior(Consumer<Void> strategy) {
this.strategy = strategy;
}
public void fight() {
strategy.accept(null);
}
public void setStrategy(Consumer<Void> strategy) {
this.strategy = strategy;
}
}But there’s a better, cleaner way with just lambdas and no class at all.
import java.util.function.Supplier;
public class FunctionalStrategy {
public static void main(String[] args) {
// Each strategy is just a lambda
Runnable tigerStyle = () -> System.out.println("Attack with swift tiger strikes!");
Runnable monkeyStyle = () -> System.out.println("Use agile monkey flips!");
Runnable pandaStyle = () -> System.out.println("Roll and belly-bounce!");
// Fighter is a high-order function executor
executeStrategy(tigerStyle);
executeStrategy(monkeyStyle);
executeStrategy(pandaStyle);
}
static void executeStrategy(Runnable strategy) {
strategy.run();
}
}Shifu (with a gentle tone):
“Po, in the art of code—as in Kung Fu—not every move needs a name, nor every master a title. In our example, we summoned the ancient scroll of Runnable… a humble interface with but one method—run(). In Java8 , we called it Functional Interface.
Think of it as a silent warrior—it expects no inputs(parameters) , demands no rewards(return type), and yet, performs its duty when called.
Each fighting style—tiger, monkey, panda—was not wrapped in robes of classes, but flowed freely as lambdas.
And then, we had the executeStrategy() method…
a higher-order sensei.
It does not fight itself, Po. It simply receives the wisdom of a move—a function—and executes it when the time is right.
This… is the way of functional composition.
You do not command the move—you invite it.
You do not create many paths—you simply choose the next step.”
Benefits – As Clear As The Sacred Pool of Tears
- No extra interfaces or classes
Easily switch behaviors at runtime
More readable, composable, and flexible
Promotes the power of behavior as data.
Real-World Example: Choosing Payment Strategy in an App
Map<String, Runnable> paymentStrategies = Map.of(
"CARD", () -> System.out.println("Processing via Credit Card"),
"UPI", () -> System.out.println("Processing via UPI"),
"CASH", () -> System.out.println("Processing via Cash")
);
String chosen = "UPI";
paymentStrategies.get(chosen).run(); // Output: Processing via UPIPo: “This is amazing! It’s like picking dumplings from a basket, but each dumpling is a deadly move.”
Shifu: “Exactly. The Strategy was never about the class, Po. It was about choosing the right move at the right moment… effortlessly.”
One move=One lambda.
The good part is this lambda only holds the move details nothing else. So any warrior can master these moves , to apply the move unnecessary he does not need to reference a bounded object which wrapped this move in a boilerplate class.
Final Words of Wisdom
“The strength of a great developer lies not in how many patterns they know… but in how effortlessly they flow between object thinking and function weaving to craft code that adapts like water, yet strikes like steel.”-- Master Shifu, on the Tao of Design Patterns.
Coming Up in the Series
- Part 2: Code of Shadows:Mastering Decorator Pattern in Java – Po & Shifu’s Thriller Story of Clean Code
- Part 3: The Command Pattern – When Po Orders Actions like Takeout .
- Part 4: Template Method – Recipes for Reuse and Inner Peace
- Part 5: Filter Chain – Training Montage for Cleaner APIs
Posts
