Class declaration.

### Usage sample for toplevel classes

Because some classes have type parameters, getting a model requires applying type arguments to the class declaration with `classApply()` in order to be able to instantiate that class. For example, here is how you would obtain a class model that you can instantiate from a toplevel class declaration:

    class Foo<T>(){
        string => "Hello, our T is: ``typeLiteral<T>()``";
    }

    void test(){
        // We need to apply the Integer closed type to the Foo declaration in order to get the Foo<Integer> closed type
        Class<Foo<Integer>,[]> classModel = `class Foo`.classApply<Foo<Integer>,[]>(`Integer`);
        // This will print: Hello, our T is: ceylon.language::Integer
        print(classModel());
    }

### Usage sample for member classes

For member classes it is a bit longer, because member classes need to be applied not only their type arguments but also the containing type, so you should use `memberClassApply()` and start by giving the containing closed type:

    class Outer(){
        shared class Inner(){
            string => "Hello";
        }
    }

    void test(){
        // apply the containing closed type `Outer` to the member class declaration `Outer.Inner`
        MemberClass<Outer,Outer.Inner,[]> memberClassModel = `class Outer.Inner`.memberClassApply<Outer,Outer.Inner,[]>(`Outer`);
        // We now have a MemberClass, which needs to be applied to a containing instance in order to become an
        // invokable class model:
        Class<Outer.Inner,[]> boundMemberClassModel = memberClassModel(Outer());
        // This will print: Hello
        print(boundMemberClassModel());
    }

no type hierarchy

- `ClassDeclaration`
  - `ClassOrInterfaceDeclaration`
    - `GenericDeclaration`
    - `NestableDeclaration`
      - `AnnotatedDeclaration`
        - `Annotated`
        - `Declaration`
      - `TypedDeclaration`
  - `FunctionalDeclaration`

no subtypes hierarchy

Attributes
`abstract` | Source Code `shared formal Boolean abstract` True if the class has an abstract annotation.
`anonymous` | Source Code `shared formal Boolean anonymous` True if the class is an anonymous class, as is the case for the class of object value declarations.
`final` | Source Code `shared formal Boolean final` True if the class has a final annotation.
`objectValue` | Source Code `shared formal ValueDeclaration? objectValue` This anonymous class' object value declaration if this class is an anonymous class. `null` otherwise.

Inherited Attributes
Attributes inherited from: `Object` `Object.hash`, `Object.string`
Attributes inherited from: `ClassOrInterfaceDeclaration` `ClassOrInterfaceDeclaration.caseTypes`, `ClassOrInterfaceDeclaration.extendedType`, `ClassOrInterfaceDeclaration.isAlias`, `ClassOrInterfaceDeclaration.satisfiedTypes`
Attributes inherited from: `Declaration` `Declaration.name`, `Declaration.qualifiedName`
Attributes inherited from: `FunctionalDeclaration` `FunctionalDeclaration.annotation`, `FunctionalDeclaration.parameterDeclarations`
Attributes inherited from: `GenericDeclaration` `GenericDeclaration.typeParameterDeclarations`
Attributes inherited from: `NestableDeclaration` `NestableDeclaration.actual`, `NestableDeclaration.container`, `NestableDeclaration.containingModule`, `NestableDeclaration.containingPackage`, `NestableDeclaration.default`, `NestableDeclaration.formal`, `NestableDeclaration.shared`, `NestableDeclaration.toplevel`
Attributes inherited from: `TypedDeclaration` `TypedDeclaration.openType`

Methods
`classApply` | Source Code `shared formal Class<Type,Arguments> classApply<Type = Anything, Arguments = Nothing>(Type<Anything>[] typeArguments) given Arguments satisfies Anything[]` Applies the given closed type arguments to this toplevel class declaration in order to obtain a class model. See this code sample for an example on how to use this. Throws `IncompatibleTypeException` If the specified `Type` or `Arguments` type arguments are not compatible with the actual result. `TypeApplicationException` If the specified closed type argument values are not compatible with the actual result's type parameters.
`instantiate` | Source Code `shared default Anything instantiate(Type<Anything>[] typeArguments = [], Anything[] arguments)` Creates a new instance of this toplevel class, by applying the specified type arguments and value arguments. Parameters: `typeArguments = []` Throws `IncompatibleTypeException` If the specified type or value arguments are not compatible with this toplevel class.
`memberClassApply` | Source Code `shared formal MemberClass<Container,Type,Arguments> memberClassApply<Container = Nothing, Type = Anything, Arguments = Nothing>(Type<Container> containerType, Type<Anything>[] typeArguments) given Arguments satisfies Anything[]` Applies the given closed container type and type arguments to this member class declaration in order to obtain a member class model. See this code sample for an example on how to use this. Throws `IncompatibleTypeException` If the specified `Container`, `Type` or `Arguments` type arguments are not compatible with the actual result. `TypeApplicationException` If the specified closed container type or type argument values are not compatible with the actual result's container type or type parameters.
`memberInstantiate` | Source Code `shared default Anything memberInstantiate(Object container, Type<Anything>[] typeArguments = [], Anything[] arguments)` Creates a new instance of this member class, by applying the specified type arguments and value arguments. Parameters: `typeArguments = []` Throws `IncompatibleTypeException` If the specified container, type or value arguments are not compatible with this method.

Inherited Methods
Methods inherited from: `Object` `Object.equals()`
Methods inherited from: `AnnotatedDeclaration` `AnnotatedDeclaration.annotations()`
Methods inherited from: `ClassOrInterfaceDeclaration` `ClassOrInterfaceDeclaration.annotatedDeclaredMemberDeclarations()`, `ClassOrInterfaceDeclaration.annotatedMemberDeclarations()`, `ClassOrInterfaceDeclaration.apply()`, `ClassOrInterfaceDeclaration.declaredMemberDeclarations()`, `ClassOrInterfaceDeclaration.getDeclaredMemberDeclaration()`, `ClassOrInterfaceDeclaration.getMemberDeclaration()`, `ClassOrInterfaceDeclaration.memberApply()`, `ClassOrInterfaceDeclaration.memberDeclarations()`
Methods inherited from: `FunctionalDeclaration` `FunctionalDeclaration.getParameterDeclaration()`
Methods inherited from: `GenericDeclaration` `GenericDeclaration.getTypeParameterDeclaration()`