java程序设计原则知道少

程序设计七大原则 一、开闭原则

​ 针对我们设计的功能模块对扩展开放,对修改关闭:利用面向接口(抽象)编程(多态的特性),实现对功能需求扩展的同时,不允许更改原来的代码。提高对象的可复用性、可维护性、灵活性。

​ 抽象的说,用抽象思维构建我们想要创建的实体对象,用具体实现去扩展实体对象的细节实现。

​ 具体的说,业务需求的功能可以去扩展,但是已经实现的功能不应该去修改。

需求:以简单工厂模式和工厂方法模式理解开闭原则

分析:

工厂模式是获取一个实例对象的建造者模式,我们不关心对象如何产生,只关心结果。

简单工厂模式是面对比较简单的业务场景,用于获取一个对象实例。我们需要传入相关业务参数,让简单工厂对象去做相应的判断,然后返回给我们对应的实例对象。这个工厂对象做了很多事情,他违背了单一职责原则,当我们的业务需要扩展的时候,这个工厂对象必须去修改,新增业务判断,新增返回对应的实例对象。这就违背了开闭原则

public class FruitsFactory { /** * @description: * @param fruitsName * @return com.lmc.gp13280.pattern.factory.fruits.IFruits * @date 2019/5/23 15:44 * @author lmc */ public IFruits product(String fruitsName){ if(null != fruitsName && fruitsName != ""){ System.out.println("客户需求的水果是"+fruitsName); if("苹果".equals(fruitsName)){ System.out.println("水果工厂生产了苹果"); return new Apple(); } if("橙子".equals(fruitsName)){ System.out.println("水果工厂生产了橙子"); return new Orange(); } if("香蕉".equals(fruitsName)){ System.out.println("水果工厂生产了香蕉"); return new Banana(); } return null; }else{ return null; } } }

上面是一个水果工厂,我如果想要草莓,就必须的修改代码去实现草莓的生产了。

工厂方法模式是抽象一个工厂接口,让具体的工厂子类实例对象实现工厂接口。我们想要一个具体的实例对象,只需要找相应的子类工厂实现类就可以了,如果需要业务扩展,我们不需要修改原来的工厂子类,只需要新增新的工厂子类就行了。这就实现了业务扩展,但是不会修改原来的程序逻辑。遵循了开闭原则单一职责原则

public interface IFruitsFactory { /** * 工厂的生产方法 * @return IFruits */ IFruits product(); } public class AppleFactory implements IFruitsFactory { @Override public IFruits product() { System.out.println("苹果工厂只生产苹果"); return new Apple(); } } public class BananaFactory implements IFruitsFactory { @Override public IFruits product() { System.out.println("香蕉工厂只生产香蕉"); return new Banana(); } } public class OrangeFactory implements IFruitsFactory { @Override public IFruits product() { System.out.println("橙子工厂只生产橙子"); return new Orange(); } }

上面的示例代码中,我们要新增具体的水果工厂去扩展业务,只需要新增对应的工厂子类去实现水果工厂的接口就行了。

实现业务扩展,不改变原来的程序就是遵循开闭原则。

二、依赖倒置原则

​ spring的依赖注入相信大家都不陌生,其实依赖倒置原则是程序对象依赖其他对象的时候,应该依赖其抽象,不要依赖实现,应该依赖顶层对象,不要依赖具体的底层对象。因为程序的具体实现都是实现类去实现的,但是我们要去依赖实现类的顶层接口对象,这就是倒置,也就是依赖倒置。

依赖倒置原则的核心是运行时多态,程序在编译时不会去实例化子类对象,在程序运行的时候虚拟机才会去选择实例化具体的子类对象。

​ 在程序设计中,一般接口定义好了,就不会去轻易改变。因为,在一个成熟的系统中,改变接口,就相当于把设计推翻重构了,你愿意做这样的事情?但是实现类,咱们可以进行轻微改动,或者说不改,新增一个新的实现类去代替。如果依赖其实现类,只要实现类改动,那么程序员的灾难是不是来了呢?如果依赖其顶层接口,我们其他依赖此接口的代码都不需要去做任何改动,因为接口没变啊,只需要改动需求具体的实现业务逻辑,或者新增业务子类实现接口。是不是可以提前下班了

​ 通过依赖倒置,可以减少类与类之间的耦合性,提高系统的稳定性,提高代码的
可读性和可维护性,并能够降低修改程序所造成的风险。

/** * 水果店 * @author: maocheng.liao * @create: 2020-02-23 15:20 */ public class FruitShop { private IFruitsFactory fruitsFactory; public IFruitsFactory getFruitsFactory() { return fruitsFactory; } public void setFruitsFactory(IFruitsFactory fruitsFactory) { this.fruitsFactory = fruitsFactory; } /** * @description: * @param :从水果生产基地去进货水果 * @return com.lmc.gp13280.pattern.factory.fruits.IFruits * @date 2020/2/23 15:34 * @author maocheng.liao */ public IFruits getFruits(){ IFruits fruits = fruitsFactory.product(); return fruits; } } /** * 水果店依赖倒置测试 * * @author: maocheng.liao * @create: 2020-02-23 15:25 */ public class FruitShopTest { public static void main(String[] args) { IFruitsFactory fruitsFactory= new AppleFactory(); FruitShop fruitShop=new FruitShop(); fruitShop.setFruitsFactory(fruitsFactory); IFruits apple = fruitShop.getFruits(); apple.getName(); fruitsFactory = new BananaFactory(); fruitShop.setFruitsFactory(fruitsFactory); IFruits banana = fruitShop.getFruits(); banana.getName(); fruitsFactory = new OrangeFactory(); fruitShop.setFruitsFactory(fruitsFactory); IFruits orange = fruitShop.getFruits(); orange.getName(); } }

内容版权声明:除非注明,否则皆为本站原创文章。

转载注明出处:https://www.heiqu.com/wpzwpd.html