java.lang

/*
append(char c)：向此Appendable添加指定字符
    可能引发IOException异常
append(CharSequence csq)：向此CharSwquence添加指定的字符序列
    csq是要添加的字符串序列，如果csg为null，则向该Appendable添加四个字符“null”
    可能引发IOException异常
Appendable(CharSwquenece csq, int start, int end)
    如果start或end为负，以及start大于end，或end大于csq.length()，引发IndexOutOfBoundsException异常
    可能引发IOException异常
*/

/*
    char charAt(int index) 返回指定索引的char值
        索引范围从零到length() - 1
        IndexOutOfBoundsException ——如果index参数为负或不小于length()
    int length() 返回此字符串序列的长度
    CharSequence CharSequence(int start, int end) 返回一个新的CharSequence，它是此序列的子序列
        IndexOutOfBoundsException ——如果start或end为负，end大于length()或者start大于end
    String toString() 返回一个包含此序列中字符的字符串，该字符串与此序列的顺序相同
*/

此类实现了Cloneable接口，以只是Object.clone()方法可以合法对该类的实例进行按字段复制

/*
    实现这个接口允许对象成为“forEach”语句的目标
*/

/*
    int read(Charbuffer cb) 试图将字符读入指定的字符缓冲区
    返回添加到缓冲区的char值的数量，如果此紫府园位于缓冲区末端，返回-1
    IOException——发生I/O异常
    NullPointerException——如果cb为空
    ReadOblyBufferException——如果cb是一个只读缓冲区
*/

/*
    Runnable接口应该由那些打算通过某一线程执行其实例的类来实现，类必须定义一个run的无参数方法
    Runnable为非Thread子类的类提供了一种激活方式，通过实例化某个Thread实例并将自身作为运行目标
    就可以实现Runnable的类无须创建Thread的子类。
    如果只想重写run()方法，而不是重写其他Thread方法，就应该使用Runnable接口
    void run() 使用实现接口Runnable的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的run方法
*/

/*
    void uncaughtException(Thread t, Throwable e)
    当给定线程因给定的未捕获异常而终止时，调用该方法
    Java虚拟机将忽略该方法抛出的异常
*/

public final class Boolean extends Object implements Serializable, Comparable<Boolean>
/*
    Boolean类将基本类型boolean的值包装在一个对象中，一个Boolean类型的对象只包含一个类型为boolean的字段
*/
public    static final Boolean FLASE  //对应基值false的Boolean对象
public    static final Boolean TRUE  //对应基值true的Boolean对象
public     static final Class<Boolean>  //TYPE 表示基本类型boolean的Class对象
//构造方法
public Boolean(boolean value)
    /*
        分配一个表示value参数的Boolean对象
        一般情况都不适用这个构造方法。如果不需要新的实例，则静态工厂valueOf(boolean)是一个更好的选择
    */
public Boolean(String s)
    /*
        如果String参数不为null且忽略大小写时等于“true”,则分配一个表示true的值的Boolean对象，否则分配一个表示false的Boolean对    象，所以默认的值为false
        new Boolean("true")生成一个表示true的Boolean对象
        new Boolean("yes")生成一个false的Boolean对象
    */
public static boolean parseBoolean(String s)
    /*
        将字符串参数解析为boolean值。如果String参数不是null且忽略大小写时等于“true”，返回boolean表示true值
        Boolean.parseBoolean("true") 返回true
        Boolean.parseBoolean("yes") 返回false
    */
public boolean booleanValue()
    /*
        将此Boolean对象的值作为基本布尔值返回
    */
public static Boolean valueOf(boolean b)
    /*
        返回一个表示指定boolean值的Boolean实例。如果不是新的实例，优先使用这个方法，而不是构造方法
        将基本类型作为对象的值
    */
public static Boolean valueOf(String s)
    /*
        返回一个用执行的字符串表示值的Boolean值
    */
public static String toString(boolean b)
    /*
        返回一个表示指定布尔值的String对象，如果指定返回true，则返回true，否则返回false
    */
