diff --git a/include/jni/array.hpp b/include/jni/array.hpp
index 68a254a..874a9dd 100644
--- a/include/jni/array.hpp
+++ b/include/jni/array.hpp
@@ -82,11 +82,11 @@ namespace jni
        };
 
     template < class TheTag >
-    class Array< Object<TheTag> >
+    class Array< TypedObject<TheTag> >
        {
         public:
             using TagType = TheTag;
-            using ElementType = Object<TagType>;
+            using ElementType = TypedObject<TagType>;
             using UntaggedType = jarray<jobject>;
             using UntaggedElementType = typename ElementType::UntaggedObjectType;
 
@@ -124,12 +124,12 @@ namespace jni
                 SetObjectArrayElement(env, SafeDereference(env, array), index, Untag(value));
                }
 
-            static Array<Object<TheTag>> New(JNIEnv& env, jsize length, const Class<TheTag>& clazz, const Object<TheTag>& initialElement = Object<TheTag>())
+            static Array<TypedObject<TheTag>> New(JNIEnv& env, jsize length, const TypedClass<TheTag>& clazz, const TypedObject<TheTag>& initialElement = TypedObject<TheTag>())
                {
-                return Array<Object<TheTag>>(&NewObjectArray(env, length, clazz, initialElement.Get()));
+                return Array<TypedObject<TheTag>>(&NewObjectArray(env, length, clazz, initialElement.Get()));
                }
 
-            UniqueArray<Object<TheTag>> NewGlobalRef(JNIEnv& env) const
+            UniqueArray<TypedObject<TheTag>> NewGlobalRef(JNIEnv& env) const
                {
                 return Seize(env, Array(jni::NewGlobalRef(env, array).release()));
                }
diff --git a/include/jni/class.hpp b/include/jni/class.hpp
index 1c087cc..4b9bfd7 100644
--- a/include/jni/class.hpp
+++ b/include/jni/class.hpp
@@ -1,40 +1,44 @@
 #pragma once
 
 #include <jni/functions.hpp>
