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数组的元素和为：4506.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 数组元素的最大值为：787. 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中自定义类和基本类型声明的数组，在对内存中存储的内容、方式和内存地址指向方面有啥区别？的主要内容，如果未能解决你的问题，请参考以下文章
1.27 Java基础总结 ①访问修饰符访问权限②类和方法的基本声明和使用1.27 Java基础总结 ①访问修饰符访问权限②类和方法的基本声明和使用