public String toString()
    /*
        返回表示布尔值的String对象，如果该对象表示true值吗，则返回等于true字符串，否则返回false字符串
        覆盖类Object中的toString
    */
public int hashCode()
    /*
        返回该Boolean对象的哈希码
        覆盖Object中的hashCode
    */    
public boolean equals(Object obj)
    /*
        当且仅当参数不是null，而是一个与此对象一样，都表示同一个Boolean值的boolean对象时，才返回true
    */
public static boolean getBoolean(String name)
    /*
        当且仅当以参数命名的系统属性存在，且等于“true”字符串时，才返回true
    */
public int compareTo(Boolean b)
    /*
        将此Boolean实例与其他实例进行比较
        指定者：接口Compareable<Boolean>中的compareTo
        如果对象与参数表示的布尔值相同，返回零，如果此对象表示true，参数表示false，返回正值，如果此对象表示false，参数表示true，返回一个负值
        NullPointerException——如果参数为null
    */

public final class Byte extends Number implements Comparable<Byte>
    /*
        Byte类将基本类型byte的值包装在一个对象中，一个Byte类型的对象只包含一个类型为byte的字段
    */
/*                                                     字段                                                        */
public static final byte MIN_VALUE
    /*
        一个常量，保存byte类型可取的最小值，即-128
    */
public static final byte MAX_VALUE
    /*
        一个常量，保存 byte类型可取的最大值，即127
    */
public static final Class<Byte> TYPE
    /*
        表示基本类型byte的Class实例
    */
public static final int SIZE
    /*
        用于以二进制补码形式表示byte值的位数
    */
/*                            构造方法                                        */
public Byte(byte value)
    /*
        构造一个新分配的Byte对象，以表示指定的byte值
    */
public Byte(String s) throws NumberFormatException
    /*
        构造一个新分配的Byte对象，以表示String参数所指示的byte值，该字符串以使用基数10的parseByte方法所使用的方式转换成一个byte值
        NumberFormatException——如果String不包含一个可解析的Byte
    */
/*
    Byte b = new Byte("1");
    Byte c = new Byte(b);
*/
public static String toString(byte b)
    /*
        返回表示指定byte的一个新String对象，假定基数为10
    */
public static Byte valueOf(byte b)
    /*
        返回表示指定byte值的一个Byte实例，如果不需要新的Byte实例，则通常有限使用此方法，而不是构造方法Byte(byte)
    */
public static byte parseByte(String s) throws NumberFormatException
    /*
        将string参数解析为有符号的十进制byte，除了第一个字符可以是表示负数的ASCII符号‘—’之外，该字符串中的字符必须是十进制数字
        返回得到的byte值与该string参数和基数10为参数的parseByte(java.lang.String, int)方法返回的值一样
        NumberFormatException——如果该string不包含一个可解析的byte
    */
public static byte parseByte(String s, int radix) throws NumberFormatException
    /*
        将String参数解析为一个有符号的byte，其基数由第二个参数指定，除了第一个字符可以是表示负值的ASCII符号‘-’之外
        这取决于Character.digit(char, int)是否返回非负值，该string中的字符必须都是指定基数的数字
        NumberFormatException —— 1、第一个参数为null或是一个长度为零的字符串； 2、基数小于Character.MIN.RADIX或大于Character.MAX.RADIX
        3、字符串的任一肺腑不是指定基数的数字，第一个字符是符号的情况除外 4、字符串所表示的值不是byte类型的值
    */
public static Byte valueOf(String s, int radix) throws NumberFormatException
    /*
        返回一个Byte对象，该对象保持从指定的String中提取的值，该值是在用第二个参数所给定的基数对指定字符串进行解析时提取的
    */
public static Byte valueOf(String s) throws NumberFormatException
    /*
        返回一个保持指定String所给出的值的Byte对象，参数被解释为表示一个有符号的十进制的byte
        该方法等于：new Byte(Byte.parseByte(s))
    */
public static Byte decode(String nm) throws NumberFormatException
    /*
        将String解码为Byte
    */
