一、Filed

package com.xit.reflect.reflect2;
import java.lang.reflect.Field;
public class ReflectTest07 {
    public static void main(String[] args) throws Exception, InstantiationException, IllegalAccessException {
        Student s = new Student();
        s.no = 11111;
        //class com.xit.reflect.reflect2.Student
        Class classStudent = Class.forName("com.xit.reflect.reflect2.Student");
        Object obj = classStudent.newInstance();
        Field field = classStudent.getDeclaredField("no");
        field.set(obj,2222);
        field.get(obj);
    }
}

二、Mehod（方法）

1、可变长度参数

1. 语法——类型…（三个点）
2. 要求参数个数是：0-n个
3. 可变长参数在参数列表上必须在最后一个位置，而且可变长度参数只能有一个
4. 可变长参数可以当做一个数组对待 ```java package com.args;

public class ArgsTest { public static void main(String[] args) { m1(); m1(10); m1(10,100,222);

    m2(2,"avv");
    m3("ss","dasd");
}
public static void m1(int... args){
    System.out.println("m方法执行了");
}
public static void m2(int a,String... args){
}
public static void m3(String... args){
    for (int i =0;i<args.length;i++){
        System.out.println(args[i]);
    }
}

}

<a name="wTuKw"></a>
## 2.反射机制调用方法
1.找到类 2，获取对象 3.获取方法 4.返回值
```java
package com.xit.reflect.reflect2;
import java.lang.reflect.Method;
/*
通过反射机制怎么调用对象的方法
 */
public class ReflectTest10 {
    public static void main(String[] args) throws Exception {
        /*
        4要素
        1.对象
        2.login方法名
        3.实参列表
        4.返回值
         */
        //不使用反射机制
        UserService userService = new UserService();
        boolean loginSuccess = userService.login("admin","123");
        System.out.println(loginSuccess ? "登录成功" : "登录失败");
        /*
        obj对象
        loginMethod方法
        "admin","123"实参
        retValue返回值
         */
        //1.找到类 2，获取对象 3.获取方法 4.返回值
        Class c = Class.forName("com.xit.reflect.reflect2.UserService");
        //实例化对象
        Object obj = c.newInstance();
        //获取Method
        Method loginMethod = c.getDeclaredMethod("login", String.class, String.class);
        Object retValue = loginMethod.invoke(obj,"admin","123");
        System.out.println(retValue);
    }
}

三、Constructor（构造方法）test12

package com.xit.reflect.reflect2;
import java.lang.reflect.Constructor;
public class ReflectTest12 {
    public static void main(String[] args) throws Exception{
        Class c = Class.forName("com.xit.reflect.reflect2.Vip");
//      调用无参构造方法
        Object obj = c.newInstance();
        System.out.println(obj);
        //调用有参构造方法
        //先获取到这个有参数的构造方法
        Constructor con = c.getDeclaredConstructor(int.class,String.class);
        //调用构造方法new对象
        Object newObj = con.newInstance(110,"jack");
        System.out.println(newObj);
    }
}

四、通过类获取父类和接口

package com.xit.reflect.reflect2;
public class ReflectTest13 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class stringClass =Class.forName("java.lang.String");
        //获取父类
        Class superClass = stringClass.getSuperclass();
        System.out.println(superClass.getName());
        //获取接口
        Class[] interfaces = stringClass.getInterfaces();
        for (Class in : interfaces){
            System.out.println(in.getName());
        }
    }
}