Java复习——反射

最新推荐文章于 2021-02-27 18:16:41 发布
最新推荐文章于 2021-02-27 18:16:41 发布
阅读量207 收藏
点赞数
分类专栏： Java Java复习 文章标签： Java基础 Java复习 Java反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wudongjiang333/article/details/83746529
版权

反射机制

什么是反射

一般而言，使用一个类，应该先知道这个类，而后通过这个类产生实例化对象，而“反”指的是通过对象找到类。

public class Temp {
    public static void main(String[] args){
        Person person = new Person(11);// 正着操作
        System.out.print(person.getClass().getName());// 反着操作，输出 包名.类名,getClass()是Object的方法(public final Class<?> getClass())，Class是发起一切发射操作的开端
    }
}

class Person {
    private int age;
    public Person(int age){
        this.age = age;
    }
    public void say(){
        System.out.print("age = "+age);
    }
}

获取Class的实例化对象（三种方式）

/**
 * 通过getClass()取得
 */
public class Temp {
    public static void main(String[] args){
        Person person = new Person(11);
        Class<? extends Person> cls = person.getClass();
        System.out.print(cls.getName());
    }
}

class Person {
    private int age;
    public Person(int age){
        this.age = age;
    }
    public void say(){
        System.out.print("age = "+age);
    }
}

/**
 * 通过类.class取得
 */
public class Temp {
    public static void main(String[] args){
        Class<? extends Person> cls = Person.class;
        System.out.print(cls.getName());
    }
}

class Person {
    private int age;
    public Person(int age){
        this.age = age;
    }
    public void say(){
        System.out.print("age = "+age);
    }
}

/**
 * 通过Class的静态方法取得（主要使用）
 */
