5.正则表达式与反射的学习

正则表达式部分
 |-- 正则规则
   |-- a-zA-Z
   |-- 0-9
   |-- ^
   |-- \\d
   |-- \\w
   |-- ? * +
   |-- {3,5}
 |-- 匹配 
   |-- String类的matches（规则）
 |-- 切割
   |-- String类split(规则)
 |-- 替换
   |-- String replaceAll(规则，替换后的内容)
 |-- 获取
   |-- Matcher 
   |-- Pattern
 |-- 正则的案例，邮件*****，叠词还原
 
 
 反射部分
  |-- 获取字节码文件的方式
  |-- 获取构造方法
    |-- Constructor  getConstructor(数据类型)
    |-- Constructor 类一个方法 newInstance(具体数据)
  |-- 获取成员变量
    |-- Field getField(变量名)
    |-- Field set(对象，具体数据)
    
 |-- 获取成员方法
    |-- Mathod  getMtehod(方法名，数据类型)
    |-- Method invoke(对象，具体数据)
 |-- 规律
    |-- 获取任何字节码文件中的内容，用的是Class类中的方法
    |-- 操作获取到的内容，用的是具体的类
    |-- 获取非公有的成员，getDeclared的方法
    |-- 暴力访问，不建议
    
 |-- 读取配置文件运行*****

 |-- 泛型的擦除，简单了解

程序实例

①package cn.itcast.demo;
 
    public class Person {
private  String name;
protected int age;
public Person() {
System.out.println("空参数构造");
}
private Person(int age){
this.age = age;
}
public Person(String name,int age){
this.name = name;
this.age = age;
System.out.println("字符串参数的构造");
}
private void qqq(int a){
System.out.println("a==="+a);
}

public void show(){
System.out.println("show...run");
}
public String toString(){
return name+"..."+age;
}
   }

②package cn.itcast.reflect;
/*
 * 反射：
 *  编译时期不知道运行谁
 *  运行时期知道运行谁
 *  
 *  在运行时期，可以对一个类的字节码文件.class文件，进行解剖
 *  并可以获取到字节码文件中的内容： 构造方法，普通方法，成员变量
 *  并可以通过解剖的方式来运行
 *  
 *  万物皆对象，在java中，有没有描述class文件的对象呢，这个类就是Class类
 *  1. 如何获取字节码文件对象
 *  2. 描述构造方法的类 Constructor
 *  3. 描述成员变量 Field
 *  4. 描述方法的类  Method
 *  5. 通过配置文件来运行用户指定的类Properties
 *  6. 通过反射技术，绕过泛型的编译器检查，将执行泛型的集合，存储其他类型数据
 *     List<String> list = new ArrayList<String>();
 *     list.add("ddd");
 *     list.add(1234);
 */
import cn.itcast.demo.Person;
import java.lang.reflect.*;
public class ReflectDemo {
public static void main(String[] args) throws Exception{
method_3("cn.itcast.demo.Person");
}

//获取成员方法并运行
private static void method_3(String str) throws Exception{
Class clazz = Class.forName(str);
//获取方法public Method[] getMethods()
Method[] methods = clazz.getMethods();
for(Method m :methods){
System.out.println(m);
}

//演示Person中show方法运行
Method mm = clazz.getMethod("show");
Constructor con = clazz.getConstructor();
Object obj = con.newInstance();
mm.invoke(obj);


Method mqqq = clazz.getDeclaredMethod("qqq", int.class);
mqqq.setAccessible(true);
mqqq.invoke(obj, 123);

}




//通过反射获取成员变量并运行
private static void method_2(String str)throws Exception{
Class clazz = Class.forName(str);
//public Field[] getFields()  公共字段
// Field[] field = clazz.getFields();
Field[] field = clazz.getDeclaredFields();
/*for(Field f:field){
System.out.println(f);
}*/


Constructor con = clazz.getConstructor();
Object obj = con.newInstance();
//获取String类型的成员变量，并改值
Field f = clazz.getDeclaredField("name");
f.setAccessible(true);
System.out.println(f);
//public void set(Object obj,Object value)
f.set(obj, "lisilisi");
System.out.println(obj);





}




//演示获取构造方法并运行
private static void method_1(String str)throws Exception{
Class clazz = Class.forName(str);
//通过字节码文件对象，获取到构造方法 
//public Constructor[] getConstructors()所有公共构造方法
Constructor[] cons = clazz.getConstructors();
/*for(Constructor con :cons){
System.out.println(con);
}*/

//public Constructor[] getDeclaredConstructors()全部构造方法
cons = clazz.getDeclaredConstructors();
/*for(Constructor con :cons){
System.out.println(con);
}*/

//public Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor c = clazz.getConstructor();
System.out.println(c);

Object obj = c.newInstance();
System.out.println(obj);
//运行获取到的构造方法，建立对象

/*Person p = new Person();
System.out.println(p);*/



//获取带String,int类型的构造方法，并建立对象
Constructor c1 = clazz.getConstructor(String.class,int.class);
//建立对象，调用参数匹配的构造方法
Object obj1 = c1.newInstance("zhangsan",15);
System.out.println(obj1);


//获取私有构造方法，带int类型参数，并建立对象
Constructor c2 = clazz.getDeclaredConstructor(int.class);
c2.setAccessible(true);//暴力访问，临时改变修饰符
Object obj2 = c2.newInstance(18);
System.out.println(obj2);
}









//获取字节码文件的三种方式
private static void method() throws Exception{
//第一种获取字节码文件对象的方式
//public final Class getClass()
Person p = new Person();
Class clazz  = p.getClass();
//System.out.println(clazz);

//第二种获取字节码文件对象的方式
Class clazz1 = Person.class; 
//System.out.println(clazz1);

//获取字节码文件对象的方法 *****
Class clazz2 = Class.forName("cn.itcast.demo.Person");//抛出ClassnotFoundException
System.out.println(clazz2==clazz1);
}
}

③package cn.itcast.reflect2;
/*
 * 通过反射技术，读取配置文件，运行所需要的类
 */
import java.io.*;
import java.util.*;
import java.lang.reflect.*;
public class ReflectDemo {
public static void main(String[] args)throws Exception {
//1. 创建集合类
Properties pro = new Properties();
//2. 创建读取流，读取配置文件
FileReader fr = new FileReader("c:\\config.properties");
//3. 配置文件和IO流关联
pro.load(fr);

//4 .通过读取配置文件来获取配置文件中的类名和方法名
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//5. 通过反射，解剖字节码文件
Class clazz = Class.forName(className);
//6 .获取构造方法
Constructor con = clazz.getConstructor();
Object obj = con.newInstance();
//7. 获取方法
Method m = clazz.getMethod(methodName);
m.invoke(obj);
}
}