public byte byteValue()
    /*
        作为一个byte返回此Byte的值
    */
public short shortValue()
    /*
        作为一个short返回此Byte的值
    */
public int intValue()
    /*
        作为一个int返回此Byte的值
    */
public long longValue()
    /*
        作为一个long返回此Byte的值
    */
public float floatValue()
    /*
        作为一个float返回此Byte的值
    */
public double doubleValue()
    /*
        作为一个double返回此Byte的值
    */
public String toString()
    /*
        返回此Byte的值的String的对象
    */
public int hashCode()
    /*
        返回此Byte的哈希码
    */
public boolean equals(Object obj)
    /*
        将此对象与指定对象比较，当且仅当参数不为null。而是一个与此对象一样包含相同的Byte的值的byte对象时，结构才返回true
    */
public int compareTo(Byte anotherByte)
    /*
        在数字上比较两个Byte对象
    */

public final class Character extends Object implements Serializable, Comparable<Character>
     /*
         Character类在对象中包装一个基本类型char的值。Characher类型的对象包含类型为char的单个字段
         Character类的方法和数据通过UnicodeData文件中的信息定义
     */
     
/*                构造方法                    */
public Character(char value)
    /*
        构造一个新分配的Character对象，用以标示指定的char值
        value是Character对象表示的值
    */
    
/*                    方法            */
public static Character valueOf(char c)
    /*
        返回一个表示指定char值的Character实例。如果不需要新的Character实例，则通常应该优先采用此方法，而不是构造方法Character(char)，
        因为该方法可能通过缓存经常请求的值显著提高空间和时间性能
        c是Character实例
    */
public char charValue()
    /*
        返回此Character对象的值
    */
public int hashCode()
    /*
        返回此Character的哈希码
    */
public boolean equals(Object obj)
    /*
        将此对象与指定对象比较，当且仅当参数不是null，而是一个与此对象包含相同char值的Character对象时，结构才是true
    */
public String toString()
    /*
        返回表示此Character值的String对象，结果是一个长度为1的字符串，其唯一组件时此Character对象表示的基本char值
    */
public static String toString(char c)
    /*
        返回一个表示指定char值的String对象，结构是长度为1的字符串，仅由指定的char组成
    */
public static boolean isValidCodePoint(int codePoint)
    /*
        确定指定的代码点是否为从0x0000到0x10FFFF范围之内的有效Unicode代码点值，该方法等于：
        codePoint >= 0x0000 && codePoint <= 0x10FFFF
        codePoint要测试的Unicode代码点，有效则返回true
    */
public static boolean isSupplementaryCodePoint(int codePoint)
    /*
        确定指定字符（Unicode代码点）是否在增补字符范围内
    */
public static boolean isHighSurrogate(char ch)
    /*
        确定给出的char值是否为一个高代理单元
    */
public static int toCodePoint(char high, char low)
    /*
        将指定的代理项对转换为其增补代码点值，该方法没有验证指定的代理项对
    */
public static int toChars(int codePoint, char[] dst, int dstIndex)
    /*
        将指定字符转换为UTF-16表示形式
    */
public static int offsetByCodePoints(CharSequence seq, int index, int codePointOffset)
    /*
        返回给定字符序列中的索引，它是从给定index到codePointOffset代码点的偏移量。index和codePointOffset给出的文本范围内的不成对代理项是
        按一个代码点算作一个项进行计数的
    */
public static int offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset)
    /*
        返回给定char子数组中的索引，它是从给定index到codePointOffset代码点的偏移量。start和count参数指定了char数组的一个子数组。
        index和codePointOffset给出的文本范围内不成对代理项是按一个代码点算作一个项进行计数的
    */    
public static boolean isLowerCase(char ch)
    /*
        确定指定字符是否为小写字母
        如果通过Character.getType(ch)提供的字符的常规类别类型为LOWERCASE_LETTER，则字符为小写字母
    */
public static boolean isLowerCase(int codePoint)
    /*
        确定指定字符(Unicode代码点)是否为小写字母
    */
public static boolean isUpperCase(char ch)
    /*
        确定指定字符是否为大写字母
    */
