Java中如何让子类拥有独立静态值并共享父类方法？

问题1：复用doesMatch方法，保留子类独立静态pattern #

Java中静态成员属于类本身，无法通过继承直接让父类访问子类的静态pattern，但可以通过以下两种方式实现逻辑复用：

方式1：父类提供静态工具方法，子类调用复用逻辑 #

将Base改为抽象类，提供通用的正则匹配工具方法，子类仅需传入自身的静态pattern即可，避免重复编写匹配逻辑：

abstract class Base {
    Base() {
        System.out.println("Base Constructor");
    }

    // 父类封装通用匹配逻辑
    protected static boolean matchPattern(String v, String pattern) {
        return v.matches(pattern);
    }
}

class Derived1 extends Base {
    private static final String pattern = "a+b+";
    Derived1() {
        super();
        System.out.println("Derived 1 Constructor");
    }

    public static boolean doesMatch(String v) {
        return matchPattern(v, pattern);
    }
}

class Derived2 extends Base {
    private static final String pattern = "c+";
    Derived2() {
        super();
        System.out.println("Derived 2 Constructor");
    }
    
    public static boolean doesMatch(String v) {
        return matchPattern(v, pattern);
    }
}

方式2：抽象实例方法关联静态pattern（面向对象风格） #

把Base定义为抽象类，要求子类实现获取pattern的抽象方法，父类统一实现匹配逻辑：

abstract class Base {
    Base() {
        System.out.println("Base Constructor");
    }

    // 子类必须实现，返回自身静态pattern
    protected abstract String getPattern();

    // 父类统一处理匹配逻辑
    public boolean doesMatch(String v) {
        return v.matches(getPattern());
    }
}

class Derived1 extends Base {
    private static final String pattern = "a+b+";
    Derived1() {
        super();
        System.out.println("Derived 1 Constructor");
    }

    @Override
    protected String getPattern() {
        return pattern;
    }
}

class Derived2 extends Base {
    private static final String pattern = "c+";
    Derived2() {
        super();
        System.out.println("Derived 2 Constructor");
    }
    
    @Override
    protected String getPattern() {
        return pattern;
    }
}

问题2：扩展子类无需修改Builder的判断逻辑 #

通过注册式多态实现：定义处理器接口封装匹配和实例创建逻辑，Builder维护处理器列表，新增子类时仅需注册新处理器，无需修改原有判断代码。

完整优化代码 #

import java.util.ArrayList;
import java.util.List;

abstract class Base {
    Base() {
        System.out.println("Base Constructor");
    }
}

// 定义处理器接口，统一匹配和实例创建逻辑
interface BaseProcessor {
    boolean matches(String v);
    Base createInstance();
}

class Derived1 extends Base {
    private static final String pattern = "a+b+";
    Derived1() {
        super();
        System.out.println("Derived 1 Constructor");
    }

    // 子类对应的处理器实现
    public static final BaseProcessor PROCESSOR = new BaseProcessor() {
        @Override
        public boolean matches(String v) {
            return v.matches(pattern);
        }

        @Override
        public Base createInstance() {
            return new Derived1();
        }
    };
}

class Derived2 extends Base {
    private static final String pattern = "c+";
    Derived2() {
        super();
        System.out.println("Derived 2 Constructor");
    }

    public static final BaseProcessor PROCESSOR = new BaseProcessor() {
        @Override
        public boolean matches(String v) {
            return v.matches(pattern);
        }

        @Override
        public Base createInstance() {
            return new Derived2();
        }
    };
}

class Builder {
    // 维护所有子类的处理器列表
    private static final List<BaseProcessor> PROCESSORS = new ArrayList<>();

    // 静态注册处理器，新增子类仅需添加一行注册代码
    static {
        PROCESSORS.add(Derived1.PROCESSOR);
        PROCESSORS.add(Derived2.PROCESSOR);
    }

    public static Base baseFromString(String v) throws Exception {
        // 遍历处理器自动匹配，无需修改判断逻辑
        for (BaseProcessor processor : PROCESSORS) {
            if (processor.matches(v)) {
                return processor.createInstance();
            }
        }
        throw new Exception("Could not match " + v + " to any derived type.");
    }
}

class Test {
    public static void main(String[] args) throws Exception {
        Base b = Builder.baseFromString("aaab");
    }
}

扩展说明 #

新增子类时仅需两步：

1. 编写子类继承Base，并实现对应的BaseProcessor；
2. 在Builder的静态代码块中添加PROCESSORS.add(NewDerived.PROCESSOR);即可，完全无需改动原有逻辑。

内容的提问来源于stack exchange，提问作者redmoncoreyl