设计模式02

七大设计原则

开闭原则

依赖倒置原则

单一职责原则

接口隔离原则

迪米特法则

里氏替换原则

组合复用原则

开闭原则

一个软件实体如类，模块和函数应该对扩展开放，对修改关闭
用抽象构建框架，用实现扩展细节
优点：提供软件系统的可复用性及可维护性

举例：打折活动

Icourse

public interface ICourse {
    Integer getId();
    String  getName();
    Double getPrice();

}

JavaCourse

public class JavaCourse implements ICourse {

    private  Integer Id;
    private String name;
    private Double price;

    public JavaCourse(Integer id, String name, Double price) {
        this.Id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public Integer getId() {
        return this.Id;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Double getPrice() {
        return this.price;
    }


}

JavaDiscountCourse

public class JavaDiscountCourse extends  JavaCourse {

    public JavaDiscountCourse(Integer id, String name, Double price) {
        super(id, name, price);
    }

    public Double getOriginPrice(){
        return super.getPrice();
    }

    public Double getPrice(){
        return super.getPrice()*0.8;

    }

}

Test

public class Test {

    public static void main(String[] args) {

        ICourse iCourse = new JavaDiscountCourse(1,"java",200d);
        JavaDiscountCourse javaCourse = (JavaDiscountCourse)iCourse;

        System.out.println("id:"+javaCourse.getId()+
                            "名称:"+javaCourse.getName()+
                            "课程原价"+javaCourse.getOriginPrice()+
                            "价格:"+javaCourse.getPrice());

    }
}

DIagram 如图

依赖倒置原则

高层模块不应该依赖于低层模块，两者应该依赖其抽象
抽象不应该依赖细节，细节应该依赖抽象
针对接口编程，不要针对实现编程

可以减少类间的耦合性，提高系统稳定性，提高代码可读性和可维护性,降低修改程序所造成的风险

Buil

public class Buil {
    /**
     * 扩展性差，不应该针对实现编程
     */

    public void StudyJavaCourse(){
        System.out.println("bill 在学习java课程");
    }


    public void StudyVueCourse(){
        System.out.println("buil 在学习vue课程");
    }

}

Test

public class Test {

    public static void main(String[] args) {
        Buil buil = new Buil();
        buil.StudyJavaCourse();
        buil.StudyVueCourse();
    }

}

Test的实现依赖于Buil的实现，高层西模块依赖于底层次模块

@通过接口方法的方式注入具体的实现

ICourse

public interface ICourse {

    void StudyCourse();

}

JavaCourse

public class JavaCourse implements  ICourse{

    @Override
    public void StudyCourse() {
        System.out.println("Buil在学习java课程");
    }

}

VueCourse

public class VueCourse implements ICourse {
    @Override
    public void StudyCourse() {
        System.out.println("Buil在学习vue课程");
    }

}

Buil

public class Buil {


    public void studyCourses (ICourse iCourse){
        iCourse.StudyCourse();
    }

}

Test

public class Test {


    public static void main(String[] args) {
        Buil buil = new Buil();
        buil.studyCourses(new JavaCourse());
        buil.studyCourses(new VueCourse());

    }

}

Diagram：

 @通过构造器方注入具体的实现

Buil

public class Buil {

    private ICourse iCourse;

    public Buil(ICourse iCourse){
        this.iCourse = iCourse;
    }

    public void studyCourses (){
        iCourse.StudyCourse();
    }

}

Test

public class Test {


    public static void main(String[] args) {
        Buil buil = new Buil(new JavaCourse());
        buil.studyCourses();
    }

}

setter注入

public class Buil {

    public ICourse iCourse;

    public void setiCourse(ICourse iCourse) {
        this.iCourse = iCourse;
    }

    public void studyCourses (){
        iCourse.StudyCourse();
    }

}

Test

public class Test {


    public static void main(String[] args) {
        Buil buil = new Buil();
        buil.setiCourse(new JavaCourse());
        buil.studyCourses();

        buil.setiCourse(new VueCourse());
        buil.studyCourses();

    }

}

Diagram：

单一职责原则

不要存在多于一个导致类变更的原因
一个类/接口/方法只负责一项职责
优点：降低类的复杂度，提高类的可读性，提高系统的可维护性，变更时风险率降低

FlyBird

public class FlyBird {

    public void mainMoveMode(String birdName) {
            System.out.println(birdName + "用翅膀飞");
        }

}

Workbird

public class WalkBird {

    public void mainMoveMode(String birdName) {
        if ("鸵鸟".equals(birdName)) {
            System.out.println(birdName + "用脚走");
        }

    }

}

Test

public class Test {

    public static void main(String[] args) {
        FlyBird flyBird = new FlyBird();
        flyBird.mainMoveMode("大雁");

        WalkBird walkBird = new WalkBird();
        walkBird.mainMoveMode("鸵鸟");

    }

}

Diagram

接口级别的单一职责

ICourseContent

public interface ICourseContent {

    String getCourseName();
    byte[] getCourseVideo();

}

ICourseManager

public interface ICourseManager {

    void studyCourse();
    void refundCourse();


}

CourseImpl

public class CourseImpl implements ICourseContent,ICourseManager {

    @Override
    public String getCourseName() {
        return null;
    }

    @Override
    public byte[] getCourseVideo() {
        return new byte[0];
    }

    @Override
    public void studyCourse() {

    }

    @Override
    public void refundCourse() {

    }
}

Diagram

方法级别的单一职责

public class Method {

    private void updateUserInfo(String userName,String address){
        userName = "Buil";
        address = "beijing";
    }

    private void updateUserName(String userName,String address){
        userName = "Buil";
    }
    
    private void updateUserAddress(String userName,String address){
        address = "beijing";
    }

    private void updateUserInfo(String userName,String... properties){
        userName = "Buil";
    }



}

未完待续