笔记10

int[] a:定义一个整型的数组A，它其实是对数组类对象的一个引用。
数组可以是一组相同类型的基本变量或者是一组相同类型的对象。

//初始化方法1
int[] a;
a=new int[10];//这句可以写在任何地方

//当然也可以连写：
int []a=new int[10];//本书作者推荐用这种方式

//初始化方法2(必须在定义数组类对象引用的同时用{}进行赋值)
int[] a={1,2,3};

每一个数组对象都有一个成员变量length,它表示数组内元素的个数，但注意！不能给它赋值。

public class H
{   
    public static void main(String[] args)
    {
        int[] a1={1,2,3,4,5};
        int[] a2;
        a2=a1;
        for(int i=0;i<=a2.length-1;i++)
        {
            a2[i]=a2[i]+1;
        }
        for(int j=0;j<=a1.length-1;j++)
        {
            printnb(a1[j]+" ");
        }
        print();
    }

}                   

输出：2 3 4 5 6

这表示数组对象之间赋值传递的是引用，数组对象本身存的是对数组的引用。
如果对数组下标越界使用C++和C都是不会报错的，但JAVA会 报错。

package net.mindview;
import static net.mindview.util.Print.*;
import java.util.*;
//数组是有初始值的，数值型整数的值为0，小数为0.0
//char是空格
//boolean是false
//类对象是null
public class H
{   
    public static void main(String[] args)
    {
        Random rand=new Random(47);
        int[] a;
        a=new int[rand.nextInt(20)];//rand.nextInt(20)[产生[0,20)的随机整数值]
        print(a.length);
        String str=Arrays.toString(a);//将数组转化成字符串的形式
        print(str);

        double[] b;
        b=new double[rand.nextInt(20)];
        print(b.length);
        print(Arrays.toString(b));

        char[] c;
        c=new char[rand.nextInt(20)];
        print(c.length);
        print(Arrays.toString(c));

        boolean[] d;
        d=new boolean[rand.nextInt(20)];
        print(d.length);
        print(Arrays.toString(d));

        String[] s;
        s=new String[rand.nextInt(20)];
        print(s.length);
        print(Arrays.toString(s));

    }

}             

输出：

public class H
{   
    public static void main(String[] args)
    {
        Integer[] a=new Integer[10];  //注意这里a是10个 Integer x...也就是说a[i]是该类对象的引用，没有初始化的话会有默认值null
        for(int i=0;i<=9;i++)
        {
            a[i]=i;
        }
        print(Arrays.toString(a));

    }
}      

输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

public class H
{   
    public static void main(String[] args)
    {
        Integer[] a=new Integer[]{new Integer(1),new Integer(2),3,};//初始列表最后的“,”是可选的，据说“,”便于护长列表
        Integer[] b={new Integer(4),new Integer(5),6};
        print(Arrays.toString(a));
        print(Arrays.toString(b));
    }
}     

输出：
[1, 2, 3]
[4, 5, 6]

下面这个脑洞我是第一见到，能理解这个过程。但是不知道这能用到什么地方，不知这段代码是处理什么问题用的。
书中写的是用于替换main()方法的命令行参数。

public class H
{   
    public static void main(String[] args)
    {
        A.main(new String[]{"hello","my","lover","java"});

    }
}   

class A
{
    public static void main(String[] args)
    {
        for(String str:args)
        {
            print(str);
        }

        print(Arrays.toString(args));
    }
}

输出：
hello
my
lover
java
[hello, my, lover, java]

补充：其实上面这段代码就是起了个和主函数同名的函数，其实完全可以简化并这样理解：

import java.util.*;
public class Hello
{

    public static void main(String[] args)
    {
        Bitch.fuckworld(new String[]{"you ","are ","a ","gammer"});
    }

}
class Bitch
{
    static void fuckworld(String[] str)
    {
        for(String i:str)
        {
            System.out.println(i);
        }
        System.out.println(Arrays.toString(str));
    }
}

