【Java数组-一维数组15】

一、什么是数组？

数组是一种引用数据类型，数组的父类是java.lang.Object

二、数组的作用：

数组是一种简单的线性数据结构，数组可以存储其他数据，可以看做一种简单的容器

三、数组的分类

一维数组，二维数组，三维数组

四、数组中存储的数据类型是统一的。比如：int类型的数组只能存储int类型数据，Object类型的数组只能存储object的数据。

五、如何定义数组类型：

语法：数据类型[]

例如：int[]  int类型的数组只能存储int类型的数据

booblean[] boolean类型的数组每个元素都是booblean类型

String[]   String类型的数组，每个元素都是String类型

六、如果在创建数组的时候，无法预知该数组存储什么类型的数据，可以使用动态话初始方法，预先分配内存地址

|--  动态初始化

|-- 数组的长度不可改变

|-- 预先在堆区中开辟空间，有默认值

byte,short,int.long  0

float,double  0.0

booblean  false

char u0000

引用 null

动态初始化和静态初始化在内存分布上没有区别

动态数组的声明方式：

一、基本类型的一维数组声明

package com.JavaStudy.studyArray0601;

/**
 * @Author wufq
 * @Date 2020/6/1 11:35
 *
 */
public class ArrayTest01 {
    public static void main(String[] args){

        //int类型的数组，长度为5
        //不知道数组的具体内容，但是知道数组的长度
        //动态数组的声明
        int[] data = new int[5];

        //默认的数组内容---->默认值都是0
        System.out.println(data[0]);
        System.out.println(data[1]);
        System.out.println(data[2]);
        System.out.println(data[3]);
        System.out.println(data[4]);

        System.out.println("-----------------");
        //修改数组的内容
        data[0]=1;
        data[1]=2;
        data[2]=3;
        data[3]=4;
        data[4]=5;

        //输出修改后的数组内容，两种方式
        System.out.println(data[0]);
        System.out.println(data[1]);
        System.out.println(data[2]);
        System.out.println(data[3]);
        System.out.println(data[4]);

        System.out.println("-----------------");
        //遍历数组中的元素，采用length属性可以获取数组的长度
        for(int i=0;i<data.length;i++){
            System.out.println(data[i]);
        }

        System.out.println("-----------------");
        //输出指定的数组元素
        System.out.println(data[3]);

        //获取首元素
        System.out.println(data[0]);

        //获取末尾元素
        System.out.println(data[4]);
        System.out.println(data[data.length-1]);

        //不能赋值成功
//        data[0] = "iii";

    }
}

 2、引用类型的一维数组

一维数组中如果存储的每个元素都是引用数据类型

引用类型的数组中每一个元素其实不是存储对象，而是该对象的内存地址

如果在创建数组的时候，无法预知该数组中将来存储什么元素，可以使用动态初始化方式，预先分配内容

package com.JavaStudy.studyArray0601;

/**
 * @Author wufq
 * @Date 2020/6/1 14:54
 * 引用类型的一维数组的声明
 */
public class ArrayTest02 {
    public static void main(String[] args){
        Object[] Obj = new Object[2];

        //遍历数组中的元素，2个元素的默认值都为null
        for(int i=0;i<Obj.length;i++){
            System.out.println(Obj[i]);
        }

        System.out.println("-------------------");
        Students[] stu1 = new Students[3];
        for(int i=0;i<stu1.length;i++){
            System.out.println(stu1[i]);
        }

//        //出现空指针
//        //因为引用类型的数组，它采用null作为默认的初始化值，必须初始化数组元素为对象，才能进行赋值
//        stu1[0].id = 1001;
//        stu1[0].name = "张三";
//
//        stu1[1].id = 1002;
//        stu1[1].name = "李四";


        System.out.println("---------赋值的第一种方式----------");
        Students[] stu2 = new Students[2];//数组的长度结合实际的内容来定义，比如Students类只有两个变量，
                                            // 那么长度为2，如果设置成3的话，在遍历数组长度的时候，没有发现给第三个元素赋值就会报空指针的错误
        //初始化数组元素为Students对象
        stu2[0] = new Students();
        stu2[0].id = 1003;
        stu2[0].name = "苗苗";

        stu2[1] = new Students();
        stu2[1].id = 1004;
        stu2[1].name = "凯凯";

        for(int i=0;i<stu2.length;i++){
            System.out.println("id="+stu2[i].id+" name="+stu2[i].name);
        }

        System.out.println("---------赋值的第二种方式----------");
        Students s1 = new Students();
        s1.id = 1005;
        s1.name="花花";
        stu2[0]=s1;

        Students s2 = new Students();
        s2.id = 1006;
        s2.name = "成成";
        stu2[1] = s2;

        for(int i=0;i<stu2.length;i++){
            System.out.println("id++ "+stu2[i].id+" name++ "+stu2[i].name);
        }

    }

}

