Java中自定义类和基本类型声明的数组,在对内存中存储的内容、方式和内存地址指向方面有啥区别?

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java中自定义类和基本类型声明的数组,在对内存中存储的内容、方式和内存地址指向方面有啥区别?相关的知识,希望对你有一定的参考价值。

有一个问题:String声明的数组每个索引值只存储一个字符串元素,那自定义的Student类声明的student数组存储的是什么呢?假定Student类有2个属性,那么student数组中每个student[i]存储的都是2个属性的值吗?如果是的话堆内存的形式是怎么样的?

参考技术A 1.前边说的基本正确,最后一句不严谨,“并指向新的内存空间”是对的,但未必是“新开辟了一个带有内容的内存空间”因为可以指向另外一个已存在的对象,后者仅在遇见new操作符(或者函数调用里使用了new)才正确。2.可以被final修饰,也可以修饰此变量所指向对象的内容,但不可变更此变量所指向的对象(即不可以指向新的地址)。3.属性也可以是基本数据类型。成员变量被static修饰,就是静态变量,意思是可以被这个类的所有对象所共享而已(如果不是private的还可以被其他类或对象访问),或者说,这个变量被绑定到类上而非对象上。因此,它完全可以被更改。①:static修饰的属性可以被子类调用(只要是protected或public),不存在“覆写”的问题,因为他们各自绑定到不同的类。但是,如果子类类名调用自身未定义的变量或方法,会在父类中找(protected或public的),当然自己重定义就调用自己定义的,用父类类名调用的静态变量调用的是绑定在父类的静态变量(即父类定义的静态变量)。②:final修饰的变量是常量,用类名直接调用由这个变量是否为static来决定,跟final无关。4.无论是否静态变量,都可以是基本或引用类型的。5.①必须是,因为你调用了newA()。另外,对于Aa1,那么a1所指向的对象不是A类型的对象也是A的子类的对象。②对象是变量的一种。变量的本质含义就是一个固定大小的储存空间。对象是变量的一种。同理,类是变量类型的一种。Aa2:在不同的语境下,用词不一样。“a1”,本质是一个指向某对象的指针。但我们谈到“a1变量”时,既可以是指a1这个储存空间(出指向了什么对象),也可以指a1所指向的对象,这得根据上下文语境理解。而“a1对象”一般指后者。6.“对象变量”一般指的是类的非静态成员变量(也就是非静态属性)。7.常量等价于final所修饰的变量。变量可以是引用类型的,也可以是值类型的。8.见7,常量跟static八竿子打不着。另外,你可能提到了一个非常重要的概念区别(在JAVA通常不重要,并没有关键词严格区分):运行时常量与编译时常量。"dsfsdf":像左边这种字符串是常量,又称字面量,是一种非常典型的编译时常量。其实严格来说,编译时常量还分两种,但这已经涉及到CPU的运行机制,过于底层,就不再细讲。

Java 基本语法---Java数组

Java 基本语法---Java数组


0. 概述

数组:相同类型的数据 按照顺序 组成的一种 引用数据类型 。

数据类型:基本数据类型 + 引用数据类型;

引用数据类型:类 + 接口 + 数组 ;

一维数组:声明,创建,初始化,元素的引用,长度


1. 数组声明

变量声明的语法格式: 变量类型 变量名;

数组声明的语法格式:数据类型 [ ] 数组名;(数据类型 数组名[ ])

int[] myIntArray;  //首选方法

(int myIntArray[];) //来源于C/C++,效果相同,但不是首选方法

String[] strArray;

2. 数组创建

语法格式一 先声明后创建

数据类型[] 数组名;

数组名 = new 数据类型[ 数组长度 ];

int[] array;

array = new int[10];

//创建一个长度为 10 的整型数组array; 

语法格式二 声明的同时进行创建数组

数据类型 [] 数组名 =  new 数据类型 [ 数组长度 ];

dataType[] arrayRefVar = new dataType[arraySize];
// 1.使用 dataType[arraySize] 创建了一个数组;
// 2.把新创建的数组的引用赋值给了变量 arrayRefVar。
int[] arr = new int[10];    //创建一个长度为10的整型数组arr

//注意:数组的长度必须给定

3. 数组的初始化

声明数组的同时给数组赋值,叫做数组的初始化;

int[] arr = {1,2,3,4,5,6,7,8,9,10};

// 数组的长度就是初始化数组时所给数组元素的个数。

4. 数组元素的引用

