WARNING: when this method is used a subclass can never be equal to a parent type.

@param <T> the type of class
@return a new instance
976612
public static <T> Meta<T> meta() {
    return new Meta<>(MetaConfig.defaultConfig(), null, TYPED_PROPERTY_ARRAYS.empty(), TYPED_STRING_ARRAYS.empty());
  }
172599
public static <T> Class<T> isAssignableFrom(final Class<?> superType, final Class<T> type, final String message) {
        return INSTANCE.isAssignableFrom(superType, type, message);
    }
161730
public static Object createInstanceByType(Class<?> type, Object... args) throws Exception {
		if (args.length == 0) {
			Constructor<?> constructor = type.getConstructor();
			return constructor.newInstance();
		} else {
			throw new UnsupportedException(null, "NOT_SUPPORTED", "Constructors with parameters are not supported");
		}
	}
1005303
public <T extends AbstractCalculator> T bind(Class<T> clazz) {
        T childCalc = null;
        try {
            childCalc = clazz.newInstance();
        }
        catch (Exception e) {
            throw new CalculatorException(e);
        }

        if (childCalc instanceof AbstractCalculator) {
            // find last child from root
            AbstractCalculator<CALC> bParent = this;
            while (bParent != null) {
                if (bParent.childCalculator != null)
                    bParent = bParent.childCalculator;
                else
                    break;
            }

            ((AbstractCalculator) childCalc).parentCalculator = bParent;
            ((AbstractCalculator) childCalc).isBind = true;
            bParent.childCalculator = childCalc;
        }
        else {
            throw new CalculatorException("Use calculator which is type of AbstractCalculator", new IllegalArgumentException());
        }

        return childCalc;
    }
782924
static <T extends Assignable> UnknownExtensionTypeException newInstance(final Class<T> type)
        throws IllegalArgumentException {
        // Precondition checks
        if (type == null) {
            throw new IllegalArgumentException("type must be specified");
        }

        // Create new
        return new UnknownExtensionTypeException(type);
    }
409977
public Class<T> getT() {
        Type subTyping = Types.getBaseClass(getClass(), Descriptor.class);
        if (!(subTyping instanceof ParameterizedType)) {
            throw new IllegalStateException(getClass()+" doesn't extend Descriptor with a type parameter.");
        }
        return Types.erasure(Types.getTypeArgument(subTyping, 0));
    }
116748
public <T> T create(Class<T> clazz) {
        return create(clazz, new Class<?>[]{}, new Object[]{});
    }
1027335
@Override
  public <T> T as(Class<T> api)
  {
    return services().newProxy(this, api);
  }
141249
public static <T> SuperclassIterable<T> of(Class<T> type) {
        return new SuperclassIterable<>(type, false);
    }
1359144
@SuppressWarnings("rawtypes")
	public static <K extends Comparable, V> TreeRangeMap<K, V> createRangeMap() {
		return TreeRangeMap.create();
	}
453672
public static Object createInstance(Class<?> type)
    {
        Object instance=null;
        try
        {
            //create instance
            instance=type.newInstance();
        }
        catch(Exception exception)
        {
            throw new FaxException("Unable to create new instance of type: "+type,exception);
        }
        
        return instance;
    }
1368431
public static <T> T newInstance(Class<?> aClass, Object... initargs) 
	throws SetupException
	{
		Class<?>[] parameterTypes = null;
		
		if(initargs != null && initargs.length > 0)
		{
			parameterTypes = new Class<?>[initargs.length];
			
			for (int i = 0; i < initargs.length; i++)
			{
				if(initargs[i] == null)
					continue; //skip
				
				parameterTypes[i] = initargs[i].getClass();
			}
		}
		
		return newInstance(aClass,parameterTypes,initargs);
	}
537016
public T instantiateAnonymousSubclass() {
        Class<T> proxyClass = giveDynamicSubclass(type);
        return objenesis.newInstance(proxyClass);
    }
75158
@SuppressWarnings("unchecked")
    public static <T> T newInstance(Class<T> c) {
        return (T) InvokerHelper.invokeConstructorOf(c, null);
    }
1211428
public static Object newInstance(String className) throws InstantiationException,
                                                              IllegalAccessException,
                                                              ClassNotFoundException
    {
        return newInstance(getClass(className));
    }
1241903
public static <T> ClassSup<T> cls(Class<T> cls) {
                return mapper.get(cls.getName(), () -> new ClassSup<>(cls));
        }
284391
public static <T> T newInstance(String name) {
        try {
            return (T) getClass(name).newInstance();
        } catch (InstantiationException | ClassNotFoundException | IllegalAccessException e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }