- 1.单一职责原则
- 2.接口隔离原则
- 3.依赖倒转(倒置)原则
- 4.里氏替换原则
- 5.开闭原则
- 6.迪米特法则
- 7.合成复用原则
一、单一职责原则
- 一个类应该只负责一项职责。
- 这一点是关于类的粒度的描述。
- 降低类的复杂度，一个类只负责一项职责
- 提高类的可读性，可维护性
- 降低变更引起的风险
- 通常情况下，我们应当遵循单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则。
二、 接口隔离原则
- 客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上
- 如下代码，在Class1和Class2在实现接口时，两个类中均存在了冗余的未实现方法，不满足接口隔离原则。
// 未优化
interface Interface{
public void function1();
public void function2();
public void function3();
}
class Class1 implements Interface{
@Override
public void function1() {
System.out.println("I have function1");
}
@Override
public void function2() {
System.out.println("I have function2");
}
@Override
public void function3() {
/*
* void
* */
}
}
class Class2 implements Interface{
@Override
public void function1() {
/*
* void
* */
}
@Override
public void function2() {
/*
* void
* */
}
@Override
public void function3() {
System.out.println("I have function3");
}
}
// 优化后
interface Interface1{
public void function1();
public void function2();
}
interface Interface2{
public void function3();
}
class Class1 implements Interface1{
@Override
public void function1() {
System.out.println("I have function1");
}
@Override
public void function2() {
System.out.println("I have function2");
}
}
class Class2 implements Interface2{
@Override
public void function3() {
System.out.println("I have function3");
}
}
三、依赖倒转原则
- 高层模块不应该依赖低层模块，二者都应该依赖其抽象；
- 抽象不应该依赖细节，细节应该依赖抽象；
- 依赖倒转中心思想是面向接口编程；
- 依赖倒置原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或者抽象类，细节就是具体的实现类。
- 使用接口或抽象类的目的是要定制好规范，而不涉及任何的具体的操作，把展现细节任务交给他们的实现类去完成
// 方式一
public class DependecyInversion {
public static void main(String[] args) {
Person person = new Person();
person.receive(new Email());
}
}
class Email{
public String getInfo(){
return "电子邮件的信息： Hello,world";
}
}
// 完成Person接收消息的功能
// 方式1分析
// 1.简单，比较容易想到
// 2.如果获取对象是 微信、短信，则新增类，同时Person也要增加相应的接收方法
// 3.解决思路：引入一个抽象的接口IReceiver，表示接收者，这样Person类与接口IReceiver发生依赖
class Person{
public void receive(Email email){
System.out.println(email.getInfo());
}
}
// 方式二
public class DependecyInversion2 {
public static void main(String[] args) {
Person person = new Person();
person.receive(new Email());
}
}
class Email implements IReceiver{
@Override
public String getInfo(){
return "电子邮件的信息： Hello,world";
}
}
interface IReceiver{
public String getInfo();
}
class Person{
public void receive(Email email){
System.out.println(email.getInfo());
}
}
依赖传递的三种方式
依赖倒转原则的注意事项和细节
- 底层模块尽量都要抽象类或者接口，或者两者都有，程序稳定性更好；
- 变量的声明类型尽量是抽象类和接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利用程序扩展和优化。
四、里氏替换原则
- 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。
- 在子类中尽量不要重写父类的方法，因为继承会形成一种较强的耦合度，因此在适当情况下，可以使用 聚合、组合、依赖 来解决问题。
五、开闭原则
- 开闭原则是编程中最基础、最重要的设计原则；
- 一个软件实体如类，模块和函数应该对扩展开放（对提供方），对修改关闭（使用方）；
- 用抽象构建框架，用实现扩展细节；
- 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化；
六、迪米特法则
- 一个对象应该对其他对象保持最少的了解；
- 类与类关系越密切，耦合度越大；
- 迪米特法则，即一个类对自己依赖的类知道的越少越好。对于被依赖的类不管多复杂，都尽量将逻辑封装在类的内部。对外通过public来提供信息。
七、合成复用原则
网友评论