设计模式中的设计原则

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

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");
    }
}