public class Temp {
    public static void main(String[] args){
        try {
            Class<?> aClass = Class.forName("com.xxx.xxx.Person");
            System.out.print(aClass.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class Person {
    private int age;
    public Person(int age){
        this.age = age;
    }
    public void say(){
        System.out.print("age = "+age);
    }
}

每种类型的Class对象只有1个 = 地址只有1个

// 对于2个String类型对象，它们的Class对象相同
Class c1 = "xxx".getClass();
Class c2 =  Class.forName("java.lang.String");
// 用==运算符实现两个类对象地址的比较
System.out.println(c1 ==c2);
// 输出结果：true

通过反射实例化一个对象

/**
 * 通过Class的静态方法取得（主要使用）
 */
public class Temp {
    public static void main(String[] args){
        try {
            Class<?> aClass = Class.forName("com.xxx.xxx.Person");// 需无参构造
            Object obj = aClass.newInstance(); // 通过该方法实例化一个对象
            Person person = (Person) obj;
            System.out.print(person);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Person {
    private int age;
    public Person(){// 保证有个无参构造
        this.age = 88;
    }
    public Person(int age){
        this.age = age;
    }
    public void say(){
        System.out.print("age = "+age);
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
}

作用

程序开发中，一直强调减少耦合，最好的做法是使用接口，但是就算使用了接口，也逃不出关键字new，所以new才是造成耦合的关键。

工厂设计模式：

public class Temp {
    public static void main(String[] args){
        Fruit fruit = Factory.getInstance("Apple");
        fruit.eat();
    }
}

interface Fruit{
    void eat();
}

class Apple implements Fruit {

    @Override
    public void eat() {
        System.out.println("eat Apple");
    }
}

class Factory{
    public static Fruit getInstance(String fruitName){
        Fruit fruit = null;
        switch (fruitName) {
            case "Apple":
                fruit = new Apple();
                break;
                default:
                    break;
        }
        return fruit;
    }
}

通过反射实现工厂设计模式：

public class Temp {
    public static void main(String[] args) {
        Fruit fruit = Factory.getInstance("com.xxx.xxx.Apple");
        fruit.eat();
    }
}

interface Fruit {
    void eat();
}

class Apple implements Fruit {

    @Override
    public void eat() {
        System.out.println("eat Apple");
    }
}

class Factory {
    public static Fruit getInstance(String fruitName) {
        Fruit fruit = null;
        switch (fruitName) {
            case "com.xxx.xxx.Apple":
                try {
                    Class<?> cls = Class.forName("com.xxx.xxx.Apple");
                    fruit = (Fruit) cls.newInstance();
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                break;
            default:
                break;
        }
        return fruit;
    }
}

反射的深入应用

对于实例化对象而言，需要调用类中的构造方法、普通方法、属性。这些操作都可以通过反射完成。

调用构造

在Class类中已定义：

getDeclaredConstructor()与getConstructor的区别：

首先看getDeclaredConstructor(Class<?>… parameterTypes)
这个方法会返回制定参数类型的所有构造器，包括public的和非public的，当然也包括private的。
getDeclaredConstructors()的返回结果就没有参数类型的过滤了。

再来看getConstructor(Class<?>… parameterTypes)
这个方法返回的是上面那个方法返回结果的子集，只返回制定参数类型访问权限是public的构造器。
getConstructors()的返回结果同样也没有参数类型的过滤

import java.lang.reflect.Constructor;

public class Temp {
    public static void main(String[] args){
        try {
            Class<?> cls = Class.forName("com.xxx.xxx.Person");
            Constructor<?>[] constructors = cls.getConstructors();// 取得该类的全部构造
            for (int i = 0;i < constructors.length;i++){
                System.out.println("constructors:"+constructors[i]);
            }


        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class Person{
    private String name;
    private int age;
    public Person(){}
    public Person(String name){}
    public Person(String name,int age){}

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

结果：

constructors:public com.xxx.Person(java.lang.String,int)

constructors:public com.xxx.Person(java.lang.String)

constructors:public com.xxx.Person()

import java.lang.reflect.Constructor;

public class Temp {
    public static void main(String[] args) {
        try {
            Class<?> cls = Class.forName("com.xxx.xxx.Person");
            Constructor<?> constructor = cls.getConstructor(String.class, int.class);
            Object tom = constructor.newInstance("tom", 11);//相当于类中，调用了含两个参数的构造方法
            System.out.print("tom = "+tom.toString());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

tom = Person{name=‘tom’, age=11}

普通方法

在Class类中已定义：

getDeclaredMethod和getMethod的区别:

getDeclaredMethod：获取当前类的所有声明的方法，包括public、protected和private修饰的方法。需要注意的是，这些方法一定是在当前类中声明的，从父类中继承的不算，实现接口的方法由于有声明所以包括在内。

getMethod：获取当前类和父类的所有public的方法。这里的父类，指的是继承层次中的所有父类。比如说，A继承B，B继承C，那么B和C都属于A的父类。

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Temp {
    public static void main(String[] args) {
        try {
            Class<?> cls = Class.forName("com.xxx.Person");
            Method[] methods = cls.getMethods();// 取得所有方法
            for (int i = 0;i < methods.length;i++){
                System.out.println("Methods :"+methods[i]);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

得到Method类对象的最大作用不在于将类中的所有方法全部列出，而是取得了Method类对象后，可以直接利用反射调用类中的方法：

public native Object invoke(Object obj, Object... args)throws IllegalAccessException,IllegalArgumentException,InvocationTargetException;

实例：

import java.lang.reflect.Method;

public class Temp {
    public static void main(String[] args) {
        try {
            Class<?> cls = Class.forName("com.xxx.Person");
            Object obj = cls.newInstance();// 实例化对象
            Method setName = cls.getMethod("setName", String.class);
            setName.invoke(obj,"tom");// 相当于调用Person实例.setName("tom");
            Method getName = cls.getMethod("getName");
            System.out.print(getName.invoke(obj));// 相当于调用Person实例.getName();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

调用成员

在Class类中已定义：

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Temp {
    public static void main(String[] args) {
        try {
            Class<?> cls = Person.class;
            Field[] fields = cls.getDeclaredFields();
            for (int i = 0;i < fields.length;i++){
                System.out.println("fields ："+fields[i]);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

getDeclaredField和getField的区别:

getDeclaredField() 是可以获取一个类本身的所有字段.

getField() 只能获取类及其父类的public 字段.

如果要调用Filed类中的set()跟get()方法，首先必须调用setAccessible()，让属性对外可见（取消封装）：

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Temp {
    public static void main(String[] args) {
        try {
            Class<?> cls = Person.class;
            Person obj = (Person) cls.newInstance();// 实例化一个Person对象
            Field name = cls.getDeclaredField("name");
            name.setAccessible(true);// 接触name属性的封装
            name.set(obj,"james");// 相当于对象.属性 = 内容
            System.out.println(name.get(obj));// 相当于对象.属性
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
_Anonymous_.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java期末复习——枚举与反射机制
08-07
Java——枚举： enum关键字、Enum类 类集对枚举的支持——EnumMap类与EnumSet类 枚举类实现接口、在枚举类中定义抽象方法 Java反射机制： Class类、Class类的使用 反射的应用：取得类的结构
算法模板（Java版）——leetcode刷题与复习指南.zip
最新发布
03-14
动态性：Java可以通过反射、注解等机制实现在运行时动态加载类和修改行为，增加了程序的灵活性。 综上所述，Java凭借其强大的特性和广泛的适用范围，在企业级应用、互联网服务、移动开发等领域均扮演着举足轻重的...
Day73.反射复习 -Java反射
阿昌爱Java
10-16 258
Java反射复习 反射的概述 1.本章的主要内容 2.关于反射的理解 Reflection（反射）是被视为***动态语言***的关键，反射机制允许程序在执行期 借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。 框架: 反射 + 注解 + 设计模式 3.体会反射机制的"动态性" //体会反射的动态性 @Test public void test2() { for (int i = 0;i < 100; i++) { int nu
java 反射机制复习
梦境迷离
04-14 194
Person p=new Person();这是什么?当然是实例化一个对象了.可是这种实例化对象的方法存在一个问题,那就是必须要知道类名才可以实例化它的对象,这样我们在应用方面就会受到限制.那么有没有这样一种方式,让我们不知道这个类的类名就可以实例化它的对象呢?Thank Goodness!幸亏我们用的是java, java就提供了这样的机制.1).java程序在运行时可以获得任何一个类的字节码信...
Java反射复习
CatAndBeer的博客
06-24 129
粗略的使用 import com.po.User; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; public class ReflectionStudyTest { public static void main(String[] args) throws Exception { /* 1.源代
java复习之反射
810cheng
01-12 205
参考文档：https://www.jianshu.com/p/9be58ee20dee；https://www.jianshu.com/p/1fc45c89e76b 反射用途：在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。运行期间我们不知道类对象，并无法通过new关键...
超详细的Java复习知识点2019——个人笔记.zip
06-24
这份名为"超详细的Java复习知识点2019——个人笔记"的文档，旨在为初学者提供一个全面且深入理解Java基础知识的指南。笔记内容可能涵盖了以下几个关键领域： 1. **Java语法基础**：包括变量、数据类型、运算符、...
JAVA复习ppt
12-14
这个“JAVA复习ppt”很可能是华南理工大学为了帮助学生系统复习Java编程知识而制作的教学材料。Java的特点包括跨平台性、简单性、面向对象、健壮性和安全性，这些特性使得它成为开发桌面应用、企业级应用、移动应用...
硅谷java基础每日复习eDiary
07-11
以下是基于描述中提到的两个文件——"Java基础每日复习笔记-JavaSE基础阶段.edf"和"Java基础每日复习笔记-JavaSE高级阶段.edf"——所包含的知识点的详细阐述： 1. **Java SE基础阶段**： - **Java简介**：了解Java...
复习java反射
CatAndBeer的博客
06-24 103
粗略的使用 import com.po.User; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; public class ReflectionStudyTest { public static void main(String[] args) throws Exception { /* 1.源代
java反射知识复习
superme5200000的博客
05-13 177
什么是反射机制 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 反射机制的作用 在运行时判断任意一个对象所属的类； 在运行时构造任意一个类的对象； 在运行时判断任意一个类所具有的成员变量和方法； 在运行时调用任意一个对象的方法； 反射机制的相关类 Class类：代表一个类，位于java.lang包下 Field类：代表类的成员变量（成员变量也称为类
Java复习-反射
xubensheng1502SDUT的博客
12-20 190
1.如何获取.Class文件对象 1, 通过Object类 getClass()方法获取 Class对象 2, 通过类名.class 方式 获取 Class对象 3, 通过反射的方式, Class.forName(String classname) 获取Class对象 public static Class&lt;?&gt; forName(String className)throws ...
Java反射复习整理
微风轻拂
07-31 704
最开始学习反射的时候接触到了Class字节码的概念，这和源代码直接编译成二进制机器码的C/C++很不相同。有一些惊讶，增加字节码这一层次后，除了跨平台这个最重要功用外，Class字节码还能够被搭积木装配，由此延伸出反射、bean、内省、注解等等操作，而JavaEE框架也几乎主要建立在这个搭积木装配基础之上。我估计Java语言最初的设计者没有料到这后面的发展吧。 编译和执行过程是：源代码定义的
java基础复习-----反射
Ahora的博客
02-27 736
什么是反射   反射机制是指程序在运行过程中，对任意一个类都能获取其所有的属性和方法，并且对任意一个对象都能调用其所有的属性和方法。这种动态获取类和对象的信息，以及动态调用对象的方法的功能被称为java语言的反射机制。 java反射常用API Class类：用于获取类的属性、方法、构造器等信息。 获得类相关的方法 方法 说明 forName(String className) 根据类名返回类的class对象 getName() 获取类的完成路径名 getPackage() 获取类
java再复习——通过反射使用类的属性，方法和构造器
Ade-rui的博客
02-28 424
知道了如何获取到类的属性，方法和构造器，那么就应该开始使用了。 public class ReflectDemo { public static void main(String[] args) throws Exception{ //加载类 Class clazz = Student.class; //取得无参构造函数 Constructor declaredConstru
Java4Android笔记之Java中的面向对象基础(三)
wudongjiang333的博客
10-22 597
对象的使用方法使用对象调用变量和函数： 1. 对象.变量 2. 对象.函数()多对象的创建方法 只要是生成对象，就会使用到new这个关键字，相应的会在堆内存在开辟一块空间放置生成的对象匿名对象的创建和使用方法可以不定义对象的引用名称，而直接调用这个对象的方法。这样的对象就叫做匿名对象，如：new Dog().jump(); 注意：以下代码为两个不同的对象，因为在堆内存中开辟了两块内存空间new
Java4Android笔记之Java中的抽象类和抽象函数
wudongjiang333的博客
11-19 561
本文通过代码实例介绍了抽象函数的语法特征与语法，抽象类的语法特征与语法，还有抽象类的优点
Java4Android笔记之Java简介与入门
wudongjiang333的博客
10-09 554
Java的诞生上世界九十年代初，Java的前身出现，名为Oak；1994年，被命名为Java。1995年，Sun正式对外界公开Java，并发布JDK1.0;1998年，正式被更名为Java2。为Java4Android的笔记，介绍Java的历史与一些基础概念，android入门教程

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值