精华内容
下载资源
问答
  • Java中继承java.lang.Enum
    千次阅读
    2017-01-15 11:43:16

    Java 5新增的enum关键词,可以定义枚举类。该类是一个特殊的类,可以定义自己的field、方法、可以实现接口,也可以定义自己的构造器。

    但枚举类使用enum定义后在编译后默认继承了java.lang.Enum类,而不是普通的继承Object类。enum声明类继承了Serializable和Comparable两个接口。且采用enum声明后,该类会被编译器加上final声明(同String),故该类是无法继承的。枚举类的内部定义的枚举值就是该类的实例(且必须在第一行定义,当类初始化时,这些枚举值会被实例化)。

    由于这些枚举值的实例化是在类初始化阶段,所以应该将枚举类的构造器(如果存在),采用private声明(这种情况下默认也是private)。

    另外补充一点,由于JVM类初始化是线程安全的,所以可以采用枚举类实现一个线程安全的单例模式。

    链接:https://www.zhihu.com/question/19908744/answer/30946346

    参考代码:

    public static final class AutoOffsetReset extends Enum {
    
            public static AutoOffsetReset[] values() {
                return (AutoOffsetReset[]) $VALUES.clone();
            }
    
            public static AutoOffsetReset valueOf(String name) {
                return (AutoOffsetReset) Enum.valueOf(com / sf / kafka / api / consume / ConsumeOptionalConfig$AutoOffsetReset, name);
            }
    
            public String getValue() {
                return value;
            }
    
            public static final AutoOffsetReset BEGIN;
            public static final AutoOffsetReset NOW;
            public static final AutoOffsetReset CUSTOM;
            private String value;
            private static final AutoOffsetReset $VALUES[];
    
            static {
                BEGIN = new AutoOffsetReset("BEGIN", 0, "smallest");
                NOW = new AutoOffsetReset("NOW", 1, "largest");
                CUSTOM = new AutoOffsetReset("CUSTOM", 2, "custom");
                $VALUES = (new AutoOffsetReset[] {
                        BEGIN, NOW, CUSTOM
                });
            }
    
            private AutoOffsetReset(String s, int i, String value) {
                super(s, i);
                this.value = value;
            }
        }
    更多相关内容
  • 创建枚举类型要使用Enum关键字,隐含了所创建的类型都是java.lang.Enum类的子类(java.lang.Enum是一个抽象类),枚举类型符合通用模式(Clss Enum >),而E表示枚举类型的名称。枚举类型的每一个值将映射到...

    创建枚举类型要使用Enum关键字,隐含了所创建的类型都是java.lang.Enum类的子类(java.lang.Enum是一个抽象类),枚举类型符合通用模式(Clss Enum <E   extends  Enum<E> >),而E表示枚举类型的名称。枚举类型的每一个值将映射到protected Enum(String name,int ordinal) 构造函数中,在这里,每个值的名称都被转换成一个字符串,并且序数设置表示了此设置被创建的顺序。


    package  com.hmw.test;
    /**
      * 枚举测试类
      */
    public  enum  EnumTest {
         MON, TUE, WED, THU, FRI, SAT, SUN;
    }
    这段代码实际上调用了7次 Enum(String name, int ordinal):

    new  Enum<EnumTest>( "MON" , 0 );
    new  Enum<EnumTest>( "TUE" , 1 );
    new  Enum<EnumTest>( "WED" , 2 );
         ... ...

    enum 对象的常用方法介绍

    int compareTo(E o) 
              比较此枚举与指定对象的顺序。

    Class<E> getDeclaringClass() 
              返回与此枚举常量的枚举类型相对应的 Class 对象。

    String name() 
              返回此枚举常量的名称,在其枚举声明中对其进行声明。

    int ordinal() 
              返回枚举常量的序数(它在枚举声明中的位置,其中初始常量序数为零)。

    String toString()

               返回枚举常量的名称,它包含在声明中。

    static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) 
              返回带指定名称的指定枚举类型的枚举常量。


    public  class  Test {
         public  static  void  main(String[] args) {
             EnumTest test = EnumTest.TUE;
             
             //compareTo(E o)
             switch  (test.compareTo(EnumTest.MON)) {
             case  - 1 :
                 System.out.println( "TUE 在 MON 之前" );
                 break ;
             case  1 :
                 System.out.println( "TUE 在 MON 之后" );
                 break ;
             default :
                 System.out.println( "TUE 与 MON 在同一位置" );
                 break ;
             }
             
             //getDeclaringClass()
             System.out.println( "getDeclaringClass(): "  + test.getDeclaringClass().getName());
             
             //name() 和  toString()
             System.out.println( "name(): "  + test.name());
             System.out.println( "toString(): "  + test.toString());
             
             //ordinal(), 返回值是从 0 开始
             System.out.println( "ordinal(): "  + test.ordinal());
         }
    }

    输出结果:

    TUE 在 MON 之后
    getDeclaringClass(): com.hmw.test.EnumTest
    name(): TUE
    toString(): TUE
    ordinal(): 1

    给 enum 自定义属性和方法

    给 enum 对象加一下 value 的属性和 getValue() 的方法:

    package  com.hmw.test;
     
    /**
      * 枚举测试类
      *
      * @author <a href="mailto:hemingwang0902@126.com">何明旺</a>
      */
    public  enum  EnumTest {
         MON( 1 ), TUE( 2 ), WED( 3 ), THU( 4 ), FRI( 5 ), SAT( 6 ) {
             @Override
             public  boolean  isRest() {
                 return  true ;
             }
         },
         SUN( 0 ) {
             @Override
             public  boolean  isRest() {
                 return  true ;
             }
         };
     
         private  int  value;
     
         private  EnumTest( int  value) {
             this .value = value;
         }
     
         public  int  getValue() {
             return  value;
         }
     
         public  boolean  isRest() {
             return  false ;
         }
    }
    public  class  Test {
         public  static  void  main(String[] args) {
             System.out.println( "EnumTest.FRI 的 value = "  + EnumTest.FRI.getValue());
         }
    }

    输出结果:

    EnumTest.FRI 的 value = 5

    EnumSet,EnumMap 的应用

    public  class  Test {
         public  static  void  main(String[] args) {
             // EnumSet的使用
             EnumSet<EnumTest> weekSet = EnumSet.allOf(EnumTest. class );
             for  (EnumTest day : weekSet) {
                 System.out.println(day);
             }
     
             // EnumMap的使用
             EnumMap<EnumTest, String> weekMap = new  EnumMap(EnumTest. class );
             weekMap.put(EnumTest.MON, "星期一" );
             weekMap.put(EnumTest.TUE, "星期二" );
             // ... ...
             for  (Iterator<Entry<EnumTest, String>> iter = weekMap.entrySet().iterator(); iter.hasNext();) {
                 Entry<EnumTest, String> entry = iter.next();
                 System.out.println(entry.getKey().name() + ":"  + entry.getValue());
             }
         }
    }

    原理分析

            enum 的语法结构尽管和 class 的语法不一样,但是经过编译器编译之后产生的是一个class文件。该class文件经过反编译可以看到实际上是生成了一个类,该类继承了java.lang.Enum<E>。EnumTest 经过反编译(javap com.hmw.test.EnumTest 命令)之后得到的内容如下:

    public  class  com.hmw.test.EnumTest extends  java.lang.Enum{
         public  static  final  com.hmw.test.EnumTest MON;
         public  static  final  com.hmw.test.EnumTest TUE;
         public  static  final  com.hmw.test.EnumTest WED;
         public  static  final  com.hmw.test.EnumTest THU;
         public  static  final  com.hmw.test.EnumTest FRI;
         public  static  final  com.hmw.test.EnumTest SAT;
         public  static  final  com.hmw.test.EnumTest SUN;
         static  {};
         public  int  getValue();
         public  boolean  isRest();
         public  static  com.hmw.test.EnumTest[] values();
         public  static  com.hmw.test.EnumTest valueOf(java.lang.String);
         com.hmw.test.EnumTest(java.lang.String, int , int , com.hmw.test.EnumTest);
    }

    所以,实际上 enum 就是一个 class,只不过 java 编译器帮我们做了语法的解析和编译而已。

    总结

        可以把 enum 看成是一个普通的 class,它们都可以定义一些属性和方法,不同之处是:enum 不能使用 extends 关键字继承其他类,因为 enum 已经继承了 java.lang.Enum(java是单一继承)。





















    展开全文
  • java反射(一)-java.lang.class方法详解

    千次阅读 2019-04-19 11:18:55
    关于javajava.lang.class类 1.获取class的方式 类名直接获取: Class cstr = String.class; 调用class的静态方法获取: Class cstr = Class.forName("java.lang.String"); 通过实例对象获得: String str =...

    关于java的java.lang.class类

    1.获取class的方式

    类名直接获取:

    Class cstr = String.class;

    调用class的静态方法获取:

    Class cstr = Class.forName("java.lang.String");

    通过实例对象获得:

    String str = "abc";
    Class cstr = str.getClass();

    Class类有如下方法

    静态方法
    方法名参数返回类型说明
    forName
    
    String className
    Class<?>

    接收className全称,使用类加载器加载class,并返回class对象

    例如:

    Class.forName("java.lang.String")

    forName
    String name, boolean initialize,ClassLoader loader
    Class<?>
    使用指定类加载器加载class文件
    public方法
    方法名参数返回类型说明
    获得ClassName相关方法
    toString
     
    String

    例如:String

    class java.lang.String

    toGenericString
     
    String

    声明全称

    public final class java.lang.String

    getName
     
    String

    获得class的名字

    例如: int->int

    String->java.lang.String

    getSimpleName
     
    String

    获得class的simple name

    例如:java.lang.String->String

    getComponentType
     
    Class<?>

    获得组成类型 针对数组而言 非数组为null 数组为基本类型

    例如:

    int[] -> int

    String->null

    getTypeName
     
    String
    如果是数组 getComponentType加上[],否则 getName()
    getCanonicalName
     
    String

     返回基础类的规范名称,如果没有则返回null

    获得相关属性和对象的方法
    newInstance
     T

    获得实例对象

    String对象的newInstance()值和该String相同

    getClassLoader
     
    ClassLoader

    获得类加载器,只能获得AppClassLoader即应用类加载器,

    父级的扩展类加载器和启动类加载器都返回null,不可获得

    例如:Objcet.class.getClassLoader() ->  null

    getTypeParameters
     
    TypeVariable<Class<T>>[]

    获得class的泛型参数变量

    例如:List<E> 返回E

    注: ArrayList<String> 返回 E

    class声明的泛型参数,

    创建时指定的会被类型擦除

    getSuperclass
     
    Class<? super T>

    获得父类,没有继承的class,父类为

    java.lang.Object

    getGenericSuperclass
     
    Type
    获得父类的类型
    getPackage
     
    Package
    获得class的package
    getInterfaces
     
    Class<?>[]
    获得该class实现的所有接口
    getGenericInterfaces
     
    Type[]
    获得class 实现的interface的Type
    getModifiers
     
    int

    获得一个描述修饰符的int值,利用modifier类去解析该int值,得到该class满足哪些修饰符

    getSigners
     
    Object[]
    此方法返回这个类的签名,或者为null,如果没有签名,如果这个对象表示一个基本类型或void,则返回null
    class相关
    getClasses
     
    Class<?>[]
    获得class里的所有public类
    getDeclaredClasses
     
    Class<?>[]
    所有定义的类
    getDeclaringClass
     
    Class<?>

    返回表示在它被声明的类的Class对象,如果此Class对象所表示的类或接口是另一个类成员。

    如果这个类或接口不属于任何其他类成员此方法返回null。如果此Class对象表示一个数组类,基本类型或void,则此方法返回null。

    getEnclosingClass
     
    Class<?>
    方法返回直接封闭类的底层类。如果这个类是一个顶级类此方法返回null
    Field相关
    getFields
     
    Field[]
    获得public的字段
    getField
    String name
    Field
    根据name获得public的字段
    getDeclaredFields
     
    Field[]
    获得所有声明的字段
    getDeclaredField
    String name
    Field
    根据name获得声明的字段
    Method相关
    getMethods
     
    Method[]
    获得所有public方法
    getMethod
    String name, Class<?>... parameterTypes
    Method
    根据name和参数类型,指定获得public方法
    getDeclaredMethods
     
    Method[]
    获得声明的方法
    getDeclaredMethod
    String name, Class<?>... parameterTypes
    Method
    根据name和参数类型,指定获得声明的方法
    getEnclosingMethod
     
    Method
    如果一个class表示在方法中的一个本地或匿名class, 那么通过java.lang.Class.getEnclosingMethod()方法将返回的底层类的立即封闭方法
    构造函数相关
    getConstructors
     
    Constructor<?>[]
    获得public的构造函数
    getConstructor
    Class<?>... parameterTypes
    Constructor<T>
    根据参数类型,获得public的构造函数
    getDeclaredConstructors
     
    Constructor<?>[]
    获得所有声明的构造函数
    getDeclaredConstructor
    Class<?>... parameterTypes
    Constructor<T>
    根据参数类型,指定获得声明的构造函数
    getEnclosingConstructor
     
    Constructor<?>
     
    枚举Enum相关
    getEnumConstants
     
    T[]
    获得枚举常量
    Annotation 注解相关
    getAnnotations
     
    Annotation[]
    获得所有public的注解
    getAnnotation
    Class<A> annotationClass
    <A extends Annotation> A
    根据指定注解class,获得所有public的注解对象
    getAnnotationsByType
    Class<A> annotationClass
    <A extends Annotation> A[]
    根据类型获得注解
    getDeclaredAnnotation
    Class<A> annotationClass
    <A extends Annotation> A
    获得指定注解声明的对象
    getDeclaredAnnotationsByType
    Class<A> annotationClass
    <A extends Annotation> A[]
    根据类型获得声明的所有注解
    getDeclaredAnnotations
     
    Annotation[]
    获得声明的所有注解
    getAnnotatedSuperclass
     
    AnnotatedType
    获得注解的父类的Type
    getAnnotatedInterfaces
     
    AnnotatedType[]
    获得注解接口
    其他属性
    getResourceAsStream
    String name
    InputStream
    根据名称获得资源的inputstream
    getResource
    String name
    java.net.URL
    根据名称获得资源的url
    getProtectionDomain
     
    java.security.ProtectionDomain
     
    cast
    Object obj
    T
    类型转换
    asSubclass
    Class<U> clazz
    <U> Class<? extends U>
     
    和其他对象的判断
    isInstance
    Object obj
    boolean

    判断是否是这个class的实例

    注: 子类是父类的实例

    isAssignableFrom
    Class<?> cls
    boolean
    判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同,或是否是其超类或超接口。如果是则返回 true;否则返回 false
    class类型和关键字的判断
    isInterface
     
    boolean
    是否是接口
    isArray
     
    boolean
    是否是数组
    isPrimitive
     
    boolean

    基本类型 

    void,boolean,byte,char,short,int,long,float,double

    封装类型不是基本类型

    isAnnotation
     
    boolean

    是否是注解类型

    注解类型为 @Interface ,因此 isInterface也返回true

    isSynthetic
     
    boolean

    是否是合成类synthetic

    即静态内部类,由jvm编译成的类

    isAnonymousClass
     
    boolean
    是否是匿名类
    isLocalClass
     
    boolean
    是否是本地类
    isMemberClass
     
    boolean
    是否是成员类
    desiredAssertionStatus
     
    boolean
     
    isEnum
     
    boolean
    是否是枚举class
    isAnnotationPresent
    Class<? extends Annotation> annotationClass
    boolean
     

     

    Demo

    static方法

    forName

        @Test
        public void classStaticMethodDemo(){
            try {
               Class clazz =  Class.forName("java.lang.String");
               System.out.println(clazz.getName());
    
               ClassLoader classLoader = this.getClass().getClassLoader();
               //指定类加载器加载class文件,完全不同的类加载器加载的同一个class不同
                Class clazz2 = Class.forName("com.hjh.java.reflect.ClassTest",true,classLoader);
                System.out.println(clazz2.getName());
                //应用类加载器,用于加载用户自己的类
                System.out.println(classLoader.getClass().getName());
                //扩展类加载器,用于加载%JAVA_HOME%/jre/lib/ext java.ext.dirs指定的类
                System.out.println(classLoader.getParent().getClass().getName());
                //启动类加载器,因为是用c++写的,所以这里报错,getParent()返回为null 用于加载Object,String等jre的运行java类
                System.out.println(classLoader.getParent().getParent().getClass().getName());
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }

    结果:

    java.lang.String
    com.hjh.java.reflect.ClassTest
    sun.misc.Launcher$AppClassLoader
    sun.misc.Launcher$ExtClassLoader
    
    java.lang.NullPointerException

    public方法

    获得className相关的方法

        @Test
        public void classNameMethodDemo(){
            Class cstr = String.class;
            Class cclose = Closeable.class;
            int[] is = new int[100];
            Class array =  is.getClass();
            HashMap<String,String> map = new HashMap<>();
            Class cmap = map.getClass();
    
            /**
             * getName 获得class的Name
             */
            System.out.println("------- getName -----------");
            //全称,带package名
            System.out.println(cstr.getName());//java.lang.String
            System.out.println(cclose.getName());//java.io.Closeable
            //基本类型数组比较特别
            System.out.println(array.getName());//[I
            System.out.println(cmap.getName());//java.util.HashMap
    
    
            /**
             * getSimpleName 获得简单ClassName,不带package的名称
             */
    
            System.out.println("------- getSimpleName -----------");
    
            //直接类名
            System.out.println(cstr.getSimpleName());//String
            System.out.println(cclose.getSimpleName());//Closeable
            System.out.println(array.getSimpleName());//int[]
            System.out.println(cmap.getSimpleName());//HashMap
    
            /**
             *toGenericString 生成一个全称的字符串,包括修饰符
             */
            System.out.println("-------- toGenericString ---------");
            // 定义语句
            System.out.println(cstr.toGenericString());//public final class java.lang.String
            System.out.println(cclose.toGenericString());//public abstract interface java.io.Closeable
            System.out.println(array.toGenericString());//public abstract final class [I
            System.out.println(cmap.toGenericString());//public class java.util.HashMap<K,V>
    
            /**
             * toString()方法
             * 分为 class 和 interface 两种开头
             */
            System.out.println("-------- toString ----------");
    
            System.out.println(cstr.toString());//class java.lang.String
            System.out.println(cclose.toString());//interface java.io.Closeable
            System.out.println(array.toString());//class [I
            System.out.println(cmap.toString());//class java.util.HashMap
    
            /**
             * getComponentType
             * 获得组成类型 针对数组而言
             * 非数组为null 数组为基本类型
             */
            System.out.println("--------- getComponentType ---------");
            System.out.println(cstr.getComponentType());//class java.lang.String
            System.out.println(cclose.getComponentType());//interface java.io.Closeable
            System.out.println(array.getComponentType());//int[]
            System.out.println(cmap.getComponentType());//java.util.HashMap
    
            /**
             * getTypeName 获得TypeName
             * 如果是数组 getComponentType加上[],
             * 否则 getName()
             */
            System.out.println("-------- getTypeName ----------");
            System.out.println(cstr.getTypeName());//class java.lang.String
            System.out.println(cclose.getTypeName());//interface java.io.Closeable
            System.out.println(array.getTypeName());//int[]
            System.out.println(cmap.getTypeName());//java.util.HashMap
    
            /**
             * getCanonicalName 返回基础类的规范名称
             * 如果没有则返回null
             */
            System.out.println("-------- getCanonicalName ----------");
            System.out.println(cstr.getCanonicalName());//class java.lang.String
            System.out.println(cclose.getCanonicalName());//interface java.io.Closeable
            System.out.println(array.getCanonicalName());//int[]
            System.out.println(cmap.getCanonicalName());//java.util.HashMap
    
        }

    获得相关属性的方法

        @Test
        public void classPropertiesDemo(){
            int[] arr = new int[10];
            HashMap<String,String> map = new HashMap<>();
            String str = new String("abc");
    
            Class carr = arr.getClass();
            Class cmap = map.getClass();
            Class cstr = str.getClass();
    
            /**
             * newInstance
             * 根据class获得实例,无法反射数组
             * 泛型对象只能反射类型擦除后的对象指针
             */
            System.out.println("------- newInstance -----------");
            try {
                //无法反射数组 抛出 InstantiationException
    //            int [] arr2 = (int[])carr.newInstance();
                // 可以反射泛型,因为类型擦除 这里转为HashMap和任意HashMap<K,V>都可以
                HashMap map2 = (HashMap<String,Integer>) cmap.newInstance();
                System.out.println(map2.size());//0
    
                //可以反射string类 但是值和原值相同
                String str2 = (String)cstr.newInstance();
                System.out.println(str);// abc
    
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
    
            /**
             * getClassLoader
             * 获得该class的类加载器
             */
            System.out.println("------- getClassLoader -----------");
            // 启动类加载器是 c++实现,所以返回null
            System.out.println(String.class.getClassLoader());//null
            // 应用类加载器是java实现,返回某个实例
            System.out.println(this.getClass().getClassLoader());//sun.misc.Launcher$AppClassLoader@18b4aac2
    
            /**
             * getTypeParameters
             * 获得泛型对象的泛型名称,无法获得泛型的具体类型
             * 补充一种可以获得泛型具体实例的办法
             * @see GenericSuperclassTest
             */
            System.out.println("------- getTypeParameters -----------");
            // 数组没有泛型
            printArray(carr.getTypeParameters());
            //输出hashmap的泛型名称K,V,但是不能获得具体是String,还是Objcet
            printArray( cmap.getTypeParameters());//K V
            // 字符串没有泛型
            printArray(cstr.getTypeParameters());
    
            /**
             * getSuperclass
             * 获得父类的class
             */
            System.out.println("------- getSuperclass -----------");
            System.out.println(carr.getSuperclass().getName());//java.lang.Object
            System.out.println(cmap.getSuperclass().getName());//java.util.AbstractMap
            System.out.println(cstr.getSuperclass().getName());//java.lang.Object
    
            /**
             * getGenericSuperclass 获得父类的类型
             * 补充一种可以获得泛型具体实例的办法
             * @see GenericSuperclassTest
             */
            System.out.println("------- getGenericSuperclass -----------");
            System.out.println(carr.getGenericSuperclass().getTypeName());//java.lang.Object
            System.out.println(cmap.getGenericSuperclass().getTypeName());//java.util.AbstractMap<K, V>
            System.out.println(cstr.getGenericSuperclass().getTypeName());//java.lang.Object
    
            /**
             * getPackage
             * 获得class的package
             */
            System.out.println("------- getPackage -----------");
            //基本类型数组没有package的概念,所以为null
            System.out.println(carr.getPackage());
            System.out.println(cmap.getPackage().getName());//java.util
            System.out.println(cstr.getPackage().getName());//java.lang
    
            /**
             * getInterfaces
             * 获得class 实现的interface的class
             */
            System.out.println("------- getInterfaces -----------");
            printArray(carr.getInterfaces());//interface java.lang.Cloneable,interface java.io.Serializable
            printArray(cmap.getInterfaces());//interface java.util.Map,interface java.lang.Cloneable,interface java.io.Serializable,
            printArray(cstr.getInterfaces());//interface java.io.Serializable,interface java.lang.Comparable,interface java.lang.CharSequence,
    
            /**
             * getGenericInterfaces
             * 获得class 实现的interface的Type
             */
            System.out.println("------- getGenericInterfaces -----------");
            printArray(carr.getGenericInterfaces());//interface java.lang.Cloneable,interface java.io.Serializable,
            printArray(cmap.getGenericInterfaces());//java.util.Map<K, V>,interface java.lang.Cloneable,interface java.io.Serializable,
            printArray(cstr.getGenericInterfaces());//interface java.io.Serializable,java.lang.Comparable<java.lang.String>,interface java.lang.CharSequence,
    
            /**
             * getModifiers
             * 获得一个描述修饰符的int值,利用modifier类去解析该int值,得到该class满足哪些修饰符
             */
            System.out.println("------- getModifiers -----------");
            int marr = carr.getModifiers();
            int mmap = cmap.getModifiers();
            int mstr = cstr.getModifiers();
            System.out.println(marr);//1041
            System.out.println(mmap);//1
            System.out.println(mstr);//17
    
            Modifier modifier = new Modifier();
    
            modifier.isPublic(marr);
            modifier.isPrivate(marr);
            modifier.isProtected(marr);
    
            /**
             * getSigners
             * 得到这个类的签名
             */
            //这个为null
            printArray(carr.getSigners());//null
            printArray(cmap.getSigners());//null
            printArray(cstr.getSigners());//null
    
        }

     

    展开全文
  • Java中的java.lang.Class API 详解

    千次阅读 2019-02-14 18:48:17
    Class是一个位于java.lang包下面的一个类,在Java中每个类实例都有对应的Class对象。类对象是由Java虚拟机(JVM)自动构造的。 Class类的方法经常在反射时被调用。 创建Class对象 有三种方法可以创建Class对象 Class....

    且将新火试新茶,诗酒趁年华。

    https://raw.githubusercontent.com/longfeizheng/longfeizheng.github.io/master/images/java/java04.jpg

    概述

    Class是一个位于java.lang包下面的一个类,在Java中每个类实例都有对应的Class对象。类对象是由Java虚拟机(JVM)自动构造的。

    Class类的方法经常在反射时被调用。

    创建Class对象

    有三种方法可以创建Class对象

    1. Class.forName(“className”):因为Class类没有公共的构造方法,所以存在一个静态的方法返回Class对象,即Class.forName()用于创建Class对象。要创建的Class对象的类名在运行时确定,不存在则抛出ClassNotFoundException。(注意className为类的完整包名)
    Class.forName("java.lang.String")
    
    1. Myclass.class:当我们在类名后面跟上.class时,就会返回当前类的Class对象。它主要应用于原始数据类型,并且仅在我们知道类的名称时才使用。要创建的Class对象的类名在编译时确定
    Class c2 = String.class;
    

    请注意,此方法与类名一起使用,而不是与类实例一起使用

    A a = new A();   // Class A 的实例a
    Class c = A.class; // 正确用法
    Class c = a.class; //编译出错
    
    1. obj.getClass() : 此方法存在时Object类中,它返回此obj对象的运行时类。
    String str = new String("string");
    Class c3 = str.getClass();
    

    Class对象里面的方法

    String toString()

    此方法将Class对象转换为字符串。它返回字符串表示形式,即字符串“class”或“interface”,后跟空格,然后是类的含包名名称。如果Class对象表示基本类型,则此方法返回基本类型的名称,如果它表示void,则返回“void”

    描述:

    语法 :
    public String toString()
    参数 :
    NA
    返回 :
    a string representation of this class object.
    重写 :
    toString in class Object
    

    测试类:

    public class ToStringTest {
        public static void main(String[] args) throws ClassNotFoundException {
            Class c1 = Class.forName("java.lang.String");
            Class c2 = int.class;
            Class c3 = void.class;
            System.out.println("Class represented by c1: "+c1.toString());
            System.out.println("Class represented by c2: "+c2.toString());
            System.out.println("Class represented by c3: "+c3.toString());
        }
    }
    

    输出:

    Class represented by c1: class java.lang.String
    Class represented by c2: int
    Class represented by c3: void
    

    String toGenericString()

    返回描述此类的字符串,包括有关修饰符和类型参数的信息。

    描述:

    语法 :
    public String toGenericString()
    参数 :
    NA
    返回 :
    a string describe of this class object.
    

    测试类:

    public class ToGenericStringTest {
        public static void main(String[] args) throws ClassNotFoundException {
            Class c1 = Class.forName("java.lang.String");
            Class c2 = int.class;
            Class c3 = void.class;
            System.out.println("Class represented by c1: "+c1.toGenericString());
            System.out.println("Class represented by c2: "+c2.toGenericString());
            System.out.println("Class represented by c3: "+c3.toGenericString());
        }
    }
    

    输出:

    Class represented by c1: public final class java.lang.String
    Class represented by c2: int
    Class represented by c3: void
    

    Class<?> forName(String className)

    返回与给定字符串名称的类或接口相关联的 类对象。

    描述:

    语法 :
    public static Class<?> forName(String className) throws ClassNotFoundException
    参数 :
    className -含包名
    返回 :
    返回指定包名的class对象
    异常:
    ClassNotFoundException
    ......
    

    测试类:

    public class ToClassForNameTest {
        public static void main(String[] args) throws ClassNotFoundException {
            Class c1 = Class.forName("java.lang.String");
        }
    }
    

    输出:

    Class<?> forName(String className,boolean initialize, ClassLoader loader)

    使用给定的类加载器返回与给定字符串名称的类或接口相关联的类对象。如果参数loader为空,则通过引导类加载器加载该类。只有当initialize参数为true并且尚未被初始化时,该类才被初始化。

    描述:

    语法 :
    public static Class<?> forName(String className,boolean initialize, ClassLoader loader)
    throws ClassNotFoundException
    参数 :
    className -含包名
    initialize - 如果true该类将被初始化。
    loader  - 类加载器
    返回 :
    返回指定包名的class对象
    异常:
    ClassNotFoundException
    ......
    

    测试类:

    public class ToClassForNameTest {
        public static void main(String[] args) throws ClassNotFoundException {
            Class myClass = Class.forName("Test");
            ClassLoader loader = myClass.getClassLoader();
            Class c = Class.forName("java.lang.String",true,loader)
        }
    }
    

    输出:

    T newInstance()

    此方法创建此Class对象表示的类的新实例。通过具有空参数列表的新表达式创建类。如果尚未初始化,则初始化该类。

    描述:

    语法 :
    public T newInstance() throws InstantiationException,IllegalAccessException
    参数 :
    NA
    返回 :
    由此对象表示的类的新分配实例
    异常:
    IllegalAccessException
    ......
    

    测试类:

    public class NewInstanceTest {
        public static void main(String[] args) throws ClassNotFoundException {
          Class c1 = Class.forName("java.lang.String");
          Object instance = c1.newInstance();
          System.out.println("instance class : " + instance.getClass());
        }
    }
    

    输出:

    instance class : class java.lang.String
    

    boolean isInstance(Object obj)

    此方法确定指定的Object是否与此Class表示的对象分配兼容。它相当于java中的instanceof运算符

    描述:

    语法 :
    public boolean isInstance(Object obj)
    参数 :
    obj - the object to check
    返回 :
    true if obj is an instance of this class else return false
    异常:
    

    测试类:

    public class IsInstanceTest {
        public static void main(String[] args) throws ClassNotFoundException {
            Class c = Class.forName("java.lang.String");
            String url = "http://niocoder.com";
            int i = 10;
            boolean b1 = c.isInstance(url);
            boolean b2 = c.isInstance(i);
            System.out.println("is url instance of String : " + b1);
            System.out.println("is i instance of String : " + b2);
        }
    }
    

    输出:

    is url instance of String : true
    is i instance of String : false
    

    boolean isAssignableFrom(Class<?> cls)

    此方法确定此Class对象表示的类或接口是否与指定的Class参数表示的类或接口相同,或者是超类或超接口。

    描述:

    语法 :
    public boolean isAssignableFrom(Class<?> cls)
    参数 :
    cls - the Class object to be checked
    返回 :
    true if objects of the type cls can be assigned to objects of this class
    

    测试类:

    public class IsAssignableFrom extends Thread {
        public static void main(String[] args) throws Exception {
            Class myClass = Class.forName("com.niocoder.test.java.method.IsAssignableFrom");
            Class c1 = Class.forName("java.lang.Thread");
            Class c2 = Class.forName("java.lang.String");
    
            boolean b1 = c1.isAssignableFrom(myClass);
            boolean b2 = c2.isAssignableFrom(myClass);
    
            System.out.println("is Thread class Assignable from IsAssignableFrom : " + b1);
            System.out.println("is String class Assignable from Test : " + b2);
        }
    }
    
    

    输出:

    is Thread class Assignable from IsAssignableFrom : true
    is String class Assignable from Test : false
    

    boolean isInterface()

    此方法确定指定的Class对象是否表示接口类型

    描述:

    语法 :
    public boolean isInterface()
    参数 :
    NA
    返回 :
    return true if and only if this class represents an interface type else return false
    

    测试类:

    public class IsInterfaceTest {
        public static void main(String[] args) throws Exception {
            Class c1 = Class.forName("java.lang.String");
            Class c2 = Class.forName("java.lang.Runnable");
            boolean b1 = c1.isInterface();
            boolean b2 = c2.isInterface();
            System.out.println("is java.lang.String an interface : " + b1);
            System.out.println("is java.lang.Runnable an interface : " + b2);
        }
    }
    
    

    输出:

    is java.lang.String an interface : false
    is java.lang.Runnable an interface : true
    

    boolean isPrimitive()

    此方法确定指定的Class对象是否表示基本类型。即boolean , byte , char , short , int , long , float和double 。

    描述:

    语法 :
    public boolean isPrimitive()
    参数 :
    NA
    返回 :
    return true if and only if this class represents a primitive type else return false
    

    测试类:

    public class IsPrimitiveTest {
        public static void main(String[] args) {
            Class c1 = int.class;
            Class c2 = IsPrimitiveTest.class;
            boolean b1 = c1.isPrimitive();
            boolean b2 = c2.isPrimitive();
    
            System.out.println("is " + c1.toString() + " primitive : " + b1);
            System.out.println("is " + c2.toString() + " primitive : " + b2);
        }
    }
    
    

    输出:

    is int primitive : true
    is class com.niocoder.test.java.method.IsPrimitiveTest primitive : false
    

    boolean isArray()

    此方法确定指定的Class对象是否表示数组类。

    描述:

    语法 :
    public boolean isArray()
    参数 :
    NA
    返回 :
    return true if and only if this class represents an array type else return false
    

    测试类:

    public class IsArrayTest {
        public static void main(String[] args) {
            int a[] = new int[2];
            Class c1 = a.getClass();
            Class c2 = IsArrayTest.class;
    
            boolean b1 = c1.isArray();
            boolean b2 = c2.isArray();
    
            System.out.println("is "+c1.toString()+" an array : " + b1);
            System.out.println("is "+c2.toString()+" an array : " + b2);
        }
    }
    
    

    输出:

    is class [I an array : true
    is class com.niocoder.test.java.method.IsArrayTest an array : false
    

    boolean isAnonymousClass()

    当且仅当此类是匿名类时,此方法才返回true。匿名类与本地类类似,只是它们没有名称

    描述:

    语法 :
    public boolean isAnonymousClass()
    参数 :
    NA
    返回 :
    true if and only if this class is an anonymous class.false,otherwise.
    

    boolean isLocalClass()

    当且仅当此类是本地类时,此方法才返回true。本地类是在Java代码块中本地声明的类,而不是类的成员。

    描述:

    语法 :
    public boolean isLocalClass()
    参数 :
    NA
    返回 :
    true if and only if this class is a local class.false,otherwise.
    

    boolean isMemberClass()

    当且仅当此类是Member类时,此方法返回true。

    描述:

    语法 :
    public boolean isMemberClass()
    参数 :
    NA
    返回 :
    true if and only if this class is a Member class.false,otherwise.
    

    boolean isEnum()

    当且仅当此类在源代码中声明为枚举时,此方法才返回true

    描述:

    语法 :
    public boolean isEnum()
    参数 :
    NA
    返回 :
    true iff this class was declared as an enum in the source code.false,otherwise.
    

    boolean isAnnotation()

    此方法确定此Class对象是否表示注释类型。请注意,如果此方法返回true,则isInterface()方法也将返回true,因为所有注释类型也是接口

    描述:

    语法 :
    public boolean isAnnotation()
    参数 :
    NA
    返回 :
    return true if and only if this class represents an annotation type else return false
    

    测试类:

    public class IsTest {

    @interface B
    {
        // Annotation element definitions
    }
    
    //枚举
    enum Color {
        RED, GREEN, BLUE;
    }
    
    //  Member class
    class A {
    }
    
    public static void main(String[] args) {
        // 匿名类
        IsTest t1 = new IsTest() {
    
        };
    
        Class c1 = t1.getClass();
        Class c2 = IsTest.class;
        Class c3 = A.class;
        Class c4 = Color.class;
        Class c5 = B.class;
    
        boolean b1 = c1.isAnonymousClass();
        System.out.println("is " + c1.toString() + " an anonymous class : " + b1);
        boolean b2 = c2.isLocalClass();
        System.out.println("is " + c2.toString() + " a local class : " + b2);
        boolean b3 = c3.isMemberClass();
        System.out.println("is " + c3.toString() + " a member class : " + b3);
        boolean b4 = c4.isEnum();
        System.out.println("is " + c3.toString() + " a Enum class : " + b4);
        boolean b5 = c5.isAnnotation();
        System.out.println("is " + c3.toString() + " an annotation  : " + b5);
    }
    

    }

    输出:

    is class com.niocoder.test.java.method.IsTest$1 an anonymous class : true
    is class com.niocoder.test.java.method.IsTest a local class : false
    is class com.niocoder.test.java.method.IsTest$A a member class : true
    is class com.niocoder.test.java.method.IsTest$A a Enum class : true
    is class com.niocoder.test.java.method.IsTest$A an annotation  : true
    

    String getName()

    返回由 类对象表示的实体(类,接口,数组类,原始类型或空白)的名称(含包明),作为 String 。

    描述:

    语法 :
    public String getName()
    参数 :
    NA
    返回 :
    returns the name of the name of the entity represented by this object.
    

    String getSimpleName()

    此方法返回源代码中给出的基础类的名称(不含包名)。如果基础类是匿名类,则返回空字符串

    描述:

    语法 :
    public String getSimpleName()
    参数 :
    NA
    返回 :
    the simple name of the underlying class
    

    测试类:

    public class GetNameTest {
        public static void main(String[] args)
        {
            Class c = GetNameTest.class;
    
            System.out.print("Class Name associated with c : ");
            System.out.println(c.getName());
            System.out.println(c.getSimpleName());
        }
    }
    
    

    输出:

    Class Name associated with c : com.niocoder.test.java.method.GetNameTest
    GetNameTest
    

    ClassLoader getClassLoader()

    此方法返回此类的类加载器。如果类加载器是bootstrap类加载器,那么此方法返回null,因为引导类加载器是用C,C ++等本机语言实现的。如果此对象表示基本类型或void,则返回null

    描述:

    语法 :
    public ClassLoader getClassLoader()
    参数 :
    NA
    返回 :
    the class loader that loaded the class or interface represented by this object
    represented by this object.
    

    TypeVariable<Class>[ ] getTypeParameters()

    此方法返回一个TypeVariable对象数组,该对象表示由此GenericDeclaration对象表示的泛型声明声明的类型变量,按声明顺序

    描述:

    语法 :
    public TypeVariable<Class<T>>[] getTypeParameters()
    参数 :
    NA
    返回 :
    an array of TypeVariable objects that represent the type variables declared
    by this generic declaration represented by this object.
    

    测试类:

    public class GetClassLoaderTest {
        public static void main(String[] args) throws Exception {
            {
                Class myClass = Class.forName("com.niocoder.test.java.method.GetClassLoaderTest");
                Class c1 = Class.forName("java.lang.String");
                Class c2 = int.class;
                System.out.print("GetClassLoaderTest class loader : ");
                System.out.println(myClass.getClassLoader());
                System.out.print("String class loader : ");
                System.out.println(c1.getClassLoader());
    
                System.out.print("primitive int loader : ");
                System.out.println(c2.getClassLoader());
            }
    
            {
                Class c = Class.forName("java.util.Set");
                TypeVariable[] tv = c.getTypeParameters();
                System.out.println("TypeVariables in "+c.getName()+" class : ");
                for (TypeVariable typeVariable : tv)
                {
                    System.out.println(typeVariable);
                }
            }
    
        }
    }
    
    

    输出:

    GetClassLoaderTest class loader : sun.misc.Launcher$AppClassLoader@18b4aac2
    String class loader : null
    primitive int loader : null
    TypeVariables in java.util.Set class :
    E
    

    Class<? super T> getSuperclass()

    此方法返回表示此Class所表示的实体(类,接口,基本类型或void)的超类的Class。如果此Class表示Object类,接口,基本类型或void,则返回null。如果此对象表示数组类,则返回表示Object类的Class对象。

    描述:

    语法 :
    public Class<? super T> getSuperclass()
    参数 :
    NA
    返回 :
    the superclass of the class represented by this object
    

    Type getGenericSuperclass()

    此方法返回表示此Class所表示的实体(类,接口,基本类型或void)的直接超类的Type。如果此Class表示Object类,接口,基本类型或void,则返回null。如果此对象表示数组类,则返回表示Object类的Class对象。

    描述:

    语法 :
    public Type getGenericSuperclass()
    参数 :
    NA
    返回 :
    athe superclass of the class represented by this object
    

    Class<?>[] getInterfaces()

    此方法返回由此对象表示的类或接口实现的接口。如果此对象表示不实现接口的类或接口,则该方法返回长度为0的数组。如果此对象表示基本类型或void,则该方法返回长度为0的数组。

    描述:

    语法 :
    public Class<?>[] getInterfaces()
    参数 :
    NA
    返回 :
    an array of interfaces implemented by this class.
    

    Package getPackage()

    此方法返回此类的包。

    描述:

    语法 :
    public Package getPackage()
    参数 :
    NA
    返回 :
    the package of the class,
    or null if no package information is available
    from the archive or codebase.
    

    测试类:

    public class GetSuperClassTest {
        public static void main(String[] args) throws Exception {
            System.out.println("getSuperclass-----------------------------------------");
            {
                Class myClass = GetSuperClassTest.class;
                Class c1 = Class.forName("com.niocoder.test.java.method.A");
                Class c2 = Class.forName("com.niocoder.test.java.method.B");
                Class c3 = Class.forName("java.lang.Object");
                System.out.print("GetSuperClassTest superclass : ");
                System.out.println(myClass.getSuperclass());
                System.out.print("A superclass : ");
                System.out.println(c1.getSuperclass());
                System.out.print("B superclass : ");
                System.out.println(c2.getSuperclass());
                System.out.print("Object superclass : ");
                System.out.println(c3.getSuperclass());
            }
    
            System.out.println("getGenericSuperclass-----------------------------------------");
            {
                Class myClass = GetSuperClassTest.class;
                Class c1 = Class.forName("java.util.ArrayList");
                Class c3 = Class.forName("java.lang.Object");
                System.out.print("GetSuperClassTest superclass : ");
                System.out.println(myClass.getGenericSuperclass());
                System.out.print("ArrayList superclass : ");
                System.out.println(c1.getGenericSuperclass());
                System.out.print("Object superclass : ");
                System.out.println(c3.getGenericSuperclass());
            }
    
            System.out.println("getInterfaces-----------------------------------------");
            {
                Class c1 = Class.forName("com.niocoder.test.java.method.D");
                Class c2 = Class.forName("java.lang.String");
                Class c1Interfaces[] = c1.getInterfaces();
                Class c2Interfaces[] = c2.getInterfaces();
                System.out.println("interfaces implemented by D class : ");
                for (Class class1 : c1Interfaces) {
                    System.out.println(class1);
                }
    
                System.out.println("interfaces implemented by String class : ");
                for (Class class1 : c2Interfaces) {
                    System.out.println(class1);
                }
            }
    
            System.out.println("getPackage-----------------------------------------");
            {
                Class c1 = Class.forName("java.lang.String");
                Class c2 = Class.forName("java.util.ArrayList");
                System.out.println(c1.getPackage());
                System.out.println(c2.getPackage());
            }
        }
    }
    
    class A {
    
    }
    
    class B extends A {
    
    }
    
    interface C {
    
    }
    
    interface D extends C {
    
    }
    
    

    输出:

    getSuperclass-----------------------------------------
    GetSuperClassTest superclass : class java.lang.Object
    A superclass : class java.lang.Object
    B superclass : class com.niocoder.test.java.method.A
    Object superclass : null
    getGenericSuperclass-----------------------------------------
    GetSuperClassTest superclass : class java.lang.Object
    ArrayList superclass : java.util.AbstractList<E>
    Object superclass : null
    getInterfaces-----------------------------------------
    interfaces implemented by D class :
    interface com.niocoder.test.java.method.C
    interfaces implemented by String class :
    interface java.io.Serializable
    interface java.lang.Comparable
    interface java.lang.CharSequence
    getPackage-----------------------------------------
    Disconnected from the target VM, address: '127.0.0.1:59273', transport: 'socket'
    package java.lang, Java Platform API Specification, version 1.8
    package java.util, Java Platform API Specification, version 1.8
    

    Field[] getFields()

    此方法返回一个Field对象数组,该对象反映此Class对象表示的类(及其所有超类)或接口(及其所有超类)的所有可访问公共字段

    描述:

    语法 :
    public Field[] getFields()  throws SecurityException
    参数 :
    NA
    返回 :
    the array of Field objects representing the public fields
    and  array of length 0 if the class or interface has no accessible public fields
    or if this Class object represents a primitive type or void.
    

    测试类:

    public class GetFieldsTest {
        public static void main(String[] args) throws Exception {
            Class c1 = Class.forName("java.lang.Integer");
            Field F[] = c1.getFields();
    
            System.out.println("Below are the fields of Integer class : ");
            for (Field field : F) {
                System.out.println(field);
            }
        }
    }
    
    
    

    输出:

    Below are the fields of Integer class :
    public static final int java.lang.Integer.MIN_VALUE
    public static final int java.lang.Integer.MAX_VALUE
    public static final java.lang.Class java.lang.Integer.TYPE
    public static final int java.lang.Integer.SIZE
    public static final int java.lang.Integer.BYTES
    

    Method[] getMethods()

    此方法返回一个Method对象数组,这些对象反映了类或接口的所有可访问的公共方法,以及从此Class对象表示的超类和超级接口继承的方法。

    描述:

    语法 :
    public Method[] getMethods() throws SecurityException
    参数 :
    NA
    返回 :
    the array of Method objects representing the public methods
    and  array of length 0 if the class or interface has no accessible public method
    or if this Class object represents a primitive type or void.
    

    测试类:

    public class GetMethodsTest {
        public static void main(String[] args) throws Exception {
            Class c1 = Class.forName("java.lang.Object");
            Method M[] = c1.getMethods();
    
            System.out.println("Below are the methods of Object class : ");
            for (Method method : M) {
                System.out.println(method);
            }
        }
    }
    
    
    

    输出:

    Below are the methods of Object class :
    public final void java.lang.Object.wait() throws java.lang.InterruptedException
    public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
    public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
    public boolean java.lang.Object.equals(java.lang.Object)
    public java.lang.String java.lang.Object.toString()
    public native int java.lang.Object.hashCode()
    public final native java.lang.Class java.lang.Object.getClass()
    public final native void java.lang.Object.notify()
    public final native void java.lang.Object.notifyAll()
    

    Constructor<?>[] getConstructors()

    此方法返回一个Constructor对象数组,这些对象反映此Class对象所表示的类的所有公共构造函数

    描述:

    语法 :
    public Constructor<?>[] getConstructors() throws SecurityException
    参数 :
    NA
    返回 :
    the array of Constructor objects representing the public constructors of this class
    and  array of length 0 if the class or interface has no accessible public constructor
    or if this Class object represents a primitive type or void.
    

    测试类:

    public class GetConstructorsTest {
        public static void main(String[] args) throws Exception {
            Class c1 = Class.forName("java.lang.Boolean");
            Constructor C[] = c1.getConstructors();
    
            System.out.println("Below are the constructors of Boolean class :");
            for (Constructor constructor : C) {
                System.out.println(constructor);
            }
        }
    }
    

    输出:

    public java.lang.Boolean(boolean)
    public java.lang.Boolean(java.lang.String)
    

    Field getField(String fieldName)

    此方法返回一个Field对象,该对象反映此Class对象所表示的类或接口的指定公共成员字段

    描述:

    语法 :
    public Field getField(String fieldName) throws NoSuchFieldException,SecurityException
    参数 :
    fieldName -  the field name
    返回 :
    the Field object of this class specified by name
    

    Method getMethod(String methodName,Class… parameterTypes)

    此方法返回一个Method对象,该对象反映此Class对象所表示的类或接口的指定公共成员方法

    描述:

    语法 :
    public Method getMethod(String methodName,Class... parameterTypes) throws
    NoSuchFieldException,SecurityException
    参数 :
    methodName -  the method name
    parameterTypes - the list of parameters
    返回 :
    the method object of this class specified by name
    

    Constructor<?> getConstructor(Class<?>… parameterTypes)

    此方法返回一个Constructor对象,该对象反映此Class对象所表示的类的指定公共构造函数.parameterTypes参数是一个Class对象的数组,用于按声明的顺序标识构造函数的形式参数类型

    描述:

    语法 :
    public Constructor<?> getConstructor(Class<?>... parameterTypes)
    throws NoSuchMethodException,SecurityException
    参数 :
    parameterTypes - the list of parameters
    返回 :
    the Constructor object of the public constructor that matches the specified parameterTypes
    

    测试类:

    public class GetFieldsNameTest {
        public static void main(String[] args) throws Exception {
            System.out.println("getField--------------------------------------------");
            {
                Class c1 = Class.forName("java.lang.Integer");
    
                Field f = c1.getField("MIN_VALUE");
    
                System.out.println("public field in Integer class with MIN_VALUE name :");
                System.out.println(f);
            }
            System.out.println("getMethod--------------------------------------------");
            {
                Class c1 = Class.forName("java.lang.Integer");
                Class c2 = Class.forName("java.lang.String");
                Method m = c1.getMethod("parseInt", c2);
    
                System.out.println("method in Integer class specified by parseInt : ");
                System.out.println(m);
            }
            System.out.println("getConstructor--------------------------------------------");
            {
                Class c1 = Class.forName("java.lang.Integer");
                Class c2 = Class.forName("java.lang.String");
                Constructor c = c1.getConstructor(c2);
    
                System.out.println("Constructor in Integer class & String parameterType:");
                System.out.println(c);
            }
        }
    }
    

    输出:

    getField--------------------------------------------
    public field in Integer class with MIN_VALUE name :
    public static final int java.lang.Integer.MIN_VALUE
    getMethod--------------------------------------------
    method in Integer class specified by parseInt :
    public static int java.lang.Integer.parseInt(java.lang.String) throws java.lang.NumberFormatException
    getConstructor--------------------------------------------
    Constructor in Integer class & String parameterType:
    public java.lang.Integer(java.lang.String) throws java.lang.NumberFormatException
    

    T cast(Object obj)

    此方法用于将对象强制转换为此Class对象表示的类或接口。

    描述:

    语法 :
    public T cast(Object obj)
    参数 :
    obj - the object to be cast
    返回 :
    the object after casting, or null if obj is null
    

    Class<? extends U> asSubclass(Class clazz)

    此方法用于转换此Class对象以表示由指定的类对象表示的类的子类。它始终返回对此类对象的引用

    描述:

    语法 :
    public <U> Class<? extends U> asSubclass(Class<U> class)
    参数 :
    clazz - the superclass object to be cast
    返回 :
    this Class object, cast to represent a subclass of the specified class object.
    

    测试类:

    public class CastTest {
        public static void main(String[] args) {
            {
                A1 a = new A1();
                System.out.println(a.getClass());
                B1 b = new B1();
                a = A1.class.cast(b);
                System.out.println(a.getClass());
            }
    
            {
                A1 a = new A1();
                Class superClass = a.getClass();
                B1 b = new B1();
                Class subClass = b.getClass();
                Class cast = subClass.asSubclass(superClass);
                System.out.println(cast);
            }
    
        }
    }
    
    class A1 {
    
    }
    
    class B1 extends A1 {
    
    }
    
    

    输出:

    class com.niocoder.test.java.method.A1
    class com.niocoder.test.java.method.B1
    class com.niocoder.test.java.method.B1
    

    参考链接


    Java.lang.Class class in Java | Set 1

    展开全文
  • java源码阅读之java.lang.Enum

    千次阅读 2018-07-29 23:53:44
    之所以要研究这个类,因为它是java中所有枚举的父类,本文基于JDK1.9.0的java源码进行展开。 一、类定义: public abstract class Enum&lt;E extends Enum&lt;E&gt;&gt; implements Comparable&...
  • Java反射之java.lang.reflect.Field

    千次阅读 2017-12-30 10:45:35
    前面一章 讲了怎么通过Class获取到成员(成员变量、成员方法、构造器),本篇文章开始详细讲解成员变量(java.lang.reflect.Field)的详细用法。获取field的类型有两种方式可以获取到field的属性,Field.getType()和...
  • java.lang.reflect.Field1、Field类:主要是用来辅助 获取和操作 类的属性。 我们提供了获取当前对象的成员变量的 全部属性信息和重新设值 的方法。 利用类型类反射该类型中的所有属性和方法2、Field类的实例:...
  • java.lang包下的类

    2020-07-20 21:46:43
    java.lang包下的类 1. Object object是所有类的超类,所有对象都实现了这个类的方法。 所有的方法都是native方法,其中最常用的equals、toString、getClass、hashCode。 2. Number 抽象类Number是表示数字值可...
  • 一、错误分析 java.lang.UnsupportedOperationException 大致的意思是,你调用的关于的容器的操作是被允许的。 注意【思想性的一些东西】: 1.这不是说没有该方法,如果没有该方法的话,在编译期间就可以识别。 2....
  • java 注解 java.lang.annotation包结构

    千次阅读 2018-05-22 15:51:56
    java注解基本定义在java.lang.annotation包下 介绍: 为java 编程语言注解设施提供类库支持 描述:这是jdk1.6版本的 annotation 类库结构描述 接口摘要 Annotation 所有 annotation 类型都要扩展的公共接口。 枚举摘要...
  • java.lang - 不用import

    千次阅读 2021-03-14 22:52:35
    java.lang包是java语言的核心,它提供了java中的基础类。包括基本Object类、Class类、String类、基本类型的包装类、基本的数学类等等最基本的类。我们介绍一下Java 8中的java.lang包。主要类如下图:类型对象基类...
  • 最近在后台日志监控系统中,发现了一个奇怪的 bug,只在 android 8.1.0 中出现,crash 日志如下,也可能会报Fatal Exception: java.lang.AssertionError: No NameTypeIndex match for SHORT_STANDARD 这个错误,本质...
  • 就是泛型吗,平时都使用着呢,没什么难的吧。 感觉了解了,但是真正的深入才知道自己了解甚少! 没有泛型的时候,只有原始类型。此时,所有的原始类型都通过字节码文件类Class类进行抽象。Class类的一个具体对象就...
  • 枚举常量未添加类定义`{}` 枚举常量添加了类定义`{}` 这两种情况生成的enum constant是有区别的,前者类型是enum type本身,后者是enum type的内部类。
  • 如果一个类的实例是有限且确定的,那么可以使用枚举类。比如:季节类,只有春夏秋冬四个实例。 枚举类使用enum进行创建,其实例必须从”第一行“开始显示写出。 enum Season{  SPRING,SUMMER,FALL,WINTER;//默认...
  • swagger模拟前端请求的json格式: { "enabled": true, "identification": "string", "name": "string", "onwerRoleGroups": [ null ], "parentId": 0, "remark": "string", "roleCategory": "NO...
  • java.lang包介绍

    万次阅读 多人点赞 2018-02-24 14:33:35
    java.lang包是java语言的核心,它提供了java中的基础类。包括基本Object类、Class类、String类、基本类型的包装类、基本的数学类等等最基本的类。我们介绍一下Java 8中的java.lang包。主要类如下图: 下面分别...
  • java.lang.Enum枚举类型

    千次阅读 热门讨论 2016-12-28 11:31:56
    enum的全称enumeration,是JDK1.5才引入的特性,存放在java.lang包中。 使用情况 当一个类型他是有一些可并列的,变化的元素组成时,这些元素就像是导游,指引程序走向不同的地方,用枚举是比较好的选择  ...
  • java基础 lang包 详细介绍

    千次阅读 2021-02-26 12:32:39
    Java、javax和org。其中以java开头的包名是JDK的基础语言包,以javax开头的属(org是...盖java.lang包和java.util包中的内容。Java语言所需要的基本的功能类、接口等信息,是进行Java语言编程的基础。默认引入的...
  • 今天在使用,set集合的add方法时,抛出了一个异常,java.lang.UnsupportedOperationException下面进行错误的复盘,代码如下:public static void main(String[] args) { Set<Object> set = PropertiesUtil.getKey...
  • java.lang:编写java程序时最广泛使用的包,自动导入到所有的程序中,包含了java程序的基础类和接口。包装类、Math类String类等常用的类都包含在此类中,java.lang包还提供了用于管理类的动态加载、外部进程创建、...
  • java.lang.Class<T>

    千次阅读 2018-06-01 14:07:43
    Java Class类理解:首先,Class是一个java类,跟Java API中定义的诸如Thread、Integer类、我们自己定义的类是一样,也继承了Object(Class是Object的直接子类)。总之,必须明确一点,它其实只是个类,只不过名字...
  • attempting to use incompatible return type(返回类型boolean与java.lang.Object兼容)
  • 起因来自于我对于java枚举类的无知。 我本来想定义这样一个枚举类: public enum MenuOptions { CHAT_ROOM("#1"), MENU("#0"), ERROR("#9999"); private String value; MenuOptions(String value) { thi...
  • java.lang.Class类详解

    万次阅读 多人点赞 2015-05-18 13:54:21
     Java程序运行时,系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行,用来保存这些类型信息的类是Class类。Class类封装一个对象和...
  • Java 枚举(enum)

    2021-11-05 16:36:34
    Java 枚举是一个特殊的类,一般表示一组常量,比如一年的 4 个季节,一个年的 12 个月份,一...enum 定义的枚举类默认继承java.lang.Enum 类,并实现了 java.lang.Seriablizable 和 java.lang.Comparable 两个接口。
  • java.lang.management
  • Java.Core】Enum

    2015-06-28 23:20:09
    Part I 转自: http://www.cnblogs.com/frankliiu-java/archive/2010/12/07/1898721.html ...因此枚举类就是class,而且是一个不可以继承的final 类。 既然枚举类是class,当然在枚举类型中有

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,141
精华内容 13,256
关键字:

为什么不可以继承java.lang.enum

java 订阅