标题：type
相关
DOS命令 Type
显示文本文件的内容。
类型：内部命令。
格式：Type [盘符:][路径]文件名
使用说明：
（1）显示由ANSI编码或Unicode编码的文本文件，对.EXE和.COM等为扩展名的文件，其显示的内容是无法阅读的，没有实际意义；
（2）该命令一次只可以显示一个文件的内容，不能使用通配符；
（3）如果文件有扩展名，则必须将扩展名写上；
（4）当文件较长，一屏显示不下时，可以按以下格式显示；TYPE [盘符:][路径]文件名|MORE，MORE为分屏显示命令，使用些参数后当满屏时会暂停，按任意键会继续显示。
（5）若需将文件内容打印出来，可用如下格式：
TYPE [盘符:][路径]文件名 >PRN
此时，打印机应处于联机状态.
程序中的type区块：用来声明类(包含类)。
(6) 在一些高级语言中作为类使用，改类型能判断 其他一切变量常量等类型
技术术语
类型（type）以及类型系统的起源以及研究与发展是独立于OOP的。早在五十年代的FORTRAN语言编译器实现中，就已经采用类型系统作为类型检查的一种手段。广义的类型一般被定义为一种约束，也就是一种逻辑公式。而在对类型的研究过程中产生多种方法，比如【C&W 1985】等。而代数方法（algebraic approach）是一种非常好的建立类型的形式化规范的方法。代数中的一个类型对应于一系列元素，在它们之上定义代数操作。同时在此基础上二阶λ演算已经被用于继承和模板所支持的模型。在上面两种方法中，类型被认为是一系列满足确定约束条件的元素，更抽象的方式可以把一个类型当作规定一个约束条件，如果我们规定的约束条件越好，相对应的被定义元素的集合就越精密，所以逻辑公式（logical formulas）就成为描叙类型特征的最合适工具。在这里，我们不想深入的探究对于类型理论的各种不同的数学模型，我们需要明白的是类型（type）以及类型理论这个在编程语言中经常应用到的概念的内涵是极其丰富的，而其自身理论的发展并非局限于OOP之中，但当两者相结合的时候就对我们的程序观产生了巨大的影响。
在面向对象设计（OOD）中，“归类”是重要步骤，一个精心设计的类层次结构是则是OOD的重要成果。类的层次和界面定义得好，将造福软件系统的实现者、维护者和以后的扩展者：他们会惊喜地发现，许多错综复杂的关系在清晰的类型层次中不言自明；而失败的类层次结构则是灾难的来源：为了绕过不合理的类型设计带来的束缚，编码员不得不把各种能想到的技巧都用了上去【4】——包括强制的类型cast、直接对对象内存的访问等，而这些技巧往往和潜在的bug形影相随。
在数据结构的归纳和发展中，类型也扮演了重要的角色。ADT的引入是一个里程碑，早期的语言就开始struct（C）、record（Pascal）等复合结构类型为ADT提供支持。
ADT是抽象数据类型。
在程序设计语言中，类型的概念由来已久，而其内涵也在不断发展之中。语言对类型机制更好效率更高的支持成为语言成熟度的标志。OOP语言对类型的支持机制包括class、interface、inheritance、polymorphism，RTTI，各种cast等，这为编程带来了许多方便，因为所有概念在语言中都有了对应物。关于OOP语言中类型的形象阐释，请参见我写的《漫谈程序设计语言的选择和学习》（发表于《程序员》2001年10月刊）和与朋友合译的《Object Unencapsulated: Eiffel, Java and C++》1.6节。而在泛性程序设计（GP）概念中，所谓“分类学”也就是对类型的一套定义。而模板参数的constraint，则其实是“类型所需符合之类型”，不妨将其与OOP中interface之概念作一对照：一个class需实现某一interface，才可说其属于(is-a)一定类型。C++中无interface直接对应物【2】，可这样表述：一个class需公有继承一个abstract class，则说其属于（is-a）该abstract class所定义之类型。而constrained genericity中，模板参数需符合某一constraint，该模板才能实例化。在GP和STL的著作中是这样表述的：模板参数（这是一个类型）叫model，其需符合的constraint（一个更为抽象的类型）叫做concept。对model更多的constraint叫做refinement。所以，concept-model-refinement可以和interface-class-inheritance对照理解。值得指出的是，Eiffel之父Bertrand Meyer在OOP经典著作Object-Oriented Software Construction 2/e中将泛型定义为类型参数化，并认为泛型技术和OOP中的继承与多态技术并列：泛型描述水平方向的类型关系；而继承则描述垂直方向上的类型关系。
Bertrand认为泛型方法是经典OOP方法的补充，因此也可纳入OOP的范畴。）两者在实现上的不同是，C++中GP采用的是generative template实现方法，这是用空间换时间的方法，所以大量使用模板的程序常体积较大，但运行速度稍快于对应的OOP版本；而OOP则采用增加间接层的方法，增加了时间开销。另外还有一点不同： OOP是成熟的设计方法，interface、class、inheritance等都有语言元素直接对应，而GP的许多概念则缺乏语言级支持。
类（class），类型(type)，接口（interface）
这三个概念是在OOP中出现频率最多，也最容易混淆的。而对于这三个概念的澄清也是文章写作的初衷。让我们先看看大师们对于这三个概念的描叙----
“The fundamental unit of programming in Java programming language is the class, but the fundamental unit of the object-oriented design is the type.while classes define types,it is very useful and powerful to be able to define a type without defining a class.Interface define types in an abstract form as a collection of methods or other types that form the contract for the type.” 【Jams 2000】。 
“In C++,A class is a user definite type”【B.S 1998】。
“A type is a name used to denote a particular interface……An object may have many types,and widely different objects can share a type.Part of an object’s interface may be characterized by one type ,and other parts by other types.Two objects of the same type need only share parts of their interface.Interface can contain other interface as subset.We say that a type is a subtype of another if its interface contain the interface of its supertype.Often we speak of a subtype inheriting the interface of its supertype”【Gamma 1995】
在其中，一共出现了四个概念：类（class），类型(type)，接口（interface）以及契约（contract）。这里我们说到的类型和上面提到的类型有所不同，是狭义的OOP中的类型。为了理解这几个概念，我先划分出三个概念域：一个是针对现实世界的，一个是针对特定程序设计范型的（在这里就是OO设计范型），最后一个是针对编译器实现的。也就是说，在现实世界中的概念必须有一种手段映射到OO范型中去，而OO范型中的概念也应该在编译器实现中有相同的概念对应。由此，我们可以这样说，类是做为现实世界中的概念，而传统的OOPL都会提供class关键字来表示对现实世界模拟的支持。而接口，是作为OO程序设计范型中与类对应的一个概念。在OO设计中，我们所要做的就是针对接口进行设计和编程，而接口的实质含义就是对象之间的一种契约。而类型就是编译器实现中针对类和接口所定义的对应概念。可以这样说，类是现实世界中存在的客观概念，是唯物的。接口是设计人员定义出来的，存在于设计人员心中的概念，是唯心的。而类型是类和接口这两种概念的编译器实现的映射概念，也是唯物的。类型主要是用来指导编译器的类型检查的谓词，类是创建现实对象的模板，接口是OO设计中的关键概念。这三个概念相互区别（分别位于不同的概念域），又相互联系（都是代表相同的概念的不同概念域的映射）。
最常见的Java语句：
people a=new man();
这代表了什么？程序员向编译器声明了一个people类型（type）的对象变量a，而对象变量a本身却指向了一个man类（class）的实体（而在编译器中理解是对象变量a指向了一个类型为man的实体）。
【Jams 2000】，其中句子的根本含义我们可以概括如下：
声明一个类或者一个接口都同时向编译器注册了一个新的类型，而此类或者接口以及类型都是共享同样的一个名字。也就是说。编译器所能理解的全部都是类型，而程序员的工作是把现实中的类概念转化为设计中的接口概念，而编译器对应于上两种概念都有直接的支持，那就是一个类声明或者接口声明在编译器的理解来看就是一个类型声明。但是反过来却不一定成立。一个类可以有多个接口（一个类完全有可能实现了设计人员的多个契约条件），同时也就可能有多个类型（因为类型不过是接口这个设计域内的概念在编译器中的实现）。
复数形式
types是java语言中的一个开发接口，用来对类型进行操作的实用工具方法。
javax
接口 Types
public interface Types
用来对类型进行操作的实用工具方法。
兼容性注意事项： 在将来的平台版本中可能会向此接口添加一些方法。
从以下版本开始： 1.6 另请参见：ProcessingEnvironment.getTypeUtils()
方法摘要
Element
asElement(TypeMirror t) 返回对应于类型的元素。
TypeMirror
asMemberOf(DeclaredType containing, Element element) 当元素被视为给定类型的成员或者直接由给定类型包含时，返回该元素的类型。
TypeElement
boxedClass(PrimitiveType p) 返回给定基本类型的装箱 (boxed) 值类型的类。
TypeMirror
capture(TypeMirror t) 对类型应用 capture 转换。
boolean
contains(TypeMirror t1, TypeMirror t2) 测试一个类型参数是否包含 另一个类型参数。
List<? extends TypeMirror>
directSupertypes(TypeMirror t) 返回类型的直接超类型。
TypeMirror
erasure(TypeMirror t) 返回删除状态的类型。
ArrayType
getArrayType(TypeMirror componentType) 返回具有指定组件类型的数组类型。
DeclaredType
getDeclaredType(DeclaredType containing, TypeElement typeElem, TypeMirror... typeArgs) 根据给定的包含类型，返回对应于类型元素和实际类型参数的类型（它是给定包含类型的成员）。
DeclaredType
getDeclaredType(TypeElement typeElem, TypeMirror... typeArgs) 返回对应于类型元素和实际类型参数的类型。
NoType
getNoType(TypeKind kind) 返回在实际类型不适用的地方所使用的伪类型。
NullType
getNullType() 返回 null 类型。
PrimitiveType
getPrimitiveType(TypeKind kind) 返回基本类型。
WildcardType
getWildcardType(TypeMirror extendsBound, TypeMirror superBound) 返回新的通配符类型参数。
boolean
isAssignable(TypeMirror t1, TypeMirror t2) 测试一种类型是否可以指派给另一种类型。
boolean
isSameType(TypeMirror t1, TypeMirror t2) 测试两个 TypeMirror 对象是否表示同一类型。
boolean
isSubsignature(ExecutableType m1, ExecutableType m2) 测试一个方法的签名是否是另一个方法的子签名。
boolean
isSubtype(TypeMirror t1, TypeMirror t2) 测试一种类型是否是另一个类型的子类型。
PrimitiveType
unboxedType(TypeMirror t) 返回给定类型的拆箱 (unboxed) 值类型（基本类型）。
方法详细信息
asElementElement asElement(TypeMirror t)返回对应于类型的元素。该类型可能是 DeclaredType 或 TypeVariable。如果该类型没有对应元素，则返回 null。 
返回：对应于给定类型的元素isSameTypeboolean isSameType(TypeMirror t1, TypeMirror t2)测试两个 TypeMirror 对象是否表示同一类型。
警告：如果此方法两个参数中有一个表示通配符，那么此方法将返回 false。因此，通配符与其本身的类型不同。初看起来这可能让人感到很奇怪，但考虑到编译器一定会拒绝以下示例时，这就很合理了：
List<?> list = new ArrayList<Object>();list.add(list.get(0)); 
参数：t1 - 第一种类型t2 - 第二种类型 
返回：当且仅当两种类型相同时返回 trueisSubtypeboolean isSubtype(TypeMirror t1, TypeMirror t2)测试一种类型是否是另一个类型的子类型。任何类型都被认为是其本身的子类型。 
参数：t1 - 第一种类型t2 - 第二种类型 
返回：当且仅当第一种类型是第二种类型的子类型时返回 true 
抛出： IllegalArgumentException - 如果给定一个 executable 或 package 类型isAssignableboolean isAssignable(TypeMirror t1, TypeMirror t2)测试一种类型是否可以指派给另一种类型。 
参数：t1 - 第一种类型t2 - 第二种类型 
返回：当且仅当第一种类型可以指派给第二种类型时返回 true 
抛出： IllegalArgumentException - 如果给定一个 executable 或 package 类型containsboolean contains(TypeMirror t1, TypeMirror t2)测试一个类型参数是否包含 另一个类型参数。 
参数：t1 - 第一种类型t2 - 第二种类型 
返回：当且仅当第一种类型包含第二种类型时返回 true 
抛出： IllegalArgumentException - 如果给定一个 executable 或 package 类型isSubsignatureboolean isSubsignature(ExecutableType m1, ExecutableType m2)测试一个方法的签名是否是另一个方法的子签名。 
参数：m1 - 第一个方法m2 - 第二个方法 
返回：当且仅当第一个签名是第二个签名的子签名时返回 true
directSupertypes
List<? extends TypeMirror> directSupertypes(TypeMirror t)返回类型的直接超类型。interface 类型将出现在列表的最后（如果有）。 
参数：t - 将被检查的类型 
返回：直接超类型；如果没有，则返回一个空列表 
抛出： IllegalArgumentException - 如果给定一个 executable 或 package 类型erasureTypeMirror erasure(TypeMirror t)返回删除状态的类型。 
参数：t - 要删除的类型 
返回：删除状态的给定类型 
抛出： IllegalArgumentException - 如果给定一个 package 类型boxedClassTypeElement boxedClass(PrimitiveType p)返回给定基本类型的装箱 (boxed) 值类型的类。即应用 boxing 转换。 
参数：p - 要转换的基本类型 
返回：类型 p 的装箱值类型的类unboxedTypePrimitiveType unboxedType(TypeMirror t)返回给定类型的拆箱 (unboxed) 值类型（基本类型）。即应用 unboxing 转换。 
参数：t - 要拆箱的类型 
返回：类型 t 的拆箱值类型 
抛出： IllegalArgumentException - 如果给定类型无法进行 unboxing 转换
capture
TypeMirror capture(TypeMirror t)对类型应用 capture 转换。 
参数：t - 要转换的类型 
返回：应用 capture 转换的结果 
抛出： IllegalArgumentException - 如果给定 executable 或 package 类型
getPrimitiveType
PrimitiveType getPrimitiveType(TypeKind kind)返回基本类型。 
参数：kind - 要返回的基本类型的种类 
返回：一个基本类型 
抛出： IllegalArgumentException - 如果 kind 不是基本种类getNullTypeNullType getNullType()返回 null 类型。该类型是 null 的类型。 
返回：null 类型getNoTypeNoType getNoType(TypeKind kind)返回在实际类型不适用的地方所使用的伪类型。要返回的类型的种类可以是 VOID 或 NONE。对于包，可以使用 Elements.getPackageElement(CharSequence).asType() 替代。 
参数：kind - 要返回的类型的种类 
返回：种类 VOID 或 NONE 的伪类型 
抛出： IllegalArgumentException - 如果 kind 无效
getArrayType
ArrayType getArrayType(TypeMirror componentType)返回具有指定组件类型的数组类型。 
参数：componentType - 组件类型 
返回：具有指定组件类型的数组类型。 
抛出： IllegalArgumentException - 如果组件类型对于数组无效
getWildcardType
WildcardType getWildcardType(TypeMirror extendsBound, TypeMirror superBound)返回新的通配符类型参数。可以指定通配符边界中的一个，也可以都不指定，但不能都指定。 
参数：extendsBound - 扩展（上）边界；如果没有，则该参数为 nullsuperBound - 超（下）边界；如果没有，则该参数为 null 
返回：新的通配符 
抛出： IllegalArgumentException - 如果边界无效
getDeclaredType
DeclaredType getDeclaredType(TypeElement typeElem, TypeMirror... typeArgs)返回对应于类型元素和实际类型参数的类型。例如，如果给定 Set 的类型元素和 String 的类型镜像，那么可以使用此方法获取参数化类型 Set<String>。
类型参数的数量必须等于类型元素的形式类型参数的数量，或者等于 0。如果等于 0，并且类型元素是泛型，则返回该类型元素的原始类型。
如 果返回一个参数化类型，则其类型元素不得包含在一般外部类中。例如，首先使用此方法获取类型 Outer<String>，然后调用 getDeclaredType(DeclaredType, TypeElement, TypeMirror...)，可以构造参数化类型 Outer<String>.Inner<Number>。
参数：typeElem - 类型元素typeArgs - 实际类型参数 
返回：对应于类型元素和实际类型参数的类型 
抛出： IllegalArgumentException - 如果给定的类型参数太多或太少，或者提供不合适的类型参数或类型元素
getDeclaredType
DeclaredType getDeclaredType(DeclaredType containing, TypeElement typeElem, TypeMirror... typeArgs)根据给定的包含类型，返回对应于类型元素和实际类型参数的类型（它是给定包含类型的成员）。例如，通过首 先使用 getDeclaredType(TypeElement, TypeMirror...) 获取类型 Outer<String>，然后调用此方法，可以构造参数化类型 Outer<String>.Inner<Number>。
如果包含类型是一个参数化类型，则类型参数的数量必须等于 typeElem 的形式类型参数的数量。如果包含类型不是参数化的，或者为 null，则此方法等效于 getDeclaredType(typeElem, typeArgs)。
参数：containing - 包含类型；如果没有，则该参数为 nulltypeElem - 类型元素typeArgs - 实际类型参数 
返回：对应于类型元素和实际类型参数的类型，该类型包含在给定类型中 
抛出： IllegalArgumentException - 如果给定的类型参数太多或太少，或者提供了不合适的类型参数、类型元素或包含类型
asMemberOf
TypeMirror asMemberOf(DeclaredType containing, Element element)当元素被视为给定类型的成员或者直接由给定类型包含时，返回该元素的类型。例如，被视为参数化类型 Set<String> 的成员时，Set.add 方法是参数类型为 String 的 ExecutableType。 
参数：containing - 包含类型element - 元素 
返回：从包含类型来看的元素的类型 
抛出： IllegalArgumentException - 如果元素对于给定类型无效[1]