java - day019 - 反射

时间 2020-06-18

标签 java day019 day 反射栏目 Java 繁體版

原文原文链接

网络程序,难点在线程css

反射 reflect
实用类对象来执行反射操做

反射得到一个类的定义信息
反射建立对象
反射调用成员变量, 方法

方法

得到类对象的三种方式
A.class
Class.forName("完整类名");
a1.getClass();

类对象的方法

c.getPackage().getName();
c.getName();
c.getSimpleName();
得到成员变量的定义信息

getFields(); 获得可见的成员变量,即能访问的, 包括继承来的
getDeclaredFields(); 本类定义的全部变量, 包括私有变量, 不包括继承的
getField(变量名); 获得单个可见的的成员变量
getDeclaredField(变量名);

得到构造方法的定义信息

getConstructors(); 得到可见的构造方法,
getDeclaredConstructors(); 得到全部的构造方法
getConstructor(参数类型列表); 得到单个可见的的构造方法
getDeclaredConstructor(int.class,String.class);

得到方法的定义信息

getMethods(); // 可见的方法, 包括继承的方法
getDeclaredMethods(); // 本类定义的方法, 包括私有的方法,不包括继承的方法
getMethod(方法名,参数类型列表);
getDeclaredMethod(方法名,int.class,String.class);

package day1901_反射; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.Arrays; import java.util.Scanner; public class Test1 { public static void main(String[] args) throws Exception { System.out.println("输入完整类名"); String s = new Scanner(System.in).nextLine(); // 得到这个类的'类对象'
 Class<?> c = Class.forName(s); // 得到包名, 类名 ,简写类名
        String p = c.getPackage().getName(); String n = c.getName(); String sn = c.getSimpleName(); System.out.println(p); System.out.println(n); System.out.println(sn); System.out.println("----成员变量------"); f1(c); System.out.println("----构造方法------"); f2(c); System.out.println("----方法------"); f3(c); } private static void f3(Class<?> c) { /* * Method 对象, 封装方法的定义信息 * public static void f(int i , String s)throws X,Y,Z */ Method[] a = c.getDeclaredMethods(); for (Method f : a) { String n = f.getName(); // 构造方法参数的类型 (int.class, String.class);
            Class<?>[] p = f.getParameterTypes(); System.out.println(n+"("+Arrays.toString(p)+")"); } } private static void f2(Class<?> c) { /* * Constructor 构造方法的封装对象 * * public A(int a, String s) throws X,Y,Z * */ Constructor<?>[] a = c.getConstructors(); for (Constructor<?> t : a) { String n = c.getSimpleName(); // 构造方法参数的类型 (int.class, String.class);
            Class<?>[] p = t.getParameterTypes(); System.out.println(n+"("+Arrays.toString(p)+")"); } } private static void f1(Class<?> c) { /* * Field对象 * 封装了成员变量的定义信息 * */ Field[] a = c.getDeclaredFields(); for (Field f : a) { System.out.println(f.getType().getSimpleName()+f.getName()); } } }

反射新建对象

经过类对象的反射操做
执行无参构造方法

object obj = c.newInstabce();

执行有参构造

先得到构造方法
Constructor t = c.getConstructor(int.class,String.class);
经过构造方法的反射操做, 来新建对象
object obj = t.newInstance(int ,String);

package day1901_反射; import java.lang.reflect.Constructor; import java.util.Scanner; public class Test2 { public static void main(String[] args) throws Exception { System.out.println("输入类名"); String s = new Scanner(System.in).nextLine(); Class<?> c = Class.forName(s); Object o1 = null; Object o2 = null; /* * 新建 o1,执行无参构造 * 新建 o2,执行有参构造 */
        
        try { o1 = c.newInstance(); System.out.println("o1:"+o1);// 默认执行 o1 的toString
        } catch (Exception e) { // TODO: handle exception
            System.out.println("o1: 不能执行无参构造"); } System.out.println("-----------------------------"); try { Constructor<?> t = c.getConstructor(int.class); o2 = t.newInstance(666); System.out.println("o2: "+o2); } catch (Exception e) { // TODO: handle exception
            System.out.println("o2: 不能执行int参数构造方法"); } } }

反射调用成员变量,

得到成员变量
Field f = c.getDeclaredField("age");
使私有变量也能够访问,
f.setAccssible(true);
赋值
f.set(对象,21);给指定对象的变量赋值
取值
int i = (int)f.get(对象);

package day1901_反射; import java.lang.reflect.Field; import day0802.Student; /* * 跨项目不能直接访问,须要项目关联 * 左侧选中须要关联项目的项目,右键弹出选中build path 选中项目project, */
public class Test3 { public static void main(String[] args) throws Exception, SecurityException { // 
        Student s = new Student(); Class<Student> c = Student.class; // 得到age变量 并赋值
        Field f = c.getDeclaredField("age"); f.setAccessible(true); f.set(s, 21); System.out.println(s.getAge()); int a = (int)f.get(s); System.out.println(a); } }