数组元素的访问是通过索引访问的。

语法格式: 数组名[ 下标 ];

注意:下标从0开始(数组索引从0开始,所以索引值从0到array.length - 1);


5. 数组的长度

int[] arr = {0,1,2,3,4,5,6,7,8,9};

//属性 length 表示数组的长度,例如:arr.length;

6. 案例

6.1 案例1:一维数组的应用

int 数组创建时数组元素默认值为0;

double数组创建时数组元素默认为0.0;

char 数组创建时数组元素默认为 ;

String 数组创建时数组元素默认为 null;

public class ArrayTest {
    public static void main(String[] args) {
        //声明一个整型数组
        int[] intArray;
        //声明一个字符串类型的数组
        String strArray[];
        //创建数组
        intArray = new int[5];
        strArray = new String[10];
        //声明数组的同时进行创建数组
        double[] doubleArray = new double[4];
        //初始化数组
        char[] chArray = {'a','b','c','d'};
        char[] ch1Array = new char[5];
        System.out.println("ch1Array 数组的长度为:" + ch1Array.length);
        System.out.println("ch1Array 数组中的第2个元素为:" + ch1Array[3]);
        System.out.println("chArray 数组的长度为:" + chArray.length);
        System.out.println("chArray 数组中的第2个元素为:" + chArray[1]);
        System.out.println("intArray 数组的长度为:" + intArray.length);
        System.out.println("intArray 数组中的第二个元素为:" + intArray[1]);
        System.out.println("strArray 数组的长度为:" + strArray.length);
        System.out.println("strArray 数组中的第5个元素为:" + strArray[4]);
        System.out.println("doubleArray 数组的长度为:" + doubleArray.length);
        System.out.println("doubleArray 数组中的第4个元素为:" + doubleArray[3]);
        System.out.println();

        //循环为整型数组赋值
        for(int i = 0;i < 5;i++)
        {
            intArray[i] = i + 2;
        }
        //循环输出整型数组中的元素
        System.out.println("整型数组intArray 中的元素值分别为:");

        //数组下标越界(数组下标超出范围)Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
        //  at com.ryanjie.ArrayTest.main(ArrayTest.java:51)
//        for(int i= 0;i < 6;i++)
//        {
//            System.out.print(intArray[i] + "    ");
//        }
//        System.out.println();
        for(int i = 0;i < 5;i++)
        {
            System.out.print(intArray[i] + "    ");
        }
        System.out.println();
    }
    
}

Output:
    ch1Array 数组的长度为:5
    ch1Array 数组中的第2个元素为: 
    chArray 数组的长度为:4
    chArray 数组中的第2个元素为:b
    intArray 数组的长度为:5
    intArray 数组中的第二个元素为:0
    strArray 数组的长度为:10
    strArray 数组中的第5个元素为:null
    doubleArray 数组的长度为:4
    doubleArray 数组中的第4个元素为:0.0

    整型数组intArray 中的元素值分别为:
    2    3    4    5    6    

6.2 案例2:求数组元素的累加和

public class ArraysSum {
    public static void main(String[] args) {
        //求整型数组的累加和
        //定义整型数组
        int[] intArray = new int[5];

        //从键盘开始接收数据,为元素进行赋值
        Scanner sc = new Scanner(System.in);
        for(int i = 0;i < intArray.length;i++)
        {
            System.out.println("请输入第 " + (i + 1) + "个元素的值:");
            intArray[i] = sc.nextInt();
        }

        //输出intArray 数组中的元素
        System.out.println("数组中的元素分别为:");
        for(int i = 0;i < intArray.length; i++ )
        {
            System.out.print(intArray[i] + "  ");
        }
        System.out.println();

        //输出intArray数组中的元素的和
        int sum = 0;
        for(int i= 0; i < intArray.length;i++)
        {
            sum += intArray[i];
        }
        System.out.println("intArray数组的元素和为:" + sum);
    }
}

Output:
    请输入第 1个元素的值:
    100
    请输入第 2个元素的值:
    100
    请输入第 3个元素的值:
    50
    请输入第 4个元素的值:
    50
    请输入第 5个元素的值:
    150
    数组中的元素分别为:
    100  100  50  50  150  
    intArray数组的元素和为:450

6.3 案例3:求数组元素的最大值

