Java中的反射和正则表达式

小灰灰 2023-10-12 18:27 34阅读 0赞

## 1.反射 ##

### 1.1 定义 ###

**官方定义：**在运行状态中，对于任何一个类，我们都能够知道这个类有哪些方法和属性。对于任何一个对象，我们都能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称之为反射机制。

关键词梳理：  
**1.动态获取**对象信息（成员变量，成员方法，构造方法）  
**2.调用**对象的属性和方法

IDEA中获取方法和属性的提示就是利用反射机制实现的

![7ece437ad26d43c1b26886ee2b8e1105.png][]

### 1.2 反射编程的核心思路 ###

步骤1：获取Class类型的字节码对象

步骤2：通过获取到的字节码对象，获取成员变量、成员方法、构造器

### 1.3 获得Class类型字节码对象的三种方式 ###

//方式1，用Class.forName()，使用最多
    Class c1 = Class.forName("test0620.Employee");
    System.out.println(c1);
    
    //方式2，调用类的class属性
    Class c2 = test0620.Employee.class;
    System.out.println(c2);
    
    //方式3，对象的getClass()方法
    Employee employee = new Employee();
    Class c3 = employee.getClass();
    System.out.println(c3);
    
    //判断三者是否为同一对象
    System.out.println(c1 == c2 && c2 == c3);

![bc5e1c3d184e48dfb89024e656602f6c.png][]

### 1.4 利用反射获取信息 ###

#### 1.4.1 获取构造方法 ####

//获取字节码对象
    Class c1 = Class.forName("test0620.Employee");
    
    //调用字节码对象的getConstructors()方法
    Constructor[] constructors =c1.getConstructors();
    
    //遍历构造器集合
    for (Constructor i:constructors) {
        System.out.println(i);
    }

![8b0b3a09e29f41ff96ada6c6105873d7.png][]

#### 1.4.2 获取成员变量 ####

所有成员变量

//调用字节码对象的getDeclaredFields()方法
    Field[] fields = c1.getDeclaredFields();
    
    for (Field i: fields) {
        System.out.println(i);
    }

![f95626f459b549a98067ccf8ca29d362.png][]

指定成员变量

//指定成员变量 getDeclaredField(str)方法
    Field field = c1.getDeclaredField("name");
    System.out.println(field);

![7e7743737a8a4dbebd80054dc697d175.png][]

#### 1.4.3 获取成员方法 ####

//调用字节码对象的getDeclaredMethods()方法
    Method[] methods = c1.getDeclaredMethods();
    for (Method i: methods) {
        System.out.println(i);
    }

![191d22d96c834a17a7b6f3200918f1d8.png][]

### 1.5 拓展实例1 ###

#### 1.5.1 创建配置文件db.properties ####

![657599a465d743bba98e655cefb202a5.png][]

#### 1.5.2 利用配置文件动态获取字节码对象 ####

//创建properties对象
    Properties properties = new Properties();
    //输入流获取文件
    FileInputStream fis = new FileInputStream("src/main/resources/db.properties");
    //数据加载
    properties.load(fis);
    //释放资源
    fis.close();
    //获取文件中的key【className】对应的value
    String key = properties.getProperty("className");
    //获取字节码对象
    Class aClass = Class.forName(key);
    System.out.println(aClass);

![54affd3d06f04db9880e63ce178c25cc.png][]

#### 1.5.3 生成实例 ####

//生成对象，newInstance()方法生成对象类为Object
    Object o = aClass.newInstance();
    
    //强转
    User user = (User)o;
    
    //调用user对象方法
    user.print();

![946ddc56a00d41f2b06f522e1e9bd9fc.png][]

### 1.6 拓展实例2 ###

#### 1.6.1 创建自定义类 ####

public class Mouse {
        private String name;
        private String bornAddress;
        private Integer height;
    
        public Mouse() {
        }
    
        public Mouse(String name, String bornAddress, Integer height) {
            this.name = name;
            this.bornAddress = bornAddress;
            this.height = height;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getBornAddress() {
            return bornAddress;
        }
    
        public void setBornAddress(String bornAddress) {
            this.bornAddress = bornAddress;
        }
    
        public Integer getHeight() {
            return height;
        }
    
        public void setHeight(Integer height) {
            this.height = height;
        }
    }

public class Cat {
        private String name;
        private String love;
        private String color;
        private String type;
        private Integer age;
    