反射调用成员方法

得到方法
Method t = c.getMethod(方法名,参数类型列表);
使得私有方法容许被调用
t.setAccessible(true);
调用方法
t.invoke(对象,参数数据);

让指定对象,执行该方法
静态方法,第一个参数传 null
没有返回值获得 null

package day1901_反射; import java.lang.reflect.Field; import java.lang.reflect.Method; import day0802.Student; /* * 跨项目不能直接访问,须要项目关联 * 左侧选中须要关联项目的项目,右键弹出选中build path 选中项目project, */
public class Test3 { public static void main(String[] args) throws Exception, SecurityException { // 
        Student s = new Student(); Class<Student> c = Student.class; // 得到age变量 并赋值
        Field f = c.getDeclaredField("age"); f.setAccessible(true); f.set(s, 21); System.out.println(s.getAge()); int a = (int)f.get(s); System.out.println(a); // 反射测试方法
        Method gg = c.getMethod("getGender"); Method sg = c.getMethod("setGender", String.class); sg.invoke(s, "男"); Object r = gg.invoke(s); System.out.println(r); } }

反射的测试应用

package day1901_反射; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; import java.lang.reflect.Method; import java.util.ArrayList; public class Runner { private static ArrayList<String> list = 
            new ArrayList<String>(); // 静态初始化快
    static { try { BufferedReader buf = 
                    new BufferedReader( new InputStreamReader( new FileInputStream( "/Users/dingzhijie/Desktop/file3.txt"), "UTF-8")); String line; while ((line = buf.readLine()) != null) { line = line.replace("\\s+", ""); if (line.length()==0) { continue; } list.add(line); } buf.close(); } catch (Exception e) { // TODO: handle exception
            throw new RuntimeException(e); } } public static void launch() { try { for (String s : list) { // 拆分字符串
                String[] a = s.split(";"); // 得到类名
                Class<?> c = Class.forName(a[0]); Object obj = c.newInstance(); // 得到方法名
                Method m = c.getMethod(a[1]); m.invoke(obj); } } catch (Exception e) { // TODO: handle exception
            System.out.println("执行失败"); e.printStackTrace(); } } public static void main(String[] args) { System.out.println("main"); for (String string : list) { System.out.println(string); } System.out.println("--------------"); Runner.launch(); } }

反射是框架的底层实现原理

SSM

注解

为其余开发工具,或其余 Java 程序,提供额外的信息
@Override
public String toString(){ }

@Override 由编译器处理,编译器识别改注解,来对方法从新进行语法检查

自定义注解

要本身编写处理代码

package day1902_注解; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(ElementType.METHOD) // 单个 //@Target({ElementType.METHOD,ElementType.FIELD}) // 多个
 @Retention(RetentionPolicy.RUNTIME) /* * 元注解 * * @Target * 设置注解目标: 类, 方法,成员变量, 参数... * * @Retention * 保留范围: * 源码文件 - 编译时注解信息被丢弃 - 编译器处理 * 字节码 - 类被加载到内存是丢弃 - 类加载器处理 * 运行期内存 - 在内存中存在,不会被丢弃 - 自定义注解使用 * */

//定义注解 @interface
public @interface Test { // 注解的属性 // 若是不指定默认值, 使用时必须赋值 // int id();
    int id() default 0; // 特殊的属性名, 有特殊待遇 // 若是单独赋值, 能够不写属性名
    String value() default ""; }

Junit 单元测试框架

Junit 第三方开源工具
Junit 是 Java 单元测试的事实标准
eclipse 集成了Junit, 能够直接在项目中引入 Junit jar 包
还集成了 Junit 的运行器

package day1903_Junit; import org.junit.Test; /* * 引入Junit 开发包 * 右键点击项目 Build path - library - * add Library - Junit - Junit 4 * * * 直接运行便可测试 * 光标定位在测试方法上, 能够只执行单个测试方法 * 定位在类上是测试单个类的代码 * */ 
public class Test1 { @Test public void a(){ System.out.println("测试a"); } public void b(){ System.out.println("测试b"); } @Test public void c(){ System.out.println("测试c"); } @Test public void d(){ System.out.println("测试d"); } }

网络爬虫

抓取网页页面内容
经常使用的网络爬虫工具

HttpClient
Jsoup

Jsoup

第三方的开源 API
须要到官网下载 Jsoup jar 文件
参考官方的使用文档, 示例代码

package day1904_网络爬虫; import java.io.IOException; import org.jsoup.Jsoup; import org.junit.Test; /* * 引入 Jsoup 开发包 * 右键点击项目 - Build path - add External jar 选中全部文件 */
public class Test1 { @Test public void test1() throws Exception { String s = Jsoup.connect("http://www.baidu.com") .execute() .body(); System.out.println(s); } @Test public void test2() throws Exception { String s = Jsoup.connect("http://www.jd.com/") .execute() .body(); System.out.println(s); } }