​JAVA的反射机制是指在运行状态中，对于任意一个类都能够知道这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意一个方法和属性。这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。反射是Java语言中非常重要机制，很多第三方框架都用到了反射，本小节将详细讲解反射机制的原理和作用。

(资料图片仅供参考)

19.3.1获得Class类对象

每个类被加载之后，虚拟机就会为该类生成一个对应的Class对象，通过该Class对象就可以访问到这个类。在Java程序中获得Class对象通常有如下三种方式：​

使用Class类的forName()静态方法。该方法需要传入字符串参数，该字符串参数的值是某个类的全限定类名，全限定类名包含完整的包名和类名。​调用某个类的class属性来获取该类对应的Class对象。例如，Person.class 将会返回Person类对应的Class对象。​调用某个对象的getClass()方法。该方法是Object 类中的一个方法，所以所有的Java对象都可以调用该方法，该方法将会返回该对象所属类对应的Class对象。​

第一种方式和第二种方式都是直接根据类来取得该类的Class对象。相比之下，第二种方式有如下两种优势。​

代码更安全。程序在编译阶段就可以检查需要访问的Class对象是否存在。​程序性能更好。因为这种方式无须调用方法，所以性能更好。​

也就是说，大部分时候都应该使用第二种方式来获取指定类的Class对象。但如果程序只能获得一个字符串，例如“java.lang.String”，如果需要根据字符串来获取对应的Class对象，则只能使用第一种方式，即使用Class的forName()静态方法获取Class对象，该方法可能抛出ClassNotFoundException异常。一旦获得了某个类所对应的Class对象之后，程序就可以调用Class对象的方法来获得该对象和该类的真实信息了。​

19.3.2从Class类对象中获取类的信息

Class类代表了一个类，而一个类的方法、属性以及所在的包也都可以用类来表示。表示普通方法的类是Method，表示构造方法的类是Constructor，表示属性的类是Field，而表示包的类是Package，只有了解了这些类的意义才能很好的学习Class类。​

Class类提供了大量方法来获取该Class对象所对应类的详细信息，这些方法中很多都包括多个重载的版本，由于重载版本众多，下面的表19-2对每个方法只列出一个版本，读者可以查阅API文档来查看每个方法的详情。​

表19-2 Class类的方法​

方法​	功能​
Connstructor getConstructor(Class... parameterTypes)​	返回此Class对象对应类的、带指定形参列表的public构造方法。​
Constructor[] getConstructors()​	返回此Class对象对应类的所有public构造方法​
Constructor getDeclaredConstructor(Class ... parameterTypes)​	返回此Class对象对应类的、带指定形参列表的构造方法，与构造方法的访问权限无关。​
Constructor[] getDeclaredConstructors()​	返回此Class对象对应类的所有构造方法，与构造方法的访问权限无关​
Method getMethod(String name, Class ... parameterTypes)​	返回此Class对象对应类的、带指定形参列表的public方法​
Method[] getMethods()​	返回此Class对象所表示的类的所有public方法​
Method getDeclaredMethod(String name, Class.. parameterTypes)​	返回此Class对象对应类的、带指定形参列表的方法，与方法的访问权限无关​
Method[] getDeclaredMethods()​	返回此Class对象对应类的全部方法，与方法的访问权限无关​
Field getField(String name)​	返回此Class对象对应类的、指定名称的public属性​
Field[]getFields()​	返回此Class对象对应类的所有public属性​
Field getDeclaredField(String name):​	返回此Class对象对应类的、指定名称的属性，与属性的访问权限无关​
Field[] getDeclaredFields():​	返回此Class对象对应类的全部属性，与属性的访问权限无关​
A getAnnotation(Class annotationClass);​	尝试获取该Class对象对应类上存在的、指定类型的注解，如果该类型的注解不存在，则返回null​
A getDeclaredAnnotation(Class annotationClass)​	该方法尝试获取直接修饰该Class对象对应类的、指定类型的注解，如果该类型的注解不存在，则返回null​
Annotation[] getAnnotations()​	返回修饰该Class对象对应类上存在的所有的注解​
Annotation[] getDeclaredAnnotations()​	返回直接修饰该Class对应类的所有注解​
A[] getAnnotationsByType(Class annotationClass)​	该方法的功能与getAnnotation()方法基本相似。但由于Java8增加了重复注解功能，因此需要使用该方法获取修饰该类的、指定类型的多个注解​
Class[] getDeclaredClasses()​	返回该Class对象对应类里包含的全部内部类​
Class getDeclaringClass()​	返回该Class对象对应类所在的外部类​
Class[] getlnterfaces()​	返回该Class对象对应类所实现的全部接口​
Class getSuperclass()​	返回该Class对象对应类的父类的Class对象​
int getModifiers()​	返回此类或接口的所有修饰符。修饰符由public、 protected、private、final、static、abstract 等对应的常量组成，返回的整数应使用Modifer工具类的方法来解码，才可以获取真实的修饰符​
Package getPackage()​	获取此类的包​
String getName()​	以字符串 形式返回此Class对象所表示的类的名称​
String getSimpleName()​	以字符串形式返回此Class对象所表示的类的简称，即不包含包名，只有类名​
boolean isAnnotation()。​ :​ 。​	返回此Class对象是否表示一个注解类型​
boolean isAnnotationPresent(Class annotationClass)​	判断此Class 对象是否使用了Annotation修饰​
boolean isAnonymousClass()​	返回此Class对象是否是一个匿 名类​
boolean isArray()​	返回此Class对象是否表示一个数组类​
boolean isEnum()​	返回此Class对象是否表示一个枚举​
boolean isInterface​	返回此Class对象是否表示一个接口​
boolean islnstance(Object obj)​	判断obj是否是此Class 对象的实例，该方法与​ instanceof操作符作用相同​

