field.setAccessible(true)

Accessable属性是继承自AccessibleObject 类. 功能是启用或禁用安全检查
在反射对象中设置 accessible 标志允许具有足够特权的复杂应用程序(比如 Java Object Serialization 或其他持久性机制)以某种通常禁止使用的方式来操作对象。
setAccessible
public void setAccessible(boolean flag)
throws SecurityException

将此对象的 accessible 标志设置为指示的布尔值。值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。值为 false 则指示反射的对象应该实施 Java 语言访问检查。

setAccessible方法是干什么用的呢让我们来看一段代码吧

public class User {
	private String name;
	
	public User(String name) {
		this.name = name;
	}


	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}
}

测试:

import java.lang.reflect.Field;

public class Demo {
public static void main(String[] args) throws Exception {  
   Class clazz = User.class;
       User u = new User("小明");
       for (Field f : clazz.getDeclaredFields()) {  
           System.out.println(f.isAccessible());//这里的结果是false
           f.setAccessible(true);
           System.out.println(f.getName()+":"+f.get(u));
       }  
 
   }  
}

通过运行以上代码,我们发现 System.out.println(f.isAccessible())这一句打印结果是"false",从字面上理解是说该字段不能被访问,但是为了保险起见我们还是去看一下源代码(Java有的时候就是比较坑,不一定能够见名知意,我们还是保险点比较好,虽然不算是做学问,但是学习的态度还是一丝不苟比较好),首先我们去掉f.setAccessible(true);

然后在 System.out.println(f.getName()+":"+f.get(u));这行打断点,但是发现不了问题,经过检查发现getName()这个方法并不抛异常,也就是是就算没有加f.setAccessible(true);

也可以获得name,抛异常的是f.get(u);这句话,我找到Field中的get(Object obj)方法,发现有这么一句

if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
checkAccess(Reflection.getCallerClass(), clazz, obj, modifiers);
}
}

这里的override就是我们用setAccessible设置的值,但是接下来就坑爹了Reflection以及其他几个类的源码不在jdk自带的源码中,找了半天才找到sun的源代码,导入源代码(最好将sun的源代码和java的放在一个文件夹里,不然一次只能导入一个源代码,要来回切换,比较麻烦)

然后我们debug定位到了Reflection类的ensureMemberAccess方法如图:
在这里插入图片描述

图中有一个verifyMemberAccess方法,这就是抛出异常的方法,进入该方法直接到了 boolean successSoFar = false;然后就return false了,因此抛出了IllegalAccessException异常,也就是说我们得出结论当isAccessible()的结果是false时不允许通过反射访问该字段

结论:当isAccessible()的结果是false时不允许通过反射访问该字段

实际上setAccessible是启用和禁用访问安全检查的开关,并不是为true就能访问为false就不能访问,一般情况下,我们并不能对类的私有字段进行操作,利用反射也不例外,但有的时候,例如要序列化的时候,我们又必须有能力去处理这些字段,这时候,我们就需要调用AccessibleObject上的setAccessible()方法来允许这种访问,而由于反射类中的Field,Method和Constructor继承自AccessibleObject,因此,通过在这些类上调用setAccessible()方法,我们可以实现对这些字段的操作。但有的时候这将会成为一个安全隐患,为此,我们可以启用java.security.manager来判断程序是否具有调用setAccessible()的权限。默认情况下,内核API和扩展目录的代码具有该权限,而类路径或通过URLClassLoader加载的应用程序不拥有此权限。例如:当我们以这种方式来执行上述程序时将会抛出异常

java.lang.IllegalAccessException: Class com.example.xj.myapplication.TestField can not access a member of class com.example.xj.myapplication.Student with modifiers "private"
	at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102)
	at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(AccessibleObject.java:296)
	at java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:288)
	at java.lang.reflect.Field.get(Field.java:390)
	at com.example.xj.myapplication.TestField.main(TestField.java:20)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

