前言设计模式的目的
编写程序过程中,软件工程师们面临着众多挑战,其中,低耦合性(功能和功能之间低耦合)、高内聚性(模块内部是十分紧密的)、可扩展性以及可维护性、灵活性(增加新功能十分方便)、重用性(相同的功能,代码无需重复编写),可靠性(增加新的功能后,原来的功能不受影响)都是必须要考虑的因素,所以设计模式是为了让程序更可靠,更灵活,更具有面向对象的精髓
设计模式七大原则
单一职责原则
对类来说,即一个类只负责一个职责,比如我们之前写过的studentMapper他就知识负责学生的增删改查,这就是一个单一职责,如果说studentMapper还要去负责老师的信息管理,这就违背的单一职责原则,这个时候我们需要把studentMapper分成A类和B类,A去管理学生,B去管理老师。
package com.rlw.principle.singleresponsibility;
public class SingleResponsibility {
public static void main(String[] args) {
Tiger tiger = new Tiger();
tiger.eat("母老虎");
tiger.eat("菜包子");
tiger.eat("菜团子");
tiger.eat("菜卷子");
}
}
class Tiger {
public void eat(String tiger) {
System.out.println(tiger + "在吃人!!!");
}
}
此时已经违反了单一职责原则,母老虎可以吃人没问题,但是菜包子什么的就违反了单一职责原则。
改良2::单一职责原则模式:但是软件花销比较大,即不仅需要修改很多个类,还要修改主方法(客户端)
package com.rlw.principle.singleresponsibility;
public class SingleResponsibility {
public static void main(String[] args) {
Tiger tiger = new Tiger();
tiger.eat("母老虎");
CaiBaoZi caiBaoZi = new CaiBaoZi();
caiBaoZi.eat("菜包子");
CaiTuanZi caiTuanZi = new CaiTuanZi();
caiTuanZi.eat("菜团子");
CaiJuanZi caiJuanZi = new CaiJuanZi();
caiJuanZi.eat("菜卷子");
}
}
class Tiger {
public void eat(String tiger) {
System.out.println(tiger + "在吃人!!!");
}
}
class CaiBaoZi{
public void eat(String cai){
System.out.println(cai + "在吃火锅!!!");
}
}
class CaiTuanZi{
public void eat(String cai){
System.out.println(cai + "菜团子在喝可乐!!!");
}
}
class CaiJuanZi{
public void eat(String cai){
System.out.println(cai + "菜卷子在想吃鸡架!!");
}
}
改良3::这类虽然没有在类的级别上实现单一职责原则,但是在方法级别上仍然遵守单一职责原则
package com.rlw.principle.singleresponsibility;
public class SingleResponsibility {
public static void main(String[] args) {
Tiger tiger = new Tiger();
tiger.tigerEat("母老虎");
tiger.caiBaoZiEat("菜包子");
tiger.caiTuanZiEat("菜团子");
tiger.caiJuanZiEat("菜卷子");
}
}
class Tiger {
public void tigerEat(String tiger) {
System.out.println(tiger + "在吃人!!!");
}
public void caiBaoZiEat(String tiger) {
System.out.println(tiger + "在吃火锅!!!");
}
public void caiTuanZiEat(String tiger) {
System.out.println(tiger + "在喝可乐!!!");
}
public void caiJuanZiEat(String tiger) {
System.out.println(tiger + "在想吃鸡架!!!");
}
}
//补充一点,改良3版本如果方法及其多,那我们还是要使用改良2的办法分多个类进行拆分
总结:单一职责原则各行其职!!!!
接口隔离原则
一个类不应该依赖它不需要的接口,即一个类对另一个类的依赖应该建立在最小接口上
package com.rlw.principle.segregation;
public class Segregation1 {
public static void main(String[] args) {
}
}
interface Interface1{
void operation1();
void operation2();
void operation3();
void operation4();
void operation5();
}
class B implements Interface1{
@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");
}
@Override
public void operation4() {
System.out.println("B 实现了 operation4");
}
@Override
public void operation5() {
System.out.println("B 实现了 operation5");
}
}
class D implements Interface1{
@Override
public void operation1() {
System.out.println("D 实现了 operation1");
}
@Override
public void operation2() {
System.out.println("D 实现了 operation2");
}
@Override
public void operation3() {
System.out.println("D 实现了 operation3");
}
@Override
public void operation4() {
System.out.println("D 实现了 operation4");
}
@Override
public void operation5() {
System.out.println("D 实现了 operation5");
}
}
class A{//A类通过接口Interface1依赖B类,但是只会用到1,2,3方法
public void depand1(Interface1 i){
i.operation1();
}
public void depand2(Interface1 i){
i.operation2();
}
public void depand3(Interface1 i){
i.operation3();
}
}
class C{//C类通过接口Interface1依赖B类,但是只会用到1,2,3方法
public void depand1(Interface1 i){
i.operation1();
}
public void depand4(Interface1 i){
i.operation4();
}
public void depand5(Interface1 i){
i.operation5();
}
}
一个类对另一个类的依赖应该建立在最小接口上
以上代码类A通过接口Interface1依赖B,类C通过接口Interface1依赖D,如果接口Interface1对于类A和类C来说不是最小接口,那么类B和类D必须去实现他们不需要的方法。
按照隔离原则应当这样处理:将接口Interface1拆分为独立的几个接口,类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则
接口Interface1中出现的方法,根据实际情况拆分为三个接口
package com.rlw.principle.segregation;
public class Segregation1 {
public static void main(String[] args) {
A a = new A();
a.depand1(new B()); //A类通过接口去依赖B
a.depand2(new B());
a.depand3(new B());
C c = new C();
c.depand1(new D());//C类通过接口去依赖D
c.depand4(new D());
c.depand5(new D());
}
}
interface Interface1{
void operation1();
}
interface Interface2{
void operation2();
void operation3();
}
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依赖B类,但是只会用到1,2,3方法
public void depand1(Interface1 i){
i.operation1();
}
public void depand2(Interface2 i){
i.operation2();
}
public void depand3(Interface2 i){
i.operation3();
}
}
class C{//C类通过接口Interface1依赖B类,但是只会用到1,2,3方法
public void depand1(Interface1 i){
i.operation1();
}
public void depand4(Interface3 i){
i.operation4();
}
public void depand5(Interface3 i){
i.operation5();
}
}