表19-2中，getMethod0方法和getConstructor()方法都需要传入多个类型为Class的参数，这些参数用于获取指定的方法或指定的构造方法。假设某个类内包含如下三个版本的info()方法：​

public void info()​public void info(String str)​public void info(String str , Integer num)​

这三个同名方法属于重载，它们的方法名相同，但参数列表不同。在Java语言中要确定一个方法​

光有方法名是不行的，如果仅仅只指定info()方法,实际上可以是上面三个方法中的任意一一个。如果需要确定一个方法，则应该由方法名和参数列表来确定，但参数名没有任何实际意义，所以只能由参数类型来确定。例如想指定第二个info()方法，则必须指定方法名为info,形参列表为String.class。因此在程序中获取第二个info()方法使用如下代码​

//前一个参数指定方法名，后面的个数可变的Class参数指定参数类型列表​clazz. getMethod("info"，String.class)​

如果需要获取第三个info()方法，则使用如下代码：​

//前一个参数指定方法名，后面的个数可变的Class参数指定形参类型列表​clazz . getMethod("info", String.class, Integer.class)​

获取构造方法时无须传入构造方法名称，因为同一个类的所有构造方法的名字都是相同的，所以要确定一个构造方法只要指定参数列表即可。下面的【例19_06】展示了如何通过Class类对象获得类的信息。​

【例19_06使用Class类对象获取类的信息】

Exam19_06.java​

