java基础-反射-day15

目录

• 1. 案例引入
• 2. Class 的理解
• 3. 反射的详细使用
• 4. Class 类都有哪些实例
• 5. 详细使用
• 6. 获取属性
• 7. 获取方法
• 8 获取类的 接口 注解 所在的包
• 9. 思考

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

都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

1. 案例引入

点外卖 有多种支付方式

微信支付 支付宝支付 。。。

接口

package com.msb.test01;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 20:46
 * @Description: com.msb.test01
 * @version: 1.0
 */
public interface Pay {
    void payOnline();
}

支付宝支付

package com.msb.test01;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 20:48
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class AliPay implements Pay {
    @Override
    public void payOnline() {
        System.out.println("Ali pay");
    }
}

微信支付

package com.msb.test01;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 20:47
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class WeChart implements Pay {
    @Override
    public void payOnline() {
        System.out.println("We Chart pay");
    }
}

银行卡支付

  package com.msb.test01;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 20:49
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class BankPay implements Pay {
    @Override
    public void payOnline() {
        System.out.println("bank card pay");
    }
}

实现支付的方式1

package com.msb.test01;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 20:50
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class Test01 {
    public static void main(String[] args) {
        String str = "wechart";
        if ("wechart".equals(str)){
            pay(new WeChart());
        }

    }
    public static void pay(WeChart wc){
        wc.payOnline();
    }

    public static void pay(AliPay ap){
        ap.payOnline();
    }

    public static void pay(BankPay bp){
        bp.payOnline();

    }
}

实现支付的方式2 多态

package com.msb.test01;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 20:50
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class Test02 {
    public static void main(String[] args) {
        String str = "wechart";
        if ("wechart".equals(str)){
            pay(new WeChart());
        }

    }
    public static void pay(Pay p){
        p.payOnline();
    }

}

实现支付的方式3 反射

package com.msb.test01;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 20:58
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class Test03 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        String str = "com.msb.test01.AliPay";
        Class clazz = Class.forName(str);
        Object o = clazz.newInstance();
        Method payOnline = clazz.getMethod("payOnline");
        payOnline.invoke(o);
    }
}

2. Class 的理解

Class 是对所有类的后抽象 所有的类 例如 Person Student 都只是Class 的一个实例而已

3. 反射的详细使用

获取 类的字节码

package com.msb.test01;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 21:30
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class Test04 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person p = new Person();
        Class c1 = p.getClass();
        System.out.println(c1);

        Class c2 = Person.class;
        System.out.println(c2);

        Class c3 = Class.forName("com.msb.test01.Person");
        System.out.println(c3); //最常用

        ClassLoader classLoader = Test04.class.getClassLoader();
        Class c4 = classLoader.loadClass("com.msb.test01.Person");
        System.out.println(c4);

        //字节码只加载一次 所以 都是同一个 字节码 c1 == c2

    }
}

4. Class 类都有哪些实例

Class类的具体的实例：

（1）类：外部类，内部类

（2）接口

（3）注解

（4）数组

（5）基本数据类型

（6）void

package com.msb.test01;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 21:36
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class Test05 {
    public static void main(String[] args) {

        Class c1 = Person.class;
        Class c2 = Comparable.class;
        Class c3 = Override.class;

        int[] arr1 = {1,2,3};
        Class c4 = arr1.getClass();

        Class c6 = int.class;
        Class c7 = void.class;
    }
}

5. 详细使用

注解

package com.msb.test01;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 21:41
 * @Description: com.msb.test01
 * @version: 1.0
 */
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnno {
    String value();
}

接口

package com.msb.test01;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 21:43
 * @Description: com.msb.test01
 * @version: 1.0
 */
public interface MyInterface {
    void myMethod();
}

父类

package com.msb.test01;

import java.io.Serializable;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 21:24
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class Person implements Serializable {
    private int age;
    public String name;

    public void eat(){
        System.out.println("eating");
    }

    public void sleep(){
        System.out.println("Sleeping");
    }
}

子类

package com.msb.test01;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 21:25
 * @Description: com.msb.test01
 * @version: 1.0
 */
@MyAnno(value="hello")
public class Student extends Person implements MyInterface {

    private int sno;
    double height;
    protected double weight;
    public double score;

    @MyAnno(value="himethod")
    public String ShowInfo(){
        return "我是 一名三好学生";
    }

    private void work(){
        System.out.println("Working");
    }

    public Student(){
        System.out.println("空参 构造器");
    }