输出：
you
are
a
gammer
[you , are , a , gammer]

public class H
{   
    H(String str)
    {
        print(str);
    }
    public static void main(String[] args)
    {
        H[] haha=new H[]{new H("I"),new H("love"),new H("java")};

    }
}  

输出：
I
love
java

这个输出说明H[] haha=new H[]{new H(“I”),new H(“love”),new H(“java”)};依次调用了构造函数

补充：

public class Hello
{
    Hello(String s)
    {
        System.out.println(s);
    }

    public static void main(String[] args)
    {
        Hello[] bitch=new Hello[3];
        for(Hello i : bitch)
        {
            System.out.println(i);
        }
    }

}

输出：
null
null
null

这说明Hello[] bitch=new Hello[3];只是创建了Hello类对象的引用，名字为Hello[0] Hello[1] Hello[2]但是这些引用没有指向的对象。

public class Hello
{
    Hello(String s)
    {
        System.out.println(s);
    }

    public static void main(String[] args)
    {
        Hello[] bitch=new Hello[]{new Hello("a"),new Hello("b"),new Hello("c")};
        for(Hello i : bitch)
        {
            System.out.println(i);
        }
    }

}

输出：
a
b
c
Hello@5e2de80c
Hello@1d44bcfa
Hello@266474c2
这说明 Hello[] bitch=new Hello[]{new Hello(“a”),new Hello(“b”),new Hello(“c”)};创建了名为Hello[0] Hello[1] Hello[2]的引用，并给他们分配了指向的对象 Hello[0]=new Hello(“a”) Hello[1]=new Hello(“b”) Hello[2]=new Hello(“c”)

class A
{
    static void f(Object []ob)
    {
        for(Object i:ob)
        {
            printnb(i+" ");
        }
        print();
    }

}
public class H
{   
    public static void main(String[] args)
    {
        A.f(new Object[]{new Integer(1),new Float(2.5),new A()});
        A.f(new Object[]{new Integer(1),new Integer(2),new Integer(3)});
        A.f(new Object[]{new Double(1.1),new Double(2.2),new Double(3.3)});
        A.f(new Object[]{new A(),new A(),new A()});//输出的每一条数据的@之前是类名，@之后是对象的地址
        print();print();
        Object[] a=new Object[]{new Integer(1),new Double(2.2),new A()};
        //也就是说所有类都是Object类的子类，用这个知识点，可以给Object类的对象赋值
        //所以Object对象的引用数组里可以存任意类型以及任意数目的类对象。
    }
}   

输出：
1 2.5 net.mindview.A@15db9742
1 2 3
1.1 2.2 3.3
net.mindview.A@6d06d69c net.mindview.A@7852e922 net.mindview.A@4e25154f

补充：简写了一个：

import java.util.*;
public class Hello
{
    static void f(Object[] ob)
    {
        System.out.println(Arrays.toString(ob));
    }

    public static void main(String[] args)
    {
        Hello.f(new Object[]{1,2,3,4,2.2});
        Hello.f(new Object[]{new Integer(1),new Double(2.2)});
        Hello.f(new Object[]{new Hello(),new Hello()});
    }

}

输出：
[1, 2, 3, 4, 2.2]
[1, 2.2]
[Hello@5e2de80c, Hello@1d44bcfa]

分析：
static void f(Object[] ob)
{
System.out.println(Arrays.toString(ob));
}
参数为Object类对象的引用数组，即Object[0],Object[1]…
在调用函数的时候，例如用这种方式：Hello.f(new Object[]{new Integer(1),new Double(2.2)});
new Object[]{new Integer(1),new Double(2.2)}它给每一个前面说的Object[0],Object[1]..赋初值，即让他们指向对象 。
Object[0]=new Integer(1) Object[1]=new Double(2.2)，这里唯一特殊的部分在于这个初值可以是任意类型的，因为 Object类是所有类的基类，即：所有类的都是Object类的子类，子类可以给基类赋初值对象。然后因为是数组，所有可以是不定个数的。

=====102未完