public class MaxElement {
    public static void main(String[] args) {
        //求数组中的最大值

        //定义整型数组
        //int[] intArray = {34,23,78,56,31,66};
        int[] intArray = new int[6];

        //从键盘读取数组元素值
        Scanner sc = new Scanner(System.in);
        for(int i = 0;i < intArray.length;i++ )
        {
            System.out.println("请输入第 " + (i+1) + "个元素的值:");
            intArray[i] = sc.nextInt();
        }

        //输出intArray数组中的元素
        System.out.println("intArray 数组中的元素分别为:");
        for(int i = 0;i < intArray.length;i++)
        {
            System.out.print(intArray[i] + "  ");
        }
        System.out.println();

        int max = intArray[0];
        for(int i = 1;i < intArray.length;i++)
        {
            if(max < intArray[i])
            {
                max = intArray[i];
            }
        }
        System.out.println("intArray 数组元素的最大值为:" + max);
    }
}


Output:
    请输入第 1个元素的值:
    34
    请输入第 2个元素的值:
    23
    请输入第 3个元素的值:
    78
    请输入第 4个元素的值:
    56
    请输入第 5个元素的值:
    31
    请输入第 6个元素的值:
    66
    intArray 数组中的元素分别为:
    34  23  78  56  31  66  
    intArray 数组元素的最大值为:78

7. foreach 循环

foreach 循环又称为增强型循环,它能在不使用下标的情况下遍历数组。

int[] arr = {1,2,3,4,5,6};
for(int n:arr)
    System.out.print(n + "  ");
//每次把数组中的元素存放到n中,输出。循环遍历一遍就终止;
public class Test {
    public static void main(String[] args) {
        //定义整型数组
        //int[] intArray = {34,23,78,56,31,66};
        int[] intArray = new int[6];

        //从键盘读取数组元素值
        Scanner sc = new Scanner(System.in);
        for(int i = 0;i < intArray.length;i++ )
        {
            System.out.println("请输入第 " + (i+1) + "个元素的值:");
            intArray[i] = sc.nextInt();
        }
        
        //foreach循环
        for(int n:intArray)
        {
            System.out.print(n + "    ");
        }
        System.out.println();
    }
}

8. 数组作为函数的参数

数组作为参数传递给方法。

调用printfDoubleArray方法打印doubleArray数组:

public static void printfDoubleArray(double[] doubleArray) {
    for (double element: doubleArray ) 
    {
        System.out.println(doubleArray[i] + "   ");
    }
}

//调用printfDoubleArray方法打印doubleArray数组
printfDoubleArray(new double[] {3.14,6.66,8,88,3.59,7.84});

9. 数组作为函数的返回值

数组可以作为函数的返回值。

将list数组中的元素值赋值给result数组:

public atstic int[] reverse(int[] list){
    //声明 result 数组 并创建 result 数组
    int[] result = new int[list.length];

    for (int i = 0, j = result.length - 1; i < list.length; i++, j--) 
    {
        result[j] = list[i];
    }
    return result;
}

10. 冒泡排序 BubbleSort

public class BubbleSort {
    public static void main(String[] args) {
        //冒泡排序BubbleSort
        int[] intArray = {34,23,78,56,31,66};
        System.out.println("排序前的数组元素分别为:");
        for(int element:intArray)
        {
            System.out.print(element + "    ");
        }
        System.out.println();
        
        //BubbleSort
        int temp;
        for (int i = 0; i < intArray.length; i++) 
        {
            for (int j = 0; j < intArray.length-i-1; j++)
            {
                if(intArray[j] > intArray[j+1])
                {
                    temp = intArray[j];
                    intArray[j] = intArray[j+1];
                    intArray[j+1] = temp;
                }
            }
        }

        //输出排序后的数组
        System.out.println("排序后的数组元素分别为:");
        for(int element:intArray)
        {
            System.out.print(element + "    ");
        }
        System.out.println();
    }
}


OutPut:
    排序前的数组元素分别为:
    34    23    78    56    31    66    
    排序后的数组元素分别为:
    23    31    34    56    66    78  

以上是关于Java中自定义类和基本类型声明的数组,在对内存中存储的内容、方式和内存地址指向方面有啥区别?的主要内容,如果未能解决你的问题,请参考以下文章

在渲染到屏幕之前对内存中的视频加载做出反应

java数据类型

java数组

Java数组1----数组的定义与使用

Java数组1----数组的定义与使用

1.27 Java基础总结 ①访问修饰符访问权限②类和方法的基本声明和使用1.27 Java基础总结 ①访问修饰符访问权限②类和方法的基本声明和使用