Java第二十七天学习笔记~（反射、正则表达式）

反射

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

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

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

动态获取类中信息就是Java反射

可以理解为对类的解剖

反射技术提高了我们程序的扩展性

给用户提供的我们之间的桥梁是配置文件（web.xml）

我们主要开发的是接口和配置文件

想要对一个类进行解剖，只要获得该文件类的字节码文件对象即可

package cn.itcast.reflect.demo;

import cn.itcast.bean.Person;

/*
 * 
 * 如何获取字节码文件对象呢？
 */

public class ReflectDemo {

	public static void main(String[] args) throws ClassNotFoundException {
		// TODO Auto-generated method stub
		getClassObject_3();
	}	
	
	/*
	 * 方式三
	 * 3，只要通过给定的类的字符串名称就可以获取该类，更为扩展
	 * 可使用Class类中的方法完成
	 * 该方法就是fotName
	 * 这种方式只要有名称即可，更为方便，扩展性；更强
	 */
	public static void getClassObject_3() throws ClassNotFoundException {
		String className="cn.itcast.bean.Person";
		Class clazz=Class.forName(className);
		System.out.println(clazz);
	}
	
	
	
	/*
	 *方式二
	 *2，任何数据类型都具备一个静态的属性。class来获取其对应的class对象 
	 * 相对简单，但还是要明确用到类中的静态成员
	 * 还是不够扩展
	 */
	private static void getClassObject_2() {
		
		Class clazz=Person.class;
		
		Class clazz1=Person.class;
		System.out.println(clazz==clazz1);
	}
	
	
	
	/*
	 * 获取字节码对象的方式：
	 * 方式一，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);
		
	}
}

获取字节码文件中的字段

import java.lang.reflect.Field;

public class ReflectDemo3 {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		getFiledDemo();
	}
	/*
	 * 获取字节码文件中的字段
	 */
	public static void getFiledDemo() throws Exception {
		// TODO Auto-generated method stub
		Class clazz=Class.forName("cn.itcast.bean.Person");
		
		Field field=null;//clazz.getField("age");  只能获取共有的
		
		field=clazz.getDeclaredField("age");
		
       //对私有字段的访问取消权限检查----暴力访问
		  field.setAccessible(true);
		Object obj=clazz.newInstance();
		
		field.set(obj,89);
		
		Object o=field.get(obj);
		//field=clazz.getDeclaredField("age");//只获取本类，但包含私有的
		
		System.out.println(o);
	}
	
}

获取Class中的方法

//获取Class中的方法
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

import cn.itcast.bean.Person;

public class ReflectDemo4 {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		getMdethodDemo3();
	}
	private static void getMdethodDemo3() throws Exception {
		// TODO Auto-generated method stub
		Class clazz=Class.forName("cn.itcast.bean.Person");
		Method method=clazz.getMethod("paramMrthod", String.class,int.class);
		
		Object obj=clazz.newInstance();
		
		method.invoke(obj, "小强",88);
	}
	
	private static void getMdethodDemo2() throws Exception {
		// TODO Auto-generated method stub
		Class clazz=Class.forName("cn.itcast.bean.Person");
		Method method=clazz.getMethod("show", null);//获取空参一般方法
		
		Constructor constructor=clazz.getConstructor(String.class,int.class);
		
		Object obj=constructor.newInstance("小明",33);
		method.invoke(obj, null);
		//Person p=new Person();
		//p.show();
	}
	/*
	 * 获取指定Class中的公共函数
	 */
	private static void getMdethodDemo() throws Exception {
		// TODO Auto-generated method stub
		Class clazz=Class.forName("cn.itcast.bean.Person");
		
		Method[] methods=clazz.getMethods();
		for(Method method:methods) {
			System.out.println(method);
		}
	}

}

练习主机运行

主程序

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 {
		// TODO Auto-generated method stub
		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();
	}

}

主板

package cn.itcast.reflect.test;

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();
		}
	}
}

PCI接口

package cn.itcast.reflect.test;

public interface PCI {
	
	public void open();
	public void close();

}

声卡

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");
	}
}

pci.properties  接口配置文件

pci1=cn.itcast.reflect.test.SoundCard

正则表达式

来操作字符串

    String qq="1234567";
    String regex="[1-9][0-9]{4,14}";  //正则表达式
    loolean b=qq.matches(regex);
    System.out.println("qq+":"+b);

通过一些特定的符号来实现的，所以我们为了掌握正则表达式，必须要学习一些符号

常见功能：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo {
	public static void main(String[] args) {
		
		/*
		 * 正则表达式对字符串的常见操作：
		 * 1，匹配
		 * 		其实使用的就是String类中的matches方法
		 * 2，切割
		 * 		其实使用的就是String类中的split方法
		 * 3，替换
		 * 
		 * 4，获取
		 * 
		 */
		functionDemo_4();
	}
	/*
	 * 获取
	 * 	将正则规则进行对象的封装
	 * Pattern p=Pattern.compile("a*b");
	 * 通过正则对象的matcher方法字符串相关联。获取要对字符串操作的匹配对象Matcher
	 * Matcher m=p.matcher("aaaaab");
	 *  //通过Matcher匹配器对象的方法对字符创进行操作
	 *  boolean b=m.matches();
	 */
	private static void functionDemo_4() {
		// TODO Auto-generated method stub
		String str="da jia hao ,ming tian bu fang jia!";
		
		String regex="[a-z]{3}";
		//1.将正则封装成对象
		Pattern p=Pattern.compile(regex);
		//2.通过正则对象获取匹配器对象
		Matcher m=p.matcher(str);
		//使用Matcher对象的方法对字符串进行操作
		//既然要获取三个字母组成的单词
		//查找 find();
		System.out.println(str);
		while(m.find()){
		System.out.println(m.group());//获取匹配的子序列
		
		System.out.println(m.start()+":"+m.end());
		}
	}
		
	/*
	 * 替换
	 */
	private static void functionDemo_3() {
		// TODO Auto-generated method stub
		String str="zhanganttttxiaoqiangmmmmzhaoliu";
	//	str=str.replaceAll("(.)\\1+", "#");  //  (.)\\1+ 叠词 替换
		str=str.replaceAll("(.)\\1+", "$1");  //  $获取前一个参数的第一组
		System.out.println(str);
	}

	/*
	 * 切割
	 */
	private static void functionDemo_2() {
		// TODO Auto-generated method stub
		String str="zhangsan    xiaoqiang     zhaoliu";
		String[] names=str.split(" +");//  +一个或者多个
		
		for(String name:names) {
			System.out.println(name);
		}
	}
	
	
	
	/*
	 * 演示匹配
	 */
	public static void functionDemo_1() {
		// TODO Auto-generated method stub
		//匹配手机号码是否正确
		String tel="15800001111";
		
		String regex="1[358][0-9]{9}";   //  "\\d"=\d=[0-9]
		boolean b=tel.matches(regex);
		System.out.println(tel+":"+b);
		
	}
}

练习（切割替换）

package cn.itcast.regex.test;

public class RegexTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 * 1,治疗口吃：我我我我.....我我要....要要要...要要学学....学学学编编编...编编编程
		 * 2,对IP地址排序
		 * 3，对邮件地址校验
		 */
		test_1();
	}

	private static void test_1() {
		// TODO Auto-generated method stub
		String str="我我我我.....我我要....要要要...要要学学....学学学编编编...编编编程";
		//1,将字符串中.去掉---替换
		str=str.replaceAll("\\.", "");
		System.out.println(str);
		//2,将叠词替换
		str=str.replaceAll("(.)\\1+", "$1");
		System.out.println(str);
	}
	

}