code: public DynamicType.Builder<?> subclass(TypeDefinition superType, ConstructorStrategy constructorStrategy) {
          TypeDescription.Generic actualSuperType;
          TypeList.Generic interfaceTypes;
          if (superType.isPrimitive() || superType.isArray() || superType.isFinal()) {
              throw new IllegalArgumentException("Cannot subclass primitive, array or final types: " + superType);
          } else if (superType.isInterface()) {
              actualSuperType = TypeDescription.Generic.OBJECT;
              interfaceTypes = new TypeList.Generic.Explicit(superType);
          } else {
              actualSuperType = superType.asGenericType();
              interfaceTypes = new TypeList.Generic.Empty();
          }
          return new SubclassDynamicTypeBuilder<Object>(instrumentedTypeFactory.subclass(namingStrategy.subclass(superType.asGenericType()),
                  ModifierContributor.Resolver.of(Visibility.PUBLIC, TypeManifestation.PLAIN).resolve(superType.getModifiers()),
                  actualSuperType).withInterfaces(interfaceTypes),
                  classFileVersion,
                  auxiliaryTypeNamingStrategy,
                  annotationValueFilterFactory,
                  annotationRetention,
                  implementationContextFactory,
                  methodGraphCompiler,
                  typeValidation,
                  visibilityBridgeStrategy,
                  classWriterStrategy,
                  ignoredMethods,
                  constructorStrategy);
      }
docs: <p>
  Creates a new builder for subclassing the provided type. If the provided type is an interface, a new class implementing
  this interface type is created.
  </p>
  <p>
  <b>Note</b>: This methods implements the supplied types <i>as is</i>, i.e. any {@link TypeDescription} values are implemented
  as raw types if they declare type variables.
  </p>
  <p>
  <b>Note</b>: Byte Buddy does not cache previous subclasses but will attempt the generation of a new subclass. For caching
  types, a external cache or {@link TypeCache} should be used.
  </p>
  
  @param superType           The super class or interface type to extend. The type must be a raw type or parameterized
  type. All type variables that are referenced by the generic type must be declared by the
  generated subclass before creating the type.
  @param constructorStrategy A constructor strategy that determines the
  @return A type builder for creating a new class extending the provided class or interface.