Java的类

在java的世界里，万物皆对象。
用java方式表述就是：
一切的开始都是java.lang.Class，类是Class类型的实例对象，类只有jvm能创建出来。
所有基本类型，void类型，对象成员方法都是对应类的实例对象。那些基本类型之所以使用上有些特别，都是java使用过程中为了简化操作而特殊处理的一些类型。

类

既然类被看作是Class世界中的祖师爷，那他一定有些过人之处。

首先看类是怎么从石头里崩出来的：

public class User{
}

public class ClassTest{
User u=new User();
 //方式1:
 Class c1=User.class;
//方式2:
Class c2=u.getClass();
//方式3:
Class c3=Class.forName("com.forezp.User");
}

我们通常使用过程对类无感知，因为我们关注的只是对象，通常new对象的时候，jvm会帮助我们先把类给静态加载出来。
我们也可以使用Class.forName("类全名")的方式动态加载一个类对象。
当然还可以通过传值的方式得到已有类对象（方式1和方式2）。

编译时刻加载类是静态加载、运行时刻加载类是动态加载类。

类的能力

得到了类，我们可以利用类的能力得到类的信息或者创建对象。

Class c1=User.class;

User user=(User)c1.newInstance(); // 可以通过类的类型创建该类的实例对象

System.out.println(c1.getName()); // 获取类的名称
System.out.println(c2.getSimpleName()); // 获取类名称简写

通过类获取类名，方法名，方法参数，成员变量，构造函数：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 类的相关使用
 */
public class TestClassApp {
    public static void main(String[] args) {
        String s="ss";
        Class c0= s.getClass();
        System.out.println("getName："+c0.getName());
        System.out.println("getSimpleName："+ c0.getSimpleName());

        User u = new User("zhangsan", 18);
        printClassInfo(u);

    }
    public static void printClassInfo(Object object){
        Class c=object.getClass();
        System.out.println("getName："+c.getName());
        System.out.println("getSimpleName："+ c.getSimpleName());

        System.out.println("获取成员变量getFileds-------------");
        /**
         * getFileds()获取public
         * getDeclaredFields()获取所有
         */
        Field[] fileds=c.getDeclaredFields();

        for(Field f:fileds){
            //获取成员变量的类型
            Class filedType=f.getType();
            System.out.println(filedType.getName()+" "+f.getName());
        }

        System.out.println("获取成员变量getDeclaredFields-------------");
        Field[] fields1=c.getDeclaredFields();

        for(Field f:fields1){
            //获取成员变量的类型
            Class filedType=f.getType();
            System.out.println(filedType.getName()+" "+f.getName());
        }

        /**
         * 一个成员方法就是一个method对象
         * getMethods()获取所有的public方法，包括父类继承的 public
         * getDeclaredMethods()获取该类所有的方法，包括private ,但不包括继承的方法。
         */
        System.out.println("getMethods------------");
        Method[] methods=c.getMethods();//获取方法

        for(int i=0;i<methods.length;i++){
            //得到方法的返回类型
            Class returnType=methods[i].getReturnType();
            System.out.print(returnType.getName()+" ");
            //得到方法名：
            System.out.print(methods[i].getName()+"(");

            Class[] parameterTypes=methods[i].getParameterTypes();
            for(Class class1:parameterTypes){
                System.out.print(class1.getName()+",");
            }
            System.out.println(")");
        }

        //获取所以的方法，包括private ,c.getDeclaredMethods();
        System.out.println("getDeclaredMethods------------");
        Method[] methods1 = c.getDeclaredMethods();
        for (int i=0;i<methods1.length;i++) {
            //得到方法的返回类型
            Class returnType=methods1[i].getReturnType();
            System.out.print(returnType.getName()+" ");
            //得到方法名：
            System.out.print(methods1[i].getName()+"(");
            Class[] parameterTypes=methods1[i].getParameterTypes();
            for(Class class1:parameterTypes){
                System.out.print(class1.getName()+",");
            }
            System.out.println(")");
        }

        System.out.println("获取构造函数getDeclaredConstructors-------------");
        Constructor[] constructors=c.getDeclaredConstructors();
        for (Constructor con:constructors){
            System.out.print(con.getName()+"(");

            Class[] typeParas=con.getParameterTypes();
            for (Class class1:typeParas){
                System.out.print(class1.getName()+" ,");
            }
            System.out.println(")");
        }
    }

}

class User {
    String name;
    private int age;
    User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private int getAge() {
        return this.age;
    }

    public String getName() {
        return name;
    }
}

结果：

getName：java.lang.String
getSimpleName：String
getName：User
getSimpleName：User
获取成员变量getFileds-------------
java.lang.String name
int age
获取成员变量getDeclaredFields-------------
java.lang.String name
int age
getMethods------------
java.lang.String getName()
void wait(long,int,)
void wait(long,)
void wait()
boolean equals(java.lang.Object,)
java.lang.String toString()
int hashCode()
java.lang.Class getClass()
void notify()
void notifyAll()
getDeclaredMethods------------
java.lang.String getName()
int getAge()
获取构造函数getDeclaredConstructors-------------
User(java.lang.String ,int ,)

以上这些在运行时通过类来获取类的信息甚至操作类的行为都可以称作反射，反射是java提供的一种机制，或者说功能，下面这种通过类获取方法，并调用方法，也是方法的反射

语法
method.invoke(对象，参数列表);

例子：

class A{

    public void add(int a,int b){
        System.out.print(a+b);
    }

    public void toUpper(String a){
        System.out.print(a.toUpperCase());
    }
}
 public static void main(String[] args) {
        A a=new A();
        Class c=a.getClass();
        try {
            Method method=c.getMethod("add",new Class[]{int.class,int.class});
            //也可以 Method method=c.getMethod("add",int.class,int.class);
            //方法的反射操作
            method.invoke(a,10,10);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

20

参考文章：
Java的反射机制