java学习笔记6

Java foreach语句

使用 foreach 循环遍历数组元素时无须获得数组长度，也无须根据索引来访问数组元素。

for(类型 变量名:集合) {
    语句块;
}

其中，“类型”为集合元素的类型，“变量名”表示集合中的每一个元素，“集合”是被遍历的集合对象或数组。

foreach 循环和普通循环不同的是，它无须循环条件，无须循环迭代语句，这些部分都由系统来完成，foreach 循环自动迭代数组的每个元素，当每个元素都被迭代一次后，foreach 循环自动结束。

public class Test7 {
    public static void main(String [] args)
    {
        int[] a =new int[]{1,2,3,4,5,6,7,8,9,0};
        for(int i=0;i<10;i++)
        {
            System.out.println(a[i]);
        }
        System.out.println();
        for(int i:a)
        {
            System.out.println(i);
        }
    }
}

运行结果：

1
2
3
4
5
6
7
8
9
0

1
2
3
4
5
6
7
8
9
0

i 保存了数组中的元素，foreach 语句将数组中的元素一一取出来，并存入 i 中，不需要循环变量数组下标访问数元素

注意：i 只是存储了数组元素的值，并不能改变数组，所以要改变数组元素的值，就不要用foreach

数组

Java 的数组要求所有的数组元素具有相同的数据类型。因此，在一个数组中，数组元素的类型是唯一的，即一个数组里只能存储一种数据类型的数据，而不能存储多种数据类型的数据。

Java 的数组既可以存储基本类型的数据，也可以存储引用类型的数据，只要所有的数组元素具有相同的类型即可。

数组也是引用类型

值得指出的是，数组也是一种数据类型，它本身是一种引用类型。例如 int 是一个基本类型，但 int[]（这是定义数组的一种方式）就是一种引用类型了。
int[] 也是一种类型，与int，String变量一样可以定义变量

引用传递

概念：多个栈空间同时指向同一块堆内存
比如说 int[ ] a = new int[ 3 ]; int[ ] b =a;
先从左向右执行，new int[ 3 ]
则在堆上开辟12个字节的空间，每四个分别用来存放a[0],a[1],a[2],并对它们进行初始化。
然后为局部变量a分配内存空间，再将堆内存中数组的首地址存到a里面，此时栈上的a的值就是堆上的数组空间的地址，因此二者建立了一定联系，这里用指向来表示。
再接着在栈上定义了一个局部变量b，并把a的值赋给b，因此b里面也存的是堆空间的首地址，此时b也指向那块堆空间，利用b也可对堆空间的值进行操作，这便称为引用传递。本质：多个栈空间同时指向同一块堆内存。没有栈内存指向的堆内存也被称为垃圾空间。

Java数组复刻

public class Test4 {
    public static void main(String[] args) {
        Test4 Test4 = new Test4();
        int[] c = new int[10];
        c[2]=3;
        //指向的是同一个地址
        int[] d = c;
        System.out.println(d);
        System.out.println(c);
        System.out.println(d[2]);
        c[2] = 10;
        System.out.println(d[2]);
        //输出10
    }
}

结果：

可以看到，d和c指向同一个地址，产生了对同一个数组的第二引用

只要稍加改动，加clone()方法

public class Test4 {
    public static void main(String[] args) {
        Test4 Test4 = new Test4();
        int[] c = new int[10];
        c[2]=3;
        //指向的是同一个地址
        int[] d = c.clone();//复刻新数组
        System.out.println(d);
        System.out.println(c);
        System.out.println(d[2]);
        c[2] = 10;
        System.out.println(d[2]);
        //输出10
    }
}

结果：

这才创建了一个新数组，b地址与c指向的数组地址不同，要用clone()方法才能复刻一个数组

Java多维数组

静态初始化：

int[][] a=new int[][]{{1,2,3},{4,5}};

动态初始化：

int[][] a = new int[3][4]; //三行四列

其中列可以省略，行不可以。

图中a为二维数组，但却把它当作一维数组来输出，只是每个数组元素都是 null，所以看到输出结果都是 null。
int [ ][ ] a = new int [5][ ]；
对数组进行初始化，指向一个长度为4的堆空间，每个元素都为引用类型，系统给他们赋默认值null，所以此时a看起来像一个一维数组，只是它里面只能存int[ ] 类型的数据
现在改为 int[ ][ ] a = new int[5][5];

可以发现，二维数组a的每个元素都有地址了

Class类型

Class 类是在Java语言中定义一个特定类的实现。一个类的定义包含成员变量，成员方法，还有这个类实现的接口，以及这个类的父类。可通过类名.class,类型.getClass(),Class.forName(“类名”)等方法获取class对象)。数组同样也被映射为为class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
Class类的对象不能像普通类一样，以 new shapes() 的方式创建，它的对象只能由JVM创建，因为这个类没有public构造函数

class QB 
{

}
public class Test
{
public static void main(String[]args)
{
int[] a = new int[2];
int[][] b = new int[2][];
QB qb = new QB();
System.out.println(qb.getClass());
System.out.println(int[].class);
System.out.println(int[][].class);
System.out.println(a.getClass());
System.out.println(b.getClass());
}

}

C:\Users\fy\Desktop>javac Test.java

C:\Users\fy\Desktop>java Test
class QB
class [I
class [[I
class [I
class [[I

获取一个Class对象

class QB
{
public static void test()
{
    System.out.println("静态方法调用");
}
}
public class Test6 extends QB{
    public static void main(String[] args)
    {
        QB qb = new QB();
        Class obj = qb.getClass();//使用getClass
        System.out.println("输出Class对象："+obj);
        Class obj1 = QB.class;//使用类字面变量
        System.out.println("输出Class对象："+obj1);
    }
}