不懂七大设计原则等于白学软件开发篇
前置介绍
软件开发，不管是前端还是后端，不管你用的是springboot还是django,uniapp还是mpvue，哪怕是数据库连接平台redis、mabits、hibernate,都或多或少用了设计原则。
fafs
你说你不会，不合理呀。
接下来给大家介绍一下我练习后的感悟。 提示：代码注释比较有用哦。
单一职责原则
代码奉上：
package singleresponsbility;
/**
* @author yzq
* @projectName designdemo
* @packageName singleresponsbility ：一个类只能有一种职责 =》一个方法只能有一个职责。
* @data 2020-09-06 09:
*/
public class SingleResponsibility1 {
public static void main(String[] args) {
Vehicle vehicle = new Vehicle();
vehicle.run("飞机");
vehicle.run("汽车");
}
}
/*违反了单一职责原则。
* 解决：
* 根据不同交通方法，分解成不同类
* */
class Vehicle{
public void run(String args) {
System.out.println(args+"在公路上运行");
}
} 改良一
package singleresponsbility;
/**
* @author yzq
* @projectName designdemo
* @packageName singleresponsbility
* @data 2020-09-06 09:
*/
public class SingleResponsibility2 {
public static void main(String[] args) {
Vehicle2 vehicle = new Vehicle2();
vehicle.run("汽车");
Aircle2 aircle2 = new Aircle2();
aircle2.run("飞机");
}
}
/*遵守单一职责原则，但是需要改动测试和执行类。
* 解决：
* 直接改动Vehicle类
* */
class Vehicle2{
public void run(String args) {
System.out.println(args+"在公路上运行");
}
}
class Aircle2{
public void run(String args) {
System.out.println(args+"在公路上运行");
}
} 改良二
package singleresponsbility;
/**
* @author yzq
* @projectName designdemo
* @packageName singleresponsbility
* @data 2020-09-06 09:
*/
public class SingleResponsibility3 {
public static void main(String[] args) {
Vehicle3 vehicle = new Vehicle3();
vehicle.airRun("飞机");
vehicle.run("汽车");
}
}
/*在类上没有遵守单一职责原则，但是在方法上遵守单一职责原则
* 优点：
* 改变代码不大，对增加开发，对修改关闭
* */
class Vehicle3{
public void run(String args) {
System.out.println(args+"在公路上运行");
}
public void airRun(String args) {
System.out.println(args+"在天空运行");
}
public void waterRun(String args) {
System.out.println(args+"在水中运行");
}
} 开闭原则
package opencloseeprinciple;
/**
* @author yzq
* @projectName designdemo
* @packageName opencloseeprinciple
* @described 对拓展开放，对修改关闭 =>将共有方法抽象出接口。
* @data 2020-09-06 14:07
*/
public class OpenClosed1 {
public static void main(String[] args) {
Shape1 circle = new Circle();
Shape1 rectangle = new Rectangle();
new GraphicCreate().drawShape(circle);
new GraphicCreate().drawShape(rectangle);
//添加新的shape对象不改变其他实现类
}
}
class GraphicCreate{
public void drawShape(Shape1 s){
s.drawShape();
}
}
interface Shape1{
public void drawShape();
}
class Circle implements Shape1{
public void drawShape(){
System.out.println("画圆");
}
}
class Rectangle implements Shape1{
public void drawShape(){
System.out.println("画矩");
}
}
里氏置换原则
package liskovsubstitution;
/**
* @author yzq
* @projectName designdemo
* @packageName liskovsubstitution：
* @describe（子类不要随意修改父类；继承造成程序有侵入性，可移植性降低，尤其不能修改父类。）
* @describe =》所有引用父子类的都使用相同的基类对象，适当用聚合、组合、依赖解决问题；子类不要重写父类方法。
* @data 2020-09-06 13:
*/
public class Substitution {
public static void main(String[] args) {
Sus sus = new Sus();
System.out.println(sus.add(2,3));
}
}
//采用聚合等方式避免重写
class Add {
public int add(int a,int b)
{
return a+b;
}
}
class Sus{
private Add a = new Add();
//不继承不会重写A
public int add(int a,int b){
//使用组合完成功能实现
return this.a.add(a,b);
}
} 接口隔离原则
package interfacesegregation;
/**
* @author yzq
* @projectName designdemo
* @packageName interfacesegregation 一个雷对另一个类的依赖建立在最小的程度上
* @data 2020-09-06 10:
*/
public class segregation {
public static void main(String[] args) {
A a = new A();
a.operation1();
a.operation4();
C c = new C();
c.operation2();
c.operation3();
}
}
//接口1
interface Interface1{
void operation1();
}
//接口2
interface Interface2{
void operation2();
void operation3();
}
//接口3
interface Interface3{
void operation4();
void operation5();
}
class B implements Interface1,Interface3{
@Override
public void operation1() {
System.out.println("B实现1");
}
@Override
public void operation4() {
System.out.println("B实现4");
}
@Override
public void operation5() {
System.out.println("B实现50");
}
}
class C implements Interface2,Interface1{
@Override
public void operation1() {
System.out.println("C 实现 1");
}
@Override
public void operation2() {
System.out.println("C 实现 2");
}
@Override
public void operation3() {
System.out.println("C 实现 3");
}
}
class A extends B{//如果AB功能是相同的使用这种方式比较少代码
} 依赖倒置原则
package dependenceinversion;
/**
* @author yzq
* @projectName designdemo
* @packageName dependenceinversion: 细节依赖抽象；具体类实现抽象；高层与底层模块依赖抽象；中心思想=》依赖接口编程。
* @data 2020-09-06 11:
*/
public class Inversion1 {
public static void main(String[] args) {
/*该方式只能接受邮箱信息，不能接受其他类比如微信、qq信息
* 优化：
* 对接受信息抽象储接口
* */
Persion1 persion = new Persion1();
Email1 email1 = new Email1();
persion.receive(email1);
}
}
class Email1{
public String getInfo(){
return "电子邮件信息";
}
}
class Persion1{
public void receive(Email1 email1){
System.out.println("接收到："+email1.getInfo());
}
} 改良一
package dependenceinversion;
/**
* @author yzq
* @projectName designdemo
* @packageName dependenceinversion: 细节依赖抽象；具体类实现抽象；高层与底层模块依赖抽象；中心思想=》依赖接口编程。
* @data 2020-09-06 11:
*/
public class Inversion2 {
public static void main(String[] args) {
/*该方式能接受邮箱信息及其他类比如微信、qq信息
* 优点：
* 对信息进行抽象实现任意组装
* */
//接口方式
Persion2 persion = new Persion2();
EInfo email1 = new Email2();
EInfo wchat = new Wechat();
persion.receive(email1);
persion.receive(wchat);
//构造方法方式
EInfo3 info3 = new Email3();
Persion3 persion3 = new Persion3(info3);
persion3.receive();
//set方式
EInfo4 info4 = new Wechat4();
Persion4 persion4 = new Persion4();
persion4.setInfo(info4);
persion4.receive();
}
}
//抽象接口方式
class Email2 implements EInfo{
public String getInfo(){
return "电子邮件信息";
}
}
class Wechat implements EInfo{
public String getInfo(){
return "微信信息";
}
}
interface EInfo{
String getInfo();
}
class Persion2{
public void receive(EInfo info){
System.out.println("接收到："+info.getInfo());
}
}
//构造方法方式
class Email3 implements EInfo3{
public String getInfo(){
return "电子邮件信息";
}
}
class Wechat3 implements EInfo3{
public String getInfo(){
return "微信信息";
}
}
interface EInfo3{
String getInfo();
}
class Persion3{
private EInfo3 info;
public Persion3(EInfo3 info){
this.info =info;
}
public void receive(){
System.out.println("接受到："+this.info.getInfo());
}
}
//set方式
class Email4 implements EInfo4{
public String getInfo(){
return "电子邮件信息";
}
}
class Wechat4 implements EInfo4{
public String getInfo(){
return "微信信息";
}
}
interface EInfo4{
String getInfo();
}
class Persion4{
private EInfo4 info;
public void setInfo(EInfo4 info) {
this.info = info;
}
public void receive(){
System.out.println("接受到："+this.info.getInfo());
}
}
迪米特法则
package demeterprinciple;
import java.util.ArrayList;
import java.util.List;
/**
* @author yzq
* @projectName designdemo
* @packageName demeterprinciple
* @describe 对象之间应保持最少了解，即减少耦合=》只与有耦合的对象通信，陌生的类不要以局部变量出现(成员变量，方法参数，方法返回值)，耦合方式：依赖（弱关联，局域变量，方法形参）、关联（成员变量）、组合（has a）、聚合（强关联）、
* @data 2020-09-06 14:
*/
public class demeter1 {
public static void main(String[] args) {
Depatrment allDep = new AllDep();
Depatrment schDep = new SchDep();
School school = new School();
school.setDepatrment(allDep);
school.setDepatrment(schDep);
school.findDep();
}
}
class School{
private List<Depatrment> depatrment = new ArrayList<Depatrment>();
public void setDepatrment(Depatrment depatrment) {
this.depatrment.add(depatrment);
}
public void findDep(){
for (Depatrment de :this.depatrment){
de.getID();
}
}
}
interface Depatrment{
public void getID();
}
class AllDep implements Depatrment{
@Override
public void getID() {
System.out.println("总部ID");
}
}
class SchDep implements Depatrment{
@Override
public void getID() {
System.out.println("学院ID");
}
} 合成复用原则
package compositereuse;
/**
* @author yzq
* @projectName designdemo
* @packageName compositereuse
* @describe 尽量使用合成/聚成，不使用继承
* @data 2020-09-06 16:05
*/
public class Reuse1 {
}
总结
设计模式怎么搞更好：
- 类独立出变化项，作为依赖，不要继承；
- 面向接口；
- 低耦合
查看7道真题和解析
