[学习交流] 【阳哥笔记】Java基础之笔记系列—Day27(反射+正则)!

总链接：http://bbs.itheima.com/thread-200600-1-1.html

Chapter 10 反射+正则

反射

JAVA反射机制是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象方法的功能称为java语言的反射机制。

动态获取类中信息，就是java反射。可以理解为对类的解剖。

如果想要对指定名称的字节码文件进行加载并获取其中的内容并调用，这时就使用到了反射技术。

P.S.

所谓的框架就是对外提供一些接口，也就是功能扩展的标准，由实现类按照这个接口标准去实现。框架内部如果需要操纵这些实现类的对象完成某些操作，那么只需要把这些实现类的全名（包名+类名）写在某个配置文件中，框架代码只需要读取这个配置文件，就可以获取这个实现类的字节码文件，然后利用反射技术创建这个实现类的对象并且调用相应的方法完成一些操作。

用于描述字节码的类就是Class类，创建对象，可以提取字节码文件中的内容，如字段、构造函数、一般函数。该类就可以获取字节码文件中的所有内容，那么反射就是依靠该类完成的。想要对一个类文件进行解剖，只要获取到该类的字节码文件对象即可。

示例：获取字节码文件对象的3种方式

Person.java

package cn.itcast.bean;
public class Person
{
private int age;
private String name;
public Person(int age,String name){
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...");
}
}

复制代码

ReflectDemo.java

import cn.itcast.bean.Person;
//要想要对字节码文件进行解剖，必须要有字节码文件对象。
public class ReflectDemo
{
public static void main(String[] args) throws ClassNotFoundException {
getClassObject_1();
System.out.println("--------------------");
getClassObject_2();
System.out.println("--------------------");
getClassObject_3();
}
/*
* 获取字节码对象的方式：
* 方式一：Object类中的getClass()方法的。
* 想要用这种方式，必须要明确具体的类，并创建对象。
* 麻烦。
*/
public static void getClassObject_1(){
Person p = new Person();
Class clazz = p.getClass();
Person p1 = new Person();
Class clazz1 = p1.getClass();
System.out.println(clazz == clazz1);
}
/*
* 方式二：任何数据类型都具备一个静态的属性.class来获取其对应的Class对象。
* 相对简单，但是还是要明确用到类中的静态成员。
* 还是不够扩展。
*/
public static void getClassObject_2(){
Class clazz = Person.class;
Class clazz1 = Person.class;
System.out.println(clazz == clazz1);
}
/*
* 方式三：只要通过给定的类的字符串名称就可以获取该类，更为扩展。
* 可以用Class类中的方法完成。
* 该方法就是forName。
* 这种方法只要有名称即可，更为方便，扩展性更强。
*/
public static void getClassObject_3() throws ClassNotFoundException {
//可以把类的字符串名称写到配置文件中，然后读取出来。
String className = "cn.itcast.bean.Person";
Class clazz = Class.forName(className);
System.out.println(clazz);
}
}

复制代码

运行结果：

示例：获取Class中的构造函数

import cn.itcast.bean.Person;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class ReflectDemo
{
public static void main(String[] args) throws Exception {
createNewObject_1();
System.out.println("--------------------");
createNewObject_2();
}
public static void createNewObject_1() throws ClassNotFoundException,InstantiationException,IllegalAccessException {
//早期：new时候，先根据被new的类的名称找寻该类的字节码文件，并加载进内存，
//并创建该字节码文件对象，并接着创建该字节文件的对应的Person对象。
//Person p = new Person();
//现在：
String name = "cn.itcast.bean.Person";
//找寻该文件类文件，并加载进内存，并产生Class对象。
Class clazz = Class.forName(name);
//如何产生该类的对象呢？
Object obj = clazz.newInstance();//调用Person的空参构造函数
}
public static void createNewObject_2() throws ClassNotFoundException,InstantiationException,NoSuchMethodException,IllegalAccessException,InvocationTargetException {
//Person p = new Person("小强",39);
/*
* 当获取指定名称对应类中的所体现的对象时。
* 而该对象初始化不使用空参数构造函数该怎么办呢？
* 既然是通过指定的构造函数进行对象的初始化。
* 所以应该先获取到该构造函数，通过字节码文件对象即可完成。
* 该方法是：getConstructor(parameterTypes);
*/
String name = "cn.itcast.bean.Person";
//找寻该名称类文件，并加载进内存，并产生Class对象。
Class clazz = Class.forName(name);
//获取到了指定的构造函数对象
Constructor constructor = clazz.getConstructor(int.class,String.class);
//通过该构造器对象的newInstance方法进行对象的初始化。
Object obj = constructor.newInstance(38,"小明");
}
}