import java.lang.annotation.*;import java.lang.reflect.*;import java.util.Arrays;//定义可重复注解@Repeatable (Annos.class)@interface Anno { }@Retention (value=RetentionPolicy.RUNTIME)@interface Annos {    Anno[] value();}//使用4个注解修饰该类@ SuppressWarnings (value="unchecked")@ Deprecated//使用重复注解修饰该类@Anno@Annoclass ClassTest{    //为该类定义一个私有的构造方法    private ClassTest (){    }    //定义一个有参数的构造方法    public ClassTest (String name){        System.out.println ("执行有参数的构造方法");    }    //定义一个无参数的info方法    public void info(){        System.out.println( "执行无参数的info方法");    }    //定义一个有参数的info方法    public void info(String str){        System.out.println("执行有参数的info方法" + "，其str参数值:"+ str);    }    //定义一个测试用的内部类    class Inner{}}public class Exam19_06 {    public static void main(String[] args) throws  Exception{        //下面代码可以获取ClassTest对应的Class        Class clazz = ClassTest.class;        //获取该Class对象所对应类的全部构造方法        Constructor[] ctors = clazz . getDeclaredConstructors ();        System.out.println ("ClassTest的全部构造方法如下: ");        for (Constructor c : ctors)            System.out.println(c);        //获取该Class对象所对应类的全部public构造方法        Constructor[] publicCtors = clazz. getConstructors();        System.out.println ("ClassTest的全部public构造方法如下: ");        for(Constructor c : publicCtors){            System.out.println(c);        }        //获取该Class对象所对应类的全部public方法        Method[] mtds = clazz .getMethods();        System.out.println ("ClassTest的全部public方法如下: ");        for (Method md : mtds ){            System.out.println (md);        }        //获取该Class对象所对应类的指定方法        System.out.println("ClassTest里带一个字符串参数的info方法为:"+clazz.getMethod("info",String.class));        //获取该Class对象所对应类的全部注解        Annotation[] anns = clazz.getAnnotations();        System.out.println ("ClassTest的全部Annotation如下: ");        for(Annotation an : anns){            System.out.println(an);        }        System.out.println ("该Class元素上的@SuppressWarnings注解为: "+ Arrays.toString(clazz.getAnnotationsByType(SuppressWarnings.class)));        System.out.println("该Class元素上的@Anno注解为: " + Arrays.toString (clazz.getAnnotationsByType(Anno.class)));        //获取该Class对象所对应类的全部内部类        Class[] inners = clazz.getDeclaredClasses();        System.out.println ("ClassTest的全部内部类如下: ");        for (Class c : inners){            System. out.println(c);        }        //使用Class. forName ()方法加载ClassTest的Inner内部类        Class inClazz = Class.forName ("ClassTest$Inner");        //通过getDeclaringClass ()访问该类所在的外部类        System.out.println ("inClazz对应类的外部类为: " +inClazz.getDeclaringClass());        System.out.println ("ClassTest的包为: " + clazz.getPackage());        System.out.println ("ClassTest的父类为: "+ clazz.getSuperclass());    }}

【例19_06】中Annotation表示注解，关于注解的知识将在19.4小节讲解。【例19_06】的运行结果如图19-6所示。​

图19-6【例19_06】运行结果​

从图19-6可以看出：getMethods()方法不仅仅能够获得这个类中定义的方法，还可以获得这个类从父类中继承过来的方法。需要注意：虽然定义ClassTest类时使用了@SuppressWarnings注解，但程序运行时无法分析出该类里包含的该注解，这是因为@SuppressWarmings使用了@Retention(value=SOURCE)修饰，这表明@SuppesWarnings只能保存在源代码级别上，而通过ClassTest.class获取该类的运行时Class对象，所以程序无法访问到@SuppressWarnings注解。​

19.3.3方法参数反射

Java 8在java.lang.reflect包下新增了一个Executable抽象类，这个类代表所有方法，它有两个子类，分别是代表构造方法的Constructor和代表普通方法的Method。Executable类提供了大量方法来获取修饰该方法的注解信息，还提供了isVarArgs()方法用于判断该方法是否包含数量可变的形式参数，以及通过getModifiers()方法来获取该方法的修饰符。除此之外，Executable提供了如表19-3所示的两个方法来获取该方法的参数个数及参数名称。​

表19-3 Executable类获取参数个数及参数名称的方法​

方法​	功能​
int getParameterCount()​	获取该方法的参数个数​
Parameter[] getParameters()​	获取该方法的所有参数​

表19-3中，Parameter类就表示方法的形式参数。Parameter也提供了大量方法来获取声明该参数的各项信息，如表19-4所示。​

表19-4 Parameter类的常用方法​

方法​	功能​
getModifiers()​	获取修饰该参数的修饰符​
String getName()​	获取参数名称​
Type getParameterizedType()​	获取带泛型的参数类型​
Class getType()​	获取参数类型​
boolean isNamePresent()​	判断该方法返回该类的class文件中是否包含了方法的参数名称信息。​
boolean isVarArgs()​	判断该参数是否为个数可变的形参​

需要指出：IDEA编译Java 源文件时，默认生成的class文件并不包含方法的参数名称信息，因此调用isNamePresent()方法将会返回false，调用getName0方法也不能得到该参数的形参名。如果希望编译Java源文件时可以保留参数名称信息，需要对IDEA进行编译参数的设置，具体步骤是：以打开“File”菜单，选择“Settings”菜单项，在弹出的对话框中按照“Build,Execution,Deployment”->“Compiler”->“Java Compiler”的顺序选择选项，并在“Additional command line parameters”后面填上“-parameters”，如图19-7所示。​

图19-7 设置编译参数​

下面的【例19_07】展示了方法参数反射实现过程。​

【例19_07方法参数反射】

Exam19_07.java​

