java第23到25天----正则表达式，反射

最新推荐文章于 2024-04-19 17:40:24 发布

weixin_42478640

最新推荐文章于 2024-04-19 17:40:24 发布

阅读量194

点赞数

本文链接：https://blog.csdn.net/weixin_42478640/article/details/82943119

版权

知识总结

1.转换流的编码
2.流的编码
3.网络通信的三要素
4.TCP
5.UDP

正则表达式

1.匹配

使用的是String类中的boolean matches(String regex)方法
实例一：匹配手机号，
要求
- 1.全部是数字
- 2.是11位
- 3.第二位不能是1,2,6,9,0
- 4.第一位只能是1

public static void piPei() throws IOException {

		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
		String qq = bufferedReader.readLine();
		String regex = "1[34578]\\d{9}";
		
		System.out.println(qq.matches(regex));
		bufferedReader.close();

实例二：可以在b和k之间有零个或多个o

//		X? X，一次或一次也没有 
//		X* X，零次或多次 
//		X+ X，一次或多次 
//		X{n} X，恰好 n 次 
//		X{n,} X，至少 n 次
    public static void piPei() throws IOException {
        String s = "boooooooooooooook";
		String regex = "bo*k";

		System.out.println(s.matches(regex));

		
	}

2.切割

使用的是String类中的 String[] split(String regex)方法
依据正则表达式的字符串来切割

    public static void qieGe() {
//		String string = "dhkjar    djkhser,as leir     uyf,aseliru";
//		String regex = ",";
		//实例要求按照空格切割
//		String string = "dhkjar    djkhser,as leir     uyf,aseliru";
//		String regex = " +";
		
		//实例：
		String string = "dhkjar.djkhser.as.leir.uyf.aseliru";
		String regex = "\\.";//.代表任意字符
		
		String[] strs = string.split(regex);
		for (String string2 : strs) {
			System.out.println(string2);
		}
	}

3.替换

使用的是String类中的 String replaceAll(String regex, String replacement)
把字符串中符合正则表达式的内容替换成第二个参数的内容

    public static void tiHuan() {
		// 实例：将连续超过三个数字的部分替换成*******
		String string = "helloworld1d333333goodboy3644747bingbing7697823456chenchen54646564zhangsan888888list";
		String regex = "\\d{4,}";
		String str = string.replaceAll(regex, "*");
		System.out.println(str);
	}

4.获取

    public static void huoQu() {
		//	获取连续超过四个字母的字符串
		String string = "hellow                  orld1d333333goodboy3644                   747bingbing7697823456ch                   enchen546               46564zhangsan8                88888list";
		String regex = "[a-zA-Z]{4,}";
		
		//	将正则表达式进行了简单的转化，但是Pattern本身没有获取数据的能力
		Pattern pattern =Pattern.compile(regex);
		
		//	有获取数据的能力
		Matcher matcher =  pattern.matcher(string);
		
		//matcher.find();//判断是否有符合要求的内容
		//matcher.group();//获取数据
		while (matcher.find()) {
			System.out.println(matcher.group());
		}
		
	}

反射

反射：动态的获取类的字节码文件对象，对其成员进行抽象
想做的：就是通过字节码文件对象，直接创建普通的对象
1.获取字节码文件对象
2.获取对象
- a. 通过字节码文件对象，获取具体的实例对象
- b. 获取具体的构造方法（通过从构造方法中抽象出来的类Constructor）
3.获取具体的属性，并给属性赋值（通过从属性中抽象出来的类Field实现）
4.获取具体的方法，并调用方法（通过从方法中抽象出来的类Method实现）

后面用到的Person类代码

public class Person {
	private String name;

	@Override
	public String toString() {
		return "Person [name=" + name + "]";
	}

	public Person(String name) {
		super();
		this.name = name;
	}

	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	//非静态无参
	public void play() {
		System.out.println("play");
	}
	//非静态有参
	public void run(String number) {
		System.out.println("run"+number);
	}

	//静态有参
	public static void show(String number,int age) {
		System.out.println("show"+number+age);
	}
}

1.获取字节码文件对象

a:通过Object提供的getClass方法得到字节码文件对象
- 缺点，首先要有一个对象

    public static void fun1() {
		Person  person = new Person();
		Class class1 = person.getClass();
		System.out.println(class1);
		Person person2 = new Person();
		Class class2 = person.getClass();
		System.out.println(class1.equals(class2));
	}

b:每种数据类型都有一个class属性，通过它也可以获取当前类的字节码文件
- 缺点：首先要知道这个类的名字

	public static void fun2() {
		Class class1 = Person.class;
		System.out.println(class1);
	}

c:Class提供的方法forName（字符串）字符串的构成：包名+类名
- 优点：只需提供一个当前类的字符串形式

	public static void fun3() throws ClassNotFoundException {
		Class class1 = Class.forName("com.qianfeng.test.Person");
		System.out.println(class1);
	}

注意：字符串表示的类，在工作的时候，必须保证对应一个真正的类，否则报异常：ClassNotFoundException

2.获取对象

通过普通方式

Person person = new Person("bingbing");

通过反射
1.无参的构造方法

    public static void fun1(Class class1) throws InstantiationException, IllegalAccessException{
		//创建实例对象
		//相当于在newInstance方法的内部调用了无参的构造方法
		Object person = class1.newInstance();
		//向下转型
		Person person2 = (Person)person;
		person2.setName("bingbing");
		System.out.println(person2.getName());
	}

通过反射
2.有参的构造方法

	public static void fun2(Class class1) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		//这里的参数是实际的构造方法的参数的字节码文件
		Constructor constructor  = class1.getConstructor(String.class);
		Object person = constructor.newInstance("bingbing");//给定的实际参数
		System.out.println(person);
	}

