A coworker and I are having a debate. In our app, there are components that behave slightly differently based on how we want it to be presented. Thus far, we have agreed our inheritance should look akin to: 

```
     Component
     /      \
  Fixed    Resizeable

```

wherein `Fixed` would have a size property and `Resizeable` would have properties for bounds and initial size. However, there are ~20 different components that fit into 4 variants: `large`, `medium`, `medium-large` (resizeable), and `medium-small` (resizeable). 

We disagree with how the components should be set into these variants. 

**His solution:**

```
// make a class that sets the properties of the variant
class MediumLargeResizeableComponent extends ResizeableComponent {
    MediumLargeResizeableComponent() {
        super(MEDIUM, LARGE); // some constants for the bounds
    }
}

class CustomComponent extends MediumLargeResizeableComponent {
    CustomComponent() {
        // doesn't have to set the size properties
    }
}

```

This solution uses a different class for each variant that sets the properties. I see this as a problem because you need a new class for each variant and doesn't seem like a good use of inheritance. He thinks it makes it easier to understand what the class is doing. He also says it makes it easier to change all the classes that use that variant. 

**My solution:**

```
// inherit directly and set the properties 
class CustomComponent extends ResizeableComponent {
    CustomComponent() {
        super(MEDIUM, LARGE); // constants for the bounds
    }
}

```

This solution is simpler and leaves the customization to the component. 

The only technical reason I can see against his solution is that the technique doesn't scale to other properties without creating a lot of variants. He doesn't see this as a problem because we don't have a need for other properties like this. 

Is his solution - using inheritance to set properties - a bad model? Or is it acceptable in situations like this?

*Edit:* 

I feel like there may be some confusion. The 20 different classes are simply different components that each do different things that are independent, but each of those classes only fit 1 of the size variants. As above, `CustomComponent` is resizeable from medium to large and nothing else.