面向對象的基本原則

一、單一職責原則

單一職責原則指的是一個類或方法應該只有一個單一的功能或責任。這可以使得代碼更加清晰易懂，更加易於維護和擴展。

例如，下面是一個單一職責原則的代碼示例：

class Car {
   private String make;
   private String model;
   private Engine engine;

   public void start() {
      engine.turnOn();
   }

   public void stop() {
      engine.turnOff();
   }
}

class Engine {
   private int cylinders;
   private boolean running;

   public void turnOn() {
      running = true;
   }

   public void turnOff() {
      running = false;
   }
}

在這個示例中，Car和Engine兩個類分別只負責車的行駛和引擎的啟動和停止，各自擁有自己的職責，從而使得代碼更加清晰易懂。

二、開閉原則

開閉原則指的是一個類或方法應該對於擴展是開放的，對於修改是關閉的。這可以使得代碼更加穩定，更加易於維護和擴展。

例如，下面是一個開閉原則的代碼示例：

interface Shape {
   public double getArea();
}

class Rectangle implements Shape {
   private double length;
   private double width;

   public double getArea() {
      return length * width;
   }
}

class Circle implements Shape {
   private double radius;

   public double getArea() {
      return Math.PI * radius * radius;
   }
}

class AreaCalculator {
   public double calculateArea(Shape shape) {
      return shape.getArea();
   }
}

在這個示例中，Shape接口為開放的，我們可以根據需要擴展它的實現類，而AreaCalculator只負責計算各種圖形的面積，不需要修改它的代碼就可以擴展新的圖形。

三、里式替換原則

里式替換原則指的是一個子類應該可以替換它的父類，而不會影響程序的正確性。這可以使得代碼更加靈活，更加易於擴展和重用。

例如，下面是一個里式替換原則的代碼示例：

class Rectangle {
   protected int length;
   protected int width;

   public void setWidth(int width) {
      this.width = width;
   }

   public void setLength(int length) {
      this.length = length;
   }

   public int getArea() {
      return length * width;
   }
}

class Square extends Rectangle {
   public void setWidth(int width) {
      this.width = width;
      this.length = width;
   }

   public void setLength(int length) {
      this.length = length;
      this.width = length;
   }
}

在這個示例中，Square類繼承自Rectangle類，但是重寫了setWidth和setLength方法，從而實現了正方形的特性。這樣，我們可以直接用Square對象替換Rectangle對象，而不會影響程序的正確性。

四、接口隔離原則

接口隔離原則指的是一個類或方法應該只依賴於它需要的接口，而不需要依賴於它不需要的接口。這可以使得代碼更加靈活，更加易於擴展和重用。

例如，下面是一個接口隔離原則的代碼示例：

interface Animal {
   public void eat();
   public void sleep();
}

interface Bird extends Animal {
   public void fly();
}

class Sparrow implements Bird {
   public void eat() { /* ... */ }
   public void sleep() { /* ... */ }
   public void fly() { /* ... */ }
}

在這個示例中，Animal接口包含eat和sleep方法，而Bird接口繼承了Animal接口，並增加了fly方法。Sparrow類實現了Bird接口，只依賴於eat、sleep和fly方法，而不需要依賴於Animal中不需要的方法。

五、依賴倒置原則

依賴倒置原則指的是抽象不應該依賴於細節，細節應該依賴於抽象。這可以使得代碼更加靈活，更加易於擴展和重用。

例如，下面是一個依賴倒置原則的代碼示例：

interface Logger {
   public void log(String message);
}

class DatabaseLogger implements Logger {
   public void log(String message) { /* ... */ }
}

class FileLogger implements Logger {
   public void log(String message) { /* ... */ }
}

class Service {
   private Logger logger;

   public void setLogger(Logger logger) {
      this.logger = logger;
   }

   public void doSomething() {
      logger.log("Something is being done");
   }
}

在這個示例中，Service類依賴於Logger接口而不依賴於具體的Logger實現類。通過設置不同的Logger實現類，可以實現不同的日誌記錄方式。