复制代码

运行结果：

示例：获取Class的字段

import cn.itcast.bean.Person;
import java.lang.reflect.Field;
public class ReflectDemo
{
public static void main(String[] args) throws Exception {
getFieldDemo();
}
/*
* 获取字节码文件中的字段。
*/
public static void getFieldDemo() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person");
//getField只能获取所有可访问公共字段，private获取不到。
//Field field = claszz.getField("age");
//getDeclaredField可以获取到公共字段，也可以获取到私有字段。
Field field = clazz.getDeclaredField("age");
//对私有字段的访问取消权限检查，暴力访问。
field.setAccessible(true);
Object obj = clazz.newInstance();
//为对象的属性赋值
field.set(obj,89);
//获取某对象的某属性值
Object o = field.get(obj);
System.out.println(field);
}
}

复制代码

运行结果：

示例：获取Class中的方法

import cn.itcast.bean.Person;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
public class ReflectDemo
{
public static void main(String[] args) throws Exception {
getMethodDemo_1();
System.out.println("---------------------------");
getMethodDemo_2();
System.out.println("---------------------------");
getMethodDemo_3();
}
/*
* 获取指定Class中的公共函数。
*/
public static void getMethodDemo_1() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person");
Method[] methods = clazz.getMethods();//获取的都是公有的方法
methods = clazz.getDeclaredMethods();//只获取本类中所有方法，包括私有。
for(Method method : methods){
System.out.println(method);
}
}
public static void getMethodDemo_2() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person");
Method method = clazz.getMethod("show",null);//获取空参数一般方法
Object obj = clazz.newInstance();
Constructor constructor = clazz.getConstructor(int.class,String.class);
obj = constructor.newInstance(37,"小明");
method.invoke(obj,null);
}
public static void getMethodDemo_3() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person");
Method method = clazz.getMethod("paramMethod",String.class,int.class);//获取空参数一般方法
Object obj = clazz.newInstance();
Constructor constructor = clazz.getConstructor();
obj = constructor.newInstance();
method.invoke(obj,"小强",89);
}
}

复制代码

运行结果：

练习：反射练习

代码：

PCI.java

package cn.itcast.reflect.test;
public interface PCI
{
public void open();
public void close();
}

复制代码

SoundCard.java

package cn.itcast.reflect.test;
public class SoundCard implements PCI
{
public void open(){
System.out.println("sound open");
}
public void close(){
System.out.println("sound close");
}
}

复制代码

NetCard.java

package cn.itcast.reflect.test;
public class NetCard implements PCI
{
public void open(){
System.out.println("net open");
}
public void close(){
System.out.println("net close");
}
}

复制代码

Mainboard.java

package cn.itcast.reflect.test;
public class Mainboard
{
public void run(){
System.out.println("main board run...");
}
public void usePCI(PCI p){
if(p != null){
p.open();
p.close();
}
}
}

复制代码

pci.Properties

pci1=cn.itcast.reflect.test.SoundCard
pci2=cn.itcast.reflect.test.NetCard

复制代码

ReflectTest.java

package cn.itcast.reflect.test;
import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;
/*
* 电脑运行
*/
public class ReflectTest
{
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子类
PCI p = (PCI)clazz.newInstance();
mb.usePCI(p);
}
fis.close();
}
}

复制代码

运行结果：

正则

示例：

/*
* 正则表达式。
*
* 正则表达式用于操作字符串数据。
* 通过一些特定的符号来体现的。
* 所以我们为了掌握正则表达式，必须要学习一些符号。
*
* 虽然简化了，但是阅读性差。
*/
public class RegexDemo
{
public static void main(String[] args){
String qq = "123456701";
//checkQQ(qq);
//正则表达式。
String regex = "[1-9][0-9]{4,14}";
boolean b = qq.matches(regex);
System.out.println(qq + ":" + b);
}
/*
* 需求：定义一个功能对QQ号进行校验。
* 需求：长度5~15，只能是数字，0不能开头。
*/
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 + ":长度错误");
}
}
}

复制代码

运行结果：

正则表达式常用构造摘要

字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）

预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]