public static boolean isUpperCase(int codePoint)
    /*
        确定指定字符（Unicode代码点）是否为大写字母
    */
public static boolean isTitleCase(char ch)
    /*
        确定指定字符是否为首字母大写字符
    */
public static boolean isTitleCase(int codePoint)
    /*
        确定指定字符（Unicode代码点）是否为首字母大写字符
    */
public static boolean isDigit(char ch)
    /*
        确定指定字符是否为数字
    */
public static boolean isDigit(int codePoint)
    /*
        确定指定字符（Unicode代码点）是否为数字
    */
public static boolean isDefined(char ch)
    /*
        确定字符是否被定义为Unicode中的字符
    */
public static boolean isDefined(int codePoint)
    /*
        确定字符（Unicode代码点）是否被定义为Unicode中的字符
    */
public static boolean isLetter(char ch)
    /*
        确定指定字符是否为字母
    */
public static boolean isLetter(int codePoint)
    /*
        确定指定字符（Unicode代码点）是否为字母
    */
public static boolean isLetterOrDigit(char ch)    /*
        确定指定字符是否为字母或数字
    */
public static boolean isLetterOrDigit(int codePoint)
    /*
        确定指定字符（Unicode代码点）是否为字母或数字
    */
public static char toLowerCase(char ch)
    /*
        使用取自UnicodeData文件的大小写映射信息将字符参数转换为小写
    */
public static int toLowerCase(int codePoint)
    /*
        使用取自UnicodeData文件的大小写映射信息将字符（Unicode代码点）参数转换为小写
    */
public static char toUpperCase(char ch)
    /*
        使用取自UnicodeData文件的大小写映射信息将字符参数转换为大写
    */
public static int toUpperCase(int codePoint)
    /*
        使用取自UnicodeData文件的大小写映射信息将字符（Unicode代码点）参数转换为大写
    */
public static char toTitleCase(char ch)
    /*
        使用取自UnicodeData文件的大小写映射信息将字符参数转换为首字母大写。
    */
public static int toTitleCase(int codePoint)
    /*
        使用取自UnicodeData文件的大小写映射信息将字符（Unicode代码点）参数转换为首字母大写
    */
public static int digit(char ch, int radix)
    /*
        返回使用指定基数的字符ch的数值
    */
public static int digit(int codePoint, int radix)
    /*
        返回使用指定基数的指定字符（Unicode代码点）的数值
    */
public static int getNumericValue(char ch)
    /*
        返回指定的Unicode字符表示的int值
    */
public static int getNumericValue(int codePoint)
    /*
        返回指定字符（Unicode代码点）表示的int值
    */
public static boolean isSpaceChar(char ch)
    /*
        确定指定字符是否为Unicode空白字符
    */
public static boolean isSpaceChar(int codePoint)
    /*
        确定指定字符（Unicode代码点）是否为Unicode空白字符
    */
public static boolean isWhitespace(char ch)
    /*
        确定指定字符依据Java标准是否为空白字符
    */
public static boolean isWhitespace(int codePoint)
    /*
        确定指定字符(Unicode代码点)依据Java标准是否为空白字符
    */
public static int getType(int codePoint)
    /*
        返回一个指示字符的常规类别的值
    */
public int compareTo(Character anotherCharacter)
    /*
        根据数字比较两个Character对象
    */
public static char reverseBytes(char ch)
    /*
        返回通过翻转指定char值中的字节顺序而获得的值
    */

public final class Class<T> extends Object implements Serializable, GenericDeclaration, Type, AnnotatedElement
    /*
        Class类的实例表示正在运行的Java应用程序中的类和接口
        枚举是一种类，注释时一种接口。每个数组属于被映射为Class对象的一个类，所有具有相同元素类型和维数的数组都共享该Class对象。
        基本的Java类型(boolean、byte、char、short、int、long、float和double)和关键字void也表示为Class对象
        Class没有公共构造方法，Class对象是在加载类时由Java虚拟机以及通过调用类加载器中的defineClass方法自动构造的
    */
