开闭原则：扩展新的功能但不改变原有的程序设计。

public class test {public static void main(String[] args) {Car benz = new Car("Benz");benz.driver();//我们需要扩展方法benz.driver180();}
}
class Car{private String name;public Car(String name){this.name = name;}public void driver(){System.out.println("我最大速度是：120km/h");}//不改变原有的代码扩展新的方法public void driver180(){System.out.println("我最大速度是：180km/h");}
}

单一职责原则：一个类只干好一方面，专心做好一件事，不使代码臃肿。

//单一原则
//汽车、轮船、飞机还可继续细分，违背单一原则
class Vehicle {public void run(String type) {if (type.equals("car")) {System.out.println("在公路上行走。。。");} else if (type.equals("steamship")) {System.out.println("在水面上运行。。。。");} else if (type.equals("plane")) {System.out.println("在天空上飞行");}}
}//分化为单一模块
class CarVehicle {public void run() {System.out.println("在公路上行走。。。");}
}
class SteamshipVehicle {public void run() {System.out.println("在水面上运行。。。。");}
}
class PlaneVehicle {public void run() {System.out.println("在天空上飞行");}
}

接口隔离原则：一个接口之中只做该接口需要的相关的功能，类似单一原则，不使代码臃肿

//接口隔离原则
//接口中定义的所有方法都是抽象方法，实现类需要实现接口中所有的抽象方法，不管需不需要
interface DataHandler {void save(String data);void load(String data);String getData();void setData(String data);void test(String data);
}
//实现类并不需要实现接口中所有的抽象方法，只需要实现接口中需要的方法即可，所以上面接口违背了接口隔离原则
class UserData implements DataHandler{public void save(String data) {}public void load(String data) {}public String getData() {return null;}public void setData(String data) {}public void test(String data) {}
}

//我们可以把当前接口用不到的功能，定义给需要的接口
interface DataHandler2{String getData();void setData(String data);void test(String data);
}
//实现类不会有冗余
class UserData implements DataHandler2{public String getData() {return null;}public void setData(String data) {}public void test(String data) {}
}

 里氏替换法：在有继承关系的代码开发中，如果需要进行功能的扩展，不要再子类中改变父类中已经实现的方法，而是通过新增方法来扩展父类的功能。

//不改变父类
class Caculate{private long height;private long width;public void setHeight(long height){this.height = height;}public void setWidth(long width){this.width = width;}public long getArea(){return height + width;}}
//子类扩展需要方法
class Rectangle extends Caculate{private long height;private long width;public void setWidth(long width){this.width = width;}public void setheight(long height){this.height = height;}public long getArea(){return super.getArea() + height;}//需要扩展的代码public long getArea2(){return super.getArea() * height;}
}

依赖倒置法：我们定义类的成员变量、参数类型、返回值类型的时候，不要写某一个具体的类而是尽可能采用接口或者抽象类，这样后续如果我们修改，很显然不需要改动这些代码，而只需要增加实现类就可以了。

package test.ep;public class test {public static void main(String[] args) {Liming liming = new Liming();//引用指向接口，实际使用实现类liming.study(new EngilshCourse());}
}
class Liming{public void study(Course c) {c.study();}
}
//定义为接口
interface Course{public void study();
}
//需要增加的业务，扩展的功能，只要实现并扩展。
class EngilshCourse implements Course{public void study() {System.out.println("study english");}
}class MathCourse implements Course{public void study() {System.out.println("study math");}
}