Clojure新手技术咨询：能否在该语言中构建Class Hierarchy？

Hey there! As someone who's navigated the shift from OOP to Clojure, I totally get why you'd ask about class hierarchies—it’s natural to look for familiar patterns when starting out. The short answer is: Clojure doesn’t have traditional abstract classes, interfaces, or class inheritance (it’s a functional-first language, after all), but it has idiomatic tools that let you achieve the same goals like abstraction and polymorphism in a more flexible way. Let’s break down the key alternatives:

1. Protocols：模拟Interfaces的核心工具 #

Protocols are Clojure’s equivalent of interfaces—they define abstract method signatures that any type can implement. You can call these methods on any instance that satisfies the protocol, just like you’d use an interface in OOP.

Example:

;; Define a protocol (like an interface)
(defprotocol Shape
  (area [this])
  (perimeter [this]))

;; Implement the protocol for a record (think of this as a concrete class)
(defrecord Circle [radius]
  Shape
  (area [this] (* Math/PI (:radius this) (:radius this)))
  (perimeter [this] (* 2 Math/PI (:radius this))))

(defrecord Rectangle [width height]
  Shape
  (area [this] (* (:width this) (:height this)))
  (perimeter [this] (* 2 (+ (:width this) (:height this)))))

;; Use the protocol methods
(area (->Circle 5)) ;; => 78.53981633974483
(perimeter (->Rectangle 3 4)) ;; => 14

Even better—you can extend existing types (like built-in String or Integer) to a protocol using extend-type or extend-protocol, which is way more flexible than OOP’s single inheritance rule.

2. Multimethods：更灵活的多态实现 #

Multimethods take polymorphism a step beyond protocols. Instead of dispatching based on a type, they can use any arbitrary value (a keyword, function result, or custom data structure) to decide which method to run. This is perfect when your logic depends on more than just an object’s type.

Example:

;; Define a multimethod that dispatches on the :type key of a map
(defmulti calculate (fn [shape] (:type shape)))

;; Implement methods for different shape types
(defmethod calculate :circle [shape]
  (* Math/PI (:radius shape) (:radius shape)))

(defmethod calculate :rectangle [shape]
  (* (:width shape) (:height shape)))

;; Use it
(calculate {:type :circle :radius 5}) ;; => 78.53981633974483
(calculate {:type :rectangle :width 3 :height 4}) ;; => 12

3. 模拟Abstract Class的默认行为 #

If you need something like an abstract class with default method implementations, you can combine protocols with helper functions. This lets you reuse common logic while letting concrete implementations override behavior when needed.

Example:

(defprotocol Vehicle
  (start-engine [this])
  (stop-engine [this])
  (drive [this]))

;; Helper function with default start behavior
(defn default-start-engine [vehicle]
  (println (str "Starting " (:model vehicle) " engine...")))

;; Implement the protocol for a Car (default + custom logic)
(defrecord Car [model]
  Vehicle
  (start-engine [this] (default-start-engine this))
  (stop-engine [this] (println (str "Stopping " (:model this) " engine...")))
  (drive [this] (println (str "Cruising in the " (:model this) "!"))))

;; Implement for a Truck (override default start behavior)
(defrecord Truck [model]
  Vehicle
  (start-engine [this] (do (default-start-engine this) (println "Turbo engaged!")))
  (stop-engine [this] (println (str "Shutting down " (:model this) " heavy-duty engine...")))
  (drive [this] (println (str "Hauling cargo with the " (:model this) "!"))))

(start-engine (->Car "Toyota Camry")) ;; Prints "Starting Toyota Camry engine..."
(start-engine (->Truck "Ford F-150")) ;; Prints "Starting Ford F-150 engine..." followed by "Turbo engaged!"

Key Takeaway #

Clojure leans into composition over inheritance—instead of building rigid class hierarchies, you combine small, focused protocols, records, and functions. This approach leads to more flexible, maintainable code that’s easier to adapt as your project grows.

内容的提问来源于stack exchange，提问作者Mishel Uchuari