#反射(二)
通过栗子来更好的理解反射，以及对反射技术进行应用。
首先，整两个model——car.java和Benz.java
```Java
public class Car {
public String type;
private String color;
public static void drive(){
System.out.println("The car is driving");
}
}
```
```java
public class Benz extends Car {
public String brand;
private String model;
private int sale;
public static String text;
public Benz() {
}
private Benz(String brand) {
this.brand = brand;
}
public Benz(String brand, String model) {
this.brand = brand;
this.model = model;
}
public int getSale() {
return sale;
}
public String getBrand() {
return brand;
}
public static void desc(){
System.out.println("这是一辆黑色的奔驰车");
}
public void getModel(String model){
System.out.println("这辆奔驰车的型号是:"+model);
}
private void getColor(){
System.out.println("这辆车的颜色是黑色");
}
}
```
## 获取反射类的几种方法
```Java
//1.获取class对象实例
//1.1 类名.class
Class clazz=Car.class;
//1.2 new一个实体，通过getClass()方法
Class clazz2=new Car().getClass();
//1.3 Class.forname()类名全路径
try {
Class clazz3=Class.forName("com.qingmu.reflect.Demo1.Car");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//1.4 通过ClassLoader获取
try {
Class clazz4= Main.class.getClassLoader().loadClass("com.qingmu.reflect.Demo1.Car");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
```
## 反射——类的操作
```Java
public static void classOpt(){
Class clazz=Car.class;
//获取类的修饰符
int modifers=clazz.getModifiers();
System.out.println("类的修饰符："+modifers);
//获取类的包名
Package packag=clazz.getPackage();
System.out.println("包名:"+packag);
//获取类的全路径名
String name = clazz.getName();
System.out.println(name);
//获取类名
String simpleName = clazz.getSimpleName();
System.out.println(simpleName);
//获取类的加载器
ClassLoader classLoader = clazz.getClassLoader();
System.out.println(classLoader);
//获取类的实现的接口列表
Class[] interfaces = clazz.getInterfaces();
System.out.println(interfaces.length);
//获取类的父类
Class superclass = clazz.getSuperclass();
System.out.println(superclass);
//获取类的注解列表
Annotation[] annotation = clazz.getAnnotations();
System.out.println(annotation.length);
}
```
## 反射——方法操作
```Java
//反射字段的基本操作
public static void filedOpt(){
Class clazz=new Benz().getClass();
//获取类中所有的公有字段 包含继承
Field[] fields = clazz.getFields();
for (Field filed: fields) {
System.out.println(filed);
}
//获取指定名称的字段
try {
Field brandField=clazz.getField("brand"); //公有字段
System.out.println(brandField.getName());
Field sale = clazz.getDeclaredField("sale"); //所有类型字段
System.out.println(sale.getName());
int modifiers = brandField.getModifiers(); //获取字段的修饰
System.out.println(modifiers);
System.out.println(sale.getModifiers());
//强制访问私有字段
sale.setAccessible(true);
//成员字段赋值
Benz benz= (Benz) clazz.newInstance();
sale.set(benz,5000000);
System.out.println(benz.getSale());
//静态字段赋值
Field textField=clazz.getField("text");
textField.set(null,"这是一个静态字段");
System.out.println(Benz.text);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
//获取类中定义的所有字段 内部
Field[] declaredFields = clazz.getDeclaredFields();
for (Field filed:declaredFields) {
System.out.println(filed);
}
}
```
## 反射——构造器操作
```Java
public static void constructorOpt() throws Exception{
Class clazz=Benz.class;
Benz benz= (Benz) clazz.newInstance();
//获取类中所有的公有构造器
Constructor[] constructors =clazz.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
//获取类中所有的构造器
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
for (Constructor declaredConstructor : declaredConstructors) {
System.out.println(declaredConstructor);
}
//获取类中无参构造器及修饰符
Constructor declaredConstructor = clazz.getDeclaredConstructor();
System.out.println(declaredConstructor+"--"+declaredConstructor.getModifiers());
//获取类中有参构造器
Constructor declaredConstructor1 = clazz.getDeclaredConstructor(String.class);
System.out.println(declaredConstructor1);
declaredConstructor1.setAccessible(true);
Benz benz1 = (Benz) declaredConstructor1.newInstance("benz"); //构造器实例对象
System.out.println(benz1.brand);
}
```
最后，要写一个main方法，调用以上几个方法，感受一下效果
