一分钟带你掌握数组

数组

数组就是存放相同数据类型的盒子

• 普通数组

声明

数据类型 [] 数组名 ；

类似于变量的声名

数组名要符合变量以及方法的命名规则及规范

初始化

动态初始化

先创建数组后赋值

格式：

创建：数据类型 [] 数组名 = new 数据类型[数组的长度]；

赋值：数组名[索引] = 具体的值

如果没有赋值会存储默认值（成员变量不赋值也会存在默认值）

静态初始化

创建的同时赋值

格式：数据类型 [] 数组名 = new 数据类型{值1，值2....}

二维数组

数组中嵌套数组

声明

数据类型 [][] 数组名；

初始化

• 动态初始化

数据类型[][] 数组名 = new 数据类型[外层的长度][内层的长度];

• 静态初始化

数据类型[][] 数组名 = new 数据类型[][]{{},{},{}...};

int [][] arr = new int [2][];
//内层数组的动态初始化
arr[0] = new int [2];
arr[0][0] = 1;
arr[0][1] = 2;
//内层数组的静态初始化
arr[1]=new double[]{1.1,1.2,1.3};

二维数组的遍历方式

普通for循环与增强for循环的组合

• 普通for与普通for

for(int i=0;i<arr.length;i++){
    for(int b=0;b<arr[i].length;b++){
        System.out.println(arr[i][b]);
    }
}

• 普通for与增强for

for(int i=0;i<arr.length;i++){
    for(int b:arr[i]){
        System.out.println(b);
    }
}

• 增强for与增强for

        for (int[] a:arr) {
            for(int i:a){
                System.out.println(i);
            }
        }

• 增强for与普通for

for(int[] a:arr){
    for(int b=0;b<a.length;b++){
        System.out.println(a[b]);
    }
}

可变参数

定义：多个参数的类型形同,参数的个数可变,0~n个参数

形式：...表示可变参数

特点：

• 方法的形参可以存在多个,如果存在可变参数,必须存在与参数列表的最后
• 编译器会为可变参数隐式构建一个数组,所在方法中使用可变参数,使用操作数组的方式操作可变参数

public class Class002_Param {
    public static void main(String[] args) {
        getSum(1,2,3,4,5,6,7,8);
    }

    public static void getSum(int a,int b,int... args){
        System.out.println(a);
        System.out.println(b);
        for(int i: args){
            System.out.println(i);
        }
        System.out.println(args[0]);
    }
}

内部类

类中定义类

• 成员内部类

当类位于外部类的成员位置时

特点：

1. 成员内部类中不能定义静态的内容，除了静态常量
2. 成员内部类可以使用外部类中的成员，包括私有的
3. 外部类可以通过内部类对象使用内部类成员，包括私有的
4. 成员内部类可以使用内部类中的变量与外部类中的成员变量
5. 成员内部类对象可以通过外部类构建

• 当在同一个包中：

外部类.内部类 引用 = new 外部类（）.内部类；

• 不在同一个包中：

import.包名.外部类.内部类

外部类.内部类 引用 = new 外部类（）.内部类；

• 私有内部类

被private修饰的内部类

特点：

1. 不能定义静态的内容，除了静态常量
2. 私有内部类中可以直接使用外部类的成员,包括 私有的
3. 在外部类中通过私有内部类的对象使用其成员,包括私有的
4. 私有内部类只能在所在的外部类中使用（类似与被private修饰的成员只能在本类中使用）

• 静态内部类

被static修饰的类

特点：

1. 静态内部类中可以定义非静态成员,可以定义静态成员
2. 静态内部类中可以使用外部类的成员,静态内容可以直接使用,成员内容需要通过外部类对象使用
3. 外部类中可以通过静态内部类类名使用其静态成员,需要通过静态内部类的对象使用内部类的成员
4. 其他类中使用静态内部类中的内容,需要根据外部类的类名找到静态内部类,根据静态内部类类名使用其静态内容,根据静态内部类对象使用其成员