public String toString()
    /*
        将对象转换为字符串，字符串的表示形式为字符串“class”或“interface"后紧跟一个空格，然后是该类的完全限定名，它具有getName返回的那种格式
    */
public static Class<?> forName(String className) throws ClassNotFoundException
    /*
        返回与带有给定字符串名的类或接口相关联的Class对象
        调用此方法等效于：Class.forName(className, true, currentLoader)
        currentLoder表示当前类的定义类加载器
        调用forName("X")将导致命名为X的类被初始化
        LinkageError——如果连接失败
        ExceptionInInitializerError——如果此方法所激发的初始化失败
        ClassNotFoundException——如果无法定位该类
    */
public static Class<?> forName(String name, boolean initialize, ClassLoder loader) throws ClassNotFoundException
    /*
        使用给定的类加载器，返回带有给定字符串名的类或接口相关联的Class对象
    */
public T newInstance() throws InstantiationException, IllegalAccessException
    /*
        创建此Class对象所表示的类的一个新实例。
    */
public boolean isInstance(Object obj)
    /*
        判断指定的Object是否与此Class所表示的对象赋值兼容
    */
public boolean isAssignableFrom(Class<?> cls)
    /*
        判断此Class对象所表示的类或接口与指定的Class参数所表示的类或接口是否相同，或是否是其超类或超接口
    */
public boolean isInterface()
    /*
        判断指定的Class对象是否表示一个接口类型
    */
public boolean isArray()
    /*
        判断此Class对象是否表示一个数组类
    */
public boolean isPrimitive()
    /*
        判断指定的Class对象是否表示一个基本类型
        有九种预定义的Class对象，表示八个基本类型和void。这些对象由Java虚拟机创建，与其表示的基本类型同名：
        boolean、byte、char、short、int、long、float和double
        这些对象仅能通过public static final的变量访问，也是使此方法返回true的仅有的几个Class对象
    */    
public boolean isAnnotation()
    /*
        如果此Class对象表示一个注释类型则返回true
        如果此方法返回true，则isInterface()也返回true，因为所有注释类型同时也是接口
    */
public boolean isSynthetic()
    /*
        如果此类是复合类，则返回true
    */
public String getName()
    /*
        以String的形式返回此Class对象所表示的实体（类、接口、数组类、基本类型或void）名称
        如果此类对象表示的是非数组类型的引用类型，则返回该类的二进制名称
    */
public ClassLoader getClassLoader()
    /*
        返回此类的类加载器
    */
public TypeVariable<Class<T>>[] getTypeParameters()
    /*
        按声明顺序返回TypeVariable对象的一个数组，这些对象对象表示用此GenericDeciarartion对象所表示的常规声明来声明的类型变量。
        如果底层常规声明不声明类型变量，则返回长度为0的数组
        指定者：接口GenericDeclaration中的getTypeParameters
    */
public Class<? super T> getSuperclass()
    /*
        返回表示此Class所表示的实体（类、接口、基本类型或void）的超类的Class，如果此Class表示Object类、一个接口、一个基本类型或void，则返回null
        如果此对象表示一个数组类，则返回表示该Object类的Class对象
    */
public Type getGenericSuperclass()
    /*
        返回此Class所表示的实体（类、接口、基本类型或void）的直接超类的Type
    */
public Package getPackage()
    /*
        获取此类的包
    */
public Class<?>[] getInterfaces()
    /*
        确定此对象所表示的类或接口实现的接口
        如果此对象表示一个类，则返回值是一个数组，它包含了表示该类所实现的所有接口的对象。
        数组中接口对象顺序与此对象所表示的类的声明的implements子句中接口名顺序一致
    */
Public Type[] getGenericInterfaces()
    /*
        返回表示某些接口的Type，这些接口由此对象所表示的类或接口直接实现
    */
public Class<?> getComponentType()
    /*
        返回表示数组组件类型的Class，如果此类不表示数组类，则此方法返回null
    */
public int getModifiers()
    /*
        返回此类或接口以整数编码的Java语言修饰符
    */
