Помощь в проектировании ООП решения

ArrayList<Shape> MyListOfShapes

public abstract class Shape
{
    Measure m_measure;
 
    // чтобы можно было выбирать какую именно меру нужно вычислить
    public double calculateMeasure( Measure neobhodimaya_mera ){}
}

public interface Measure
 {
    
    public Measure getMeasure( Measure m)
    {
        m.Calculate();
 
    }
 
}

ArrayList<Shape> MyListOfShapes

// создаем квадрат
Shape shape = new Square();
 
// добавляем его в список фигур
myListOfShapes.add(shape);
 
// создаем меру объема
Measure measure = new Measure("amount");
 
// проверяем
Shape shape = myListOfShapes.get(0);
if (shape instanceof Square && measure.getName == "amount") {
    throw new Exception("Square don't has amount");
}

public class Rectangle extends Shape{
    
    public Rectangle() {
        super(Arrays.asList(Measure.SQUARE));
    }
 
}

public abstract class Shape {
    
    protected Collection<Measure> supportedMeasures;
 
    public Shape(Collection<Measure> supportedMeasures) {
        this.supportedMeasures = supportedMeasures;
    }
 
    public boolean supportsMeasure(Measure targetMeasure) {
        return supportedMeasures.contains(targetMeasure);
    }
}

List<Shape> shapes = Arrays.asList(new Rectangle(), new Sphere());
Measure targetMeasure = Measure.SQUARE;
List<Shape> supportedShapes = shapes.stream().filter(shape -> shape.supportsMeasure(targetMeasure)).collect(Collectors.toList());

public abstract class Shape
{
   public ArrayList getSupportedMeasures() {}
}

public class Rectangle extends Shape
{
 
    ArrayList supportedMeasures = New ArrayList();
 
    Rectangle()
   { 
       supportedMeasures.add(square);
       supportedMeasures.add(otherMeasure);
   }
    
    public ArrayList getSupportedMeasures(){
        return  supportedMeasures;
    }

public abstract class Shape
{
   public abstract Collection<Measure> getSupportedMeasures();
}

public class Rectangle extends Shape
{
    @Override
    public Collection<Measure> getSupportedMeasures(){
        return  Arrays.asList(square, otherMeasure);
    }

public interface  Operator
 {
     public double execute(){}  
}
 
public class addition implements Operator
{
        public double execute( ArrayList<Shape> shapesList, Measure m )
     {
         double tmp_res = 0.0;
 
         while( shapesList.hasnext() )
        {
                   tmp_res +=  shapesList.calculateMeasure( m );
         }
     }
}
 
public class GroupOfShapes
{
   Operator m_operator;
   Measure m_measure;
   ArrayList<Shape> shapesList;
   
   public void addFiure(/*bla bla*/)
{
   /*bla bla bla*/
}   
 
   public void setOperator( Operator MathOperator)
   {
       m_operator = MathOperator;
    }
 
    public void setMeasure( Measure m)
   {
       m_measure = m;
    }
 
     public void Calculate()
     { 
         m_operator.execute( ArrayList<Shape> shapesList, m_measure );
     }
   
}
 
public static void main (String[] args) throws java.lang.Exception
{
 
     GroupOfShapes mygroup = new GroupOfShapes();
     mygroup.addFigure(/*bla bla*/);
 
//И ВОТ ЕСЛИ ТУТ ВСЁ ПОНЯТНО что можно вставить любой математический оператор типа new Multiplication и т.д.
// т.к. есть общий интерфейс Operator и унаследовавшись от него мы получаем гибкость и возможность   
// реализации любого алгоритма  который нам нужен и можем спокойно расширять кол-во алгоритмов 
     mygroup.setOperator( new addition );
 
//ТО КАК сделать тоже самое для меры чтобы с помощью полиморфизма выбирались из коллекции те классы
//которые поддерживают конкретную меру и в зависимости и от меры и от фигуры для каждой фигуры  
//по своему рассчитывалась эта мера через ... я немогу это решить и у меня взрывается мозг как
// выстроить такую архитектуру наследований?
               
}

@FunctionalInterface
public interface Measure {
 
    double calculate();
}

import java.util.Optional;
 
public interface Shape {
 
    Optional<Measure> getMeasure(String name);
}

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
 
public final class StandardMeasures {
 
    private static final Set<String> ALL = new HashSet<>();
 
    public static final String SIDE = add("side");
    public static final String RADIUS = add("radius");
    public static final String SQUARE = add("square");
 
    public static Collection<String> all() {
        return Collections.unmodifiableSet(ALL);
    }
 
    private static String add(String s) {
        ALL.add(s);
        return s;
    }
 
    private StandardMeasures() {
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.function.*;
 
public final class Square implements Shape, ShapeMeasureTrait<Square> {
 
    private static final Map<String, Function<Square, Measure>> MEASURES;
 
    static {
        MEASURES = new HashMap<>();
        MEASURES.put(StandardMeasures.SIDE, square -> square::side);
        MEASURES.put(StandardMeasures.SQUARE, square -> square::square);
    }
 
    private final double side;
 
    public Square(double side) {
        this.side = side;
    }
 
    @Override
    public Optional<Measure> getMeasure(String name) {
        return getMeasure(MEASURES, this, name);
    }
 
    public double side() {
        return side;
    }
 
    public double square() {
        return side * side;
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
 
public final class Circle implements Shape, ShapeMeasureTrait<Circle> {
 
    private static final Map<String, Function<Circle, Measure>> MEASURES;
 
    static {
        MEASURES = new HashMap<>();
        MEASURES.put(StandardMeasures.RADIUS, circle -> circle::radius);
        MEASURES.put(StandardMeasures.SQUARE, circle -> circle::square);
    }
 
    private final double radius;
 
    public Circle(double radius) {
        this.radius = radius;
    }
 
    @Override
    public Optional<Measure> getMeasure(String name) {
        return getMeasure(MEASURES, this, name);
    }
 
    public double radius() {
        return radius;
    }
 
    public double square() {
        return Math.PI * radius * radius;
    }
}

import java.io.PrintStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.DoubleStream;
 
public final class Main {
 
    public static void main(String[] args) {
        final List<Shape> shapes = new ArrayList<>();
        shapes.add(new Square(4));
        shapes.add(new Circle(3));
        for (final String measure : StandardMeasures.all()) {
            print(System.out, measure, calculateMeasure(shapes, measure));
        }
    }
 
    private static DoubleStream calculateMeasure(List<Shape> shapes, String measure) {
        return shapes.stream()
                .map(s -> s.getMeasure(measure))
                .filter(Optional::isPresent)
                .map(Optional::get)
                .mapToDouble(Measure::calculate);
    }
 
    private static void print(PrintStream out, String measure, DoubleStream values) {
        out.println();
        out.println(measure);
        values.forEach(out::println);
    }
}

import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
 
interface ShapeMeasureTrait<T extends Shape> {
 
    default Optional<Measure> getMeasure(Map<String, Function<T, Measure>> measures, T object, String measure) {
        final Function<T, Measure> m = measures.get(measure);
        if (m == null) {
            return Optional.empty();
        }
        return Optional.of(m.apply(object));
    }
}

private static final Set<String> ALL = new HashSet<>();

private static final Set<String> ALL = new HashSet<String>();