7大设计原则
单一职责（Signle Responsibility Principle）
- 降低类的复杂度，一个类只负责一项职责
- 提高类的可读性，可维护性
- 降低变更引起的风险
- 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则，只有类中方法数量足够少，可以在方法级保持单一职责原则
package com.zho.test.single_responsibility;
import java.util.Vector;
public class SingleResponsibility1 {
public static void main(String[] args) {
Vehicle roadVehicle = new RoadVehicle();
roadVehicle.run("摩托车");
Vehicle airVehicle = new AirVehicle();
airVehicle.run("飞机");
Vehicle waterVehicle = new WaterVehicle();
waterVehicle.run("船");
}
}
//交通工具类
interface Vehicle {
public void run(String vehicle);
}
class RoadVehicle implements Vehicle {
@Override
public void run(String vehicle) {
System.out.println(vehicle + "在公路运行");
}
}
class AirVehicle implements Vehicle {
@Override
public void run(String vehicle) {
System.out.println(vehicle + "在天上飞");
}
}
class WaterVehicle implements Vehicle {
@Override
public void run(String vehicle) {
System.out.println(vehicle + "在水里跑");
}
}
接口隔离原则 (Interface Segregation Principle)
客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上
public class InterfaceSegregation1 {
public static void main(String[] args) {
A a = new A();
//A类通过接口去依赖B类
a.depend1(new B());
a.depend2(new B());
a.depend3(new B());
C c = new C();
//C类通过接口去依赖D类
c.depend1(new D());
c.depend4(new D());
c.depend5(new D());
}
}
//接口1
interface Interface1 {
void operation1();
}
//接口2
interface Interface2 {
void operation2();
void operation3();
}
//接口3
interface Interface3 {
void operation4();
void operation5();
}
class B implements Interface1, Interface2 {
@Override
public void operation1() {
System.out.println("B 实现了 operation1");
}
@Override
public void operation2() {
System.out.println("B 实现了 operation2");
}
@Override
public void operation3() {
System.out.println("B 实现了 operation3");
}
}
class D implements Interface1, Interface3 {
@Override
public void operation1() {
System.out.println("D 实现了 operation1");
}
@Override
public void operation4() {
System.out.println("D 实现了 operation4");
}
@Override
public void operation5() {
System.out.println("D 实现了 operation5");
}
}
class A {//A类通过接口Interface1,Interface2 依赖B类，但是只会用到1，2，3 方法
public void depend1(Interface1 i) {
i.operation1();
}
public void depend2(Interface2 i) {
i.operation2();
}
public void depend3(Interface2 i) {
i.operation3();
}
}
class C { //C类通过接口Interface1，Interface3 依赖D类， 但是只会用刮刀1，4，5方法
public void depend1(Interface1 i) {
i.operation1();
}
public void depend4(Interface3 i) {
i.operation4();
}
public void depend5(Interface3 i) {
i.operation5();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5DAjKxmM-1600670830917)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\image-20200921084947391.png)]
依赖倒转原则 (Dependence Inversion Principle)
- 高层模块不应该依赖底层模块，二者都应该依赖器抽象
- 抽象不应该依赖细节，细节应该依赖抽象
- 依赖倒转的中心思想是面向接口编程
- 依赖倒转原则是基于这样的设计理念： 相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类
- 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成
public class DependenceInversion1 {
public static void main(String[] args) {
Person person = new Person();
person.receive(new Email());
}
}
//完成Person接受消息的功能
interface Info {
String getInfo();
}
class Email implements Info {
@Override
public String getInfo() {
return "电子邮件信息: hello Email";
}
}
class Person {
public void receive(Info info) {
System.out.println(info.getInfo());
}
}
//通过构造方法依赖传递
interface IOpenAndClose {
void open();
}
interface ITV{ // ITV接口
void play();
}
class OpenAndClose implements IOpenAndClose {
public ITV itv;
public OpenAndClose(ITV itv) {
this.itv = itv;
}
@Override
public void open() {
this.itv.play();
}
}
class ChangHong implements ITV {
@Override
public void play() {
System.out.println("长虹电视机打开了");
}
}
//通过构造方法依赖传递
public static void func2() {
ChangHong changHong = new ChangHong();
OpenAndClose openAndClose = new OpenAndClose(changHong);
openAndClose.open();
}
//通过setter方法传递
interface IOpenAndClose {
void open();
void setTv(ITV itv);
}
interface ITV {
void play();
}
class OpenAndClose implements IOpenAndClose {
private ITV itv;
@Override
public void open() {
this.itv.play();
}
@Override
public void setTv(ITV itv) {
this.itv = itv;
}
}
class ChangHong implements ITV {
@Override
public void play() {
System.out.println("长虹电视机打开了");
}
}
//通过setter方法传递
public static void func3() {
OpenAndClose openAndClose = new OpenAndClose();
openAndClose.setTv(new ChangHong());
openAndClose.open();
}
里氏替换原则 （Lishov Substitution Principle）
OO总的继承性的思考和说明
- 继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有子类必须遵守这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏
- 继承在给程序设计带来便利的同时，也带来了弊端，比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他类所继承，则当这个类需要修改时，必须考虑到所有子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障
里氏替换原则
- 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2时类型T1的子类型，换句话说，所有引用基类的地方必须能透明的使用其子类的对象
- 在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法
- 里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题
public class LiskovSubstitution1 {
public static void main(String[] args) {
A a = new A();
System.out.println("11 - 3 = " + a.func1(11, 3));
System.out.println("1 - 8 = " + a.func1(1, 8));
System.out.println("--------------------");
B b = new B();
System.out.println("11 - 3 = " + b.func1(11, 3));
System.out.println("1 - 8 = " + b.func1(1, 8));
System.out.println("11 + 3 + 9 = " + b.func2(11, 3));
}
}
class A {
public int func1(int a, int b) {
return a - b;
}
}
//增加了一个新功能：完成两个类相加，然后和9求和 （本意）
class B extends A {
//这里重写了A类的方法，可能是无意识的
public int func1(int a, int b) {
return a + b;
}
public int func2(int a, int b) {
return func1(a, b) + 9;
}
}
我们发现原来运行正常的相减功能发生了错误，原因就是类B无意间重写了父类的方法，造成原有功能出现错误，在实际编程中，我们常常会通过重写父类的方法完成新的功能，这样写起来虽然简单，但整个继承体系的复用性就会比较差，特别是运行多态比较频繁的时候
通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合等关系替代
public class LiskovSubstitution1 {
public static void main(String[] args) {
A a = new A();
System.out.println("11 - 3 = " + a.func1(11, 3));
System.out.println("1 - 8 = " + a.func1(1, 8));
System.out.println("--------------------");
B b = new B();
//因为B类不再继承A类，因此调用者不再认为func1是求减方法
System.out.println("11 + 3 = " + b.func1(11, 3));
System.out.println("1 + 8 = " + b.func1(1, 8));
System.out.println("11 + 3 + 9 = " + b.func2(11, 3));
//使用组合仍然可以使用到A类相关方法
System.out.println("11 - 3 = " + b.func3(11, 3));
}
}
//创建一个更加基础的基类
class Base {
}
class A extends Base {
public int func1(int a, int b) {
return a - b;
}
}
//增加了一个新功能：完成两个类相加，然后和9求和 （本意）
class B extends Base {
//如果B需要使用A类的方法，使用组合关系
private A a = new A();
//这里重写了A类的方法，可能是无意识
public int func1(int a, int b) {
return a + b;
}
public int func2(int a, int b) {
return func1(a, b) + 9;
}
//我们仍然想使用A的方法
public int func3(int a, int b) {
return this.a.func1(a, b);
}
}
开闭原则 (Open Closed Principle)
- 一个软件实现如类，模块和函数应该对扩展开放，对修改关闭，用抽象构建框架，用实现扩展细节
- 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是铜鼓哦修改已有的代码来实现变化
public class OpenClosed1 {
public static void main(String[] args) {
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawShape(new Rectangle());
graphicEditor.drawShape(new Circle());
graphicEditor.drawShape(new Triangle());
graphicEditor.drawShape(new OtherGraphic());
}
}
abstract class Shape {
int m_type;
public abstract void draw();
}
class GraphicEditor {
public void drawShape(Shape s) {
s.draw();
}
}
class Rectangle extends Shape {
Rectangle() {
super.m_type = 1;
}
@Override
public void draw() {
System.out.println("绘制矩形");
}
}
class Circle extends Shape {
Circle() {
super.m_type = 2;
}
@Override
public void draw() {
System.out.println("绘制圆形");
}
}
class Triangle extends Shape {
Triangle() {
super.m_type = 3;
}
@Override
public void draw() {
System.out.println("绘制三角形");
}
}
//新增一个图形
class OtherGraphic extends Shape {
@Override
public void draw() {
System.out.println("绘制其他图形");
}
}
迪米特法则 (Demeter Principle)
- 一个对象应该对其他对象保持最少的了解
- 类与类关系越密切，耦合度越大
- 迪米特法则又叫最小知道原则，即一个类对自己依赖的类知道的越少越好，也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部，对外除了提供的public方法，不对外泄露任何信息
- 迪米特法则还有个更简单的定义，只与直接的朋友通信
- 直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系，耦合的方式很多，依赖，关联，组合，聚合等，其中，我们中出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友，也就是说，陌生的类最好不要以局部变量的形式出现在类的内部
//有一个学校，下属有各个学院和总部，
//现要求打印出学校总部员工id和学院员工的id
public class Demeter1 {
public static void main(String[] args) {
SchoolManager schoolManager = new SchoolManager();
schoolManager.printAllEmployee(new CollegeManager());
}
}
//学校总部员工
class Employee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
//学院员工
class CollegeEmployee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
//管理学院员工的管理类
class CollegeManager {
public List<CollegeEmployee> getAllEmployee() {
ArrayList<CollegeEmployee> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
CollegeEmployee emp = new CollegeEmployee();
emp.setId("学院员工id = " + i);
list.add(emp);
}
return list;
}
}
class SchoolManager {
public List<Employee> getAllEmployee() {
List<Employee> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
Employee emp = new Employee();
emp.setId("学校总部员工id = " + i);
list.add(emp);
}
return list;
}
void printAllEmployee(CollegeManager collegeManager) {
//1、这里的CollegeEmployee不是SchoolManager的直接朋友
//2、CollegeEmployee 是以局部变量的方式出现在SchoolManager中
List<CollegeEmployee> list1 = collegeManager.getAllEmployee();
System.out.println("------分公司员工--------");
for (CollegeEmployee collegeEmployee : list1) {
System.out.println(collegeEmployee.getId());
}
List<Employee> list2 = this.getAllEmployee();
System.out.println("-------学校总部员工--------");
list2.forEach(c -> {
System.out.println(c.getId());
});
}
}
改进
//有一个学校，下属有各个学院和总部，
//现要求打印出学校总部员工id和学院员工的id
public class Demeter1 {
public static void main(String[] args) {
SchoolManager schoolManager = new SchoolManager();
schoolManager.printAllEmployee(new CollegeManager());
}
}
//学校总部员工
class Employee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
//学院员工
class CollegeEmployee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
//管理学院员工的管理类
class CollegeManager {
public List<CollegeEmployee> getAllEmployee() {
ArrayList<CollegeEmployee> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
CollegeEmployee emp = new CollegeEmployee();
emp.setId("学院员工id = " + i);
list.add(emp);
}
return list;
}
//输出学院员工的信息
public void printEmployee() {
List<CollegeEmployee> list1 = this.getAllEmployee();
System.out.println("------分公司员工--------");
for (CollegeEmployee collegeEmployee : list1) {
System.out.println(collegeEmployee.getId());
}
}
}
class SchoolManager {
public List<Employee> getAllEmployee() {
List<Employee> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
Employee emp = new Employee();
emp.setId("学校总部员工id = " + i);
list.add(emp);
}
return list;
}
void printAllEmployee(CollegeManager collegeManager) {
//1 将输出学院的员工方法，封装到CollegeManager
collegeManager.printEmployee();
List<Employee> list2 = this.getAllEmployee();
System.out.println("-------学校总部员工--------");
list2.forEach(c -> {
System.out.println(c.getId());
});
}
}
合成复用原则 (Composite Reuse Principle)
原则是尽量使用合成/聚合的方式，而不是使用继承
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