import java.util.*;import java.lang.reflect.*;class ParameterTest {    public void rep(String str,List list){}}public class Exam19_07 {    public static void main(String[] args)throws Exception {        //获取String的类        Class clazz = ParameterTest.class;        //获取String类的带两个参数的replace()方法        Method rep = clazz.getMethod("rep", String.class, List.class);        //获取指定方法的参数个数        System.out.println("rep()方法参数个数: " + rep.getParameterCount ());        //获取replace的所有参数信息        Parameter[] parameters = rep.getParameters();        int index = 1;        //遍历所有参数        for (Parameter  p : parameters) {            if (p.isNamePresent()) {                System.out.println("---第" + index++ + "个参数信息---");                System.out.println("参数名: " + p.getName());                System.out.println("形参类型: " + p.getType());                System.out.println("泛型类型:" + p.getParameterizedType());            }        }    }}

如果希望能够正确运行【例19_07】，就必须对IDEA设置编译参数，设置完成后还需重新编译项目，具体做法是：打开“菜单”，单击“Rebuild Project”菜单项。完成这一步操作后，运行【例19_07】的结果如图19-8所示。​

图19-8【例19_07】运行结果​

19.3.4利用反射生成并操作对象

一个Class类对象就代表一个类，程序员不仅仅能够通过这个Class类对象获得对应类的信息，还能通过这个Class类对象创建出对应类的对象。这句话听起来有点绕口，它的意思是：如果一个Class类对象clazz代表A类，那么程序员能够通过clazz来创建出一个A类对象。19.3.3小节曾介绍过：Constructor类代表类的构造方法，而通过反射的方式来生成对象需要先使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建该Class对象对应类的对象。下面的【例19_08】展示了使用反射方式创建对象的过程。​

【例19_08 用反射技术创建对象1】

Exam19_08.java​

import java.util.*;class ObjectPoolFactory{    String[] classNames;//存放类名称的字符串数组    //定义一个Map类集合，Map的key是对象名，value是实际对象    Map objectPool = new HashMap() ;    //构造方法    public ObjectPoolFactory(String[] classNames){        this.classNames = classNames;    }    //createObject()方法根据String型参数clazzName生成Java对象    private Object createObject (String clazzName) throws Exception {        //根据字符串来获取对应的Class对象        Class clazz = Class.forName (clazzName) ;        //使用clazz对应类的默认构造器创建实例        return clazz. getConstructor().newInstance() ;    }    //initPool()方法根据一组类的名称生成相应的对象并存入objectPool    public Map initPool() throws Exception {        if(classNames!=null){            for (int i=0;i< classNames.length;i++){                Object o = createObject(classNames[i]);//根据类名创建对象                objectPool.put(classNames[i],o);//把类名和创建出的对象存入objectPool            }        }        return objectPool;    }}public class Exam19_08 {    public static void main(String[] args) throws Exception {        String[] className = {"java.text.SimpleDateFormat","java.util.Date"};        ObjectPoolFactory opf = new ObjectPoolFactory(className);        Map objectPool = opf.initPool();        for (int i=0;i< objectPool.size();i++){//循环取出objectPool中的对象            System.out.println(objectPool.get(className[i]));        }    }}

【例19_08】中定义了一个ObjectPoolFactory类，这个类的createObject()方法可以根据参数指定的类名称通过反射方式创建出该类的对象，而initPool()根据一组类的名称生成一组对象并存入Map集合中。main()方法创建了ObjectPoolFactory类对象并调用其initPool()方法生成一组对象并循环打印这些对象。【例19_08】的运行结果如图19-9所示。​

图19-9【例19_08】运行结果​

需要注意：利用反射方式生成的第二个对象是Date类对象，而Date类无参数构造方法所创建的对象表示当前时间，因此读者的运行结果中Date类对象的打印结果可能与图19-9不同。​

【例19_08】中调用的是类的无参数构造方法创建的对象，如果希望调用有参数的构造方法创建对象，则需要调用有参数的getConstructor()方法来获得Constructor对象。有参数的getConstructor()方法的参数类型是Class，这个参数表示对应类构造方法的参数，而获得的Constructor对象则是对应类的带参数构造方法。例如A类有一个带有参数的构造方法，这个构造方法的参数是String类型，那么通过Class类的有参数的getConstructor()就能获得这个有参数的构造方法，在调用getConstructor()时需要以String.class作为getConstructor()方法的参数。当获得了表示有参数构造方法的Constructor对象后，再调用其newInstance()方法就能以A类有参数的构造方法创建出一个A类对象，并且在调用newInstance()方法时需要向它传递相应的构造方法参数。下面的【例19_09】展示了如何用反射的方式调用到java.util.Date类的有long型参数的构造方法。​

【例19_09 用反射技术创建对象2】​

Exam19_09.java​

import java.lang.reflect.*;public class Exam19_09 {    public static void main(String[] args) throws Exception {        //获取到表示java.util.Date类的Class对象        Class clazz = java.util.Date.class;        //获取到java.util.Date类的以long为参数类型的构造方法        Constructor constructor = clazz.getConstructor(long.class);//①        //以long型参数的构造方法创建对象        Object o = constructor.newInstance(9876543210L);        System.out.println(o);    }}

【例19_09】中，语句①调用了有参数的getConstructor()方法来获得Date类有参数的构造方法，由于为getConstructor()方法传递的参数是“long.class”，因此获得的Constructor对象表示的是“Date(long date)”这个构造方法。同样，在调用Constructor对象的newInstance()方法时，也需要传递一个long型的参数，这相当于为“Date(long date)”这个构造方法传递了构造参数。此外还需强调，Java语言中，基础数据类型也可以通过“.class”来获得其对应类型的Class对象，并且“long.class”与“Long.class”所得到的Class对象并不是同一个对象。【例19_09】的运行结果如图19-10所示。​

图19-10【例19_09】运行结果​

通过反射的方式不仅能创建出一个类的对象，还能调用到一个类中的方法。如果想通过反射方式调用一个类的方法，先要调用Class的getMethods()方法或getMethod()方法来获取全部方法或指定方法,这两个方法的返回值是Method数组和Method对象。前文介绍过：每个Method对象对应一个方法，获得Method对象后，程序就可通过该Method来调用它对应的方法。调用的具体方式是：在程序中执行Method类的invoke()方法，需要指出：invoke()方法在执行时需要一个对象作为参数，执行invoke()方法就相当于调用了这个对象相应的方法。下面的【例19_10】展示了使用反射方式调用类方法的过程。​

【例19_10用反射技术调用类中的方法】

Exam19_10.java​

import java.lang.reflect.*;public class Exam19_10 {    public static void main(String[] args) throws Exception {        Class clazz = System.out.getClass();        //获取表示println()方法的Method对象        Method method = clazz.getMethod("println",String.class);        //通过invoke()方法执行System.out的println()方法        method.invoke(System.out,"这是通过反射方式打印的字符串");    }}

【例19_10】的语句①通过Method对象的invoke()方法调用了System.out的println()方法，而“这是通过反射方式打印的字符串”则是传递给println()方法的参数。【例19_10】的运行结果如图19-11所示。​

图19-11【例19_10】运行结果​

通过反射的方式还可以访问类的属性。程序员只需要通过Class类的getFields()或getField()方法可以获取该类所包括的全部属性或指定的属性。Java语言中，属性由Field类表示，Field类提供了一组getXxx()方法来获取对象的某个属性的值，而此处的Xxx对应8种基础数据类型，如果该属性的类型是引用类型，则取消get后面的Xxx。此外，Field类还提供了一组setXxx()方法为对象的属性设置成值，此处的Xxx也对应8种基础数据类型，同样如果该属性的类型是引用类型则取消set后面的Xxx。下面的【例19_11】演示了如何使用反射技术操作属性。​

【例19_11用反射技术访问属性】

Exam19_11.java​

import java.lang.reflect.*;class Person{    private String name;    private int age;    public String toString(){        return " Person[name:" + name +"age:"+age+"]";    }}public class Exam19_11 {    public static void main(String[] args) throws Exception{        //创建-一个Person对象        Person p = new  Person() ;        //获取Person类对应的Class对象        Class personClazz = Person.class;        //获取Person的名为name的属性        //使用getDeclaredField ()方法表明可获取各种访问控制符的属性        Field nameField = personClazz .getDeclaredField ("name") ;        //设置通过反射访问该属性时取消访问权限检查        nameField. setAccessible (true) ;        //调用set()方法为P对象的name属性设置值        nameField.set(p,"张三") ;        //获取Person类名为age的属性        Field ageField = personClazz . getDeclaredField("age") ;        //设置通过反射访问该属性时取消访问权限检查        ageField.setAccessible (true) ;        //调用setInt()方法为p对象的age属性设置值        ageField. setInt(p,20) ;        System. out.println(p) ;    }}

【例19_11】中定义了一个Person类，该类里包含两个private属性：name和age，在通常情况下，这两个属性只能在Person 类里访问。但main()方法中通过反射修改了Person对象的name、age两个属性的值。语句①使用getDeclaredField()方法获取了名为name 的属性，注意此处不是使用getField()方法，因为getField()方法只能获取public的属性,而getDeclaredField()方法则可以获取所有的属性。语句②是设置访问该属性时不受访问权限的控制，语句③修改了Person对象的name属性的值。修改Person对象的age属性值的方式与修改name属性的方式完全相同。【例19_11】的运行结果如图19-12所示。​

图19-12【例19_11】运行结果​

19.3.5利用反射操作数组

在Java语言中，数组也可以用反射的方式生成并进行操作。在java.lang.reflect包下提供了一个Array类，Array对象可以代表所有的数组。程序员可以通过使用Array类动态地创建数组，操作数组元素等。Array类所提供的操作数组常用方法如表19-5所示。​

表19-5 Array类操作数组的方法​

方法​	功能​
static Object newInstance(Class componentType, int... length)​	创建一个具有指定的元素类型、指定维度的新数组​
static xxx getXxx(Object array, int index)​	返回array 数组中第index个元素。其中xxx是各种基础数据类型，如果数组元素是引用类型，则该方法变为get(Object array, int index)​
static void setXxx(Object array, int index, xxx val)​	将array数组中第index 个元素的值设为val，其中xxx是各种基础数据类型，如果数组元素是引用类型，则该方法变成set(Object array, intindex, Object val)​

下面的【例19_12】展示了使用Array类创建并操作数组的过程。​

【例19_12 Array类操作数组1】

Exam19_12.java​

import java.lang.reflect.Array;public class Exam19_12 {    public static void main(String[] args) {        //创建 一个元素类型为String, 长度为10的数组        Object arr = Array.newInstance (String. class, 10);        //依次为arr数组中index为5、6的元素赋值        Array.set(arr,5,"《Java语言入门》");        Array.set(arr,6,"《数据库基础》");        //依次取出arr数组中index为5、6的元素的值        Object book1 = Array .get (arr,5);        Object book2 = Array.get (arr,6);        //输出arr数组中index为5、6的元素        System. out .println (book1) ;        System. out .println (book2) ;    }}

【例19_12】的运行结果如图19-13所示。​

图19-13【例19_12】运行结果​

【例19_12】创建并操作了一个一维数组，而Array实际上也能创建并操作多维数组，下面的【例19_13】展示了如何使用Array类创建并操作三维数组。在3.2小节曾经介绍过：多维数组实际上也是一维数组，例如三维数组可以看作是由多个二维数组组成的一维数组，因此可以用操作一维数组的方式来操作二维、三维或更高维度的数组。​

【例19_13 Array类操作数组2】​

Exam19_13.java​

import java.lang.reflect.Array;public class Exam19_13 {    public static void main(String[] args) {        //创建一个String型三维数组        Object arr = Array.newInstance (String.class, 3,4,10) ;        //获取arr数组中index为2的元素，该元素应该是二维数组        Object arrObj = Array .get(arr, 2);        //使用Array为二维数组的数组元素赋值，二维数组的数组元素是一维数组        //所以传入Array的set()方法的第三个参数是一 个一维数组        Array.set (arrObj,2,new String []{"《Java语言入门》", "《数据库基础》"}) ;        //获取arrObj数组中index为3的元素，该元素应该是一维数组        Object anArr = Array.get (arrObj, 3) ;        Array. set (anArr,8,"《Android开发教程》");        //将arr强制类型转换为三维数组        String[][] [] cast = (String[][][])arr;        //获取cast三维数组中指定元素的值        System.out.println(cast[2][3][8]) ;        System.out.println(cast[2][2][0]) ;        System.out.println(cast[2][2][1]) ;    }}

【例19_13】创建并操作了一个三维数组，操作的每一步都添加了详细的注释，读者可以根据注释理解每一步的操作意义。【例19_13】的运行结果如图19-14所示。​

图19-14【例19_13】运行结果​

本文字版教程还配有更详细的视频讲解，小伙伴们可以​​点击这里​​观看。