        public Cat() {
        }
    
        public Cat(String name, String love, String color, String type, Integer age) {
            this.name = name;
            this.love = love;
            this.color = color;
            this.type = type;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getLove() {
            return love;
        }
    
        public void setLove(String love) {
            this.love = love;
        }
    
        public String getColor() {
            return color;
        }
    
        public void setColor(String color) {
            this.color = color;
        }
    
        public String getType() {
            return type;
        }
    
        public void setType(String type) {
            this.type = type;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    }

#### 1.6.2 测试类，编写获取属性方法 ####

public class Test {
        public static void save(Object o) throws IllegalAccessException {
            Class aClass = o.getClass();
            Field[] fields = aClass.getDeclaredFields();
            for (Field i:fields) {
                //设置可以利用封装获取对象private修饰的属性值
                i.setAccessible(true);
                //getName方法获得属性名
                System.out.println(i.getName());
                //getType方法获得类型
                System.out.println(i.getType());
                //get方法直接获得属性值
                System.out.println(i.get(o));
            }
        }
    }

1.6.3 调用方法

public static void main(String[] args) throws IllegalAccessException {
            Mouse mouse = new Mouse("杰瑞","加州",50);
            Cat cat = new Cat("汤姆","杰瑞","蓝色","加菲",51);
            save(mouse);
            save(cat);
        }

结果为

![84877a5aa0554802a970c8b34f7d3429.png][]

## 2.正则表达式 ##

### 2.1 正则概述 ###

又称规则表达式,（Regular Expression，在代码中常简写为regex、regexp或RE），是一种**文本模式**，包括**普通字符**（例如字母,数字）和**特殊字符**（称为"元字符"）。  
正则一般应用于校验文本格式，检索、替换那些符合某个模式的文本。  
Java中使用正则的方法放在java.lang.String类与java.util.regex.Pattern类中，其中String类中的正则方法的底层实现就是Pattern类中的方法。

### 2.2 正则的使用 ###

#### 2.2.1 matches()方法 ####

public static void main(String[] args) {
        String s1 = "abc";
        System.out.println("abc".matches("..."));// . 可以匹配任一字符//true
        System.out.println("abc".matches(".."));//长度不同时无法匹配//false
    }

#### 2.2.2 replaceAll()方法 ####

public static void main(String[] args) {
        System.out.println("a11054bc".replaceAll("\\d","-"));
    }

![b760fc7f369449be803ecf26a9f489b3.png][]

#### 2.2.3 ?\*+ 数量符 ####

![1720ba7e7c8f4c4abc358e306d5c6773.png][]

public class Demo4 {
        public static void main(String[] args) {
            //?一次或零次
            show("a".matches("a?"));//true
            show("".matches("a?"));//true
            //*零次或多次
            show("a".matches("a*"));//true
            show("".matches("a*"));//true
            show("aaaa".matches("a*"));//true
            //+一次或多次
            show("a".matches("a+"));//true
            show("".matches("a+"));//false
            show("aaaa".matches("a+"));//true
            
        }
    
        public static void show(Object o){
            System.out.println(o);
        }
    }

#### 2.2.4 \[\]符 ####

![31b28a1a61654b9c82f74b7b93ee4499.png][]

public class Demo5 {
        public static void main(String[] args) {
            //[abc] a或b
            show("a".matches("[ab]"));//true
            show("b".matches("[ab]"));//true
            show("c".matches("[ab]"));//false
            //[^ab] 任意字符，除了a和b
            show("a".matches("[^ab]"));//false
            show("b".matches("[^ab]"));//false
            show("c".matches("[^ab]"));//true
            //[a-pB-K] a到p或B到K
            show("a".matches("[a-pB-K]"));//true
            show("q".matches("[a-pB-K]"));//false
            show("A".matches("[a-pB-K]"));//false
            show("D".matches("[a-pB-K]"));//true
            //[a-x&&[^m-p]] a到x排除m到p
            show("m".matches("[a-x&&[^m-p]]"));//false
            show("x".matches("[a-x&&[^m-p]]"));//true
            show("y".matches("[a-x&&[^m-p]]"));//false
        }
    
        static void show(Object o){
            System.out.println(o);
        }
    }

#### 2.2.5 \{\}符 ####

public class Demo3 {
        public static void main(String[] args) {
            //complie中[]内表示单个字符的匹配集 如果在后面加上{}可以表示连续多少位的相同的匹配模式
            Pattern pattern1 = Pattern.compile("[a-z]{3}");//a-z的字母，长度为3
    
            String str1 = "fgh";//三个字母
            String str2 = "f2g";//包含了非字母
            String str3 = "fghs";//四个字母
            match(pattern1,str1);//true
            match(pattern1,str2);//false
            match(pattern1,str3);//false
    
            //{}内可以用逗号隔开表示一段范围
            Pattern pattern2 = Pattern.compile("[a-y]{3,9}");//a-y字母,长度为3-9
    
            String str4 = "azz";//包含字母z
            String str5 = "abcccc";//长度为6
            String str6 = "abccsddddd";//长度为10
            match(pattern2,str4);//false
            match(pattern2,str5);//true
            match(pattern2,str6);//false
    
            //多个匹配段
            Pattern pattern3 = Pattern.compile("[a]{2,5}[a-z]{1,4}");
            
            String str7 = "aab";
            String str8 = "aaa";
            match(pattern3,str7);//true
            match(pattern3,str8);//true
    
        }
        public static void match(Pattern p,String str){
            Matcher matcher = p.matcher(str);
            System.out.println(matcher.matches());
        }
    }

#### 2.2.6 预定义字符类 ####

![fd743b60797b42f6b5b608508911561b.png][]

public class Demo6 {
        public static void main(String[] args) {
            //以下均为true
            // . 匹配任意字符
            System.out.println("%".matches("."));
            // \d 匹配数字
            System.out.println("12".matches("\\d*"));
            // \D 匹配非数字
            System.out.println("ab1".matches("\\D*\\d?"));
            // \s 空白字符
            System.out.println("a b".matches("a\\sb"));
            // \S 非空白字符
            System.out.println("abc".matches("a\\Sc"));
            // \w 单词字符 a-zA-Z_0-9
            System.out.println("aA_9".matches("\\w*"));
            // \W 非单词字符
            System.out.println("%$#@".matches("\\W*"));
        }
    }

[7ece437ad26d43c1b26886ee2b8e1105.png]: https://img-blog.csdnimg.cn/7ece437ad26d43c1b26886ee2b8e1105.png
[bc5e1c3d184e48dfb89024e656602f6c.png]: https://img-blog.csdnimg.cn/bc5e1c3d184e48dfb89024e656602f6c.png
[8b0b3a09e29f41ff96ada6c6105873d7.png]: https://img-blog.csdnimg.cn/8b0b3a09e29f41ff96ada6c6105873d7.png
[f95626f459b549a98067ccf8ca29d362.png]: https://img-blog.csdnimg.cn/f95626f459b549a98067ccf8ca29d362.png
[7e7743737a8a4dbebd80054dc697d175.png]: https://img-blog.csdnimg.cn/7e7743737a8a4dbebd80054dc697d175.png
[191d22d96c834a17a7b6f3200918f1d8.png]: https://img-blog.csdnimg.cn/191d22d96c834a17a7b6f3200918f1d8.png
[657599a465d743bba98e655cefb202a5.png]: https://img-blog.csdnimg.cn/657599a465d743bba98e655cefb202a5.png
[54affd3d06f04db9880e63ce178c25cc.png]: https://img-blog.csdnimg.cn/54affd3d06f04db9880e63ce178c25cc.png
[946ddc56a00d41f2b06f522e1e9bd9fc.png]: https://img-blog.csdnimg.cn/946ddc56a00d41f2b06f522e1e9bd9fc.png
[84877a5aa0554802a970c8b34f7d3429.png]: https://img-blog.csdnimg.cn/84877a5aa0554802a970c8b34f7d3429.png
[b760fc7f369449be803ecf26a9f489b3.png]: https://img-blog.csdnimg.cn/b760fc7f369449be803ecf26a9f489b3.png
[1720ba7e7c8f4c4abc358e306d5c6773.png]: https://img-blog.csdnimg.cn/1720ba7e7c8f4c4abc358e306d5c6773.png
[31b28a1a61654b9c82f74b7b93ee4499.png]: https://img-blog.csdnimg.cn/31b28a1a61654b9c82f74b7b93ee4499.png
[fd743b60797b42f6b5b608508911561b.png]: https://img-blog.csdnimg.cn/fd743b60797b42f6b5b608508911561b.png