java实现业务逻辑 java开发逻辑

1、开闭原则（Open Close Principle）

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

package com.principle.lsp;

/**
 * 四边形接口
* @Author : liyang
* Description
* @Date : 14:48 2017/12/28
*/
public interface Quadrangle {
    public long getWidth();

    public long getHeigth();

}


package com.principle.lsp;

/**
 *
 * 长方形是四边形的子类
* @Author : liyang
* Description
* @Date : 14:49 2017/12/28
*/
public class Rectangle  implements Quadrangle{
    private long width;
    private long heigth;

    @Override
    public long getWidth() {
        return width;
    }

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

    @Override
    public long getHeigth() {
        return heigth;
    }

    public void setHeigth(long heigth) {
        this.heigth = heigth;
    }
}


package com.principle.lsp;


/**
 *
 * 正方形是四边形的子类，具有赋值方法
* @Author : liyang
* Description
* @Date : 14:56 2017/12/28
*/
public class Square implements Quadrangle {
    private long side;

    public long getSide(){
        return this.side;
    }
    public void setSide(long side){
        this.side = side;
    }

    @Override
    public long getWidth() {
        return getSide();
    }

    @Override
    public long getHeigth() {
        return getSide();
    }
}


package com.principle.lsp;


/**
 * 里氏代换原则(Liskov Substitution Principle, LSP)
 * 子类可以扩展父类的功能，但不能改变父类原有的功能。
 *
 * 基类Quadrangle类没有赋值方法。因此上面的resize()方法不可能适用于Quadrangle类型，
 * 而只能适用于不同的具体子类Rectangle和Square
* @Author : liyang
* Description
* @Date : 11:48 2017/12/28
*/
public class TestCenter {

    //将长方形变为正方形
    public static void resize(Rectangle r){
        while(r.getWidth()<=r.getHeigth()){
            r.setWidth(r.getWidth()+1);
        }
    }

    public static void main(String[] args) {
        Rectangle r = new Rectangle();
        r.setWidth(1541);
        r.setHeigth(522);
        resize(r);
        System.out.println(r.getWidth());

    }
}

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（Demeter Principle）

为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、单一职责原则(Single Responsibility Principle, SRP)

一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。单一职责原则告诉我们：一个类不能太“累”！在软件系统中，一个类（大到模块，小到方法）承担的职责越多，它被复用的可能性就越小，而且一个类承担的职责过多，就相当于将这些职责耦合在一起，当其中一个职责变化时，可能会影响其他职责的运作，因此要将这些职责进行分离，将不同的职责封装在不同的类中，即将不同的变化原因封装在不同的类中，如果多个职责总是同时发生改变则可将它们封装在同一类中。

package com.principle.srp;

public interface FatherInterface {

    public void gotoWork();
    public void gotoCleanHome();

}

package com.principle.srp;

public interface MotherInterface {

    public void gotoLunch();
    public void gotoDinner();

}


package com.principle.srp;

public class Son implements FatherInterface, MotherInterface {

    @Override
    public void gotoLunch() {
        System.out.println("mather lunch");
    }

    @Override
    public void gotoDinner() {
        System.out.println("mather dinner");

    }

    @Override
    public void gotoWork() {
        System.out.println("father Workr");

    }

    @Override
    public void gotoCleanHome() {
        System.out.println("father clean home");
    }


}

package com.principle.srp;

public class Son1 implements MotherInterface {


    @Override
    public void gotoLunch() {
        System.out.println("learn mother goto lunch");
    }

    @Override
    public void gotoDinner() {
        System.out.println("learn mother goto dinner");
    }
}


package  com.principle.srp;
/**
 * 单一性原则   Single responsibility principle
 * 尽量一个接口、类完成一个功能，这样的话后续扩展比较容易，代码可阅读行也会提高
* @Author : liyang
* Description
* @Date : 10:48 2017/12/28
*/
public class TestCenter {

    public static void main(String[] args) {
        FatherInterface fatherInterface;
        MotherInterface motherInterfacel;
        Son son =new Son();
        fatherInterface = son;
        motherInterfacel = son;
        fatherInterface.gotoWork();
        fatherInterface.gotoCleanHome();
        motherInterfacel.gotoLunch();
        motherInterfacel.gotoDinner();

        Son1 son1 = new Son1();
        motherInterfacel = son1;
        motherInterfacel.gotoLunch();
        motherInterfacel.gotoDinner();
    }

}

（更新中。。。）