1)定义抽象类Operation，有double型数据成员numberA、numberB，有抽象方法getResult() (2)定义Operation的4个子类，分别实现加、减、除运算，二个数的平均数运算 (3)定义类OperationFactory：有静态方法Operation createOperate(String operate); 根据形参operate的值创建相应加、减、除、平均值类的对象，赋给抽象类引用后返回 (4)定义测试类及主方法：用户从键盘输入运算数及运算符，根据运算符调用OperationFactory类的静态方法，创建相应实例，设置运算数，输出运行结果

好的，你的问题是如何实现一个简单的运算器，下面是一个可能的解决方案：

首先是抽象类Operation的定义：

public abstract class Operation {
    protected double numberA;
    protected double numberB;
    
    public Operation(double numberA, double numberB) {
        this.numberA = numberA;
        this.numberB = numberB;
    }
    
    public abstract double getResult();
}

这个抽象类有两个数据成员numberA和numberB，表示两个运算数，以及一个抽象方法getResult()，用于计算运算结果。我们还定义了一个构造方法，用于初始化这两个数据成员。

接下来是Operation的四个子类，分别实现加、减、除、平均数运算：

public class AddOperation extends Operation {
    public AddOperation(double numberA, double numberB) {
        super(numberA, numberB);
    }
    
    public double getResult() {
        return numberA + numberB;
    }
}

public class SubOperation extends Operation {
    public SubOperation(double numberA, double numberB) {
        super(numberA, numberB);
    }
    
    public double getResult() {
        return numberA - numberB;
    }
}

public class DivOperation extends Operation {
    public DivOperation(double numberA, double numberB) {
        super(numberA, numberB);
    }
    
    public double getResult() {
        if (numberB == 0) {
            throw new IllegalArgumentException("除数不能为0");
        }
        
        return numberA / numberB;
    }
}

public class AvgOperation extends Operation {
    public AvgOperation(double numberA, double numberB) {
        super(numberA, numberB);
    }
    
    public double getResult() {
        return (numberA + numberB) / 2;
    }
}

这四个子类都继承自Operation类，实现了getResult()方法。其中AddOperation和SubOperation分别表示加法和减法运算，DivOperation表示除法运算，并且在除数为0的情况下会抛出异常，AvgOperation表示两个数的平均数运算。

最后是OperationFactory的定义：

public class OperationFactory {
    public static Operation createOperate(String operate) {
        switch (operate) {
            case "+":
                return new AddOperation(numberA, numberB);
            case "-":
                return new SubOperation(numberA, numberB);
            case "/":
                return new DivOperation(numberA, numberB);
            case "avg":
                return new AvgOperation(numberA, numberB);
            default:
                throw new IllegalArgumentException("不支持的运算符：" + operate);
        }
    }
}

这个类有一个静态方法createOperate()，根据传入的运算符字符串创建相应的Operation子类对象，然后返回抽象类引用。注意，这个方法并不知道传入的具体运算数值，它只是根据运算符字符串创建相应的对象。这就意味着我们需要在调用这个方法之前从用户输入中获取运算数值。

最后是测试类及主方法的定义：

import java.util.Scanner;

public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入第一个运算数：");
        double numberA = scanner.nextDouble();
        
        System.out.print("请输入第二个运算数：");
        double numberB = scanner.nextDouble();
        
        System.out.print("请输入运算符（+、-、/、avg）：");
        String operate = scanner.next();
        
        Operation operation = OperationFactory.createOperate(operate);
        operation.numberA = numberA;
        operation.numberB = numberB;
        double result = operation.getResult();
        
        System.out.println("运算结果为：" + result);
    }
}

这个测试类先从用户输入中获取两个运算数和一个运算符，然后调用OperationFactory的静态方法创建相应的Operation子类对象，设置运算数值，最后调用getResult()方法计算运算结果并输出。注意，这里直接设置了Operation对象的numberA和numberB属性，这是因为我们的OperationFactory类并不知道具体的运算数值。