一、单一职责原则

单一职责原则指的是一个类或方法应该只有一个单一的功能或责任。这可以使得代码更加清晰易懂，更加易于维护和扩展。 例如，下面是一个单一职责原则的代码示例：

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实现类，可以实现不同的日志记录方式。