所以 f.setAccessible(true);得作用就是让我们在用反射时访问私有变量

  • 19
    点赞
  • 44
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JAVA高级特性 1.静态导入:先举个离例子 。 import java.lang.Integer.parseInt; public class StaticImport { int x = parseInt("123"); System.out.println(x); } 这样的程序如果不在IDE 工具中输入,是很难看出这个程序代码会出现问题,可它偏偏就出问题了,这是为什么呢?因为程序里面有个静态方法,如果导入import static java.lang.Integer.parseInt;这样的程序就可以运行了。 2.可变参数与for循环增强 这个是一般的用法: public static void loop(String[] args){ for(int i=0;i<args.length;i++) { System.out.println(args[i]); } } 这个是JDK 增加的新特性的用法! public static void loop(int x,int... args ) { //这里的参数一定要以这样的形式输入 for(int i:args) { System.out.println(i); } } 3.枚举 写枚举技巧: 1. enum Gender{MALE,FEMALE,BOTH} 2. enum Gender{MALE,FEMALE,BOTH;public abstract getTitle();} 3.enum Gender{MALE{},FEMALE{},BOTH{};public abstract getTitle();} 4.填充各个{}中的getTitle方法。 下面是个红绿黄灯的例子: public enum TrafficLamp { RED(30){ public TrafficLamp next() { return GREEN; } }, GREEN(50){ public TrafficLamp next() { return YELLOW; } }, YELLOW(5){ public TrafficLamp next() { return RED; } }; public abstract TrafficLamp next(); private int time; private TrafficLamp(int time) { this.time = time; } 4.反射. 这个知识点,真是费了我好大劲才理解。当真正理解了,其实也就不难了。先举例子来理解什么是反射。 先建这样的一个类,带会下面有个类里面有反射成员变量的方法的! public class ReflectPoint { private int x; public int y; public ReflectPoint(int x, int y) { super(); this.x = x; this.y = y; } } public class Test{ String obj = (String)Class.forName("java.lang.String").newInstance(); 这是制造另一个章:Class.forName("java.lang.Integer") --------------------- 讲Constructor://构造方法 Constructor constructors[] = Class.forName("java.lang.String").getConstructors(); Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class); String str = (String)constructor.newInstance(new StringBuffer("abc")); System.out.println(str); class.newInstance()内部其实就是在用默认的构造方法 ----------------------- 讲Method //方法 Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class); System.out.println(charAt.invoke(str, 1)); ------------------------- 讲Field //成员变量 ReflectPoint point = new ReflectPoint(1,7); Field y = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("y"); y.setAccessible(true); System.out.println(y.get(point)); Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x"); x.setAccessible(true); System.out.println(x.get(point)); } 在这里我们运行的时候可以看出,ReflectPoint类里面的x和y 都可以打印出来了! 学习心得:先从这四个知识点来看,张老师的确很让人敬佩!以上的一些程序代码均为张老师课堂即兴发挥所写,也可以看出,张老师对JAVA特性的深刻理解能力!现在说说我对这些程序代码的理解,说实话,才开始听张老师讲的时候,我感觉很模糊的,但是当我真正理解了之后,觉得这些程序写的真是太好了。象以后我门在学习JAVA 的时候,一定要对每个知识点要慢慢的消化吃透,切不能走马观花。一个知识点必须要反复的动手练习,不然很难理解其中的奥秘所在的! 5.在JAVA的程序中,我经常性的看到字符前面有@这种标志的符号.这个就叫做注解! 下面是使用 @SuppressWarnings 来取消 deprecation 警告的一个例子: public class Test { @Deprecated //在eclipse下运行的时候,方法名上会加一横线 public static void sayHello() { } } public class Test2 { @SuppressWarnings("deprecation") //在mian方法内调用一个没有定义的方法时,运行的时候将会出现这一注解! public static void main(String [] args) { Test.sayHello(); } } @SuppressWarnings 批注允许您选择性地取消特定代码段(即,类或方法)中的警告。其中的想法是当您看到警告时,您将调查它,如果您确定它不是问题,您就可以添加一个 @SuppressWarnings 批注,以使您不会再看到警告。虽然它听起来似乎会屏蔽潜在的错误,但实际上它将提高代码安全性,因为它将防止您对警告无动于衷 — 您看到的每一个警告都将值得注意。 由如下代码引出@Override的讲解: User类中的方法: public boolean equals(User other) { return name.equals(other.name); } 下面的代码执行时将有问题: User user1 = new User(); User user2 = new User(); user1.setName("abc"); user2.setName("abc"); System.out.println(user1.equals(user2)); HashSet set = new HashSet(); set.add(user1); set.add(user2); System.out.println(set.size());//期望结果为1,但实际为2 这时候在User类的equals方法上加上@Override,发现了问题。 再看看这个代码:一看就知道有问题, 这里 就有个很好的解决办法,在写public @interface MyAnnotation {}这样的类的时候,下面的代码上的错误提示就是结束的! public class dsds { public static void main(String[] args) throws Exception{ // TODO Auto-generated method stub System.out.println(User.class.isAnnotationPresent(MyAnnotation.class) ); System.out.println( User.class.getAnnotation(MyAnnotation.class) ); } } 运行的结果为:false null 下面演示了一下@Target和@Retention import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target({ElementType.TYPE}) //用于构造方法 @Retention(RetentionPolicy.RUNTIME) //在运行是加载Annotation到JVM中 public @interface MyAnnotation { public String value() default "yellow"; public int[] array() default {1,2}; public MetaAnnotation annotation() ; } 注解最主要的就是这么多,其实注解真正的,我们都很少留心的,但是有的注解会给你在写程序和查找错误的时,会有很大的帮助的! 6.泛型: 1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。 2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。 3、泛型的类型参数可以有多个。 4、泛型的参数类型可以使用extends语句,例如<T extends superclass>。习惯上成为“有界类型”。 5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName(java.lang.String); 例子: a..使用?通配符可以引用其他各种参数化的类型,但不能调用与参数化有关的方法; Collection<?> c = new Vector<String>(); c.add("abc");//报错 c.size();//正确 所以,?通配符定义的变量主要用作引用,调用与参数化无关的方法,如果要调用与参数化相关的方法,那么必须在使用?通配符引用之前调用,否则就与java 5提供泛型的目的背道而驰了。 b..向下限定通配符: 正确:Vector<? extends Number> x = new Vector<Integer>(); 错误:Vector<? extends Number> x = new Vector<String>(); 向上限定通配符: 正确:Vector<? super Integer> x = new Vector<Number>(); 错误:Vector<? super Integer> x = new Vector<Byte>(); 7.代理 这里就直接先应用张老师写的代码然后再讲清其原理吧! package cn.itcast.corejava; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.Collection; import java.util.Vector; public class ProxyTest { public static void main(String[] args) { System.out.println(Integer.class.getClassLoader()); //System.out.println(ProxyTest.class.getClassLoader().getParent().getClass().getName()); System.out.println(ProxyTest.class.getClassLoader().getClass().getName()); //test1(); //test2(); } private static void test3() { Vector v = new Vector(); class MyInvocationHandler implements InvocationHandler { Collection target = null; public Collection bind(Collection target) { this.target = target; Collection proxy1 = (Collection)Proxy.newProxyInstance( ProxyTest.class.getClassLoader(), new Class[]{Collection.class} , this); return proxy1; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub System.out.println("begin " + method.getName()); Object retval = method.invoke(target, args); System.out.println("end" + method.getName()); return retval; } } MyInvocationHandler handler = new MyInvocationHandler(); Collection proxy1 = handler.bind(v); System.out.println(proxy1.getClass().getName()); proxy1.add("abc"); proxy1.add("xyz"); System.out.println(proxy1.size()); } private static void test2() { Vector v = new Vector(); class MyInvocationHandler implements InvocationHandler { Collection target = null; public MyInvocationHandler(){} public MyInvocationHandler(Collection target){this.target = target;} public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub System.out.println("begin " + method.getName()); Object retval = method.invoke(target, args); System.out.println("end" + method.getName()); return retval; } } Collection proxy1 = (Collection)Proxy.newProxyInstance( ProxyTest.class.getClassLoader(), new Class[]{Collection.class} , new MyInvocationHandler(v)); System.out.println(proxy1.getClass().getName()); proxy1.add("abc"); proxy1.add("xyz"); System.out.println(proxy1.size()); } private static void test1() { Collection proxy = (Collection)Proxy.newProxyInstance( ProxyTest.class.getClassLoader(),//first parameter new Class[]{Collection.class} , //second parameter new InvocationHandler(){ //third parameter Vector target = new Vector(); public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub System.out.println("begin " + method.getName()); Object retval = method.invoke(target, args); System.out.println("end" + method.getName()); return retval; } } ); System.out.println(proxy.getClass().getName()); proxy.add("abc"); proxy.add("xyz"); System.out.println(proxy.size()); } } 以下是Proxy的API文档: public class Proxyextends extends Object implements Serializable Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods. To create a proxy for some interface Foo: InvocationHandler handler = new MyInvocationHandler(...); Class proxyClass = Proxy.getProxyClass( Foo.class.getClassLoader(), new Class[] { Foo.class }); Foo f = (Foo) proxyClass. getConstructor(new Class[] { InvocationHandler.class }). newInstance(new Object[] { handler }); or more simply: Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(), new Class[] { Foo.class }, handler);从以上的程序中在方法中定义参数的时候总是三个参数,可这三个参数有分别代表什么意思呢!?现在以我自己个人的理解,比如我是买家,我要买本书,可是现在我有事,是不是需要别人代我买呢?那带我买的人是不是一定要到卖书的地方买呢?所以着中间产生了三个实体.说白了就是一种代理机制.需要三方一起运行! 代理其实很好理解的,而且会用固定的语法格式,很快会掌握这一原理的!
/** * @title 测试打电话 * @author Tian * */ public class TestActivity extends Activity { private static String TAG = TestActivity.class.getSimpleName(); private HashMap<String, String> infos = new HashMap<String, String>(); @ViewInject(R.id.btn) private Button btn; @ViewInject(R.id.sql_btn) private Button sql_btn; @ViewInject(R.id.move_btn) private Button move_btn; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.test); ViewUtils.inject(this); } @OnClick({R.id.btn,R.id.move_btn}) public void onClick(View v) { //LayoutInflater // SelectPopupWindow menuWindow = new SelectPopupWindow(this, null); // menuWindow.showAtLocation(v, Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL, 0, 0); // Toast.makeText(this, "被点钟啦", Toast.LENGTH_SHORT).show(); // HttpUtils http = new HttpUtils(); // http.send(HttpRequest.HttpMethod.GET, // "http://www.baidu.com", // new RequestCallBack<String>(){ // @Override // public void onSuccess(ResponseInfo<String> responseInfo) { // } // // @Override // public void onFailure(HttpException error, String msg) { // } // // }); // tt(); tb(); // if(v==move_btn){ // Intent intent = new Intent(this,MoveActivity.class); // startActivity(intent); // } } private void tb(){ View timeView = LayoutInflater.from(this).inflate(R.layout.dialog_time_select, null); ScreenInfo screenInfo = new ScreenInfo(this); final WheelView wv_hours = (WheelView) timeView.findViewById(R.id.hour); final WheelView wv_mins = (WheelView) timeView.findViewById(R.id.min); wv_hours.setAdapter(new NumericWheelAdapter(0, 23)); wv_hours.setCyclic(true);// 可循环滚动 wv_hours.setLabel("点");// 添加文字 wv_hours.setCurrentItem(0); wv_mins.setAdapter(new NumericWheelAdapter(0, 59)); wv_mins.setCyclic(true);// 可循环滚动 wv_mins.setLabel("分");// 添加文字 wv_mins.setCurrentItem(0); // 根据屏幕密度来指定选择器字体的大小(不同屏幕可能不同) int textSize = 0; textSize = (screenInfo.getHeight() / 100) * 3; wv_hours.TEXT_SIZE = textSize; wv_mins.TEXT_SIZE = textSize; final PopDialog timeDialog = new PopDialog(); timeDialog.popDialog(this, timeView, 0.94f, null); timeView.findViewById(R.id.time_cansle).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { timeDialog.dismiss(); } }); timeView.findViewById(R.id.time_sure).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { // KTVOrderActivity.this.hours = wv_hours.getCurrentItem(); // KTVOrderActivity.this.mins = wv_mins.getCurrentItem(); // timeTv.setText(wv_hours.getCurrentItem() + ":" + wv_mins.getCurrentItem()); timeDialog.dismiss(); } }); } private void tt() { // 通过反射获取用户硬件信息 Field[] fields = Build.class.getDeclaredFields(); for (Field field : fields) { try { // 暴力反射,获取私有信息 field.setAccessible(true); infos.put(field.getName(), field.get(null).toString()); Log.i(TAG, field.getName() + " : " + field.get(null)); } catch (Exception e) { Log.e(TAG, "an error occured when collect crash info", e); } } fields = Build.VERSION.class.getDeclaredFields(); for (Field field : fields) { try { // 暴力反射,获取私有信息 field.setAccessible(true); infos.put("VERSION." + field.getName(), field.get(null) .toString()); Log.i(TAG, field.getName() + " : " + field.get(null)); } catch (Exception e) { Log.e(TAG, "an error occured when collect crash info", e); } } fields = Build.VERSION_CODES.class.getDeclaredFields(); for (Field field : fields) { try { // 暴力反射,获取私有信息 field.setAccessible(true); infos.put("VERSION_CODES." + field.getName(), field.get(null) .toString()); Log.i(TAG, field.getName() + " : " + field.get(null)); } catch (Exception e) { Log.e(TAG, "an error occured when collect crash info", e); } } Toast.makeText(this,infos.toString(), Toast.LENGTH_SHORT).show(); } }
1. 反射: Class 类的实例表示正在运行的 Java 应用程序中的类和接口; 枚举是一种类,注解(指的是注解Annotation)是一种接口; 每个数组都是 Class字节码类中的一个具体 对象 基本的 Java 类型(boolean、byte、char、short、int、long、float 和 double)和关键字 void 也表示为 Class 对象; 注意 : 1、 Class类 和它的实例的产生: Class的对象是已经存在的类型, 所以不能够直接new一个Class对象出来,是通过Class类中的一个方法获取到的。 例如:通过全限定路径类名 2、同一种类型不管通过什么方式得到Class的实例都是相等的;一个类型的字节码对象只有一份,在元空间。 3、Class的实例就看成是Java中我们学过的所有的数据类型在JVM中存在的一种状态(字节码对象) String.class int.class List.class int[].class 1.概念:通过一个全限定类名,获取字节码文件 2.作用: 1. 提高开发灵活度,提高程序的扩展性 2. 框架(提高开发效率的别人封装好的代码)底层都是使用反射技术。例如:Tomcat、Spring... 3. 缺点:破坏封装性,性能低下(以后,能不用反射技术就不用) 3. 使用:(重点) 1. 获取字节码文件 1. 1.1 Class clazz = Class.forName(全限定路径名) (最多使用)默认就是调用下面的方法 1.2 static 类<?> forName(String name, boolean initialize, ClassLoader loader) name:全限定路径名 initialize:表示是否初始化,默认是false loader:可以指定一个类加载器加载字节码文件 2. 全限定类名.class 3. 对象名.getClass() Class类中方法newInstance():创建当前字节码对象(只能调用无参且是public修饰的构造方法) 2. 根据字节码文件获取构造方法、普通方法、字段等 构造方法 Constructor[] constructors = clazz.getConstructors() 获取public修饰的构造方法数组 Constructor[] constructors = clazz.getDeclaredConstructors() 获取任意权限的所有造方法数组 Constructor constructor = clazz.getConstructor(Class 参数字节码)根据参数类型获取public修饰的指定的的构造方法 Constructor constructor = clazz.getDeclearConstructor(Class 参数字节码) 获取任意访问权限指定的构造方法 //通过构造方法对象去用构造方法创建对象 => 相当于new 一个对象 Object instance = constructor.newInstance(Object 实参);//可以创建任意访问权限的有参或者无参构造 普通方法 Method[] methods = clazz.getMethods() 获取public修饰的构造方法数组,有父类中的方法 Method[] methods = clazz.getDeclaredMethods() 获取任意访问权限所有造方法数组,并且都是自己的方法 Method method = clazz.getMethod(String methodName,Class... 参数字节码)根据方法名和参数类型获取指定的的方法 methodName:方法名 Class:形参类型。如果方法没有形参,则Class可变参数不用写 Method method = clazz.getDeclaredMethod(String methodName,Class... 参数字节码)根据方法名和参数类型获取指定的的方法 methodName:方法名 Class:形参类型。如果方法没有形参,则Class可变参数不用写 //通过普通方法对象调用执行方法 method.invoke(Object obj,Object... args); obj:对象。如果是对象的方法,就传入一个当前字节码创建的对象,如果是static方法,则写null args:就是具体实参 字段 Field[] fields = clazz.getFields() 获取public修饰的字段 Field[] fields = clazz.getDeclaredFields() 获取任意权限所有字段 Field field = clazz.getDeclaredField(String fieldName) 根据字段名获取任意访问权限的指定字段 Field field = clazz.Field(String fieldName)根据字段名获取public的指定字段 //通过当前的字段对象,给某一个字段赋值取值 field.get(Object obj);//如果是属于非static,就传入一个对象,如果是静态的,就传入null obj:对象 field.set(Object obj, Object value);//如果是属于非static,就传入一个对象,如果是静态的,就传入null obj:对象 value:值 String getName() 获取全限定类名(全限定,包含包名) Class类中方法 String getSimpleName() 获取类名简称 Class类中方法 Package getPackage() 获取包名 Class类中方法 T newInstance() 根据当前字节码创建对应的对象 Class类中方法 注意: 1. Class类中方法newInstance():创建当前字节码对象(只能调用无参且是public修饰的构造方法) 2. Constructor类中方法newInstance(Object 实参);//可以创建任意访问权限的有参或者无参构造 3. 私有化方法、字段、构造方法都必须破坏封装才能使用: public void setAccessible(boolean flag) true表示破坏封装,false是不破坏 是哪个private修饰的方法、字段、构造方法需要执行,就需要用这个对象破坏哪一个的封装 例如: //获取cn.itsource.reflect.User字节码文件 Class<?> clazz = Class.forName("cn.itsource.reflect.User"); //获取User的有String参构造 Constructor<?> constructor = clazz.getConstructor(String.class); //调用有参String构造,创建一个User对象 Object newInstance = constructor.newInstance("某文"); //获取private修饰的方法:testPrivate Method method2 = clazz.getDeclaredMethod("testPrivate"); method2.setAccessible(true);//破坏普通方法Method封装 //破坏封装后就可以执行了 Object invoke2 = method2.invoke(newInstance);//没有形参就不用写 System.out.println(invoke2); 4. 调用static方法、字段: 例如: Field field = clazz.getDeclaredField("country");//获取任意访问权限静态变量country field.set(null, "中国");//因为字段country是static修饰,所以不用对象调用,就传入null。字段country赋值:中文 Object object = field.get(null);//字段country取值 System.out.println(object); 2. 注解: 1.概念: 就是一个标签,有标签后,就具有某一些标签的特性。 本质就是跟类、接口、枚举平级的新结构 2.作用: 1. 帮助程序员校验代码 2. 可以提高开发效率和程序的扩展性 @Test @Before @After 3. 可以生成文档说明 api 操作步骤: 1.选中项目/代码,右键选中Export 2.输入Javadoc 3.第一个next(可以设置生成文档注释的目录),第二个next,设置字符集 如果是UTF-8编码,且有中文,请输入-encoding UTF-8 -charset UTF-8 4. 勾选一个生成完毕后,直接通过浏览器打开的选项 5. finish 3.使用:(重点) 1. 使用jdk或者别人定义好的标签 @ + 注解的名称 -- 比如@Override ->注解 2. 使用自定义的标签 1.JDK的元注解:就是专门用来声明其他注解的注解 作用:通过元注解了解其他注解的使用特点,还可以自定义注解 2.元注解: 1. @Target @Target 作用 用来限制被修饰注解的使用范围,即注解可以在类的哪些成员上使用 @Target 取值使用ElementType.() 1. CONSTRUCTOR:可以在构造器上使用注解 2. FIELD:可以在字段上使用注解 3. LOCAL_VARIABLE:可以在局部变量上使用注解 4. METHOD:可以在普通方法上使用注解 5. PACKAGE:可以在包上使用注解 6. PARAMETER:可以在参数列表上使用注解 7. TYPE:可以在类、接口(包括注解类型) 或enum上使用注解 例如:@Target(ElementType.METHOD)//意味着@Override只能在普通方法上使用 public @interface Override { } 2. @Retention

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值