+#include <jni/type.hpp>
 #include <jni/tagging.hpp>
 #include <jni/pointer_to_value.hpp>
 
 namespace jni
    {
-    template < class TheTag > class Object;
-    template < class TheTag, class... > class Constructor;
-    template < class TheTag, class > class Field;
-    template < class TheTag, class > class StaticField;
-    template < class TheTag, class > class Method;
-    template < class TheTag, class > class StaticMethod;
+    template < class TagType > class TypedObject;
+    template < class TagType, class... > class TypedConstructor;
+    template < class TagType, class > class TypedField;
+    template < class TagType, class > class TypedStaticField;
+    template < class TagType, class > class TypedMethod;
+    template < class TagType, class > class TypedStaticMethod;
 
-    template < class TheTag >
-    class Class;
+    template < class TagType >
+    class TypedClass;
 
     template < class TagType >
-    class ClassDeleter;
+    class TypedClassDeleter;
 
     template < class TagType >
-    using UniqueClass = std::unique_ptr< const Class<TagType>, ClassDeleter<TagType> >;
+    using TypedUniqueClass = std::unique_ptr< const TypedClass<TagType>, TypedClassDeleter<TagType> >;
+
+    template < class Tag >
+    using Class = TypedClass< TypeFromTag<Tag> >;
 
-    template < class TheTag >
-    class Class
+    template <char... Chars>
+    class TypedClass< Type<Chars...> >
        {
         private:
             jclass* clazz = nullptr;
 
         public:
-            using TagType = TheTag;
+            using TagType = Type<Chars...>;
 
-            explicit Class(std::nullptr_t = nullptr)
+            explicit TypedClass(std::nullptr_t = nullptr)
                {}
 
-            explicit Class(jclass& c)
+            explicit TypedClass(jclass& c)
                : clazz(&c)
                {}
 
@@ -44,115 +48,116 @@ namespace jni
             jclass& operator*() const { return *clazz; }
             jclass* Get() const { return clazz; }
 
-            friend bool operator==( const Class& a, const Class& b )  { return a.Get() == b.Get(); }
-            friend bool operator!=( const Class& a, const Class& b )  { return !( a == b ); }
+            friend bool operator==( const TypedClass& a, const TypedClass& b )  { return a.Get() == b.Get(); }
+            friend bool operator!=( const TypedClass& a, const TypedClass& b )  { return !( a == b ); }
 
             template < class... Args >
-            Object<TagType> New(JNIEnv& env, const Constructor<TagType, Args...>& method, const Args&... args) const
+            TypedObject<TagType> New(JNIEnv& env, const TypedConstructor<TagType, Args...>& method, const Args&... args) const
                {
-                return Object<TagType>(&NewObject(env, *clazz, method, Untag(args)...));
+                return TypedObject<TagType>(&NewObject(env, *clazz, method, Untag(args)...));
                }
 
             template < class T >
-            auto Get(JNIEnv& env, const StaticField<TagType, T>& field) const
+            auto Get(JNIEnv& env, const TypedStaticField<TagType, T>& field) const
                -> std::enable_if_t< IsPrimitive<T>::value, T >
                {
                 return jni::GetStaticField<T>(env, *clazz, field);
                }
 
             template < class T >
-            auto Get(JNIEnv& env, const StaticField<TagType, T>& field) const
+            auto Get(JNIEnv& env, const TypedStaticField<TagType, T>& field) const
                -> std::enable_if_t< !IsPrimitive<T>::value, T >
                {
                 return T(reinterpret_cast<UntaggedType<T>>(jni::GetStaticField<jobject*>(env, *clazz, field)));
                }
 
             template < class T >
-            auto Set(JNIEnv& env, const StaticField<TagType, T>& field, T value) const
+            auto Set(JNIEnv& env, const TypedStaticField<TagType, T>& field, T value) const
                -> std::enable_if_t< IsPrimitive<T>::value >
                {
                 SetStaticField<T>(env, *clazz, field, value);
                }
 
             template < class T >
-            auto Set(JNIEnv& env, const StaticField<TagType, T>& field, const T& value) const
+            auto Set(JNIEnv& env, const TypedStaticField<TagType, T>& field, const T& value) const
                -> std::enable_if_t< !IsPrimitive<T>::value >
                {
                 SetStaticField<jobject*>(env, *clazz, field, value.Get());
                }
 
             template < class R, class... Args >
-            auto Call(JNIEnv& env, const StaticMethod<TagType, R (Args...)>& method, const Args&... args) const
+            auto Call(JNIEnv& env, const TypedStaticMethod<TagType, R (Args...)>& method, const Args&... args) const
                -> std::enable_if_t< IsPrimitive<R>::value, R >
                {
                 return CallStaticMethod<R>(env, *clazz, method, Untag(args)...);
                }
 
             template < class R, class... Args >
-            auto Call(JNIEnv& env, const StaticMethod<TagType, R (Args...)>& method, const Args&... args) const
+            auto Call(JNIEnv& env, const TypedStaticMethod<TagType, R (Args...)>& method, const Args&... args) const
                -> std::enable_if_t< !IsPrimitive<R>::value, R >
                {
                 return R(reinterpret_cast<UntaggedType<R>>(CallStaticMethod<jobject*>(env, *clazz, method, Untag(args)...)));
                }
 
             template < class... Args >
-            void Call(JNIEnv& env, const StaticMethod<TagType, void (Args...)>& method, const Args&... args) const
+            void Call(JNIEnv& env, const TypedStaticMethod<TagType, void (Args...)>& method, const Args&... args) const
                {
                 CallStaticMethod<void>(env, *clazz, method, Untag(args)...);
                }
 
-            static Class Find(JNIEnv& env)
+            static TypedClass Find(JNIEnv& env)
                {
-                return Class(FindClass(env, TagType::Name()));
+                static constexpr const char name[] { Chars..., '\0' };
+                return TypedClass(FindClass(env, name));
                }
 
             template < class... Args >
-            Constructor<TagType, Args...> GetConstructor(JNIEnv& env)
+            TypedConstructor<TagType, Args...> GetConstructor(JNIEnv& env)
                {
-                return Constructor<TagType, Args...>(env, *this);
+                return TypedConstructor<TagType, Args...>(env, *this);
                }
 
             template < class T >
-            Field<TagType, T> GetField(JNIEnv& env, const char* name)
+            TypedField<TagType, T> GetField(JNIEnv& env, const char* name)
                {
-                return Field<TagType, T>(env, *this, name);
+                return TypedField<TagType, T>(env, *this, name);
                }
 
             template < class T >
-            StaticField<TagType, T> GetStaticField(JNIEnv& env, const char* name)
+            TypedStaticField<TagType, T> GetStaticField(JNIEnv& env, const char* name)
                {
-                return StaticField<TagType, T>(env, *this, name);
+                return TypedStaticField<TagType, T>(env, *this, name);
                }
 
             template < class T >
-            Method<TagType, T> GetMethod(JNIEnv& env, const char* name)
+            TypedMethod<TagType, T> GetMethod(JNIEnv& env, const char* name)
                {
-                return Method<TagType, T>(env, *this, name);
+                return TypedMethod<TagType, T>(env, *this, name);
                }
 
             template < class T >
-            StaticMethod<TagType, T> GetStaticMethod(JNIEnv& env, const char* name)
+            TypedStaticMethod<TagType, T> GetStaticMethod(JNIEnv& env, const char* name)
                {
-                return StaticMethod<TagType, T>(env, *this, name);
+                return TypedStaticMethod<TagType, T>(env, *this, name);
                }
 
-            UniqueClass<TagType> NewGlobalRef(JNIEnv& env) const
+            TypedUniqueClass<TagType> NewGlobalRef(JNIEnv& env) const
                {
-                return Seize(env, Class(*jni::NewGlobalRef(env, clazz).release()));
+                return Seize(env, TypedClass(*jni::NewGlobalRef(env, clazz).release()));
                }
        };
 
-    template < class TagType >
-    class ClassDeleter
+    template <char... Chars>
+    class TypedClassDeleter< Type<Chars...> >
        {
         private:
             JNIEnv* env = nullptr;
 
         public:
-            using pointer = PointerToValue< Class<TagType> >;
+            using pointer = PointerToValue< TypedClass< Type<Chars...> > >;
 
-            ClassDeleter() = default;
-            ClassDeleter(JNIEnv& e) : env(&e) {}
+            TypedClassDeleter() = default;
+            TypedClassDeleter(JNIEnv& e) : env(&e) {}
 
             void operator()(pointer p) const
                {
@@ -165,8 +170,8 @@ namespace jni
        };
 
     template < class TagType >
-    UniqueClass<TagType> Seize(JNIEnv& env, Class<TagType>&& clazz)
+    TypedUniqueClass<TagType> Seize(JNIEnv& env, TypedClass<TagType>&& clazz)
        {
-        return UniqueClass<TagType>(PointerToValue<Class<TagType>>(std::move(clazz)), ClassDeleter<TagType>(env));
+        return TypedUniqueClass<TagType>(PointerToValue<TypedClass<TagType>>(std::move(clazz)), TypedClassDeleter<TagType>(env));
        };
    }
diff --git a/include/jni/constructor.hpp b/include/jni/constructor.hpp
index 97896c9..8ad0e09 100644
--- a/include/jni/constructor.hpp
+++ b/include/jni/constructor.hpp
@@ -4,12 +4,16 @@
 
 namespace jni
    {
+
+    template < class Tag, class... Args >
+    using Constructor = TypedConstructor< TypeFromTag<Tag>, Args... >;
+
     template < class TagType, class... Args >
-    class Constructor : public Method<TagType, void (Args...)>
+    class TypedConstructor : public TypedMethod<TagType, void (Args...)>
        {
         public:
-            Constructor(JNIEnv& env, const Class<TagType>& clazz)
-               : Method<TagType, void (Args...)>(env, clazz, "<init>")
+            TypedConstructor(JNIEnv& env, const TypedClass<TagType>& clazz)
+               : TypedMethod<TagType, void (Args...)>(env, clazz, "<init>")
                {}
        };
    }
diff --git a/include/jni/field.hpp b/include/jni/field.hpp
index 63f5281..19f04e4 100644
--- a/include/jni/field.hpp
+++ b/include/jni/field.hpp
@@ -8,16 +8,22 @@
 
 namespace jni
    {
-    template < class TheTag, class T >
-    class Field
+    template < class TagType, class T >
+    class TypedField;
+
+    template < class Tag, class T >
+    using Field = TypedField< TypeFromTag<Tag>, T >;
+
+    template <char... Chars, class T>
+    class TypedField< Type<Chars...>, T >
        {
         private:
             jfieldID& field;
 
         public:
-            using TagType = TheTag;
+            using TagType = Type<Chars...>;
 
-            Field(JNIEnv& env, const Class<TagType>& clazz, const char* name)
+            TypedField(JNIEnv& env, const TypedClass<TagType>& clazz, const char* name)
               : field(GetFieldID(env, clazz, name, TypeSignature<T>()()))
                {}
 
diff --git a/include/jni/method.hpp b/include/jni/method.hpp
index bbca4ec..b58f607 100644
--- a/include/jni/method.hpp
+++ b/include/jni/method.hpp
@@ -8,19 +8,22 @@
 
 namespace jni
    {
-    template < class TheTag, class >
-    class Method;
+    template < class TagType, class >
+    class TypedMethod;
 
-    template < class TheTag, class R, class... Args >
-    class Method< TheTag, R (Args...) >
+    template < class Tag, class R, class... Args >
+    using Method = TypedMethod< TypeFromTag<Tag>, R (Args...) >;
+
+    template < char... Chars, class R, class... Args >
+    class TypedMethod< Type<Chars...>, R (Args...) >
        {
         private:
             jmethodID& method;
 
         public:
-            using TagType = TheTag;
+            using TagType = Type<Chars...>;
 
-            Method(JNIEnv& env, const Class<TagType>& clazz, const char* name)
+            TypedMethod(JNIEnv& env, const TypedClass<TagType>& clazz, const char* name)
               : method(GetMethodID(env, clazz, name, TypeSignature<R (Args...)>()()))
                {}
 
diff --git a/include/jni/native_method.hpp b/include/jni/native_method.hpp
index 573b8a4..4f2444d 100644
--- a/include/jni/native_method.hpp
+++ b/include/jni/native_method.hpp
@@ -165,9 +165,9 @@ namespace jni
                {}
 
             template < class Peer, class TagType, class = std::enable_if_t< std::is_same<P, Peer>::value > >
-            auto operator()(const Field<TagType, jlong>& field)
+            auto operator()(const TypedField<TagType, jlong>& field)
                {
-                auto wrapper = [field, lambda = lambda] (JNIEnv& env, Object<TagType> obj, Args... args)
+                auto wrapper = [field, lambda = lambda] (JNIEnv& env, TypedObject<TagType> obj, Args... args)
                    {
                     return lambda(env, *reinterpret_cast<P*>(obj.Get(env, field)), std::move(args)...);
                    };
@@ -201,9 +201,9 @@ namespace jni
                {}
 
             template < class Peer, class TagType, class = std::enable_if_t< std::is_same<P, Peer>::value > >
-            auto operator()(const Field<TagType, jlong>& field)
+            auto operator()(const TypedField<TagType, jlong>& field)
                {
-                auto wrapper = [field] (JNIEnv& env, Object<TagType> obj, Args... args)
+                auto wrapper = [field] (JNIEnv& env, TypedObject<TagType> obj, Args... args)
                    {
                     return method(env, *reinterpret_cast<P*>(obj.Get(env, field)), std::move(args)...);
                    };
@@ -238,9 +238,9 @@ namespace jni
                {}
 
             template < class Peer, class TagType, class = std::enable_if_t< std::is_same<P, Peer>::value > >
-            auto operator()(const Field<TagType, jlong>& field)
+            auto operator()(const TypedField<TagType, jlong>& field)
                {
-                auto wrapper = [field] (JNIEnv& env, Object<TagType> obj, Args... args)
+                auto wrapper = [field] (JNIEnv& env, TypedObject<TagType> obj, Args... args)
                    {
                     return (reinterpret_cast<P*>(obj.Get(env, field))->*method)(env, std::move(args)...);
                    };
@@ -279,9 +279,9 @@ namespace jni
      */
 
     template < class Peer, class TagType, class... Methods >
-    void RegisterNativePeer(JNIEnv& env, const Class<TagType>& clazz, const char* fieldName, Methods&&... methods)
+    void RegisterNativePeer(JNIEnv& env, const TypedClass<TagType>& clazz, const char* fieldName, Methods&&... methods)
        {
-        static Field<TagType, jni::jlong> field { env, clazz, fieldName };
+        static TypedField<TagType, jni::jlong> field { env, clazz, fieldName };
         RegisterNatives(env, clazz, methods.template operator()<Peer>(field)...);
        }
 
@@ -294,9 +294,9 @@ namespace jni
         using UniquePeer = std::unique_ptr<Peer>;
         using Initializer = UniquePeer (JNIEnv&, Args...);
 
-        auto MakeInitializer(const Field<TagType, jlong>& field, const char* name, Initializer* initializer) const
+        auto MakeInitializer(const TypedField<TagType, jlong>& field, const char* name, Initializer* initializer) const
            {
-            auto wrapper = [field, initializer] (JNIEnv& e, Object<TagType> obj, std::decay_t<Args>... args)
+            auto wrapper = [field, initializer] (JNIEnv& e, TypedObject<TagType> obj, std::decay_t<Args>... args)
                {
                 UniquePeer previous(reinterpret_cast<Peer*>(obj.Get(e, field)));
                 UniquePeer instance(initializer(e, std::move(args)...));
@@ -307,9 +307,9 @@ namespace jni
             return MakeNativeMethod(name, wrapper);
            }
 
-        auto MakeFinalizer(const Field<TagType, jlong>& field, const char* name) const
+        auto MakeFinalizer(const TypedField<TagType, jlong>& field, const char* name) const
            {
-            auto wrapper = [field] (JNIEnv& e, Object<TagType> obj)
+            auto wrapper = [field] (JNIEnv& e, TypedObject<TagType> obj)
                {
                 UniquePeer instance(reinterpret_cast<Peer*>(obj.Get(e, field)));
                 if (instance) obj.Set(e, field, jlong(0));
@@ -321,13 +321,13 @@ namespace jni
        };
 
     template < class Peer, class TagType, class Initializer, class... Methods >
-    void RegisterNativePeer(JNIEnv& env, const Class<TagType>& clazz, const char* fieldName,
+    void RegisterNativePeer(JNIEnv& env, const TypedClass<TagType>& clazz, const char* fieldName,
                             Initializer initialize,
                             const char* initializeMethodName,
                             const char* finalizeMethodName,
                             Methods&&... methods)
        {
-        static Field<TagType, jlong> field { env, clazz, fieldName };
+        static TypedField<TagType, jlong> field { env, clazz, fieldName };
 
         using InitializerMethodType = typename NativeMethodTraits<Initializer>::Type;
         NativePeerHelper<Peer, TagType, InitializerMethodType> helper;
diff --git a/include/jni/object.hpp b/include/jni/object.hpp
index 6dd97e8..36bc538 100644
--- a/include/jni/object.hpp
+++ b/include/jni/object.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <jni/functions.hpp>
+#include <jni/type.hpp>
 #include <jni/tagging.hpp>
 #include <jni/pointer_to_value.hpp>
 
@@ -8,55 +9,70 @@
 
 namespace jni
    {
-    template < class TheTag > class Class;
-    template < class TheTag, class > class Field;
-    template < class TheTag, class > class Method;
+    template < class TagType > class TypedClass;
+    template < class TagType, class > class TypedField;
+    template < class TagType, class > class TypedMethod;
 
     struct ObjectTag { static constexpr auto Name() { return "java/lang/Object"; } };
 
     template < class TagType >
-    struct UntaggedObjectType { using Type = jobject; };
+    struct TypedUntaggedObjectType;
 
-    template < class TheTag >
-    class Object;
+    template <char... Chars>
+    struct TypedUntaggedObjectType<Type<Chars...>> { using Type = jobject; };
+
+    template < class TagType = TypeFromTag<ObjectTag> >
+    class TypedObject;
 
     template < class TagType >
-    class ObjectDeleter;
+    class TypedObjectDeleter;
+
+    template < class TagType = TypeFromTag<ObjectTag> >
+    using TypedUniqueObject = std::unique_ptr< const TypedObject<TagType>, TypedObjectDeleter<TagType> >;
 
-    template < class TagType = ObjectTag >
-    using UniqueObject = std::unique_ptr< const Object<TagType>, ObjectDeleter<TagType> >;
+    template < class Tag = ObjectTag >
+    using UniqueObject = TypedUniqueObject< TypeFromTag<Tag> >;
 
     template < class TagType >
-    class WeakObjectRefDeleter;
+    class TypedWeakObjectRefDeleter;
+
+    template < class TagType = TypeFromTag<ObjectTag> >
+    using TypedUniqueWeakObject = std::unique_ptr< const TypedObject<TagType>, TypedWeakObjectRefDeleter<TagType> >;
 
-    template < class TagType = ObjectTag >
-    using UniqueWeakObject = std::unique_ptr< const Object<TagType>, WeakObjectRefDeleter<TagType> >;
+    template < class Tag = ObjectTag >
+    using UniqueWeakObject = TypedUniqueWeakObject< TypeFromTag<Tag> >;
 
     template < class TagType >
-    class LocalObjectRefDeleter;
+    class TypedLocalObjectRefDeleter;
 
-    template < class TagType = ObjectTag >
-    using UniqueLocalObject = std::unique_ptr< const Object<TagType>, LocalObjectRefDeleter<TagType> >;
+    template < class TagType = TypeFromTag<ObjectTag> >
+    using TypedUniqueLocalObject = std::unique_ptr< const TypedObject<TagType>, TypedLocalObjectRefDeleter<TagType> >;
 
-    template < class TheTag = ObjectTag >
-    class Object
+    template < class Tag = ObjectTag >
+    using UniqueLocalObject = TypedUniqueLocalObject< TypeFromTag<Tag> >;
+
+    template < class Tag = ObjectTag >
+    using Object = TypedObject< TypeFromTag<Tag> >;
+
+    template < char... Chars >
+    class TypedObject< Type<Chars...> >
        {
         public:
-            using TagType = TheTag;
-            using UntaggedObjectType = typename UntaggedObjectType<TagType>::Type;
+            using TagType = Type<Chars...>;
+            using UntaggedObjectType = typename TypedUntaggedObjectType<TagType>::Type;
 
         private:
             UntaggedObjectType* obj = nullptr;
 
         public:
-            explicit Object(std::nullptr_t = nullptr)
+            explicit TypedObject(std::nullptr_t = nullptr)
                {}
 
-            explicit Object(UntaggedObjectType* o)
+            explicit TypedObject(UntaggedObjectType* o)
                : obj(o)
                {}
 
-            explicit Object(UntaggedObjectType& o)
+            explicit TypedObject(UntaggedObjectType& o)
                : obj(&o)
                {}
 
@@ -66,110 +82,113 @@ namespace jni
             UntaggedObjectType& operator*() const { return *obj; }
             UntaggedObjectType* Get() const { return obj; }
 
-            friend bool operator==( const Object& a, const Object& b )  { return a.Get() == b.Get(); }
-            friend bool operator!=( const Object& a, const Object& b )  { return !( a == b ); }
+            friend bool operator==( const TypedObject& a, const TypedObject& b )  { return a.Get() == b.Get(); }
+            friend bool operator!=( const TypedObject& a, const TypedObject& b )  { return !( a == b ); }
 
             template < class T >
-            auto Get(JNIEnv& env, const Field<TagType, T>& field) const
+            auto Get(JNIEnv& env, const TypedField<TagType, T>& field) const
                -> std::enable_if_t< IsPrimitive<T>::value, T >
                {
                 return GetField<T>(env, obj, field);
                }
 
             template < class T >
-            auto Get(JNIEnv& env, const Field<TagType, T>& field) const
+            auto Get(JNIEnv& env, const TypedField<TagType, T>& field) const
                -> std::enable_if_t< !IsPrimitive<T>::value, T >
                {
                 return T(reinterpret_cast<UntaggedType<T>>(GetField<jobject*>(env, obj, field)));
                }
 
             template < class T >
-            auto Set(JNIEnv& env, const Field<TagType, T>& field, T value) const
+            auto Set(JNIEnv& env, const TypedField<TagType, T>& field, T value) const
                -> std::enable_if_t< IsPrimitive<T>::value >
                {
                 SetField<T>(env, obj, field, value);
                }
 
             template < class T >
-            auto Set(JNIEnv& env, const Field<TagType, T>& field, const T& value) const
+            auto Set(JNIEnv& env, const TypedField<TagType, T>& field, const T& value) const
                -> std::enable_if_t< !IsPrimitive<T>::value >
                {
                 SetField<jobject*>(env, obj, field, value.Get());
                }
 
             template < class R, class... Args >
-            auto Call(JNIEnv& env, const Method<TagType, R (Args...)>& method, const Args&... args) const
+            auto Call(JNIEnv& env, const TypedMethod<TagType, R (Args...)>& method, const Args&... args) const
                -> std::enable_if_t< IsPrimitive<R>::value, R >
                {
                 return CallMethod<R>(env, obj, method, Untag(args)...);
                }
 
             template < class R, class... Args >
-            auto Call(JNIEnv& env, const Method<TagType, R (Args...)>& method, const Args&... args) const
+            auto Call(JNIEnv& env, const TypedMethod<TagType, R (Args...)>& method, const Args&... args) const
                -> std::enable_if_t< !IsPrimitive<R>::value, R >
                {
                 return R(reinterpret_cast<UntaggedType<R>>(CallMethod<jobject*>(env, obj, method, Untag(args)...)));
                }
 
             template < class... Args >
-            void Call(JNIEnv& env, const Method<TagType, void (Args...)>& method, const Args&... args) const
+            void Call(JNIEnv& env, const TypedMethod<TagType, void (Args...)>& method, const Args&... args) const
                {
                 CallMethod<void>(env, obj, method, Untag(args)...);
                }
 
             template < class R, class... Args >
-            auto CallNonvirtual(JNIEnv& env, const Class<TagType>& clazz, const Method<TagType, R (Args...)>& method, const Args&... args) const
+            auto CallNonvirtual(JNIEnv& env, const TypedClass<TagType>& clazz, const TypedMethod<TagType, R (Args...)>& method, const Args&... args) const
                -> std::enable_if_t< IsPrimitive<R>::value, R >
                {
                 return CallNonvirtualMethod<R>(env, obj, clazz, method, Untag(args)...);
                }
 
             template < class R, class... Args >
-            auto CallNonvirtual(JNIEnv& env, const Class<TagType>& clazz, const Method<TagType, R (Args...)>& method, const Args&... args) const
+            auto CallNonvirtual(JNIEnv& env, const TypedClass<TagType>& clazz, const TypedMethod<TagType, R (Args...)>& method, const Args&... args) const
                -> std::enable_if_t< !IsPrimitive<R>::value, R >
                {
                 return R(reinterpret_cast<UntaggedType<R>>(CallNonvirtualMethod<jobject*>(env, obj, clazz, method, Untag(args)...)));
                }
 
             template < class... Args >
-            void CallNonvirtual(JNIEnv& env, const Class<TagType>& clazz, const Method<TagType, void (Args...)>& method, const Args&... args) const
+            void CallNonvirtual(JNIEnv& env, const TypedClass<TagType>& clazz, const TypedMethod<TagType, void (Args...)>& method, const Args&... args) const
                {
                 CallNonvirtualMethod<void>(env, obj, clazz, method, Untag(args)...);
                }
 
-            UniqueObject<TagType> NewGlobalRef(JNIEnv& env) const
+            TypedUniqueObject<TagType> NewGlobalRef(JNIEnv& env) const
                {
-                return Seize(env, Object(jni::NewGlobalRef(env, obj).release()));
+                return Seize(env, TypedObject(jni::NewGlobalRef(env, obj).release()));
                }
 
-            UniqueWeakObject<TagType> NewWeakGlobalRef(JNIEnv& env) const
+            TypedUniqueWeakObject<TagType> NewWeakGlobalRef(JNIEnv& env) const
                {
-                return SeizeWeakRef(env, Object(jni::NewWeakGlobalRef(env, obj).release()));
+                return SeizeWeakRef(env, TypedObject(jni::NewWeakGlobalRef(env, obj).release()));
                }
 
-            UniqueLocalObject<TagType> NewLocalRef(JNIEnv& env) const
+            TypedUniqueLocalObject<TagType> NewLocalRef(JNIEnv& env) const
                {
-                return SeizeLocalRef(env, Object(jni::NewLocalRef(env, obj).release()));
+                return SeizeLocalRef(env, TypedObject(jni::NewLocalRef(env, obj).release()));
                }
 
             template < class OtherTag >
-            bool IsInstanceOf(JNIEnv& env, const Class<OtherTag>& clazz) const
+            bool IsInstanceOf(JNIEnv& env, const TypedClass<OtherTag>& clazz) const
                {
                 return jni::IsInstanceOf(env, obj, clazz);
                }
        };
 
-    template < class TagType >
-    class ObjectDeleter
+    template < class Tag = ObjectTag >
+    using ObjectDeleter = TypedObjectDeleter< TypeFromTag<Tag> >;
+
+    template < char... Chars >
+    class TypedObjectDeleter< Type<Chars...> >
        {
         private:
             JNIEnv* env = nullptr;
 
         public:
-            using pointer = PointerToValue< Object<TagType> >;
+            using pointer = PointerToValue< TypedObject< Type<Chars...> > >;
 
-            ObjectDeleter() = default;
-            ObjectDeleter(JNIEnv& e) : env(&e) {}
+            TypedObjectDeleter() = default;
+            TypedObjectDeleter(JNIEnv& e) : env(&e) {}
 
             void operator()(pointer p) const
                {
@@ -182,22 +201,25 @@ namespace jni
        };
 
     template < class TagType >
-    UniqueObject<TagType> Seize(JNIEnv& env, Object<TagType>&& object)
+    TypedUniqueObject<TagType> Seize(JNIEnv& env, TypedObject<TagType>&& object)
        {
-        return UniqueObject<TagType>(PointerToValue<Object<TagType>>(std::move(object)), ObjectDeleter<TagType>(env));
+        return TypedUniqueObject<TagType>(PointerToValue<TypedObject<TagType>>(std::move(object)), TypedObjectDeleter<TagType>(env));
        };
 
-    template < class TagType >
-    class WeakObjectRefDeleter
+    template < class Tag = ObjectTag >
+    using WeakObjectRefDeleter = TypedWeakObjectRefDeleter< TypeFromTag<Tag> >;
+
+    template < char... Chars >
+    class TypedWeakObjectRefDeleter< Type<Chars...> >
        {
         private:
             JNIEnv* env = nullptr;
 
         public:
-            using pointer = PointerToValue< Object<TagType> >;
+            using pointer = PointerToValue< TypedObject< Type<Chars...> > >;
 
-            WeakObjectRefDeleter() = default;
-            WeakObjectRefDeleter(JNIEnv& e) : env(&e) {}
+            TypedWeakObjectRefDeleter() = default;
+            TypedWeakObjectRefDeleter(JNIEnv& e) : env(&e) {}
 
             void operator()(pointer p) const
                {
@@ -210,22 +232,25 @@ namespace jni
        };
 
     template < class TagType >
-    UniqueWeakObject<TagType> SeizeWeakRef(JNIEnv& env, Object<TagType>&& object)
+    TypedUniqueWeakObject<TagType> SeizeWeakRef(JNIEnv& env, TypedObject<TagType>&& object)
        {
-        return UniqueWeakObject<TagType>(PointerToValue<Object<TagType>>(std::move(object)), WeakObjectRefDeleter<TagType>(env));
+        return TypedUniqueWeakObject<TagType>(PointerToValue<TypedObject<TagType>>(std::move(object)), TypedWeakObjectRefDeleter<TagType>(env));
        };
 
-    template < class TagType >
-    class LocalObjectRefDeleter
+    template < class Tag = ObjectTag >
+    using LocalObjectRefDeleter = TypedLocalObjectRefDeleter< TypeFromTag<Tag> >;
+
+    template < char... Chars >
+    class TypedLocalObjectRefDeleter< Type<Chars...> >
        {
         private:
             JNIEnv* env = nullptr;
 
         public:
-            using pointer = PointerToValue< Object<TagType> >;
+            using pointer = PointerToValue< TypedObject< Type<Chars...> > >;
 
-            LocalObjectRefDeleter() = default;
-            LocalObjectRefDeleter(JNIEnv& e) : env(&e) {}
+            TypedLocalObjectRefDeleter() = default;
+            TypedLocalObjectRefDeleter(JNIEnv& e) : env(&e) {}
 
             void operator()(pointer p) const
                {
@@ -238,14 +263,14 @@ namespace jni
        };
 
     template < class TagType >
-    UniqueLocalObject<TagType> SeizeLocalRef(JNIEnv& env, Object<TagType>&& object)
+    TypedUniqueLocalObject<TagType> SeizeLocalRef(JNIEnv& env, TypedObject<TagType>&& object)
        {
-        return UniqueLocalObject<TagType>(PointerToValue<Object<TagType>>(std::move(object)), LocalObjectRefDeleter<TagType>(env));
+        return TypedUniqueLocalObject<TagType>(PointerToValue<TypedObject<TagType>>(std::move(object)), TypedLocalObjectRefDeleter<TagType>(env));
        };
 
 
     template < class OutTagType, class InTagType >
-    Object<OutTagType> Cast(JNIEnv& env, const Object<InTagType>& object, const Class<OutTagType>& clazz)
+    TypedObject<OutTagType> Cast(JNIEnv& env, const TypedObject<InTagType>& object, const TypedClass<OutTagType>& clazz)
        {
         if (!object.IsInstanceOf(env, clazz))
            {
diff --git a/include/jni/static_field.hpp b/include/jni/static_field.hpp
index 42c2944..8a499c4 100644
--- a/include/jni/static_field.hpp
+++ b/include/jni/static_field.hpp
@@ -8,16 +8,22 @@
 
 namespace jni
    {
-    template < class TheTag, class T >
-    class StaticField
+    template < class TagType, class T >
+    class TypedStaticField;
+
+    template < class Tag, class T >
+    using StaticField = TypedStaticField< TypeFromTag<Tag>, T >;
+
+    template <char... Chars, class T>
+    class TypedStaticField< Type<Chars...>, T >
        {
         private:
             jfieldID& field;
 
         public:
-            using TagType = TheTag;
+            using TagType = Type<Chars...>;
 
-            StaticField(JNIEnv& env, const Class<TagType>& clazz, const char* name)
+            TypedStaticField(JNIEnv& env, const TypedClass<TagType>& clazz, const char* name)
               : field(GetStaticFieldID(env, clazz, name, TypeSignature<T>()()))
                {}
 
diff --git a/include/jni/static_method.hpp b/include/jni/static_method.hpp
index 9b28cce..29cf7e9 100644
--- a/include/jni/static_method.hpp
+++ b/include/jni/static_method.hpp
@@ -8,19 +8,22 @@
 
 namespace jni
    {
-    template < class TheTag, class >
-    class StaticMethod;
+    template < class TagType, class >
+    class TypedStaticMethod;
 
-    template < class TheTag, class R, class... Args >
-    class StaticMethod< TheTag, R (Args...) >
+    template < class Tag, class R, class... Args >
+    using StaticMethod = TypedStaticMethod< TypeFromTag<Tag>, R (Args...) >;
+
+    template <char... Chars, class R, class... Args>
+    class TypedStaticMethod< Type<Chars...>, R (Args...) >
        {
         private:
             jmethodID& method;
 
         public:
-            using TagType = TheTag;
+            using TagType = Type<Chars...>;
 
-            StaticMethod(JNIEnv& env, const Class<TagType>& clazz, const char* name)
+            TypedStaticMethod(JNIEnv& env, const TypedClass<TagType>& clazz, const char* name)
               : method(GetStaticMethodID(env, clazz, name, TypeSignature<R (Args...)>()()))
                {}
 
diff --git a/include/jni/string.hpp b/include/jni/string.hpp
index 0e5b00c..bac05b7 100644
--- a/include/jni/string.hpp
+++ b/include/jni/string.hpp
@@ -13,7 +13,7 @@ namespace jni
     struct StringTag { static constexpr auto Name() { return "java/lang/String"; } };
 
     template <>
-    struct UntaggedObjectType<StringTag> { using Type = jstring; };
+    struct TypedUntaggedObjectType< TypeFromTag<StringTag> > { using Type = jstring; };
 
     using String = Object<StringTag>;
 
diff --git a/include/jni/type.hpp b/include/jni/type.hpp
new file mode 100644
index 0000000..b26e45d
--- /dev/null
+++ b/include/jni/type.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <type_traits>
+
+namespace jni
+   {
+    template < char... Chars > struct Type {};
+
+    template < class Tag >
+    struct TypeFactory {
+    private:
+        static constexpr std::size_t Size(char const* str, std::size_t count = 0) {
+            return (str[0] == '\0') ? count : Size(str + 1, count + 1);
+        }
+
+        template <std::size_t... I>
+        static Type<Tag::Name()[I]...> ExpandType(std::index_sequence<I...>);
+
+    public:
+        using TagType = decltype(ExpandType(std::make_index_sequence<Size(Tag::Name())>{}));
+    };
+
+    template < class Tag >
+    using TypeFromTag = typename TypeFactory<Tag>::TagType;
+   }
diff --git a/include/jni/type_signature.hpp b/include/jni/type_signature.hpp
index 090b95d..a22281f 100644
--- a/include/jni/type_signature.hpp
+++ b/include/jni/type_signature.hpp
@@ -21,13 +21,13 @@ namespace jni
     template <> struct TypeSignature< jdouble  > { const char * operator()() const { return "D"; } };
     template <> struct TypeSignature< void     > { const char * operator()() const { return "V"; } };
 
-    template < class TheTag >
-    struct TypeSignature< Object<TheTag> >
+    template < char... Chars >
+    struct TypeSignature< TypedObject< Type<Chars...> > >
        {
         const char * operator()() const
            {
-            static std::string value { std::string("L") + TheTag::Name() + ";" };
-            return value.c_str();
+            static constexpr const char value[] = { 'L', Chars..., ';', '\0' };
+            return value;
            }
        };
 
diff --git a/test/high_level.cpp b/test/high_level.cpp
index 9dc2d10..a1de6de 100644
--- a/test/high_level.cpp
+++ b/test/high_level.cpp
@@ -63,7 +63,7 @@ int main()
 
     env.functions->FindClass = [] (JNIEnv*, const char* name) -> jclass
        {
-        assert(name == Test::Name());
+        assert(strcmp(name, Test::Name()) == 0);
         return Unwrap(classValue.Ptr());
        };