Greedy 数量词
X?    X，一次或一次也没有
X*    X，零次或多次
X+    X，一次或多次
X{n}    X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次

边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
\z 输入的结尾

示例：

public class RegexDemo
{
public static void main(String[] args){
String str = "aoob";
String reg = "ao?b";
boolean b = str.matches(reg);
System.out.println(str + ":" + b);
reg = "ao+b";
b = str.matches(reg);
System.out.println(str + ":" + b);
str = "ab";
reg = "ao+b";
b = str.matches(reg);
System.out.println(str + ":" + b);
str = "ab";
reg = "ao*b";
b = str.matches(reg);
System.out.println(str + ":" + b);
str = "aooooooob";
reg = "ao{4,}b";
b = str.matches(reg);
System.out.println(str + ":" + b);
reg = "ao{4,6}b";
b = str.matches(reg);
System.out.println(str + ":" + b);
}
}

复制代码

运行结果：

正则表达式常见功能：匹配、切割、替换、获取

示例：

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexDemo
{
public static void main(String[] args){
functionDemo_1();
System.out.println("------------------------");
functionDemo_2();
System.out.println("------------------------");
functionDemo_3();
System.out.println("------------------------");
functionDemo_4();
System.out.println("------------------------");
functionDemo_5();
System.out.println("------------------------");
functionDemo_6();
System.out.println("------------------------");
functionDemo_7();
}
/*
* 正则表达式对字符串的常见操作
* 1. 匹配
* 其实使用的就是String类中的matches方法。
*
* 2. 切割
* 其实使用的就是String类中的split方法。
*
* 3. 替换
*
* 4. 获取
*/
/*
* 演示匹配
*/
public static void functionDemo_1(){
//匹配手机号码是否正确
String tel = "15800001111";
String regex = "1[358]\\d{9}";
boolean b = tel.matches(regex);
System.out.println(tel + ":" + b);
}
/*
* 演示切割
*/
public static void functionDemo_2(){
String str = "zhangsan xiaoqiang zhaoliu";
String[] names = str.split(" +");
for(String name : names){
System.out.println(name);
}
}
public static void functionDemo_3(){
String str = "zhangsan.xiaoqiang.zhaoliu";
String[] names = str.split("\\.");
for(String name : names){
System.out.println(name);
}
}
/*
* 在表达式 ((A)(B(C))) 中，存在四个这样的组：
* 1 ((A)(B(C)))
* 2 \A
* 3 (B(C))
* 4 (C)
* 组零始终代表整个表达式。
*/
public static void functionDemo_4(){
String str = "zhangsanttttxiaoqiangmmmmmzhaoliu";
//(.)表示一组，\\1+表示与第1组相同的出现1次以上
String[] names = str.split("(.)\\1+");
for(String name : names){
System.out.println(name);
}
}
/*
* 演示替换
*/
public static void functionDemo_5(){
String str = "zhangsanttttxiaoqiangmmmmmzhaoliu";
//$表示前一个参数的第一组
str = str.replaceAll("(.)\\1+","$1");
System.out.println(str);
}
public static void functionDemo_6(){
String str = "15800001111";
str = str.replaceAll("(\\d{3})(\\d{4})(\\d{4})","$1****$2");
System.out.println(str);
}
/*
* 演示获取
* 将正则规则进行对象的封装。
* Pattern p = Pattern.compile("a*b");
* 通过正则对象的matcher方法字符串相关联。获取要对字符串操作的匹配器对象Matcher。
* boolean b = m.matches();
*/
public static void functionDemo_7(){
String str = "da jia hao,ming tian bu fang jia";
// \\b表示单词边界
String regex = "\\b[a-z]{3}\\b";
//1. 将正则封装成对象
Pattern p = Pattern.compile(regex);
//2. 通过正则对象获取匹配器对象
Matcher m = p.matcher(str);
//使用Matcher对象的方法对字符串进行操作。
//既然要获取三个字母组成的单词。
//查找：find();
while(m.find()){
System.out.println(m.group());//获取匹配的子序列
System.out.println(m.start() + ":" + m.end());
}
}
}

复制代码

运行结果：

P.S.
1、Pattern类为正则表达式的编译表示形式。指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建Matcher对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。

练习1：

