单一职责原则

定义

就一个类而言,应该只有一个引起它变化的原因,简而言之就是一个类只负责一件事情,将强关联性的聚合到一个类中

实例

//原始案例
public interface IUserInfo {
    void getId();
    void setId(int id);
    void getName();
    void setName(String name);
    void getPassword();
    void setPassword(String password);

    void addUser(int id, String name, String password);
    void deleteUser(int id);
}

这种情况下类的业务逻辑和业务对象放在一个接口中

//更改后
public interface IUserBo {
    void getId();
    void setId(int id);
    void getName();
    void setName(String name);
    void getPassword();
    void setPassword(String password);
}
public interface IUserBiz {
    void addUser(int id, String name, String password);
    void deleteUser(int id);
}

将User的接口分为两个接口,一个存放User的属性,另一个作为User对象调用

优点

1.类的复杂性降低,使用单一职责原则每个类的职责清楚明确
2.提高代码的可读性，降低代码的负责度

开闭原则

定义

一个软件实体如类，模块和函数应该对扩展开放，对修改关闭（一个软件应对扩展开放对修改关闭，软件通过扩展进行修改）

实例

//学生实例类
public class Student {
    private String name;
    private String grade;
    public Student(String name, String grade) {
        this.name = name;
        this.grade = grade;
    }
    public String getName() {
        return name;
    }
    public String getGrade() {
        return grade;
    }
}
//教师类
public class Teacher {
    public final static List<Student> students = new ArrayList<Student>();
    static {
        students.add(new Student("张三", "60"));
        students.add(new Student("李四", "70"));
        students.add(new Student("王五", "80"));
    }
}
//测试类
public class Client {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        for (Student student : teacher.students) {
            System.out.println("姓名：" + student.getName() + " 成绩：" + student.getGrade());
        }
    }
}

如果改变需求，将学生成绩改为等级，通常情况下直接改变学生类中的getGrade()方法，但是这样做违反了开闭原则，因此我们需要实现对Student类的扩展

//扩展类
public class StudentExp extends Student{

    public StudentExp(String name, String grade) {
        super(name, grade);
    }

    //覆盖Student中的方法
    @Override
    public String getGrade() {
        String level=null;
        int gradeExp=Integer.valueOf(super.getGrade());
        if (gradeExp >= 90) {
            level = "优秀";
        } else if (gradeExp >= 80 && gradeExp < 90) {
            level = "良好";
        } else if (gradeExp >= 70 && gradeExp < 80) {
            level = "一般";
        } else if (gradeExp >= 60 && gradeExp < 70) {
            level = "及格";
        } else if (gradeExp < 60) {
            level = "不及格";
        }
        return level;
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        for (Student student : teacher.students) {
            student=new StudentExp(student.getName(),student.getGrade());
            System.out.println("姓名：" + student.getName() + " 成绩：" + student.getGrade());
        }
    }
}

里氏替换原则

定义

里氏替换原则：所有应用基类(父类)的地方必须透明的使用其子类的对象

实例

public class A {
    public void fun(int a,int b){
        System.out.println(a+"+"+b+"="+(a+b));
    }
}
 
public class B extends A{
    @Override
    public void fun(int a,int b){
        System.out.println(a+"-"+b+"="+(a-b));
    }
}
 
public class demo {
    public static void main(String[] args){
        System.out.println("父类的运行结果");
        A a=new A();
        a.fun(1,2);
        //父类存在的地方，可以用子类替代
        //子类B替代父类A
        System.out.println("子类替代父类后的运行结果");
        B b=new B();
        b.fun(1,2);
    }
}

注意点

1.子类的所有方法必须在父类中声明，或子类必须实现父类中的说有方法
2.在使用里氏替换原则时尽量把父类设置为抽象类或者接口，并实现在父类中声明的方法，运行时子类实例替换父类实例，我们可以很方便地扩展系统的功能，同时无须修改原有子类的代码，增加新的功能可以通过增加一个新的子类来实现

参考

http://tianweili.github.io/blog/2015/02/15/open-close-principle