网站模版可以修改吗,海南海口最新新闻事件,大家都在哪些网站上做医药招商,如何进行网站分析软件设计模式是前辈们代码设计经验的总结#xff0c;可以反复使用。设计模式共分为3大类#xff0c;创建者模式(5种)、结构型模式(7种)、行为型模式(11种)#xff0c;一共23种设计模式#xff0c;软件设计一般需要满足7大基本原则。下面通过5章的学习一起来看看设计模式的魅…软件设计模式是前辈们代码设计经验的总结可以反复使用。设计模式共分为3大类创建者模式(5种)、结构型模式(7种)、行为型模式(11种)一共23种设计模式软件设计一般需要满足7大基本原则。下面通过5章的学习一起来看看设计模式的魅力吧。
目录 1.1、设计模式概述
1.2、设计模式的分类
1.3、UML类图
1.4、设计原则
1.4.1 开闭原则
1.4.2、里式代换原则
1.4.3、依赖倒转原则
1.4.4、接口隔离原则
1.4.5、迪米特法则
1.4.6、合成复用原则
1.4.7、单一职责原则 1.1、设计模式概述
软件设计模式是前辈们代码设计经验的总结本质上是对面向对象设计原则的实际应用是对类的封装、继承、多态以及类的关联关系与组合关系的充分理解。
使用设计模式的代码可重用性与可维护性高、可读性强、可以减少软件开发周期提升开发效率。 1.2、设计模式的分类
创建型模式(5种)本质上就是将对象的创建与使用分离就是描述怎样去创建对象。
包括单例、原型、工厂方法、抽象工厂、建造者模式
结构型模式(7种)本质上是将类或者对象按照某种布局组成更大的结构。
包括代理、适配器、桥接、装饰、外观、享元、组合模式
行为模式(11种)本质是描述类与对象协助完成单个对象无法完成的任务以及怎么分配职责。
包括模板方法、策略、命令、责任链、状态、观察者、中介者模式、迭代器、访问者、备忘录、解释器。 1.3、UML类图
类图是面向对象建模的主要组成部门类图显示了模型的内部结构主要包括模型中存在的类、类的属性以及类与类之间的关系等。 1.4、设计原则
设计模式的7大原则具体如下
1.开闭原则软件实体 (类、模块、函数等等) 应该是可以被扩展的但是不可被修改。
2.里式代换原则继承的时候尽量不要重写父类的方法如果重写要保证不破坏原方法的功能。
3.依赖倒转原则抽象不应该依赖于细节细节应该依赖于抽象依赖接口面向接口编程。
4.接口隔离原则客户端不应该依赖它不需要的接口一个类对另一个类的依赖应该建立在最小的接口上。
5.迪米特法则最少知道原则它表示一个对象应该对其它对象保持最少的了解。通俗来说就是只与直接的朋友通信。
6.合成复用原则通过组合或者聚合的方式替代继承增强封装性与提升复用的灵活性。
7.单一职责表示一个模块的组成元素之间的功能相关性即一个类只负责一项职责。
1.4.1 开闭原则
1.开闭原则对扩展开放对修改关闭。扩展源程序的时候不要修改原有代码通过使用接口与抽象类实现。
通过定义一个抽象类抽象类中定义抽象方法通过多个子类继承抽象类并重写重写抽象方法同时设置一个中间类用于注入抽象类并调用抽象方法这样在客户端测试类中就可以实例化中间类并注入抽象类的子类即实现了扩展类方法也没更改代码本身。
1.定义一个抽象类如下
/*** ClassName AbstractSkin* description: 抽象皮肤类* author nuist__NJUPT* date 2024年01月18日* version: 1.0*/
public abstract class AbstractSkin {// 显示方法public abstract void display() ;}
2.定义两个子类继承抽象类并实现抽象方法display /*** ClassName DefaultSkin* description: 默认皮肤* author nuist__NJUPT* date 2024年01月18日* version: 1.0*/
public class DefaultSkin extends AbstractSkin{Overridepublic void display() {System.out.println(默认皮肤);}}
/*** author nuist__NJUPT* ClassName NewSkin* description: 新皮肤* date 2024年01月18日* version: 1.0*/
public class NewSkin extends AbstractSkin {Overridepublic void display() {System.out.println(新皮肤);}
}3.定义一个中间类在中间类中注入抽象类并调用抽象方法。
/*** author nuist__NJUPT* ClassName SogouInput* description: 搜狗输入法* date 2024年01月18日* version: 1.0*/
public class SogouInput {private AbstractSkin abstractSkin ;public void setAbstractSkin(AbstractSkin abstractSkin) {this.abstractSkin abstractSkin;}public void display(){abstractSkin.display();}
}
4.定义一个客户端测试类在测试类中实例化中间类并注入实例化子类即可调用子类方法
/*** author nuist__NJUPT* ClassName Client* description: TODO* date 2024年01月18日* version: 1.0*/
public class Client {public static void main(String[] args) {//1.创建搜狗输入法对象SogouInput sogouInput new SogouInput() ;//2.创建皮肤对象并将皮肤设置到输入法sogouInput.setAbstractSkin(new DefaultSkin());// sogouInput.setAbstractSkin(new NewSkin());//4.显示皮肤sogouInput.display();}}
1.4.2、里式代换原则
里式代换原则子类可以扩展父类的功能但是不允许更改父类的内容。
子类继承父类得时候可以新增方法但是尽量不要重写父类当中得方法
这里通过定义接口在接口中定义方法通过实现类的方式实现接口中方法的功能。
1.定义四边形接口并定义获取长于宽的方法。 /*** author nuist__NJUPT* InterfaceName Quadrilateral* description: 四边形接口* date 2024年01月18日* version: 1.0*/
public interface Quadrilateral {double getLength() ;double getWidth() ;}
2.定义四边形接口的两个实现类正方法与长方形。
/*** author nuist__NJUPT* ClassName Rectangle* description: 长方形实现类* date 2024年01月18日* version: 1.0*/
public class Rectangle implements Quadrilateral {private double length ;private double width ;public void setLength(double length) {this.length length;}public void setWidth(double width) {this.width width;}Overridepublic double getLength() {return length;}Overridepublic double getWidth() {return width;}
}/*** author nuist__NJUPT* ClassName Square* description: 正方形实现类* date 2024年01月18日* version: 1.0*/
public class Square implements Quadrilateral {private double side ;public double getSide() {return side;}public void setSide(double side) {this.side side;}Overridepublic double getLength() {return side;}Overridepublic double getWidth() {return side;}
}3.定义测试类测试通过实现类进行扩充长宽并打印。
import com.company.p1.demo2.Rectangle;/*** author nuist__NJUPT* ClassName RectangleDemo* description: 测试类* date 2024年01月18日* version: 1.0*/
public class RectangleDemo {public static void main(String[] args) {Rectangle rectangle new Rectangle() ;rectangle.setLength(20);rectangle.setWidth(10);resize(rectangle);print(rectangle);}/*** 扩宽方法* param rectangle*/public static void resize(com.company.p1.demo2.Rectangle rectangle){// 宽比长小则扩充while(rectangle.getLength() rectangle.getWidth()){rectangle.setWidth(rectangle.getWidth() 1);}}/*** 打印长与宽* param rectangle*/public static void print(Rectangle rectangle){System.out.println(长方形的长为 rectangle.getLength());System.out.println(长方形的宽为 rectangle.getWidth());}}
1.4.3、依赖倒转原则
依赖倒转原则模块应该依赖于抽象就是面向抽象编程而不是对实现进行编程这样可以降低客户与实现之间的耦合。具体说就是依赖接口而不是依赖具体的实现类。
首先定义三个接口硬盘内存cpu的如下 /*** author nuist__NJUPT* InterfaceName HardDisk* description: 硬盘接口* date 2024年01月18日* version: 1.0*/
public interface HardDisk {// 存储数据public void save(String data) ;// 获取数据public String get() ;
}/*** author nuist__NJUPT* InterfaceName Cpu* description: CPU接口* date 2024年01月18日* version: 1.0*/
public interface Cpu {public void run() ;} /*** author nuist__NJUPT* InterfaceName Memory* description: 内存条接口* date 2024年01月18日* version: 1.0*/
public interface Memory {//存储数据的接口public void save() ;}然后分别定义三个接口的实现类如下 /*** author nuist__NJUPT* ClassName XiJieHardDisk* description: 硬盘实现类* date 2024年01月18日* version: 1.0*/
public class XiJieHardDisk implements HardDisk {Overridepublic void save(String data) {System.out.println(使用希捷硬盘存储数据);}Overridepublic String get() {return 从硬盘中获取的数据 ;}
}/*** author nuist__NJUPT* ClassName IntelCpu* description: Intel的CPU* date 2024年01月18日* version: 1.0*/
public class IntelCpu implements Cpu {Overridepublic void run() {System.out.println(运行Intel的cpu);}
}/*** author nuist__NJUPT* ClassName KingstonMemory* description: TODO* date 2024年01月18日* version: 1.0*/
public class KingstonMemory implements Memory {Overridepublic void save() {System.out.println(使用金士顿内存条);}
}然后定义一个中间类用于依赖这些接口而不是这些实现类。
/*** author nuist__NJUPT* ClassName Computer* description: 计算机类* date 2024年01月18日* version: 1.0*/
public class Computer {/*** 依赖的是抽象接口而不是具体的实现类这样后面增加新的实现类不需要改动Computer* 只需要增加实现类并且在测试类中进行实例化就可以了*/private HardDisk hardDisk ;private Cpu cpu ;private Memory memory ;public HardDisk getHardDisk() {return hardDisk;}public void setHardDisk(HardDisk hardDisk) {this.hardDisk hardDisk;}public Cpu getCpu() {return cpu;}public void setCpu(Cpu cpu) {this.cpu cpu;}public Memory getMemory() {return memory;}public void setMemory(Memory memory) {this.memory memory;}/*** 运行计算机的方法*/public void run(){System.out.println(运行计算机);System.out.println(从硬盘上获取的数据 hardDisk.get());cpu.run();memory.save();}
}
最后定义测试类在测试类中实例化中间类与实现类并调用实现类的方法在测试类中依赖具体而不是在中间类中间类依赖的是抽象的接口。这样在就可以避免中间层的代码修改只需要增加实现类然后在测试类也就是客户端修改代码即可。
/*** author nuist__NJUPT* ClassName ComputerDemo* description: 测试类* date 2024年01月18日* version: 1.0*/
public class ComputerDemo {public static void main(String[] args) {HardDisk hardDisk new XiJieHardDisk() ;Cpu cpu new IntelCpu() ;Memory memory new KingstonMemory() ;Computer computer new Computer() ;computer.setCpu(cpu);computer.setMemory(memory);computer.setHardDisk(hardDisk);computer.run();}}
1.4.4、接口隔离原则
接口隔离原则一个类对另外一个类的依赖应该建立在最小的接口上也就是定义接口的功能最小化然后通过实现类的方式重写接口中的抽象方法即可这样可以避免客户端依赖的方法是它并不使用的。
1.定义三个相互隔离的最小化接口而不是定义一个接口包含三个方法避免实现类依赖不使用的方法。 /*** author nuist__NJUPT* InterfaceName AntiTheft* description: 防盗接口* date 2024年01月18日* version: 1.0*/
public interface AntiTheft {void antiTheft() ;}/*** author nuist__NJUPT* InterfaceName Fireproof* description: 防火接口* date 2024年01月18日* version: 1.0*/
public interface Fireproof {void fireproof() ;
}/*** author nuist__NJUPT* InterfaceName Waterproof* description: 防水接口* date 2024年01月18日* version: 1.0*/
public interface Waterproof {void waterproof() ;
}2.定义多个实现类分别实现接口并重写接口中的抽象方法需要用到接口方法的才去实现接口。
/*** author nuist__NJUPT* ClassName SafeDoor* description: TODO* date 2024年01月18日* version: 1.0*/
public class SafeDoor implements AntiTheft, Fireproof, Waterproof {Overridepublic void antiTheft() {System.out.println(防盗);}Overridepublic void fireproof() {System.out.println(防火);}Overridepublic void waterproof() {System.out.println(防水);}
}/*** author nuist__NJUPT* ClassName SafeDoor2* description: TODO* date 2024年01月18日* version: 1.0*/
public class SafeDoor2 implements AntiTheft, Fireproof{Overridepublic void antiTheft() {System.out.println(防盗);}Overridepublic void fireproof() {System.out.println(防火);}
}3.在测试类中实例化实现类并调用相应的实现方法。 /*** author nuist__NJUPT* ClassName Client* description:测试类* date 2024年01月18日* version: 1.0*/
public class Client {public static void main(String[] args) {// 实例化对象SafeDoor safeDoor new SafeDoor() ;safeDoor.antiTheft();safeDoor.fireproof();safeDoor.waterproof();System.out.println(-----------------------------);SafeDoor2 safeDoor2 new SafeDoor2() ;safeDoor2.antiTheft();safeDoor2.fireproof();}
}1.4.5、迪米特法则
迪米特法则最少只知识原则也就是说如果两个实体无需直接通信就尽量不要产生直接交互这样可以降低模块的耦合度提高模块的独立性。
1、首先定义三个类分别为公司类、明星类、粉丝类
/*** author nuist__NJUPT* ClassName Company* description: 公司类* date 2024年01月18日* version: 1.0*/
public class Company {private String name ;public Company(String name) {this.name name;}public String getName() {return name;}
}/*** author nuist__NJUPT* ClassName Star* description: 明星类* date 2024年01月18日* version: 1.0*/
public class Star {private String name ;public Star(String name) {this.name name;}public String getName() {return name;}
}/*** author nuist__NJUPT* ClassName Fans* description: 粉丝类* date 2024年01月18日* version: 1.0*/
public class Fans {private String name ;public Fans(String name) {this.name name;}public String getName() {return name;}}
2、定义一个经纪人的类通过该类实现明星与粉丝以及明星与公司的交互避免它们直接交互降低模块的耦合性提高模块的独立性。
/*** author nuist__NJUPT* ClassName Agent* description: 经纪人类* date 2024年01月18日* version: 1.0*/
public class Agent {private Star star ;private Company company ;private Fans fans ;public Star getStar() {return star;}public void setStar(Star star) {this.star star;}public Company getCompany() {return company;}public void setCompany(Company company) {this.company company;}public Fans getFans() {return fans;}public void setFans(Fans fans) {this.fans fans;}/*** 粉丝见面方法*/public void meeting(){System.out.println(明星 star.getName() 与粉丝 fans.getName()见面);}/*** 与公司洽谈*/public void business(){System.out.println(明星 star.getName() 与公司 company.getName()洽谈);}}3.最后在测试类实例化经纪人类并调用相应的方法。
/*** author nuist__NJUPT* ClassName Client* description: 测试类* date 2024年01月18日* version: 1.0*/
public class Client {public static void main(String[] args) {Agent agent new Agent() ;agent.setStar(new Star(刘德华));agent.setCompany(new Company(大碗娱乐公司));agent.setFans(new Fans(张三));agent.meeting();agent.business();}
}1.4.6、合成复用原则
合成复用原则尽量使用组合或者聚合等关联关系来实习复用而不是通过继承的方式实现复用
因为继承首先破环了类的封装性父类暴露给子类了同时子类与父类的耦合度高另外继承限制了复用的灵活性。 1.4.7、单一职责原则
单一职责原则通俗的来说就是尽量让一个类中只负责一件事当然这个还是要结合实际情况来看。有些场景可以一个类中做多件事然后子类继承并重写方法。
我们假设有两种动物分别呼吸空气与水那么可以定义两个类每个类中定义一个方法。这样满足单一职责原则。
/*** author nuist__NJUPT* ClassName Client* description: 单一职责测试类* date 2024年01月19日* version: 1.0*/
class Terrestrial{public void breathe(String animal){System.out.println(animal 呼吸空气);}
}
class Aquatic{public void breathe(String animal){System.out.println(animal 呼吸水);}
}public class Client{public static void main(String[] args){Terrestrial terrestrial new Terrestrial();terrestrial.breathe(牛);terrestrial.breathe(羊);terrestrial.breathe(猪);Aquatic aquatic new Aquatic();aquatic.breathe(鱼);}
}
