设计模式目的
编写软件过程中,程序员面临来自耦合性内聚性以及可维护性,可扩展性,重用性,灵活性等多方面的挑战,设计模式是为了让程序(软件),具有更好的如下特点:
1.代码重用性
2.可读性
3.可拓展性
4.可靠性
5.程序具有高内聚,低耦合的特点
设计模式七大原则
单一职责
简单理解,对类来说,一个类应该只负责一个职责
package com.ll.SevenResponsibility;
public class SingleResponsibility {
public static void main(String[] args) {
//单一职责原则,不同类控制不同的功能(function)
VehicleAir vehicleAir = new VehicleAir();
vehicleAir.run1("飞机");
vehicleAir.run2("汽车");
vehicleAir.run3("潜艇");
}
}
class VehicleAir{//相比与创建三个类,更简洁
public void run1(String vehicle){
System.out.println(vehicle + "在空中run");
}
public void run2(String vehicle){
System.out.println(vehicle + "在陆地上run");
}
public void run3(String vehicle){
System.out.println(vehicle + "在海中run");
}
}
接口隔离
目的:客户端不应该依赖它不需要的类,即一个类对另一个类的依赖应该建立在最小的接口上。比如一个接口Interface1有方法1,2,3,4,5,其中B类通过接口Interface1依赖于A类,需要使用其中1,2,3方法,类C通过接口Interface1依赖于B类,需要使用其中的1,4,5方法
package com.ll.SevenResponsibility;
public class JKGL {
public static void main(String[] args) {
}
}
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("实现了方法1");
}
@Override
public void operation2() {
System.out.println("实现了方法2");
}
@Override
public void operation3() {
System.out.println("实现了方法3");
}
}
class C implements Interface1,Interface3{
@Override
public void operation1() {
System.out.println("实现了方法1");
}
@Override
public void operation4() {
System.out.println("实现了方法4");
}
@Override
public void operation5() {
System.out.println("实现了方法5");
}
}
class A{//A通过接口依赖Interface1依赖于B类,只会用到1,2,3类
public void depend1(Interface1 i){
i.operation1();
}
public void depend2(Interface1 i){
i.operation2();
}
public void depend3(Interface1 i){
i.operation3();
}
}
class D{//D通过接口依赖Interface1依赖于C类,只会用到1,4,5类
public void depend1(Interface1 i){
i.operation1();
}
public void depend2(Interface1 i){
i.operation4();
}
public void depend3(Interface1 i){
i.operation5();
}
}
依赖倒转
基本介绍
依赖倒转原则(Dependence Inversion Principle)是指:
- 高层模块不应该依赖低层模块,二者都应该依赖其抽象
- 抽象不应该依赖细节,细节应该依赖抽象
- 依赖倒转(倒置)的中心思想是面向接口编程
- 依赖倒转原则是基于这样的设计理念:相对于细节的多变性,抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在 java 中,抽象指的是接口或抽象类,细节就是具体的实现类
- 使用 接口或抽象类的目的是制定好规范,而不涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成
package com.ll.SevenResponsibility;
public class DependencyInversion {
public static void main(String[] args) {
Person person = new Person();
person.receive(new Email());
}
}
interface IReciever{
public String getInfo();
}
class Email implements IReciever{
public String getInfo(){
return "返回信息 zzz";
}
}
class Person{//如果增加其他功能,如接受微信功能等
public void receive(IReciever ir){
ir.getInfo();
}
}
上述方式通过接口去实现不同的方法。
下一种方法通过构造器实现
interface IOpenAndClose {
public void open(); //抽象方法
}
interface ITV { //ITV 接口
public void play();
}
class OpenAndClose implements IOpenAndClose{
public ITV tv; //成员
public OpenAndClose(ITV tv){ //构造器
this.tv = tv;
}
public void open(){
this.tv.play();
}
}
方式3,使用set方法实现
// 方式 3 , 通过 setter 方法传递
interface IOpenAndClose {
public void open(); // 抽象方法
public void setTv(ITV tv);
}
interface ITV { // ITV 接口
public void play();
}
class OpenAndClose implements IOpenAndClose {
private ITV tv;
public void setTv(ITV tv) {
this.tv = tv;
}
public void open() {
this.tv.play();
}
}
class ChangHong implements ITV {
@Override
public void play() {
// TODOAuto-generated method stub
System.out.println("长虹电视机,打开");
}
}
总结:DI的实现方式有三种
- 接口
- 构造器
- set()方法
里式替换原则
继承时遵循里氏替换原则
- 继承包含这样一层含义:父类中凡是已经实现好的方法,实际上是在设定规范和契约,虽然它不强制要求所有的子类必须遵循这些契约,但是如果子类对这些已经实现的方法任意修改,就会对整个继承体系造成破坏。
- 继承在给程序设计带来便利的同时, 也带来了弊端。比如使用继承会给程序带来 侵入性,程序的可移植性降低,增加对象间的耦合性,如果一个类被其他的类所继承则当这个类需要修改时,必须考虑到所有的子类,并且父类修改后,所有涉及到子类的功能都有可能产生故障
- 问题提出: 在编程中,如何正确的使用继承? => 里氏替换原则
目的:
- 在使用继承时,遵循里氏替换原则,在 子类中尽量不要重写父类的方法
- 里氏替换原则告诉我们,继承实际上让两个类耦合性增强了,在适当的情况下,可以通过聚合 , 组合 , 依赖来解决问题
开闭原则
- 开闭原则(Open Closed Principle)是编程中最基础、最重要的设计原则
- 一个软件实体如类,模块和函数应该 对扩展开放( 对提供方),对修改关闭( 对使用方)。用抽象构建框架,用实现扩展细节
- 当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化
- 编程中遵循其它原则,以及使用设计模式的目的就是遵循开闭原则。
package com.ll.SevenResponsibility;
public class OpenClosedPrince {
public static void main(String[] args) {
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawCircle(new Circle());
graphicEditor.drawRectangle(new Rectangle());
graphicEditor.drawTriangle(new Triangle());
}
}
//这是一个用于绘图的类 [使用方]
class GraphicEditor {
//接收 Shape 对象,然后根据 type,来绘制不同的图形
//绘制矩形
public void drawRectangle(Shape r) {
r.draw();
}
//绘制圆形
public void drawCircle(Shape r) {
r.draw();
}
//绘制三角形
public void drawTriangle(Shape r) {
r.draw();
}
}
//Shape 类,基类
abstract class Shape {
int m_type;
abstract void draw();
}
class Rectangle extends Shape {
@Override
void draw() {
System.out.println("绘制了矩形");
}
}
class Circle extends Shape {
@Override
void draw() {
System.out.println("绘制了圆形");
}
}
//新增画三角形
class Triangle extends Shape {
@Override
void draw() {
System.out.println("绘制了三角形");
}
}
迪米特法则
- 一个对象应该对其他对象保持最少的了解
- 类与类关系越密切,耦合度越大
- 迪米特法则(Demeter Principle)又叫 最少知道原则,即一个类 对自己依赖的类知道的越少越好。也就是说,对于被依赖的类不管多么复杂,都尽量将逻辑封装在类的内部。对外除了提供的 public 方法,不对外泄露任何信息
- 直接的朋友:每个对象都会与其他对象有 耦合关系,只要两个对象之间有耦合关系,我们就说这两个对象之间、是朋友关系。耦合的方式很多,依赖,关联,组合,聚合等。其中,我们称出现成员变量, 方法参数, 方法返回值中的类为直接的朋友,而出现在 局部变量中的类不是直接的朋友。也就是说,陌生的类最好不要以局部变量的形式出现在类的内部。
合成复用原则
原则是尽量使用合成/聚合的方式,而不是使用继承
设计原则核心思想
- 找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。
- 针对接口编程,而不是针对实现编程。
- 为了交互对象之间的 松耦合设计而努力