class Students{
    int id;
    String name;
}

3、基本类型的一维数组和引用类型的一维数组在堆栈内占用区别图

基本类型的一维数组内存分布图

 引用类型的一维数组的内存分布图

两者的区别：

1、基本数据类型的数组可以直接赋值

2、引用类型的数组必须通过初始化数组元素为对象才可进行赋值

Students[] stu1 = new Students[3];

Students s1 = new Students();

 s1.id = 1005;
 s1.name="花花";

stu1[0]=s1;

两个额外的知识点：

1、 遍历数组的元素：for循环和length关键字

2、引用类型数组的长度必须要结合实际的类型定义，如果定义的长度比类里面的元素多，那么在遍历数组元素的时候会报空指针异常

二、静态数组的声明方式

在创建数组时，已经知道数组中存储那些元素，一定使用静态初始化

package com.JavaStudy.studyArray0601;

/**
 * @Author wufq
 * @Date 2020/6/2 15:14
 * 静态数组初始化
 */
public class ArrayTest03 {
    public static void main(String[] args){
        //基本类型的数组静态初始化
        int[] data ={1,2,3,4,5};

        for(int i=0;i<data.length;i++){
            System.out.print(data[i]+" 
");
        }

        Student s1 = new Student();
        s1.id=1001;
        s1.name = "张三";

        Student s2 = new Student();
        s2.id = 1002;
        s2.name = "李四";

        //引用类型数组的静态初始化
        Student[] stu = {s1,s2};

        for(int i=0;i<stu.length;i++){
            System.out.println("id= "+stu[i].id+" name= "+stu[i].name);
        }

    }
}

class Student{
    int id;
    String name;
}
=====执行结果====
1 
2 
3 
4 
5 
id= 1001 name= 张三
id= 1002 name= 李四

例子：继承类用数组去调用子类的方法

package com.JavaStudy.studyArray0601;

/**
 * @Author wufq
 * @Date 2020/6/2 15:33
 */
public class ArrayTest04 {
    public static void main(String[] args){
        Cat c = new Cat();
        Dog d = new Dog();

        //把子类的两个对象放到父类为引用类型的数组内
        Animal[] ani = {c,d};

        for(int i=0;i<ani.length;i++){
            //采用多态-->向上转型（父引用-->子类对象）
            //因为Animal类里面是没有catchMouse()和jump()方法的，所以遍历Animal[]时是实现不了的，所以的进行强制类型的一个转换，
            // 把Animal的对象强制转换成Cat、Dog的对象，这样就可以调通这两个对象了
            Animal a = ani[i];
            //目的是调用子类内的两个方法，所以需要强制转换
            if(a instanceof Cat){
                Cat cat = (Cat) a;
                cat.catchMouse();
            }

            if(a instanceof Dog){
                Dog dog = (Dog) a;
                dog.jump();
            }

        }
    }
}

class Animal{

}

class Cat extends Animal{
    public void catchMouse(){
        System.out.println("catchMouse");
    }
}

class Dog extends Animal{
    public void jump(){
        System.out.println("jump");
    }
}