精华内容
下载资源
问答
  • Java Class类及反射机制

    千次阅读 2017-12-30 09:47:00
    Class类也是一个Java类,它也可以实例化得到对象,与普通类不一样的是Class类中存储的是其它类的类型信息。而这些类型信息正是Java反射机制所需要的,Java的反射机制是由Class类java.lang.reflect包下的Method、...

    首先要分清楚Class类和关键词class的不同,虽然Class类名称上和class很相似,但两者其实没有什么关联。Class类也是一个Java类,它也可以实例化得到对象,与普通类不一样的是Class类中存储的是其它类的类型信息。而这些类型信息正是Java反射机制所需要的,Java的反射机制是由Class类和java.lang.reflect包下的Method、Field、Constructor等类支持的。下面就来了解下这几个类。

    1.Class类

    类是程序的一部分,每个类都有一个Class对象,换而言之每编写一个新类,就会产生一个Class对象(更准确的来说,是被保存在一个同名的.class文件中)。当程序中需要使用到这个类的时候(包括需要这个类的对象或引用这个类的静态变量)就通过类加载器将类加到内存中来。
    在进行类加载的时候,类加载器会先检查这个类的Class对象是否已经加载,如果还未加载,则默认的类加载器就会根据类名查找.class文件(这里不一定都是从文件系统中获取,可以从数据库读取字节码或者接受网络中传输过来的字节码)。这些字节码在被加载的时候,会检查验证保证它们没有被破坏。一旦某个类的Class对象被载入内存,它就会被用来创建这个类的所有对象。下面来看下Class类一些操作。
    1.1获取Class对象的三种方式
    总共有三种方式可以获取一个类的Class对象:Class类的forName()方法、类字面常量、对象的getClass()方法。下面是一个示例,Student类是用来进行测试的对象。

    package com.sankuai.lkl;
    public class Student {
    
        public static final String test1 = "final_test";
        public static       String test2 = "static_test";
    
        static {
            System.out.println("init static");
        }
    
        private String name;
        private int    id;
        private String grade;
    }

    下面是一个测试方法:

    public static void test1() throws Exception{
          //获取Class对象的三种方式
            try {
                //使用Class.forName()方法载入的时候,需要类的全限定名
                Class<?> cc = Class.forName("com.sankuai.lkl.Student");
                System.out.println(cc);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
            //使用类字面常量
            Class<?> cc1 = Student.class;
            System.out.println(cc1);
    
            //通过对象的getClass()
            Student student = new Student();
            Class<?> cc = student.getClass();
            System.out.println(cc);
        }

    真正测试的时候每次只会运行一个方法,下面是三种方式对应的输出:
    这里写图片描述
    这里写图片描述
    这里写图片描述
    可以看到第二次的输出有点不同,没有输出static初始化块中的值。这是因为使用类字面常量方式获取Class对象的时候,类加载器虽然将类对应的class文件载入到内存中并创建了Class对象,但是没有给类进行初始化工作。这里稍微介绍下类加载的流程,分为三步:

    1. 加载。这一步是类加载器执行的,负责查找字节码(通常是在classpath所指定的路径中查找,但这不是必要的)。并从这些字节码中创建一个Class对象。
    2. 链接。在链接阶段将验证类中的字节码,并为类中的静态变量分配存储空间,并且如果必需的话,将解析这个类创建的对其他类的所有引用(静态变量是引用并且直接初始化的情况)。
    3. 初始化。如果该类有父类,则先对其进行初始化,调用静态初始化器和静态初始化块。

    在使用类字面常量获取Class对象的时候,初始化这一步被延迟到对类的静态方法或静态变量进行首次调用的时候(这里有一个很有意思的情况,其实构造器也是隐式静态的)。

    1.2从Class对象中获取类信息
    上面讨论了如何获取一个类的Class对象,那么拿到这个Class对象之后,我们又能做些什么呢。Class对象存储了类的类型信息,对于一个类来说比较重要的信息有其中定义的属性、方法、构造器,还有就是它扩展了哪些父类和接口等等。而这些方法Class对象中都是包含的,并且还提供了获取的方法。下面是一些具体的例子,先给两个测试用的类定义:

    package com.sankuai.lkl.reflect;
    
    public interface Person {
    
        void read();
    }
    package com.sankuai.lkl.reflect;
    public class Student implements Person {
    
        private String id;
        public String name;
        private String age;
    
        //构造函数1
        public Student() {
    
        }
        //构造函数2
        public Student(String id) {
            this.id = id;
        }
        //构造函数3
        public Student(String id, String name) {
            this.id = id;
            this.name = name;
        }
    
        public String getId() {
            return id;
        }
         public void setId(String id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getAge() {
            return age;
        }
        public void setAge(String age) {
            this.age = age;
        }
        //静态方法
        public static void update() {
    
        }
        @Override
        public void read() {
    
        }
    }

    可以看到Student类是继承自Person类的。
    首先来通过Class对象获取Student的所有属性:

    public static void main(String[] args) {
            Class<?> cc = Student.class;
    
            //getFields返回的是申明为public的属性,包括父类中定义
            Field[] fields = cc.getFields();
            System.out.println("cc.getFields()");
            for (Field field : fields) {
                System.out.println(field);
            }
            System.out.println("\n");
    
            //getDeclaredFields返回的是指定类定义的所有定义的属性,不包括父类的。
            Field[] fields1 = cc.getDeclaredFields();
            System.out.println("cc.getDeclaredFields()");
            for (Field field : fields1) {
                System.out.println(field);
            }
        }
    
    输出如下:
    cc.getFields()
    public java.lang.String com.sankuai.lkl.reflect.Student.name
    public static final java.lang.String com.sankuai.lkl.reflect.Person.test
    
    cc.getDeclaredFields()
    private java.lang.String com.sankuai.lkl.reflect.Student.id
    public java.lang.String com.sankuai.lkl.reflect.Student.name
    private java.lang.String com.sankuai.lkl.reflect.Student.age

    除了上面两个方法,还有getField(String name)和 getDeclaredField(String name)两个可以通过名称拿到指定属性Field对象的方法,它们的区别同上。

    获取类所有的方法:

             Class<?> cc = Student.class;
            //获取所有pulbic类型方法,包括父类中定义的(Object和Person类中)
            //被子类重写过的方法,只算子类的
            Method[] methods = cc.getMethods();
            System.out.println("cc.getMethods()");
            for (Method method : methods) {
                System.out.println(method);
            }
            System.out.println("\n");
    
            //获取本类中所有方法
            Method[] methods1 = cc.getDeclaredMethods();
            System.out.println("cc.getDeclaredMethods()");
            for (Method method : methods1) {
                System.out.println(method);
            }
    输出如下:
    cc.getMethods()
    public java.lang.String com.sankuai.lkl.reflect.Student.getName()
    public void com.sankuai.lkl.reflect.Student.setName(java.lang.String)
    public java.lang.String com.sankuai.lkl.reflect.Student.getId()
    public void com.sankuai.lkl.reflect.Student.read()
    public static void com.sankuai.lkl.reflect.Student.update()
    public void com.sankuai.lkl.reflect.Student.setId(java.lang.String)
    public java.lang.String com.sankuai.lkl.reflect.Student.getAge()
    public void com.sankuai.lkl.reflect.Student.setAge(java.lang.String)
    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 final void java.lang.Object.wait() 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()
    
    
    cc.getDeclaredMethods()
    public java.lang.String com.sankuai.lkl.reflect.Student.getName()
    public void com.sankuai.lkl.reflect.Student.setName(java.lang.String)
    public java.lang.String com.sankuai.lkl.reflect.Student.getId()
    public void com.sankuai.lkl.reflect.Student.read()
    public static void com.sankuai.lkl.reflect.Student.update()
    public void com.sankuai.lkl.reflect.Student.setId(java.lang.String)
    public java.lang.String com.sankuai.lkl.reflect.Student.getAge()
    public void com.sankuai.lkl.reflect.Student.setAge(java.lang.String)

    除了上面的批量方法,也有通过名称和参数来获取单个Method对象的方法:
    这里写图片描述
    分别是getMethod()和getDeclaredMethod(),这里需要注意的是光通过名字是可能无法唯一确定一个方法的,所以这里还需要传入参数,两个方法都是传入参数的Class对象数组,注意int.class和Integer.class分别对应到参数中的int和Integer类型,不能通用。

    获取类的所有构造器
    在展示Class对象的方法之前,先将Person类进行改造:将其改造成抽象类,并增加两个构造器。Student仍然是Person类的子类。

    public abstract class Person {
    
        static String test = "test";
    
        private int age;
    
        public abstract void read();
    
        private Person() {
        }
    
        private Person(int age) {
            this.age = age;
        }
    }

    下面是具体方法和输出结果

      Class<?> cc = Student.class;
            //获取所有构造器
            Constructor<?>[] constructors = cc.getConstructors();
            System.out.println("cc.getConstructors()");
            for (Constructor<?> constructor : constructors) {
                System.out.println(constructor);
            }
            System.out.println("\n");
    
            Constructor<?>[] constructors1 = cc.getDeclaredConstructors();
            System.out.println("getDeclaredConstructors()");
            for (Constructor<?> constructor : constructors1)                 
            {
                System.out.println(constructor);
            }
    
    输出:
    cc.getConstructors()
    public com.sankuai.lkl.reflect.Student(java.lang.String,java.lang.String)
    public com.sankuai.lkl.reflect.Student(java.lang.String)
    public com.sankuai.lkl.reflect.Student()
    
    
    getDeclaredConstructors()
    public com.sankuai.lkl.reflect.Student(java.lang.String,java.lang.String)
    public com.sankuai.lkl.reflect.Student(java.lang.String)
    public com.sankuai.lkl.reflect.Student()

    这次看起来倒是两个方法表现一致,所有私有的构造器都没查找出来。对于构造器来说也有根据名字和参数获取类单个构造器Constructor对象的方法。

    通过Class获取类继承的父类和实现的接口的Class对象:

      Class<?> cc = Student.class;
            //获取该类实现了的所有接口
            Class<?>[] ccs = cc.getInterfaces();
            System.out.println("getInterfaces");
            for(Class<?> c : ccs){
                System.out.println(c);
            }
    
            System.out.println("\n");
    
            //获取该类的直接父类,如果没有显示声明的父类,则是Object
            Class<?> cc1 = cc.getSuperclass();
            System.out.println(cc1);

    通过Class对象判断当前类是不是接口并创建类的实例:

            Class<?> cc = Student.class;
            if (!cc.isInterface()) {
                //调用Class对象的newInstance创建对象,要求类必须具有无参构造器
                //并且创建出来的对象是Object类型,必须强制转型
                Student student = (Student) cc.newInstance();
                System.out.println(cc);
            }
    
     输出:
     com.sankuai.lkl.reflect.Student@19501026

    通过上面几个方法的介绍,大致上明白了Class类的作用,下面看下它是如何和反射来结合的。

    2.Java反射机制

    通过Class对象可以拿到类的类型信息,方法、属性、构造器;但是如果只能拿到这些信息,没有办法对其进行操作其实意义也不大。Java的反射机制正是提供了对上面获取的Method、Field、Constructor等进行操作的能力。其实这些类本身就属于java.lang.reflect包下的一部分,都实现了Member接口。下面来看下如何对它们进行操作。

    2.1通过Field改变对象属性

    public static void test1() throws Exception{
          try{
              Class<?> cc = Class.forName("com.sankuai.lkl.reflect.Student");
              Object object =  cc.newInstance();
    
              Field field = cc.getDeclaredField("id");
              //id是private类型的,如果没有下面的设置,会抛出IllegalAccessException
              field.setAccessible(true);
              field.set(object,"12313");
              System.out.println(((Student)object).getId());
          }catch (ClassNotFoundException e){
              e.printStackTrace();
          }
        }
        //输出:12313
    

    上面的id属性是私有的,但是通过将其对应Field的accessible设置为true,就可以对其进行修改了,这其实破坏了Java的封装。

    2.2通过Method来调用对象的方法

     public static void test1() throws Exception{
          try{
              Class<?> cc = Class.forName("com.sankuai.lkl.reflect.Student");
              Object object =  cc.newInstance();
              Method method = cc.getDeclaredMethod("setName",String.class);
              method.invoke(object,"testName");
              Method method1 = cc.getDeclaredMethod("getName");
              //将getName()方法设置成private,但将accessible设置为true之后,仍然可以方法
              method1.setAccessible(true);
              System.out.println(method1.invoke(object));
          }catch (ClassNotFoundException e){
              e.printStackTrace();
          }
        }
       //输出:testName

    上面展示了通过Class对象获得一个类实例,然后通过Method来操作这个类实例方法的过程。需要注意的是调用Class对象的getDeclaredMethod方法时,如果是想获得一个有参数的方法的Method对象,那么是需要传入参数类型的Class对象的,这里对顺序是有严格要求的并且int.class和Integer.class是不一样的,对其它基本类型也是同样的情况。并且和Field一样,只要将accessible设置为true,就可以实现对私有方法的调用。

    2.3通过Constructor来构造对象

     public static void test1() throws Exception {
            try {
                Class<?> cc = Class.forName("com.sankuai.lkl.reflect.Student");
                Constructor<?> constructor = cc.getDeclaredConstructor();
                System.out.println(constructor.newInstance());
                Constructor<?> constructor1 = cc.getConstructor(int.class, String.class);
                constructor1.setAccessible(true);
                Student student = (Student) constructor1.newInstance(1, "2321");
                System.out.println(student.getId() + " " + student.getName());
    
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    
    输出:
    com.sankuai.lkl.reflect.Student@24e5ddd0
    1 2321

    看起来构造器调用的形式和方法有些类似,不同的只是不再需要指定名字。并且对于私有构造器,也可以通过设置accessible为true来进行访问。

    总的来说反射机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息,包括其modifiers(诸如public, static 等)、superclass(例如Object)、实现之interfaces(例如Cloneable),也包括fields和methods的所有信息,并可于运行时改变fields内容或唤起methods。
    Java反射机制容许程序在运行时加载、探知、使用编译期间完全未知的classes。

    展开全文
  • java反射以及Class类类型

    千次阅读 多人点赞 2018-12-10 02:46:42
    java的反射机制: 在运行状态中,对于任意一个类,都能知道这个...1.Class类的使用   在面向对象的世界中,万事万物都是对象 普通数据类型不是面向对象 比如int long 但是它们的包装类型 integer Long是对象 ...

    java的反射机制:

    在运行状态中,对于任意一个类,都能知道这个类的所有属性和方法,

    对于任意一个对象,都能调用它的任意一个方法和属性,

    这种动态获取信息,以及动态调用对象的方法的功能称为java语言的反射机制

     

    1.Class类的使用

     

    在面向对象的世界中,万事万物都是对象

    普通数据类型不是面向对象 比如int long

    但是它们的包装类型 integer Long是对象

     

    静态的成员 不是对象 是属于类的

     

     

     

    什么是类

    具有相同特性(数据元素)和行为(功能)的对象抽象就是类。因此,对象抽象是类,类的具体化就是对象,也可以说类的实例是对象,类实际上就是一种数据类型

     

    类是对象的模版

    对象是类的实例

     

    但是 类也是对象 类是java.lang.Class类的实例对象

     

    比如:

    Class Foo{}

     

    Foo的对象 是 Foo f1=new Foo();

     

    但是 Foo类 也是一个对象 它是Class类的对象

    只有java的虚拟机 可以访问Class.java的构造方法 从而构造出任何Class

     

    任何一个类都是Class的实例对象 这个实例对象有三种表示方式

     

    第一种:

    Class c1=Foo.class

    //任何一个类都有一个隐含的静态成员变量

     

    第二种:

    Class c2=f1.getClass()

    //已经该类的对象 通过getClass方法

     

    // 官网的解释 c1 c2 此时表示的是Foo类的 类类型 (class type)

    类也是对象 是Class类的实例对象

    这个对象 我们称为该类的类类型

     

     

    第三种

     

    Class c3=Class.forName("Foo");

     

    这里 c1==c2==c3 true

     

     

    我们完全可以通过该类的类类型创建该类的对象实例

     

    Class c1=Foo.class

    Foo foo=(Foo)c1.newInstance(); //需要做强制类型转换

     

     

     

    动态加载类

     

    Class.forName("类的全称")

     

    不仅表示了类的Class type 还代表了动态加载类

    编译时刻加载类是静态加载

    运行时刻加载类是动态加载

     

     

    比如说

     

    这样直接去进行编译 会报错,因为Word和Excel类均不存在

     

    new 创建对象 是静态加载必须在编译期的时候就将所有类都加载进去

     

    如果是动态加载类

    那么在编译期是不会报错的

    new 创建对象 是静态加载类 再编译时刻就

    需要加载所有的可能使用到的类

    比如 Foo foo=new Foo();

    如果 Foo类不存在的话 是不能通过编译的

     

    但是 动态加载类是在运行时刻进行加载

    需要用到的时候才会去加载

    比如

     

    //运行时刻加载

    Class c= Class.forName(args[0]);

    //通过类类型 创建该类对象

    Object oa=(Object)c.newInstance();

     

    是可以在编译的时候通过,在运行的时候

    输入参数args[0]去加载对象

     

    这里如果是要加载Foo 那么Foo 实现 Object接口就行

    先定义 interface Object

    然后 foo implement Object

     

    这样即可实现动态加载任何实现了Object接口的类 而不需要重新编译该程序

    这样也可以实现热部署

     

    因此功能性的类 尽可能的使用动态加载类 而不是静态加载类

    这样方便重新升级的时候不用重新编译所有的代码

     

     

    获取方法信息

    Class c1=int.class //int的类类型

    Class c2=String.class //String 的类类型

    Class c3=void.class

     

    拿到类类型之后

     

    c1.getName(); //结果是 int

    c2.getName() //结果是java.lang.String

    c2.getsimpleName //结果是 String

     

    //getName 基本数据类型直接拿到名字

    // 类拿到是带包名的名字

     

     

    Class类的基本API

     

    获取方法的信息

    //要获取类的信息 首先要获取类的类类型

     

    Class c=obj.getClass();

     

    //获取类的名称

     

    c.getName();

     

    //获取类的方法

     

    //Method类 方法对象 所有的方法 都是这个类的对象

     

    //一个成员方法 就是一个Method对象

     

    //getMethods()方法 获取的事的所有public的函数 包括父类继承来的

     

    //getDeclareMethods() 获取的是所有该类自己声明的方法 不论访问权限 父类继承来的没有

     

     

    Method[] ms=c.getMethods(); //获取这个类里所有的public方法 存到一个method的数组中

     

    ms[i].getReturnType();//获取方法返回值类型的Class type

    //比如说返回值是String 我们拿到的是String.class

    //所以返回值类型是 ms[i].getReturnType().getName()

     

    ms[i].getName();//获取方法名字

     

    //获取参数类型 得到的是参数列表的类型的Class type

    Class[] paramTypes=ms[i].getParameterTypes();

     

    paramTypes[i].getName();//拿到参数名字

     

    获取成员变量的信息

     

    成员变量也是对象

    java.lang.reflect.Field 的对象

    FieId类封装了关于成员变量的操作

     

    getFieIds()方法获取的是所有的public的成员变量的信息

    getDeclaredFields()获取的是该类自己声明的成员变量的信息

     

    Field[] fs=c.getDeclareFields();

     

    //得到成员变量的类类型

    Class fieldType =fs[i].getType();

    //得到成员变量的类型名字

    String typeName=fieldType.getName();

    //得到成员变量的名字

    String fieldName=fs[i].getName();

     

     

    获取构造函数信息

     

    Class c=obj.getClass();

    //构造函数也是对象

    //是 java.lang.Constructor中封装了构造函数的信息

    //getConstructors获取所有的public的构造函数

    //getDeclaredConstructors 获取所有的构造方法 包括私有

    Constructor[] cs=c.getDeclareConstructors();

    cs[i].getName() //获取构造函数的名字

     

    //获取构造函数的参数的类类型

    Class[] paramTypes = cs[i].getParameterTypes();

    paramTypes[i].getName()// 获取类型名字

     

    2.方法的反射

     

    1.如何获取某个方法

     

    方法的名称和方法的参数列表才能唯一决定某个方法

     

    方法的反射操作

    method的对象有个invoker方法 ,这个方法通过参数列表确定某个方法

    method.invoke(对象,参数列表)

     

     

     

    public static void main(String[] args) {

    //要获取print(int ,int) 方法

    //要获取一个方法,就是要获取类的信息,获取类的信息,首先要获取类的类类型

     

    A a1 = new A();

    Class c = a1.getClass();

    ///获取方法:名称和参数列表来决定

    //getMethod 获取的是public方法

    //getDelcareMethod自己声明的方法

    try {

    Method m = c.getMethod("print", int.class, int.class);

    //此时获取到了method的方法的对象

    //方法的反射操作:是用Method对象来进行方法的调用操作

    //方法如果没有返回值则返回null,如果有返回值 则返回具体的返回值

    Object o = m.invoke(a1, 1, 2);

    //等同于

    a1.print(1, 2);

     

    //通过反射调用方法的私有对象

    //先获取声明的所有方法

    Method m2 = c.getDeclaredMethod("print",int.class);

    System.out.println("开始获取方法");

    System.out.println(m2.getName());

    System.out.println("参数列表为");

    for (Class<?> aClass : m2.getParameterTypes()) {

    System.out.println(aClass.getName());

    }

    System.out.println("调用私有方法");

    // m2.invoke(a1, 1);

    //会报异常

    //java.lang.IllegalAccessException: Class classDemo.demo3.MethodDemo1 can not access a member of class

    // classDemo.demo3.A with modifiers "private"

    //但是手动将该方法改为公有的即可

    m2.setAccessible(Boolean.TRUE);// 将私有访问限制改为public

    m2.invoke(a1, 1);

    } catch (Exception ex) {

    ex.printStackTrace();

    }

    }

     

     

    输出如下

     

     

    泛型:

    java集合种的泛型 是防止错误输入的,只有在编译阶段有效

    绕过编译 ,就无效了

    比如说 通过反射来操作,绕过编译

    反射是在运行期起作用的

     

     

    public class MethodDemo4 {

    public static void main(String[] args) {

    ArrayList list=new ArrayList();

     

    ArrayList<String> list1=new ArrayList<String>();

    list1.add("hello");

    // list1.add(2); //直接放是错误的 会报错 因为编译时限制了类型是String

     

    Class c1=list.getClass();

    Class c2=list1.getClass();

    System.out.println(c1==c2);

     

    //c1==c2 编译之后集合的泛型是去泛型化的

    try {

    Method m=c2.getMethod("add",Object.class);

    m.invoke(list1,2); //绕过泛型的限制 将2这个整型放进去了 ,说明在运行时候 去没有限制的

    System.out.println(list1.size());

    } catch (NoSuchMethodException e) {

    e.printStackTrace();

    } catch (IllegalAccessException e) {

    e.printStackTrace();

    } catch (InvocationTargetException e) {

    e.printStackTrace();

    }

     

    }

     

    }

     

     

     

    对象除了可以通过new创建,也可以反射创建,class.instant 或者反序列化创建

     

     

     

    展开全文
  • Java反射 Class类常用方法详解

    万次阅读 多人点赞 2018-05-19 18:47:49
    1.返回Class类对应的实体类的相关的Class类的方法:如果我们已经有了一个类的 Class类,可以使用下面的一些方法来获得它相关的类:(1)返回当前Class类对应的实体类的父类的Class类:public Class&lt;? super T&...

    获取一个类对应的Class类的方法

    1.使用Object.getClass ()方法----引用类型的对象的获取方式

    如果我们已经拿到了一个对象,可以使用这个对象的 getClass 方法获得一个 Class 对象(不过这仅限于引用类型的对象):

    String string=new String();
    //使用已经存在的对象的getClass()方法获取Class对象
    Class  class1=string.getClass();

    2.使用类的class成员属性

    如果我们当前没有某个类的对象,无法使用 getClass() 方法来获取Class对象,那还可以使用 类名.class 来获取 Class对象:

    //使用 类名.class来获取Class对象
    Class class2=String.class;

    其实这种方式不仅能用于引用类型,基本类型也可以。数组也是可以的:

    Class class3=int.class;
    Class class4=int[][].class
    3.使用Class类的forName("类完整路径")方法获取:

    如果我们有一个类的完整路径,就可以使用 Class.forName(“类完整的路径”) 来得到相应的 Class,这个方法只能用于引用类型,所谓类的完整路径是:包名.类名 例如:java.lang.String。

    Class<?> strClass=Class.forName("java.lang.String");

    4.使用包装类的TYPE属性来获取包装类对应的Class类:

    public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

    返回Class类对应的实体类的相关的Class类的方法:

    如果我们已经有了一个类的 Class类,可以使用下面的一些方法来获得它相关的类:

    1.返回当前Class类对应的实体类的父类的Class类:

    public Class<? super T> getSuperclass()

    例如:

    public static void main(String[] args) throws ClassNotFoundException
    {
        Class<String> strClass = (Class<String>) Class.forName("java.lang.String");
        // 返回调用类的父类
        Class<?> superClass = strClass.getSuperclass();
        System.out.println("当前实体类的Class类    :"+strClass);
        System.out.println("实体类的父类的Class类:"+superClass);
    }

    结果:

    当前实体类的Class类    :class java.lang.String
    实体类的父类的Class类:class java.lang.Object

    2.返回类定义的公共的内部类,以及从父类、父接口那里继承来的内部类

    public Class<?>[] getClasses()

    3.返回类中定义的公共、私有、保护的内部类

    public Class<?>[] getDeclaredClasses()

    实例:

    Person类:

    public class Person
    {
    	public class PA{};
    	private class PB{};
    	public interface PIA{};
    	private interface PIB{};
    }

    Student类:

    public class Student extends Person
    {
    	//公共的内部类
    	public class A{}
    	//保护内部类
    	protected class B{}
    	//默认内部类
    	class C{}
    	//私有内部类:
    	private class D{}
    	//共有静态内部类
    	public static class E{}
    	//共有内部接口
    	public interface IA{}
    	//保护内部接口
    	protected interface IB{}
    	//默认内部接口
    	interface IC{}
    	//私有内部接口
    	private interface ID{}
    }
    

    main方法:

    public static void main(String[] args) throws ClassNotFoundException
    {
    	Class<String> stuClass = (Class<String>) Class.forName("reflect.Student");
    	//获取调用类的所有公共的内部类和接口,包括继承的共有的内部类和接口的Class
    	System.out.println(stuClass.getName()+"的公有内部类和接口(包括继承):");
    	Class[]   strClasses=stuClass.getClasses();
    	for (Class class1 : strClasses)
    	{
    		System.out.println(class1.getName());
    	}
    	System.out.println("-------------------------");
    	System.out.println(stuClass.getName()+"的所有内部类和接口(包括继承):");
    	Class[]   stuAllClasses=stuClass.getDeclaredClasses();
    	for (Class class1 : stuAllClasses)
    	{
    		System.out.println(class1.getName());
    	}
    	
    }

    运行结果:

    reflect.Student的公有内部类和接口(包括继承):
    reflect.Student$A
    reflect.Student$E
    reflect.Student$IA
    reflect.Person$PA
    reflect.Person$PIA
    -------------------------
    reflect.Student的所有内部类和接口(包括继承):
    reflect.Student$A
    reflect.Student$B
    reflect.Student$C
    reflect.Student$D
    reflect.Student$E
    reflect.Student$IA
    reflect.Student$IB
    reflect.Student$IC
    reflect.Student$ID
    

    4. 返回一个成员内部类/属性/方法/构造器所在的类的Class,这些方法是上面那两个方法的逆操作

    java.lang.reflect.Class.getDeclaringClass()    ;//返回一个成员内部类所在的类的Class
    java.lang.reflect.Field.getDeclaringClass()      ;//返回一个字段所在的类的Class
    java.lang.reflect.Method.getDeclaringClass()    ;//返回一个方法所在的类的Class
    java.lang.reflect.Constructor.getDeclaringClass() ;//返回一个构造器所在的类的Class

    (1) Class.getDeclaringClass()实例:--获取该成员内部类所在声明类的Class,所谓声明类,就是声明该内部类的外部类

    测试类:

    public class A
    {
    	String name;
    	class C{}
    }

    在这里,内部类C的声明类就是A,在类A里面声明了内部类C和成员属性name.对于成员属性name和成员内部类C而言,它们的声明类都是A.这样说可以理解了吧。

    main方法:

    public static void main(String[] args) throws ClassNotFoundException
    {
    	Class stuClass =  Class.forName("reflect.A$C");//获取一个成员内部类的Class对象
    	//获取成员内部类的声明类,也就是他的外部类
    	Class stuclass2=stuClass.getDeclaringClass();
    	System.out.println(stuClass);
    	System.out.println(stuclass2);
    }

    运行结果:

    class reflect.A$C
    class reflect.A
    

    (2)获取声明该字段,方法,构造器的类的Class后面再补上。


    5.获取Class对应类(或者接口)的修饰符:Class.getModifiers()

    public int getModifiers();//返回此类或接口以整数编码的 Java 语言修饰符。
    修饰符由 Java 虚拟机的 public、protected、private、final、static、abstract 和 interface 对应的常量组成;
    它们应当使用 Modifier 类的方法来解码。

    一个 类(或接口)可以被以下修饰符的一种或者多种修饰:

    • 访问权限控制符:public, protected, private
    • 抽象的、需要实现的:abstract
    • 限制只能有一个实例的:static
    • 不允许修改的:final
    • 线程同步锁:synchronized
    • 原生函数:native
    • 采用严格的浮点精度:strictfp
    • 接口
    • 注解

    当然上面的修饰符不是所有类(或接口)都可以修饰,比如:

    • Interface 不能是 final
    • enum 不能是 abstract

    java.lang.reflect.Modifier 可以用来解码 Class 修饰符。我们可以使用 Class.getModifiers() 获得调用类的修饰符的二进制值,然后使用 Modifier.toString(int modifiers) 将获取到的二进制值转换为字符串。

    实例:

    测试类:

    public class A
    {
    	String name;
    	public class B{};
    	protected class C{};
    	private class D{};
    	public static class E{};
    	abstract class F{};
    	interface G{};
    }

    测试类:

    public class ModifierTest 
    {
    	public static void printModifier(String ClassPath) throws ClassNotFoundException
    	{
    		Class aClass=Class.forName(ClassPath);
    		int modifier=aClass.getModifiers();
    		System.out.println(ClassPath+"的修饰符为:"+Modifier.toString(modifier));
    	}
    	public static void main(String[] args) throws ClassNotFoundException
    	{
    		printModifier("reflect.A");
    		printModifier("reflect.A$B");
    		printModifier("reflect.A$C");
    		printModifier("reflect.A$D");
    		printModifier("reflect.A$E");
    		printModifier("reflect.A$F");
    		printModifier("reflect.A$G");
    	}
    	
    }

    运行结果:

    reflect.A的修饰符为:public
    reflect.A$B的修饰符为:public
    reflect.A$C的修饰符为:protected
    reflect.A$D的修饰符为:private
    reflect.A$E的修饰符为:public static
    reflect.A$F的修饰符为:abstract
    reflect.A$G的修饰符为:abstract static interface
    

    下面给上Modifier.toString(int modifiers)JDK的源码:

     public static String toString(int mod) {
            StringBuilder sb = new StringBuilder();
            int len;
    
            if ((mod & PUBLIC) != 0)        sb.append("public ");
            if ((mod & PROTECTED) != 0)     sb.append("protected ");
            if ((mod & PRIVATE) != 0)       sb.append("private ");
    
            /* Canonical order */
            if ((mod & ABSTRACT) != 0)      sb.append("abstract ");
            if ((mod & STATIC) != 0)        sb.append("static ");
            if ((mod & FINAL) != 0)         sb.append("final ");
            if ((mod & TRANSIENT) != 0)     sb.append("transient ");
            if ((mod & VOLATILE) != 0)      sb.append("volatile ");
            if ((mod & SYNCHRONIZED) != 0)  sb.append("synchronized ");
            if ((mod & NATIVE) != 0)        sb.append("native ");
            if ((mod & STRICT) != 0)        sb.append("strictfp ");
            if ((mod & INTERFACE) != 0)     sb.append("interface ");
    
            if ((len = sb.length()) > 0)    /* trim trailing space */
                return sb.toString().substring(0, len-1);
            return "";
        }
    总结:

    Class.getModifiers():获取当前Class类的修饰符编码(int 类型),

    Modifier.toString(int modifiers):把上面获取到的修饰符编码,转换成字符串形式。

    注意:

    • Interface 默认是 abstract 的,虽然我们没有添加,编译器会在编译器为每个 Interface 添加这个修饰符。
    • 只有被 @Retention(RetentionPolicy.RUNTIME) 修饰的注解才可以在运行时被发射获取
    • Java 中预定义的注解 @Deprecated,@Override, 和 @SuppressWarnings 中只有 @Deprecated 可以在运行时被访问到

    6. 获取Class对应的类或者接口的成员Member(成员有:属性,方法,构造方法)

    java.lang.reflect.Member 是一个接口,代表 Class 的成员,每个成员都有类型,分为是否从父类继承,还有是否可以直接访问。

    Member 有三个实现类:

    • java.lang.reflect.Constructor:表示该 Class 的构造函数
    • java.lang.reflect.Field:表示该 Class 的成员变量
    • java.lang.reflect.Method:表示该 Class 的成员方法

    (1)获取构造函数

    java.lang.Class 提供了以下方法用于获取该类的构造函数:

    a.返回构造器数组:

     Constructor<?>[] getDeclaredConstructors();//返回所有的构造方法的Constructor对象的数组的Constructor对象的数组
     Constructor<?>[] getConstructors();        //返回所有共有的构造方法的Constructor对象的数组

    b.返回指定的一个构造器:

    Constructor<T> getConstructor(Class<?>... parameterTypes) 
              返回一个 Constructor 对象,它反映此 Class 对象所表示的类的指定公共构造方法。 
    Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 
              返回一个 Constructor 对象,该对象反映此 Class 对象所表示的类或接口的指定构造方法。 

    (2)获取成员变量

    java.lang.Class 提供了以下方法用于获取该类的成员变量:

    a.返回字段对象数组:

    Field[] getFields() 
              返回此 Class 对象所表示的类或接口的所有公有字段数组(Field 对象数组)
    Field[] getDeclaredFields() 
              返回此 Class 对象所表示的类或接口中所有声明的字段数组(Field对象数组)。 

    b.返回单个字段对象:

    Field getField(String name) 
              返回此 Class 对象所表示的类或接口的指定的公有成员字段对象(Field对象)。 
     Field getDeclaredField(String name) 
              返回一个此 Class 对象所表示的类或接口的指定已声明字段(Field 对象)

    7.获取成员方法

    java.lang.Class 提供了以下方法用于获取该类的成员方法:

    a.获取方法对象数组:第一个只能获取public修饰的方法数组,第二个可以获取除继承外的所有方法

     Method[] getMethods() 
              返回一个包含某些 Method 对象的数组,这些对象反映此 Class 对象所表示的类或接口
              (包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口)的公共 member 方法 
     Method[] getDeclaredMethods() 
              返回 Method 对象的一个数组,这些对象反映此 Class 对象表示的类或接口声明的所有方法,
               包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法。 

    b.获取单个方法:第一个只能获取到public修饰的方法,第二个能获取除继承外的方法所有方法(公有,保护,默认,私有)

    Method getMethod(String name, Class<?>... parameterTypes) 
              返回一个 Method 对象,它反映此 Class 对象所表示的类或接口的指定的public成员方法。 
    Method getDeclaredMethod(String name, Class<?>... parameterTypes) 
              返回一个 Method 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明方法。

    8.创建对象的方法:

     T newInstance() 
              创建此 Class 对象所表示的类的一个新实例。

    9.返回字符串(String)的方法:

     String getCanonicalName() 
              返回 Java Language Specification 中所定义的底层类的规范化名称。 
     String getName() 
              以 String 的形式返回此 Class 对象所表示的实体(类、接口、数组类、基本类型或 void)名称(全限定名:包名.类名)。
     String getSimpleName() 
              返回源代码中给出的底层类的简称。 
     String toString() 
              将对象转换为字符串。 

    解释:

    (1)获取当前Class表示的类的完整名字:(包名.类名):

    public String getName();
    //以 String 的形式返回此 Class 对象所表示的实体(类、接口、数组类、基本类型或 void)名称。 

    (2)获取当前Class表示的实体的简称(类名):

    public String getSimpleName();
    //返回源代码中给出的底层类的简称。如果底层类是匿名的则返回一个空字符串。 

    (3)把对象转换成String:这个方法太常见了,不举例了。

     String toString() 
              将对象转换为字符串。

    (4)返回底层类的规范化名称:

     String getCanonicalName() 
              返回 Java Language Specification 中所定义的底层类的规范化名称。 

    例如:

    public static void main(String[] args) throws ClassNotFoundException
    {
    	Class<String> strClass = (Class<String>) Class.forName("java.lang.String");
    	System.out.println("当前Class表示的实体的      规范化名字:"+strClass.getCanonicalName());
    	System.out.println("当前Class表示的实体的          完整名字:"+strClass.getName());
    	System.out.println("当前Class表示的实体的                  简称:"+strClass.getSimpleName());
    	System.out.println("当前Class表示的实体的toString():"+strClass.toString());
    }

    结果:

    当前Class表示的实体的      规范化名字:java.lang.String
    当前Class表示的实体的          完整名字:java.lang.String
    当前Class表示的实体的                  简称:String
    当前Class表示的实体的toString():class java.lang.String
    

    10.返回boolean的方法:

    (1)判断当前类是什么类

    boolean isLocalClass()     ;//判断是不是局部类,也就是方法里面的类 
    boolean isMemberClass()    ;//判断是不是成员内部类,也就是一个类里面定义的类
    boolean isAnonymousClass() ;//判断当前类是不是匿名类,匿名类一般用于实例化接口
    

    实例:

    public class ClassTest{  
        public static void main(String[] args) {  
            ClassTest son = new ClassTest();  
     
            //测试匿名类  
            son.testAnonymous(new AnonymousClass() {  
                @Override  
                public void test() {  
                    System.out.println("AnonymousClass是成员类:-> " + this.getClass().isMemberClass());  
                    System.out.println("AnonymousClass是匿名类: -> " + this.getClass().isAnonymousClass());  
                    System.out.println("AnonymousClass是局部类:-> " + this.getClass().isLocalClass());  
                    System.out.println("---------------------------------------");  
                }  
            });  
            //测试成员类  
            son.testMember();  
            //测试静态成员类  
            new StaticMemberClass();  
            //测试局部类  
            class LocalClass{  
                public LocalClass(){  
                    System.out.println("LocalClass是成员类:-> " + this.getClass().isMemberClass());  
                    System.out.println("LocalClass是匿名类: -> " + this.getClass().isAnonymousClass());  
                    System.out.println("LocalClass是局部类:-> " + this.getClass().isLocalClass());  
                    System.out.println("---------------------------------------");  
                }  
            }  
            new LocalClass();  
        }  
        //测试匿名内部类
        private void testAnonymous(AnonymousClass inner) {  
            inner.test();  
        }  
        //测试成员内部类:
        private void testMember() {  
            new MemberClass();  
        }  
          
        /** 
         * 接口,用于测试匿名类
         */  
        interface AnonymousClass{  
            public void test();  
        }  
          
        /** 
         * 静态成员类 
         */  
        static class StaticMemberClass{  
            public StaticMemberClass() {  
                System.out.println("StaticMemberClass是成员类:-> " + this.getClass().isMemberClass());  
                System.out.println("StaticMemberClass是匿名类: -> " + this.getClass().isAnonymousClass());  
                System.out.println("StaticMemberClass是局部类:-> " + this.getClass().isLocalClass()); 
                System.out.println("---------------------------------------");  
            }  
        }  
        /** 
         * 成员类 
         */  
        class MemberClass{  
            public MemberClass() {  
            	 System.out.println("MemberClass是成员类:-> " + this.getClass().isMemberClass());  
                 System.out.println("MemberClass是匿名类: -> " + this.getClass().isAnonymousClass());  
                 System.out.println("MemberClass是局部类:-> " + this.getClass().isLocalClass());  
                System.out.println("---------------------------------------");  
            }  
        }  
    }  
    

    运行结果:

    AnonymousClass是成员类:-> false
    AnonymousClass是匿名类: -> true
    AnonymousClass是局部类:-> false
    ---------------------------------------
    MemberClass是成员类:-> true
    MemberClass是匿名类: -> false
    MemberClass是局部类:-> false
    ---------------------------------------
    StaticMemberClass是成员类:-> true
    StaticMemberClass是匿名类: -> false
    StaticMemberClass是局部类:-> false
    ---------------------------------------
    LocalClass是成员类:-> false
    LocalClass是匿名类: -> false
    LocalClass是局部类:-> true
    ---------------------------------------
    

    (2)其他返回boolean的方法:---》以后再给例子

     boolean isAnnotation() ;//判断当前Class对象是否是注释类型
     boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) 
              如果指定类型的注释存在于此元素上,则返回 true,否则返回 false。
     boolean isAssignableFrom(Class<?> cls) 
              判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同,或是否是其超类或超接口。 
     boolean isEnum() 
              当且仅当该类声明为源代码中的枚举时返回 true。 
     boolean isInstance(Object obj) 
              判定指定的 Object 是否与此 Class 所表示的对象赋值兼容。 
     boolean isInterface() 
              判定指定的 Class 对象是否表示一个接口类型。 
     boolean isPrimitive() 
              判定指定的 Class 对象是否表示一个基本类型。 
     boolean isSynthetic() 
              如果此类是复合类,则返回 true,否则 false。


    参考:

    张拭心的博客 shixinzhang 的:深入理解 Java 反射:Class (反射的入口)

    张兴华的技术博客 的:匿名内部类、成员类与局部类


    展开全文
  • Java Class类简介

    万次阅读 2011-01-22 17:48:00
    class类的实例表示java应用运行时的类(class ans enum)或接口(interface and annotation)(每个java类运行时都在JVM里表现为一个class对象,可通过类名.class,类型.getClass(),Class.forName("类名")等方法...

    一,Class类有什么用?

       Class类的实例表示java应用运行时的类(class and enum)或接口(interface and annotation)(每个java类运行时都在JVM里表现为一个class对象,可通过类名.class, 类型.getClass(), Class.forName("类名")等方法获取class对象)。数组同样也被映射为为class 对象的一个类,所有具有相同元素类型和维数的数组都共享该 Class 对象。基本类型boolean,byte,char,short,int,long,float,double和关键字void同样表现为 class  对象。

     

    二,Class类的特征
        Class类没有公有的构造方法,它由JVM自动调用(在new对象或者加载-classLoader时)。

        下面的方法作用是打印出对象的class name:

     void printClassName(Object obj) {
             System.out.println("The class of " + obj +
                                " is " + obj.getClass().getName());
       }
      同样可以根据class literal 获得class name:
      System.out.println("The name of class Foo is: "+Foo.class.getName());//你可以将Foo改为void尝试下。
    三,Class的主要方法

    Class类的方法还是挺多的。主要是用于得到运行时类的相关信息(可用于反射)。

      重要的几个方法:

    1, public static Class<?> forName(String className) :native 方法,动态加载类。非常重要。
           如在sql中动态加载驱动程序:class.forName(sqlDriver);

    2,public T newInstance() :根据对象的class新建一个对象,用于反射。非常重要。
           可用在反射中构建对象,调用对象方法:

           class doubleClass= class.forName("java.lang.Double");

           Object objDouble = doubleClass.newInstance();

           如在javaBean中就应用了这个方法,因为java默认要有一个无参构造函数。

    3, public ClassLoader getClassLoader() :获得类的类加载器Bootstrap  ,Extension ,System or user custom      ClassLoader(一般为system classloader)。重要。

     

    4,public String getName() :获取类或接口的名字。记住enum为类,annotation为接口。重要

    5,public native Class getSuperclass():获取类的父类,继承了父类则返回父类,否则返回java.lang.Object。返回Object的父类为空-null。一般
    6,public java.net.URL getResource(String name) :根据字符串获得资源。

    7,其他类 

     public boolean isEnum() :判断是否为枚举类型。

     public native boolean isArray() :判断是否为数组类型。

     public native boolean isPrimitive() :判断是否为基本类型。
     public boolean isAnnotation() :判断是否为注解类型。


    public Package getPackage() :反射中获得package,如java.lang.Object 的package为java.lang。

    public native int getModifiers() : 反射中获得修饰符,如public static void等 。

    public Field getField(String name):反射中获得域成员。

    public Field[] getFields() :获得域数组成员。    
    public Method[] getMethods() :获得方法。

    public Method getDeclaredMethod(String name, Class<?>... parameterTypes):加个Declared代表本类,继承,父类均不包括。

    public Constructor<?>[] getConstructors() :获得所有的构造函数。

    如此我们可以知道反射可以运行时动态获得类的所有信息,并新建对象(newInstance()方法)。

    如我们定义一个类:

    public class Test{
    
       //Constructor
    
       public Test(){this("");}
    
       public Test(String name){}
    
       //Field
    
       public int id;
    
       public String name;
    
       //Method
    
       public void testMethod(){
    
    
    
       }
    
    }


    我们可以:

    Class c = Class.forName("Test");
    Method m[] = c.getDeclaredMethods();
    for (int i = 0; i < m.length; i++)
       System.out.println(m[i].toString());//输出testMethod
    }
    
    Constructor c[] = cls.getDeclaredConstructors();
    for (int i = 0; i < c.length; i++) {
       Constructor ct = c[i];
    System.out.println("name = " + ct.getName());//输出两个构造函数信息
    
    

    没时间写了,别人用电脑了。。。。

     

     

    展开全文
  • Class T - 由此 Class 对象建模的的类型。例如,String.class 的类型是 Class。如果将被建模的未知,则使用 Class。 public final class Class extends Object implements java.io.Serializable, ...
  • java 一个 class 里面 包含 另一个 class 时,需要将这个子 class 声明为 static,不然经常出错 举例: public class toStringTest { static class Item{ private double price; private String name; ...
  • JavaClass对象详解

    万次阅读 多人点赞 2018-06-01 14:50:40
    https://blog.csdn.net/mcryeasy/article/details/52344729待优化整理 总结Class类简介  在java世界里,一切皆对象。从某种意义上来说,java有两种对象:实例对象和Class对象。每个类的运行时的类型信息就是用...
  • 简述JavaClass类的作用与快速理解

    万次阅读 2017-03-09 15:20:27
    在程序运行期间,Java运行时系统始终为所有的对象维护一个被称为运行时的类型标识。这个信息跟踪着每个对象所属的类。JVM利用运行时信息选择...Class类可以帮助我们在程序运行时分析类,说白了就是获取类中的值。...
  • JAVA类之间方法的调用

    万次阅读 多人点赞 2018-11-02 23:39:15
    JAVA类方法的调用一、静态方法调用其他方法:1. 静态方法调用非静态方法2.静态方法调用静态方法二、非静态方法调用其他方法1.非静态方法在同一内调用其他方法2.非静态方法在不同之间调用其他方法 注:调用方法...
  • Java语言从诞生之时就宣称一次编写,到处运行的跨平台特性,其实现原理是源码文件并没有直接编译成机器指令,而是编译成Java虚拟机可以识别和运行的字节码文件(Class类文件,*.class),字节码文件是一种平台无关的...
  • Kotlin的 class Person { var name: String = "" var age: Int = 0 ...java类 public class Man { } 要知道获取的到底是什么,可以利用andorid stuido的类型提示,一目了然。 ...
  • Java 变量和方法

    万次阅读 2018-05-22 14:16:35
    一、变量1、静态代码块 static{ } 静态代码块只会被执行一次;...public class LearnStatic { static int i=1; static{//静态代码块只会被执行一次 System.out.println("a"); i++; } publ...
  • Java中的Object类和Class类

    千次阅读 多人点赞 2019-04-24 19:59:33
    Java中,无论是类还是接口,它们在JVM的内存逻辑模型中都会存在Super和Class指针,分别指向根类(Object类)和反射类(Class类) 在这一篇blog中会了解到很多常用方法,建议大家看api 1. 位置和内容 Object类和...
  • Java类类getMethod()方法及示例

    千次阅读 2020-07-11 19:35:59
    getMethod()方法 (Class class getMethod() method) getMethod() method is available in java.lang package. getMethod()方法在java.lang包中可用。 getMethod() method is used to return Method objects ...
  • java中的Class和可变参数

    千次阅读 2018-11-05 15:43:02
    import java.util.ArrayList; import java.util.List; public class Tool { public static Object copy(Object object) throws Exception { // 得到对象的类型信息 Class cla = object.getClass(); ...
  • 自己每创建的一个类都会有对应的class类吗?如果是那class类有什么作用呢?class对象又是干什么的?
  • JAVA|Point

    万次阅读 2019-12-10 00:16:55
    Point 创建一个Point,有成员变量x,y,方法getX(),setX(),还有一个构造方...import java.util.Scanner; public class shiyan12 { public static void main(String[] arg){ Point point=new Point(34,46)...
  • Java重复问题探究

    千次阅读 2018-09-01 23:58:37
    本文抛开IDE,用最原始的方式还原重复引发的一个问题,希望能给大家一点启发。 重复的定义 重复可能引起的问题 重复举例 重复报错原因分析 重复的定义 重复是指程序中存在两个或者多个...
  • java Class.getSimpleName()和getName()的区别

    千次阅读 2018-09-19 11:29:13
    getSimplName() //得到类的简写名称(不包含包路径) getName() //得到类名称(包含路径...类名.class.getClass().getName() //得到Class类的名称 转载自 http://blog.sina.com.cn/s/blog_6e0c17b901010f0d.html...
  • 1.1 Java程序介绍 在...2. 编译:然后通过编译器把源文件编译成字节码文件,字节码文件扩展名为.class;3. 运行:最后使用解释器来运行字节码文件。 编译和运行操作需要使用DOS命令,所以在编写源代码文件之后...
  • JavaClass.forName()用法详解

    万次阅读 多人点赞 2018-11-22 20:10:59
    Class.forName(xxx.xx.xx)的作用是要求JVM查找并加载指定的,也就是说JVM会执行该的静态代码段。 下面,通过解答以下三个问题的来详细讲解下Class.forName()的用法。 一.什么时候用Class.forName()? 给你一...
  • Java中的java.lang.Class API 详解

    千次阅读 2019-02-14 18:48:17
    且将新火试新茶,诗酒趁年华。 概述 Class是一个位于java.lang包下面的一个类,在Java中每个类实例都有对应的Class对象。...Class.forName(“className”):因为Class类没有公共的构造方法,所以存在一个静态的方法...
  • java class生成jar包

    万次阅读 2012-11-29 21:11:52
    cd进入要打成jar包的class文件所有文件夹目录 jar cvf [生成jar的名称.jar] [列出class文件] //若有多个,以空隔隔开 如: 一。操作零散的单个或几个class文件 jar cvf ibstool.jar ...
  • kotlin反射class.java和javaClass区别

    千次阅读 2017-12-28 19:51:27
    kotlin反射class.java和javaClass区别kotlin文件的class Person { var name: String = "" var age: Int = 0 } java文件的public class Cat {}测试代码:fun main(args: Array) { val person = Person() val
  • 说道用JAVA获取文件,对于很多像我这样的人来说,肯定会第一个想到用JAVA的File
  • 现在手里有两个class 一个A(泛型) 一个B 我想通过实例化泛型A来为其指定B这个类型 我该如何操作?
  • Java Class文件命名规则

    千次阅读 2020-03-22 15:09:31
    1、编译后产生的.class文件个数:有多少个,产生多少个.class文件 2、.class文件命名规则: 2.1普通内部 外部类名 + $ + 内部类名 [+ $ + 内部类名 + …]+ .class,类名之间使用符号隔开例如:ClassD 隔开例如:...
  • JavaClass类与Object类之间的关系

    千次阅读 2018-02-22 15:57:06
    Object类和Class类没有直接的关系。...Class类是用于java反射机制的,一切java类,都有一个对应的Class对象,他是一个final类。Class 类的实例表示,正在运行的 Java 应用程序中的类和接口。平时看代码时,总是...
  • Linux Shell 调用Java class文件实例

    千次阅读 2018-01-30 11:09:26
    JAVA_HOME=/usr/lib/jvm/java # classes的上级目录 GWOS_HOME=/home/user/project/ttd/test-pro # 第三包jar包存放位置,指定的log4j文件位置 CLASSPATH=.:/home/user/project/ttd/test-pro/lib/*:/home/user/project

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,176,866
精华内容 1,270,746
关键字:

javaclass类

java 订阅