java（十四）反射和正则表达式

迈不过友情╰ 2022-01-17 10:19 162阅读 0赞

反射机制：

java反射机制是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法；

对于任意一个对象，都能够调用他的任意一个方法和属性；

这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

说简单点：动态获取类中的信息，就是java的反射。可以理解为对类的剖析。

反射技术提高了应用的扩展性，而且应用简单，所以很常用。

想要对一个类文件进行解剖，只要获取该类的字节码文件对象即可。怎么获取呢？

获取字节码对象的方式：

package day28;

public class Person \{

private int age;

private String name;

public Person(String name,int age) \{

super();

this.age = age;

this.name = name;

System.out.println("Person param run..."+this.name+":"+this.age);

public Person() \{

super();

System.out.println("person run...");

public void show()\{

System.out.println(name+"...show run..."+age);

private void privateMethod()\{

System.out.println("method run");

public void paramMethod(String str,int num)\{

System.out.println("paramMethod run..."+str+":"+num);

public static void staticMethod()\{

System.out.println("static method run");

package day28;

public class ReflectDemo1 \{

/\*\*

\* 获取字节码对象的方式：

\* 1.Object类中的getClass()方法。

\* 想要用这种方式，必须要明确具体的类，并创建对象。

\* 2.任何数据类型都具备一个静态的属性.class来获取其对应的class对象。

\* 这种方法相对简单，但还是需要明确用到类中的静态成员，还是不够扩展。

\* 3.可以用Class类中forName方法完成。

\* 只要通过给定的类的字符串名称就可以获取该类，更为方便，扩展性更强。

\* @param args

\* @throws ClassNotFoundException

\*/

public static void main(String\[\] args) throws ClassNotFoundException \{

getClassObject\_3();

public static void getClassObject\_3() throws ClassNotFoundException \{

String className="day28.Person"; //注意这里得带着包名，否则就异常了。

Class clazz=Class.forName(className);

System.out.println(clazz);

public static void getClassObject\_2() \{

Class clazz=Person.class;

Class clazz1=Person.class;

System.out.println(clazz==clazz1);

public static void getClassObject\_1() \{

Person p=new Person();

Class clazz=p.getClass();

Person p1=new Person();

Class clazz1=p.getClass();

System.out.println(clazz==clazz1);

获取字节码文件的构造函数，并创建对象。

package day28;

import java.lang.reflect.Constructor;

public class ReflectDemo2 \{

/\*\*

\* 获取字节码文件的构造函数，并创建对象。

\* @param args

\* @throws Exception

\*/

public static void main(String\[\] args) throws Exception \{

createNewObject\_2();

public static void createNewObject\_2() throws Exception \{

//以前这样就能创建带参的对象。

Person p=new Person("小强",39);

/\* 现在：

\* 当获取指定名称对应类中的所体现的对象时，而该类对象初始化不使用空参数构造该怎么办呢？

\* 既然是通过指定的构造函数进行对象的初始化，就要先获取到该构造函数。如何获取？

\* 通过字节码文件对象的方法即可完成。该方法是：getConstructor(paramterTypes);

\*/

String name="day28.Person";

Class clazz=Class.forName(name);

Constructor constructor=clazz.getConstructor(String.class,int.class);

Object obj=constructor.newInstance("小明",38);

public static void createNewObject\_1() throws ClassNotFoundException, InstantiationException, IllegalAccessException\{

//以前这么写,new的时候，先根据被new的类的名称找寻改类的字节码文件，

//然后加载进内存，并创建该字节码文件对象，接着创建该字节码文件对应的person对象。

//Person p=new Person();

//现在

String name="day28.Person";

//找寻该名称的类文件，并加载进内存，并产生class对象。

Class clazz=Class.forName(name);

//如何产生该类的对象呢？newInstance方法可以产生空参的对象，但只能是空参。

Object obj=clazz.newInstance();

获取字节码文件中的字段。

package day28;

import java.lang.reflect.Field;

public class ReflectDemo3 \{

/\*\*

\* 获取字节码文件中的字段。

\* @param args

\* @throws Exception

\*/

public static void main(String\[\] args) throws Exception \{

getFiledDemo();

public static void getFiledDemo() throws Exception \{

Class clazz=Class.forName("day28.Person");

//Field field=clazz.getField("age"); //只能获取共有的，private修饰的拿不到。

Field field=clazz.getDeclaredField("age"); //只获取本类，但可以获取到私有的内容。

field.setAccessible(true);//对私有字段的访问要取消权限检查。暴力访问。

Object obj=clazz.newInstance();

field.set(obj,89);

Object o=field.get(obj);

System.out.println(o);

获取字节码文件中的函数。

package day28;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

public class ReflectDemo4 \{

/\*\*

\* 获取字节码文件中的函数。

\* @param args

\* @throws Exception

\*/

public static void main(String\[\] args) throws Exception \{

getMethodDemo\_3();

public static void getMethodDemo\_3() throws Exception, Exception \{

Class clazz=Class.forName("day28.Person");

Method method=clazz.getMethod("paramMethod",String.class,int.class);

Object obj=clazz.newInstance();

method.invoke(obj, "小强",89);

public static void getMethodDemo\_2() throws Exception \{

Class clazz=Class.forName("day28.Person");

Method method=clazz.getMethod("show",null); //获取空参数一般方法。

Constructor constructor=clazz.getConstructor(String.class,int.class);

Object obj=constructor.newInstance("小明",37);

method.invoke(obj, null);

public static void getMethodDemo() throws Exception \{

Class clazz=Class.forName("day28.Person");

Method\[\] methods=clazz.getMethods(); //获取的都是共有的方法

Method\[\] methods1=clazz.getDeclaredMethods(); //只获取本类中的所有方法，包含私有

for(Method method:methods1)\{

System.out.println(method);

反射的实际应用：

package day28;

import java.io.File;

import java.io.FileInputStream;

import java.util.Properties;

public class ReflectTest \{

/\*\*

\* 电脑运行事例。

\* 涉及到的类：MainBoard SoundCard PCI

\* @param args

\* @throws Exception

\*/

public static void main(String\[\] args) throws Exception \{

MainBoard mb=new MainBoard();

mb.run();

//早期就这么做，每次添加一个设备都要修改代码传递一个新创建的对象。

//mb.usePCI(new SoundCard());

//能不能不修改代码就可以完成这个动作呢？

//不用new来完成，而是只获取其class文件，在内部实现创建对象的动作。

File configFile=new File("PCI.properties");

Properties prop=new Properties();

FileInputStream fis=new FileInputStream(configFile);

prop.load(fis);

for(int x=0;x<prop.size();x++)\{

String PCIName=prop.getProperty("PCI"+(x+1));

Class clazz=Class.forName(PCIName); //用class去加载PCI的子类

Object obj=clazz.newInstance();

PCI p=(PCI)clazz.newInstance();

mb.usePCI(p);

fis.close();

package day28;

public class MainBoard \{

public void run()\{

System.out.println("main board run...");

public void usePCI(PCI p)\{ //PCI p=new SoundCard()

if(p!=null)\{

p.open();

p.close();

package day28;

public interface PCI \{

public void open();

public void close();

package day28;

import day28.PCI;

public class SoundCard implements PCI \{

public void open() \{

System.out.println("Sound Open");

public void close() \{

System.out.println("Sound Close");

配置文件：PCI.properties

PCI1=day28.SoundCard //这下电脑要填网卡啊啥的，直接在配置文件一写就行了，不用改源代码了。

正则表达式：正确规则的表达式

正则表达式主要用于操作字符串数据。它是通过一些特定的符号来体现的。

所以为了掌握正则表达式，必须要学习并掌握这些符号。

正则表达式虽然将代码简化了，但是阅读性变差了。

package day28;

public class RegexDemo \{

/\*\*

\* 正则表达式：正确规则表达式

\* 正则表达式主要用于操作字符串数据。

\*/

public static void main(String\[\] args) \{

/\*

\* 需求：定义一个功能对qq号进行校验。

\* qq号的要求：长度5-15 ， 只能是数字 ，0不能开头

\*/

String qq="1234556jkl369";

//checkQQ(qq);

String regex="\[1-9\]\[0-9\]\{4,14\}"; //正则表达式

boolean b=qq.matches(regex);

System.out.println(qq+":"+b);

public static void checkQQ(String qq)\{

int len=qq.length();

if(len>=5&&len<=15)\{

if(!qq.startsWith("0"))\{

try\{

long l=Long.parseLong(qq);

System.out.println(l+"正确！");

\}catch(NumberFormatException e)\{

System.out.println(qq+":含有非法字符");

\}else\{

System.out.println(qq+":不能以0开头");

\}else\{

System.out.println(qq+":长度错误");

package day28;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class RegexDemo2 \{

public static void main(String\[\] args) \{

/\*

\* 正则表达式对字符串的常见操作：

\* 1.匹配

\* 其实使用的就是String类中的matches方法。

\* 2.切割

\* 其实使用的就是String类中的split方法。

\* 组：(A(B(C))) 从左括号数，依次为第一组，第二组....

\* 3.替换

\* 其实使用的就是String类中的replaceAll方法

\* 4.获取

\* 将正则规则进行对象的封装。

\*  Pattern p = Pattern.compile("a\*b");

\* 通过正则对象的matcher方法和字符串关联，获取要对字符串操作的匹配器对象Matcher。

\*  Matcher m = p.matcher("aaaaab");

\* 通过Matcher匹配器对象的方法对字符串进行操作。

\* boolean b = m.matches();

\*/

functionDemo\_4();

public static void functionDemo\_1()\{

//匹配手机号码是否正确

String tel="15800001111";

String regex="1\[358\]\\\\d\{9\}"; //这里要两个反斜线+d，第一个是把第二个转义，让它变成反斜线的意思

boolean b=tel.matches(regex);

System.out.println(tel+":"+b);

public static void functionDemo\_2()\{

String str="zhangsan\*\*\*\*xiaoqiang\#\#\#\#\#\#\#\#zhaoliu";

String regex="(.)\\\\1+"; //括号(.)就是把.封装成组，这里默认就是第一组，然后引用第一组。

String\[\] names=str.split(regex);

for(String name:names)\{

System.out.println(name);

public static void functionDemo\_3()\{

String str="zhangsan\*\*\*\*xiaoqiang\#\#\#\#\#\#\#\#zhaoliu";

str=str.replaceAll("(.)\\\\1+", "$1"); //$1表示获取前面参数的第一组

System.out.println(str);

String tel="15800001111";

tel=tel.replaceAll("(\\\\d\{3\})\\\\d\{4\}(\\\\d\{4\})","$1\*\*\*\*$2"); //这就等于把第一组和第二组留下，中间换成\*

System.out.println(tel);

public static void functionDemo\_4()\{

//获取长度为三个字母的词

String str="da jia hao,ming tian bu fang jia";

String regex="\\\\b\[a-z\]\{3\}\\\\b"; //两边得有单词边界，否则就把四个五个字母的词也获取到了，只不过获取的是前三个字母，但这并不是我们想要的

System.out.println(str);

//1.将正则封装成对象

Pattern p=Pattern.compile(regex);

//2.通过正则对象获取匹配器对象

Matcher m=p.matcher(str);

//3.使用Matcher对象的方法对字符串进行操作。

//既然要获取三个字母组成的单词，用查找方法find()

while(m.find())\{

System.out.println(m.group());//获取匹配的子序列

System.out.println(m.start()+":"+m.end()); //获取位置

正则表达式的几个练习：

package day28;

import java.util.TreeSet;

public class RegexTest \{

/\*\*

\* 练习：

\* 1.治疗口吃：我我...我..我...我我要..要...要要..要要学.学学...学学.学编...编编...编编编..编程.程.程.程

\* 2.对IP地址排序。

\* 3.对邮件地址校验

\* @param args

\*/

public static void main(String\[\] args) \{

test\_1();

test\_2();

test\_3();

public static void test\_3() \{

String mail="woshinibaba@sina.com.cn";

String regex="\[a-zA-Z0-9\_\]+@\[a-zA-Z0-9\]+(\\\\.\[a-zA-Z\]\{1,3\})\{1,3\}";

boolean b=mail.matches(regex);

System.out.println(mail+":"+b);

public static void test\_2() \{

String ip\_str="192.168.10.34 127.0.0.1 3.3.3.3 105.70.11.55";

//为了让IP可以按照字符串顺序比较，只要每段位数相同即可。

//所以就要补0。最多补两个0，所以每段前面都加两个0。然后每段保留后3位即可。

ip\_str=ip\_str.replaceAll("(\\\\d+)", "00$1");

ip\_str=ip\_str.replaceAll("0\*(\\\\d\{3\})", "$1");

String\[\] ips=ip\_str.split(" +");

TreeSet<String> ts=new TreeSet<String>();

for(String ip:ips)\{

ts.add(ip);

for(String ip:ts)\{

System.out.println(ip.replaceAll("0\*(\\\\d+)","$1" ));

/\* 这么做可以排序，但结果不对3.3.3.3应该是最小，排在最前面。

\* 但是却排在了最后，但只要变成003.003.003.003就可以完成了，所以就要补0.

String\[\] ips=ip\_str.split(" +");

TreeSet<String> ts=new TreeSet<String>();

for(String ip:ips)\{

ts.add(ip);

for(String ip:ts)\{

System.out.println(ip);

\*/

public static void test\_1()\{

String str="我我...我..我...我我要..要...要要..要要学.学学...学学.学编...编编...编编编..编程.程.程.程";

//1.将字符串中的.去掉。用替换

str=str.replaceAll("\\\\.", "");

//2.替换叠词

str=str.replaceAll("(.)\\\\1+", "$1");

System.out.println(str);

//实现 网页爬虫功能。

package day28;

import java.io.BufferedReader;

import java.io.FileReader;

import java.util.ArrayList;

import java.util.List;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class RegexTest2 \{

/\*\*

\* 网页爬虫。

\* 就是一个程序，用于在互联网中获取符合指定规则的数据。

\* 爬取邮箱地址。

\* @param args

\* @throws Exception

\*/

public static void main(String\[\] args) throws Exception \{

List<String> list=getMails();

for(String mail:list)\{

System.out.println(mail);

public static List<String> getMails() throws Exception\{

//1.读取源文件

BufferedReader bufr=new BufferedReader(new FileReader("mail.html"));

/\*

\* 如果要源文件是网络上的一个网页，稍微修改就行。

\* URL url=new URL("网址");

\* BufferedReader bufIn=new BufferedReader(new InputStreamReader(url.openStream()));

\* 再把下面的bufr换成bufIn就行。

\*/

//2.对读取的数据进行规则的匹配，从中获取符合规则的数据。

String mail\_regex="\\\\w+@\\\\w+(\\\\.\\\\w+)+";

List<String> list=new ArrayList<String>();

Pattern p=Pattern.compile(mail\_regex);

String line=null;

while((line=bufr.readLine())!=null)\{

Matcher m=p.matcher(line);

//3.将符合规则的数据存储到集合中。

while(m.find())\{

list.add(m.group());

return list;

转载于:https://blog.51cto.com/12956849/1955747

java（十四）反射和正则表达式

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java 算法和正则表达式

相关 Java中的反射和正则表达式

相关 java正则表达式语法(java正整数正则表达式)

相关【正则表达式】正则表达式应用

相关 java正则 (_Java正则表达式

相关十分钟掌握正则表达式！1_初识正则表达式

相关正则表达式入门教程(四)

相关 java（十四）反射和正则表达式

相关 jmeter（十六）正则表达式

相关十三 Java正则表达式