3.获取具体的属性，并给属性赋值

通过普通的方式

	public static void main(String[] args) {
		// 通过普通的方式
//		Person person = new Person();
//		person.setName("bingbing");
//		System.out.println(person.name);

通过反射

    public static void     main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException,
			InstantiationException, IllegalAccessException {
		//1.获取字节码文件
		Class class1 = Class.forName("com.qianfeng.test.Person");
		//2.调出Field的方法得到对应的属性
		//参数就是那个实际的属性
		//注意：getField方法在获取属性的时候，必须保证属性存在，还要保证权限够大--public
		// Field field1 = class1.getField("name");

		//当属性是私有的，可以通过下面的设置，临时更改属性的权限,完成属性的获取
		Field field1 = class1.getDeclaredField("name");
		field1.setAccessible(true);
		// 3.给当前的属性指定一个具体的实例对象
		Person person1 = (Person)class1.newInstance();
		System.out.println(person1);
		//4.将filed1指定给person1
		//第一个参数是field对应的具体的实例对象 第二个参数是赋的具体的值
		field1.set(person1, "bingbing");
		System.out.println(field1.get(person1));
		System.out.println(person1.getName());
		
		//3.给当前的属性指定一个具体的实例对象
		Object person2 = class1.newInstance();
		//4.将filed1指定给person2
		//第一个参数是field对应的具体的实例对象 第二个参数是赋的具体的值
		field1.set(person2, "chenchen");
		System.out.println(field1.get(person2));
	}

4.获取具体的方法，并调用方法

调用普通的方法

		Person person = new Person();
		person.run("123");

使用反射

调用非静态的无参方法

	public static void fun1(Class class1) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		//第一个参数:对应的方法的具体名字   第二个参数:具体方法参数的字节码文件对象
		Method method = class1.getMethod("play");
		
		//创建实例对象
		Constructor constructor = class1.getConstructor(String.class);
		Object person = constructor.newInstance("bingbing");
		
		//调用方法
		//第一个参数:给当前方法指定的具体对象   第二个参数:方法的具体参数
		method.invoke(person);
	}

调用非静态的有参方法

	public static void fun2(Class class1) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		//第一个参数:对应的方法的具体名字   第二个参数:具体方法参数的字节码文件对象
		Method method = class1.getMethod("run",String.class);
		
		//创建实例对象
		Constructor constructor = class1.getConstructor(String.class);
		Object person = constructor.newInstance("bingbing");
		
		//调用方法
		//第一个参数:给当前方法指定的具体对象   第二个参数:方法的具体参数
		method.invoke(person,"123");
	}

调用静态的有参方法

	public static void fun3(Class class1) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		//第一个参数:对应的方法的具体名字   第二个参数:具体方法参数的字节码文件对象
		//注意:所有数据类型都有自己的字节码文件对象.
		Method method = class1.getMethod("show",String.class,int.class);
		//调用方法
		//第一个参数:给当前方法指定的具体对象   第二个参数:方法的具体参数
		method.invoke(null, "苹果",222);
	}

