对于数组的一点理解

一：

声明一个数组:int [] arr  = new int[10];

 

二：

利用java的反射来获取一些java类的信息

package com.cn.am;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Test1 {
    public static void showModifier(int modifiers){
        //权限
        if(Modifier.isPublic(modifiers)){
            System.out.println("public");
        } else if (Modifier.isProtected(modifiers)) {
            System.out.print("protected ");
        } else if (Modifier.isPrivate(modifiers)) {
            System.out.print("private ");
        } else {
            System.out.print("");
        }
        if (Modifier.isFinal(modifiers)) {
            System.out.print(" final ");
        }
        if (Modifier.isAbstract(modifiers) && !Modifier.isInterface(modifiers)) {
            System.out.print(" abstract ");
        }
        if (Modifier.isInterface(modifiers)) {
            System.out.print(" interface ");
        } else {
            System.out.print(" class ");
        }
        System.out.println("");
    }
    
    public static void main(String[] args) {
        Class clazz=int[].class;
        // 获取父类
        Class<?> superclass = clazz.getSuperclass();// class java.lang.Object
        System.out.println("superclass:" + superclass);
        // 获取类所在的包名
        Package packageName = clazz.getPackage();// null
        System.out.println("Package:" + packageName);
        // 获取类的注解
        Annotation[] declaredAnnotations = clazz.getDeclaredAnnotations();
        if (null != declaredAnnotations && declaredAnnotations.length > 0) {
            for (Annotation ann : declaredAnnotations) {
                System.out.println(ann);
            }
        }
        // 获取类的修饰符
        int modifiers = clazz.getModifiers();
        System.out.print("modifier: ");
        showModifier(modifiers);
        // 获取类的名称
        String name = clazz.getName();// [I
        System.out.println("className:" + name);
        // 获取类的接口
        Class<?>[] interfaces = clazz.getInterfaces();
        if (null != interfaces && interfaces.length > 0) {
            for (Class<?> cl : interfaces) {
                System.out.println(cl);
            }
        }
        // 获取类构造器
        Constructor<?>[] constructors = clazz.getConstructors();// []
        if (null != interfaces && interfaces.length > 0) {
            for (Constructor<?> con : constructors) {
                System.out.println(con);
            }
        }
        // 获取类成员变量
        Field[] declaredFields = clazz.getDeclaredFields();// []
        if (null != declaredFields && declaredFields.length > 0) {
            for (Field field : declaredFields) {
                System.out.println(field);
            }
        }
        // 获取类成员方法
        Method[] declaredMethods = clazz.getDeclaredMethods();// []
        if (null != declaredMethods && declaredMethods.length > 0) {
            for (Method method : declaredMethods) {
                System.out.println(method);
            }
        }
    }
}

console:

superclass:class java.lang.Object
Package:null
modifier: public
 final  abstract  class 
className:[I
interface java.lang.Cloneable
interface java.io.Serializable

由此可以发现

1.数组没有成员变量、成员方法，只有默认构造函数，此外，它实现了 Cloneable和Serializable 两个接口，可以说它就是一个的空类。

2.它的类名也比较特殊：

    对基础类型而言为：[+类型名称的首字母大写
    对引用类型而言为：[L+类的全名称+;     eg [Ljava.lang.String;

3.对于1维数组而言有一个"["，n维数组而言有n个"[",java数组最多有255维度

 

三：数组的length属性

public class ArrayLengthDemo {
    public static void main(String args[]) {
        int[] arr = new int[1];
        System.out.println(arr.length);
    }
}

反编译一下 javap -c ArrayLengthDemo.class

我们可以看到 main方法中序号为8处有一个arraylength指令，由此可见Java专门为数组定义了取得长度的指令，数组的length不是数组的成员变量，数组的实例是java虚拟机动态创建动态加载的。