通过反射修改 被 private final static修饰的成员

package newFeatures8;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class ModifierValue {
	
	public static void main(String[] args) throws Exception {
		Person1.main(args);
	}
}


 class Person1 {
    public static void main(String[] args) throws Exception {
    	 Person1 p = new Person1();
    	 //getDeclaredField(String name) 获取指定成员对象不论修饰符
    	 //返回的包含指定成员对象信息的一个Field类
         Field field = p.getClass().getDeclaredField("NAME");
         /* Field[] fields=field.getClass().getDeclaredFields();
         for (Field field2 : fields) {
			System.out.println(field2.getName());
			打印结果为：
			    clazz
				slot
				name
				type
				modifiers
				signature
				genericInfo
				annotations
				fieldAccessor
				overrideFieldAccessor
				root
				declaredAnnotations
		 }*/
         
         //获取该成员权限修饰符对象
         Field modifiers = field.getClass().getDeclaredField("modifiers");
         modifiers.setAccessible(true);//设置为可访问
         //将字段的值设置为指定对象上的一个 int值
         //对于使用  final static 修饰的成员可以先去掉final修饰符的影响
         //field.getModifiers() & ~Modifier.FINAL:作用是去掉final修饰符的影响
         modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);
         //如果此字段对象强制执行java语言访问控制并且基础字段是不可访问的(private)，或是最终的(final)
         /*If the underlying field is final, the method throws an IllegalAccessException 
           unless setAccessible(true) has succeeded for this Field object 
           and the field is non-static*/
         //大意是：如果字段被final修饰而且是非static的除非先调用了setAccessible(true) 否则抛异常
         field.set(p,"Hello");
         //field.set(p,4.0);
        
         System.out.println(field.get(p));
         p.printName();
    }

    //private static final Double NAME=3.0;
    //常量赋值，受字符串常量池影响，反射修改值失败
    // private static final String NAME="Clive";//都忘了String 本身就是final的
    //动态赋值，不受字符串常量池影响，反射修改值成功
    private final static String NAME=(null!=null?"":"Clive");
    public  Person1() {}//构造函数优先于成员变量，而静态变量又优先于构造函数

    public  void printName() {
    	//由于字符串常量池的存在：虚拟机优化成 System.out.println("Clive");
        System.out.println(NAME);
    }
}
 
 enum Coin{
	 A(1),B(2),C(3),D(4);//A等价于A(),A{}等价于A(){},而这种写法就是匿名子类
	 private  int value=0;
	 private Coin(int value){this.value=value; }	  
	 private Coin(){ }
	 public int getValue(){
		 return value;
	 }
 }
 //使用枚举写单例
 enum Singleton{
	//INSTANCE等价于INSTANCE(),INSTANCE{}等价于INSTANCE(){},而这种写法就是匿名子类
	 INSTANCE;
	 //定义为final就不能修改其引用，所以不能为final
	 //定义为static就不能在构造函数中分配空间，所以不能定义为static
	 private  Person1 p=null;
	 private Singleton(){p=new Person1();}
	 public Person1 getInstance(){
		 return p;
	 }
 }