    public Student(int sno){
        this.sno = sno;
    }

    public Student(int sno, double weight){
        this.sno = sno;
        this.weight = weight;

    }
    protected Student(int sno,double height,double weight){
        this.sno = sno;
    }

    @Override
    public void myMethod() {
        System.out.println("Student override myMethod!!!");
    }

    @Override
    public String toString() {
        return "Student{" +
                "sno=" + sno +
                ", height=" + height +
                ", weight=" + weight +
                ", score=" + score +
                '}';
    }
}

package com.msb.test01;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 21:49
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class Test06 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        Class cls = Student.class;

        // 构造器的获取
        Constructor[] constructors = cls.getConstructors();//只能获取当前运行时类的被public修饰的构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        Constructor constructor1 = cls.getConstructor();
        System.out.println(constructor1);//空参构造器

        Constructor constructor = cls.getDeclaredConstructor(double.class, double.class);
        System.out.println(constructor);//两个double参数的构造器

        Constructor declaredConstructor = cls.getDeclaredConstructor(int.class);
        System.out.println(declaredConstructor);//private修改的构造器

        Object o1 = constructor1.newInstance();
        System.out.println(o1);//创建对象

        Object o2 = constructor.newInstance(180.0, 170.1);
        System.out.println(o2);

    }
}

6. 获取属性

package com.msb.test01;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 22:01
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class Test07 {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InstantiationException {
        Class cls = Student.class;

        Field[] fields = cls.getFields();//获取运行时类和父类中被public修饰的属性
        for (Field field : fields) {
            System.out.println(field);
        }

        Field[] declaredFields = cls.getDeclaredFields();
        System.out.println(declaredFields);//获取运行时类中的所有属性

        Field score = cls.getDeclaredField("score");
        System.out.println(score);

        Field sno = cls.getDeclaredField("sno");
        System.out.println(sno);

        //修饰符 modifiers
        int modifiers = sno.getModifiers();
        System.out.println(modifiers);
        System.out.println(Modifier.toString(modifiers));

        //获取filed的数据类型
        Class type = sno.getType();
        System.out.println(type.getName());

        String name = sno.getName();
        System.out.println(name);

        Field score1 = cls.getField("score");
        Object o = cls.newInstance();
        score1.set(o, 98);
        System.out.println(o);

    }
}

7. 获取方法

package com.msb.test01;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 22:10
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class Test08 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {

        Class cls = Student.class;
        Method[] methods = cls.getMethods();//取运行时类的方法还有所有父类中的方法（被public修饰）
        for (Method method : methods) {
            System.out.println(method);
        }

        Method[] declaredMethods = cls.getDeclaredMethods();//获取运行时类中的所有方法
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }

        Method showInfo = cls.getMethod("ShowInfo");
        System.out.println(showInfo);

        Method work = cls.getDeclaredMethod("work", int.class);
        System.out.println(work);

        String name = work.getName();//方法的名字
        System.out.println(name);

        int modifiers = work.getModifiers();//方法的修饰符
        System.out.println(Modifier.toString(modifiers));

        Class<?> returnType = work.getReturnType();
        System.out.println(returnType);

        Class<?>[] parameterTypes = work.getParameterTypes();//方法的参数类型
        for (Class<?> parameterType : parameterTypes) {
            System.out.println(parameterType);
        }

        Object o = cls.newInstance();
        Method myMethod = cls.getMethod("myMethod");
        myMethod.invoke(o);

    }
}

8 获取类的 接口 注解 所在的包

  package com.msb.test01;

import java.lang.annotation.Annotation;

/**
 * @Auther: jack.chen
 * @Date: 2023/10/9 - 10 - 09 - 22:23
 * @Description: com.msb.test01
 * @version: 1.0
 */
public class Test09 {
    public static void main(String[] args) {
        Class cls = Student.class;

        Class[] interfaces = cls.getInterfaces();
        for (Class anInterface : interfaces) {
            System.out.println(anInterface);
        }

        Class superclass = cls.getSuperclass();
        System.out.println(superclass);

        Class[] interfaces1 = superclass.getInterfaces();
        for (Class c : interfaces1) {
            System.out.println(c);

        }

        Package aPackage = cls.getPackage();
        System.out.println(aPackage);
        System.out.println(aPackage.getName());

        Annotation[] annotations = cls.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

    }
}

9. 思考

反射是否破坏了 封装

private proteted属性方法外部还是能访问到