public Object[] getSigners()
    /*
        获取此类的标记
        此类的比较，无标记返回null。如果此对象表示一个基本类型或void，则返回null
    */
public Method getEnclosingMethod()
    /*
        如果此Class对象表示某一方法中的一个本地或匿名类，则返回Method对象，它表示底层类的立即封闭方法，否则返回null
        如果底层类是由一个类型声明、实例初始值设定项或静态初始值设定项立即封闭的本地或匿名类，则此方法返回null
    */
public Constructor<?> getEnclosingConstructor()
    /*
        如果该Class对象表示构造方法中的一个本地或匿名类，则返回Constructor对象，它表示底层类的立即封闭构造方法，则返回null
        如果底层了是由一个类型声明、实例初始值设定项或静态初始值设定项立即封闭的本地或匿名类，则此方法返回null
    */
public Class<?> getDeclaringClass()
    /*
        返回此Class对象所表示的类或接口是另一个类的成员，则返回的Class对象表示该对象的声明类。
        如果该类或接口不是其他类的成员，则此方法范湖inull。如果此Class对象表示一个数组类、基本类型或void，则此方法返回null
    */
public Class<?> getEnclosingClass()
    /*
        返回底层类的立即封闭类，如果底层类是顶层类，则此方法返回null
    */
public String getSimpleName()
    /*
        返回源代码中给出的底层类的简称，如果底层类是匿名的则返回一个空字符串
    */
public String getCanonicalName()
    /*
        返回Java Language Specification中所定义的底层类的规范化名称，如果规范化没有名称，返回null
    */
public boolean isAnonymousClass()
    /*
        当且仅当底层类是匿名类时返回true
    */
public boolean isLocalClass()
    /*
        当且仅当底层类是本地类时返回true
    */
public boolean isMemberClass()
    /*
        当且仅当底层类是成员类时但会true
    */
public  Class<?>[] getClasses()
    /*
        返回一个包含某些Class对象的数组，这些对象表示属于此Class对象所表示的类的成员的所有公共类和接口
        包括从超类继承的公共类和接口成员以及该类声明的公共类和接口成员
        如果没有公共成员或接口，则返回长度为0的数组
        如果此Class对象表示一个基本类型、一个数组或void，则此方法也返回一个长度为0 的数组
    */
public Field[] getFields()
    /*
        返回一个包含某些Field对象的数组，这些对象反映此Class对象所表示的类或接口所有可访问的公共字段。
        返回数组中的元素没有排序，也没有任何特定的顺序
    */
public Method[] getMethods() throws SecurityException
    /*
        返回一个包含某些Method对象的数组，这些对象反映此Class对象所表示的类或接口
    */
public Constructor<?>[] getConstructors() throws SecurityException
    /*
        返回一个包含某些Constructor对象的数组，这些对象反映此Class对象所表示的类的所有公共构造方法
    */
public Field getField(String name) throws NoSuchFieldException, SecurityException
    /*
        返回一个Field对象，它反映此Class对象所表示的类或接口的指定公共成员字段，name参数是一个String，用于指定所需字段的简称
    */
public Method getMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException
    /*
        返回一个Method对象，它反映此Class对象所表示的类或接口的指定公共方法。
    */
public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException
    /*
        返回一个Constructor对象，它反映此Class对象所表示的类的指定公共构造方法
    */
public Class<?> getDeclaredClasses()
    /*
        返回Class对象的一个数组，这些数组反映声明为此Class对象所表示的类的成员的所有类和接口
    */
public Field[] getDeclaredFields() throws SecurityException
    /*
        返回Field对象的一个数组，这些对象反映此Class对象所表示的类或接口所声明的所有字段
    */
public boolean isEnum()
    /*
        当且仅当该类声明为源代码中的枚举时返回true
    */
public T[] getEnumConstants()
    /*
        如果此Class对象不表示枚举类型，则返回枚举类的元素或null
    */
public T cast(Object obj)
    /*
        将一个对象强制转换成此Class对象所表示的类或接口
    */