Java：面向抽象编程实现OCP

title: Java：面向抽象编程实现OCP
copyright: true
tags: 单例模式
categories:

JavaSE
OCP
cover: 'https://typora-1304191864.cos.ap-shanghai.myqcloud.com/typora/qiniu1384.png'
abbrlink: 2d10a40e
date: 2021-02-16 23:04:50

涉及技术基础点：

反射
泛型
抽象
工厂模式
interface

一、代码优化原则

代码复杂性的根本

代码编写的出发点：不啰嗦自描述性的代码可维护性好代码

总结，所有软件的复杂性，都是为了可维护性。

开闭原则 OCP

为什么java写出来的代码是可维护的，一个非常重要的原则就是开闭原则，也就是OCP。可能会听过里式替换原则，还有迪米特法则，这些都不是最重要的，最重要的是开闭原则，这是代码可维护的基础。其它的原则都是开闭原则的子原则，其他的原则都是为了实现开闭原则。

除了里式替换原则，迪米特法则，还有控制反转，依赖注入，其实也是为了实现开闭原则。

OCP的英文：Open Closed Principle。

不管是软件，还是函数，还是类，都要对扩展是开放的，对修改是封闭的。

当要修改的时候，我们通过新增一业务模块或类，来代替原来的类

注意：不要面对一个具体的类去编程，要面向抽象。

示例：

public class A{
    private C c ;
    
    public void print(){
        C c = new C();
            c.text1();
        System.out.println("This is Class A");
    }

为什么要面向抽象编程？

interface abstract

使用抽象接口，可以避免因新增实现类而改动控制代码。

因为如果面向实体类去新建对象，并调用方法，在后续维护(指出现新需求)的时候，改动一个类，会影响到其他依赖此类的类做出改动 new语句以及调用方法的语句，这将是灾难性的修改。

如何能够忽略掉一个具体类，而面向抽象编程？

就是用的interface（接口）

IOC DI 的过程：

interface
设计模式：工厂模式
IOC，DI

目的：

=》面向对象 =》OCP =》可维护的代码

二、代码优化之路（从强耦合到稳定）

创建 Diana、Irelia、Camille三个类，分别有多个相同的方法可供调用，例子：

public class Irelia {
    public void g(){
        System.out.println("Irelia Q");
    }

    public void w(){
        System.out.println("Irelia W");
    }

    public void e(){
        System.out.println("Irelia E");
    }

    public void r() {
        System.out.println("Irelia R");
    }
}

案例代码一：

多个类创建多个对象来调用各自的方法，耦合度高，当有新的类加入时，需要更改main中的代码；

   public static void main(String[] args) {
        String name = Main.getPlayerInput();
        switch (name) {
            case "Diana":
                Diana diana = new Diana();
                diana.r();
            case "Irelia":
                Irelia irelia = new Irelia();
                irelia.r();
            case "Camille":
                Camille camille = new Camille();
                camille.r();
        }
    }

当前的案例中，每个方法的调用需要分别使用所属类的实例去调用，代码的耦合度太高，变更太频繁；

2.案例代码二：

使用 interface 来统一调用方法，这里创建 ISkill 接口，Diana、Irelia、Camille实现该接口;

    public static void main(String[] args) throws Exception {
        String name = Main.getPlayerInput();
        ISkill iSkill;
        switch (name) {
            case "Diana":
                iSkill = new Diana();
                break;
            case "Irelia":
                iSkill = new Irelia();
                break;
            case "Camille":
                iSkill = new Camille();
                break;
            default:
                throw new Exception();
        }
        iSkill.r();
    }

从以上的代码中，可以看出，确实在原有代码上进行了优化。

但是：

单纯的interface可以统一方法的调用，但是他不能统一对象的实例化
面向对象在做两件事情
a)实例化对象
b)调用方法(完成业务逻辑)
只有一段代码中没有new的出现，才能保证代码的相对稳定，才能逐步实现OCP
上面这句话的只是表象，实质是一段代码如果要保持稳定，就不应该负责对象的实例化
对象实例化的过程不可能消除掉
把对象实例化的过程，转移到其他的代码片段里

方法统一的意义在哪？
1、某方法被大量调用时很繁琐，方法统一后一行代码搞定；
2、事项功能的单一性，便于后面的提取封装

多个类实现同一个接口，通过反射与多态的方式进行向上转型，从而可以使用一个统一的出口进行方法的调用。代码的耦合度较低，只需要更改要实例化的对象，对于具体调用方法的实例本身是不变的。

案例代码三：

在案例代码二的基础上，将主要进行 new 的switch-case 代码进行抽取，通过 Factory 的方式来生成具体的实例：

public class HeroFactory {

    public static ISkill getHero(String name) throws Exception {
        ISkill iSkill;
        switch (name) {
            case "Diana":
                iSkill = new Diana();
                break;
            case "Irelia":
                iSkill = new Irelia();
                break;
            case "Camille":
                iSkill = new Camille();
                break;
            default:
                throw new Exception();
        }
        return iSkill;
    }
}

Main.java

    public static void main(String[] args) throws Exception {
        String name = Main.getPlayerInput();
        ISkill iSkill = HeroFactory.getHero(name);
        iSkill.r();
    }

工厂类的作用就是负责创建类的实例，而不影响主业务代码，主业务代码甚至不需要知道工厂类的内部实现，满足了功能也实现了代码分离

当前方式的优化：

代码中总会存在不稳定，所以我们要做的就是隔离不稳定，保证其他的代码是稳定的。
把散落在各处的不稳定性全部抽取和集中起来管理，使得绝大多数代码保持稳定，这就是IOC的意义。

弊端：

   当前的代码中存在的不稳定是变化，工厂模式类 HeroFactory 依旧存在 new 这一个过程。

案例代码四：

基于反射 new 对象，消除变化

public class HeroFactory {

    public static ISkill getHero(String name) throws Exception {
        ISkill iSkill;

        //反射
        //元素
        // C# 、Python
        // 类 是对象的抽象
        // 对象 类 元素
        // reflect.hero.Irelia
        String classStr = "reflect.hero." + name;
        Class<?> cla = Class.forName(name);
        Object obj = cla.newInstance();
        return (ISkill)obj;
    }
}

反射机制，一般情况，我们可以通过用户输入的名字去new一个对象，但是，如果用反射机制，可以根据用户输入的名字，去创建一个对象，注意：使用反射机制接收到的参数是要求是完整的包路径。

知识点：

java9以上废弃了newInstance，由clazz.getDeclaredConstructor().newInstance()代替

结束：到这一步，代码基本上就消除了变化。

现在的写法有一定的缺点：

每一次调用都需要重新反射生成对象，性能不好；

而spring是可以把生成的对象加到缓存里面，就不再重复生成；

Spring的配置文件变更属不属于违反OCP原则：

配置文件是属于系统外部的，而不是代码本身的，不违反OCP原则。

面向对象中变化的应对方案？有两种

1.制定一个interface,然后用多个类实现同一个interface ---策略模式

2.一个类，属性配置类中配置变化的属性值--- 修改数据库链接、端口号。

更改配置文件，在配置文件中更改，比如修改数据库链接、端口号 支付账号等。
前者更灵活，后者属性值是固定的，扩展性没有第一种强

Java：面向抽象编程实现OCP

推荐阅读