代理

作用：根据OCP（对扩展开发，对修改关闭）的原则，在不改变原来类的基础上，给这个类增加额外的功能

静态代理

作用：可以实现代理
缺点：代理对象要保证跟目标对象实现同样的接口，在维护的时候两个对象都要维护，而且代理对象实现的接口是死的，这是如果要给想实现不同功能的多个目标添加代理对象的话，要添加很多个类

public class Test {
	public static void main(String[] args) {
		Bingbing bingbing = new Bingbing();
		//bingbing.findHouse();
		
		Chenchen chenchen = new Chenchen();
		//chenchen.findHouse();
		
		Agent agent = new Agent(bingbing);
		agent.findHouse();
	}
}

interface TestInter {
	public void findHouse();
}

class Bingbing implements TestInter {

	@Override
	public void findHouse() {
		
		System.out.println("冰冰到西三旗找房");

	}
}

class Chenchen implements TestInter {

	@Override
	public void findHouse() {
		System.out.println("晨晨到宝盛里找房");

	}

}

//代理类
public class Agent implements TestInter{
	private TestInter persom;
	
	
	public Agent(TestInter persom) {
		super();
		this.persom = persom;
	}


	@Override
	public void findHouse() {
		// TODO Auto-generated method stub
		System.out.println("扣一半房租作为中介费");
		
		this.persom.findHouse();
		
		System.out.println("哈哈大笑");
	}
}

动态代理

动态代理
*要实现InvocationHandler接口
调用动态代理的方法实现功能
动态生成代理对象的方法–通过JDK内置的java.lang.reflect.Proxy动态代理类完成代理对象的创建
参数一：这里代表类加载器，代理类的类加载器要与目标类的类加载器一致，类加载器用来装载内存中的字节码文件
参数二：代理类的与目标类实现的接口必须相同，既指定给代理类的接口，目标类必须实现了
参数三：代理类的构造方法生成的对象–主意：指定给构造方法的参数要使用Object

下面要用到的类

interface TestInter {
	public void findHouse();
}

class Bingbing implements TestInter {

	@Override
	public void findHouse() {
		
	
		System.out.println("冰冰到宝盛里找房");

	}
}

通过新写一个具体类的方式完成动态代理

public class Test {
	public static void main(String[] args) {
		TestInter bingbing = new Bingbing();
		TestInter agent = (TestInter)Proxy.newProxyInstance(bingbing.getclass.getClassLoader(),new Class[] {TestInter.class},new Agent(bingbing));
		//代理对象调动方法的时候，invoke方法会自动被调用
		agent.findHouse();
	}
    
}
public class Agent implements InvocationHandler{
	private Object person;
	
	
	
	public Agent(Object person) {
		super();
		this.person = person;
	}



	@Override
	/**
	 * 接口中的方法
	 * 主要：这个方法在调用接口方法的时候，会自动调动
	 * 参数一：代理对象的引用
	 * 参数二：目标对象的方法
	 * 参数三：目标对象的参数
	 */
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("扣一半房租作为中介费");
		
		//通过反射的方法调用具体的对象的方法
		Object object = method.invoke(person, args);
		
		System.out.println("哈哈大笑");
		
		return object;
	}
	
}

通过匿名内部类的方式完成动态代理

public class Test {
	public static void main(String[] args) {
		TestInter bingbing = new Bingbing();
		TestInter agent = (TestInter)Proxy.newProxyInstance(bingbing.getClass().getClassLoader(), new Class[] {TestInter.class},new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				System.out.println("扣一半房租做中介费");
				// TODO Auto-generated method stub
				//通过反射的方法调用具体对象的方法
				Object object = method.invoke(bingbing, args);
				
				System.out.println("哈哈大笑");
				
				return object;
			}
		});
		agent.findHouse();
	}
}

weixin_42478640

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java第23到25天----正则表达式，反射

文章目录知识总结正则表达式1.匹配2.切割3.替换4.获取反射后面用到的Person类代码1.获取字节码文件对象2.获取对象3.获取具体的属性，并给属性赋值4.获取具体的方法，并调用方法调用非静态的无参方法调用非静态的有参方法调用静态的有参方法代理静态代理动态代理下面要用到的类通过新写一个具体类的方式完成动态代理通过匿名内部类的方式完成动态代理知识总结1.转换流的编码2.流的编码3.网络...
复制链接

扫一扫