public class RegexTest
{
public static void main(String[] args){
test();
}
/*
* 1. 治疗口吃：我我...我我...我我我我...要要要要...要要要要...学学学学学...学学编编...编编编编..编..编...程程...程程程
* 2. 对ip地址排序
* 3. 对邮件地址校验
*/
/*
* 1. 治口吃
*/
public static void test(){
String str = "我我...我我...我我我我...要要要要...要要要要...学学学学学...学学编编...编编编编..编..编...程程...程程程";
//1. 将字符串中.去掉，用替换。
str = str.replaceAll("\\.+","");
//2. 替换叠词
str = str.replaceAll("(.)\\1+","$1");
System.out.println(str);
}
}

复制代码

运行结果：

练习2：

import java.util.TreeSet;
import java.io.PrintStream;
public class RegexTest
{
public static void main(String[] args){
test();
}
/*
* ip地址排序。
* 192.168.10.34 127.0.0.1 3.3.3.3 105.70.11.55
*/
public static void test(){
String ip_str = "192.168.10.34 127.0.0.1 3.3.3.3 105.70.11.55";
//1. 为了让ip可以按照字符串顺序比较，只要让ip的每一段的位数相同。
//所以，补零，按照每一位所需最多0进行补充，每一段都加两个0。
ip_str = ip_str.replaceAll("(\\d+)","00$1");
System.out.println(ip_str);
//然后每一段保留数字3位。
ip_str = ip_str.replaceAll("0*(\\d{3})","$1");
System.out.println(ip_str);
//1. 将ip地址切出。
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：

import java.util.TreeSet;
import java.io.PrintStream;
public class RegexTest
{
public static void main(String[] args){
test();
}
//对邮件地址校验。
public static void test(){
String mail = "abc1@sina.com";
String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]{1,3})+";
boolean b = mail.matches(regex);
System.out.println(mail + ":" + b);
}
}

复制代码

运行结果：

练习4：爬虫

import java.util.ArrayList;
import java.util.List;
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.io.IOException;
/*
* 网页爬虫：其实就是一个程序用于在互联网中获取符合指定规则的数据。
* 爬取邮箱地址。
*/
public class RegexTest
{
public static void main(String[] args) throws IOException {
List<String> list = getMails();
for(String mail : list){
System.out.println(mail);
}
}
public static List<String> getMails() throws IOException {
//1. 读取源文件。
BufferedReader bufr = new BufferedReader(new FileReader("c:\\mail.html"));
//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);
while(m.find()){
list.add(m.group());
}
}
//3. 将符合规则的数据存储到集合中。
return list;
}
}

复制代码

运行结果：

从互联网上爬邮箱

import java.util.ArrayList;
import java.util.List;
import java.io.BufferedReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
public class RegexTest
{
public static void main(String[] args) throws IOException {
List<String> list = getMailsByWeb();
for(String mail : list){
System.out.println(mail);
}
}
public static List<String> getMailsByWeb() throws IOException {
URL url = new URL("http://www.itheima.com/aboutt/1376.html");
BufferedReader bufr = new BufferedReader(new InputStreamReader(url.openStream()));
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);
while(m.find()){
list.add(m.group());
}
}
return list;
}
}

复制代码

运行结果：

~END~

13120298870

表示已蒙圈，哈哈，继续努力中，我是拍不死的小强

独行浪子 · 独行浪子

马了先收藏

lktz · lktz

标记标记

lh951329230 · lh951329230

路过参考一下

鳌少宝 · 鳌少宝

支持阳哥

李放 · 李放

收藏一下

沐一风 · 沐一风

此关键字是来自语言的艺术意识!

凤凰城nash · 凤凰城nash

我感觉这两个挺重要的，收藏了

潇湘夜雨 · 潇湘夜雨

刚刚在基础班学习,看到过这个课程内容,先收藏,定能用到.

s1714534118 · s1714534118

看不懂，感觉好难呀！~

3872982

赞一个。

周亚飞 · 周亚飞

感谢大神的分享

流水落花 · 流水落花

慢慢看吧辛苦了

冷光之神 · 冷光之神

666

一江夜雨 · 一江夜雨

过来看看

传奇查 · 传奇查

太牛了~大神啊~膜拜下~

超级宝贝乐爷 · 超级宝贝乐爷

还好阳哥笔记可以复制,出大问题了

fenger7 · fenger7

好好的看看

小鹿 · 小鹿

八错八错！赞！大赞！

帐号		自动登录	找回密码
密码			加入黑马

[学习交流] 【阳哥笔记】Java基础之笔记系列—Day27(反射+正则)!

93 个回复