笔记12

//getClass()是Object类中的方法，因为Object类是所有类的基类，所以所有的东西(除了基本类型，但注意基本类型的数组是数组类对象的引用，它属于一个类)都可以用该方法
//它返回的是调用它的那个东西的类型 class表示这是一个类 [表示这是一个数组 I表示类型为int
//Integer表示类型为Integer   C表示类型为char  Character表示类型为Character A表示是A类型
//这么细的说明不是为了让您记住...只是为了方便回过头来查看代码啊，别搞错了目的。
//然后，忘了的话就像haha.g1(new Integer[]{1,2,3,4});这样调用一下函数您就明白怎么回事了，这玩意不用记。
//数组.length返回数组中原元素的个数
//从这个例子可以看出 参数表为：类型... a 时，a就是该类型的数组，而不是别的什么东西
class A
{
}
public class H
{
    public void f(String... args)
    {
        printnb("args的类型为 "+args.getClass()+"     ");
        print("args数组中元素的个数为"+args.length);
    }


    public void g(int... args)
    {
        printnb("args的类型为 "+args.getClass()+"     ");
        print("args数组中元素的个数为"+args.length);
    }
    public void g1(Integer... args)
    {
        printnb("args的类型为 "+args.getClass()+"     ");
        print("args数组中元素的个数为"+args.length);
    }


    public void h(char... args)
    {
        printnb("args的类型为 "+args.getClass()+"     ");
        print("args数组中元素的个数为"+args.length);
    }
    public void h1(Character... args)
    {
        printnb("args的类型为 "+args.getClass()+"     ");
        print("args数组中元素的个数为"+args.length);
    }


    public void t(A... args)
    {
        printnb("args的类型为 "+args.getClass()+"     ");
        print("args数组中元素的个数为"+args.length);
    }


    public static void main(String[] args)
    {
        H haha=new H();
        haha.f("hi","lo");
        haha.f();

        haha.g(1,2,3);
        haha.g();

        haha.g1(1,2,3);
        haha.g1();
        haha.g1(new Integer[]{1,2,3,4});

        haha.h('a','b','c');
        haha.h();//注意这种，调用后仍会显示类型，但是元素个数为0

        haha.h1('a','b','c');
        haha.h1();

        haha.t(new A(),new A());

    }

输出：

args的类型为 class [Ljava.lang.String;     args数组中元素的个数为2
args的类型为 class [Ljava.lang.String;     args数组中元素的个数为0
args的类型为 class [I     args数组中元素的个数为3
args的类型为 class [I     args数组中元素的个数为0
args的类型为 class [Ljava.lang.Integer;     args数组中元素的个数为3
args的类型为 class [Ljava.lang.Integer;     args数组中元素的个数为0
args的类型为 class [Ljava.lang.Integer;     args数组中元素的个数为4
args的类型为 class [C     args数组中元素的个数为3
args的类型为 class [C     args数组中元素的个数为0
args的类型为 class [Ljava.lang.Character;     args数组中元素的个数为3
args的类型为 class [Ljava.lang.Character;     args数组中元素的个数为0
args的类型为 class [Lnet.mindview.A;     args数组中元素的个数为2

关于这个getClass()函数，我觉的书上说的太少了，让我们做进一步的测试，以分析这个函数的功能

public class Hello
{
    public static void main(String[] args)
    {

        /*
        int a=3;
        System.out.println(a.getClass());
        报错
        */

        Integer b=new Integer(1);
        System.out.println(b.getClass());

        /*
        char c='*';
        System.out.println(c.getClass());
        报错
        */

        Character d=new Character('*');
        System.out.println(d.getClass());

        /*
        double e=1.1;
        System.out.println(e.getClass());
        报错
        */

        Double f=new Double(1.1);
        System.out.println(f.getClass());

    }

}

输出：
class java.lang.Integer
class java.lang.Character
class java.lang.Double
这可以看出来，getClass()函数对基本类型是不适用的。
所以就有个问题…为什么对基本类型的数组是适用的…可以这样理解：数组名其实是数组类对象的引用，也就是说数组名其实是数组类的对象，也就是说它属于一个类…但基本类型就是基本类型，它不属于任何类。

//下面这段代码，主要告诉我们：在函数参数表中只有一个参数时，例如：,
//这种参数形式： 类型... 名字  它的包装器在起作用
//例如Integer..args 它会把它的int 参数转化为Integer   反过来也行哦
//例如Character..args 它会把它的char 参数转化为Character   反过来也行哦
//其实以上可以总结为一句话：char Character这种，基本类型和它的类在使用上没差别

public class H
{
    void f(Integer... args)
    {
        for(Integer e:args)
        {
            printnb(e+" ");
        }
        print();
    }

    void g(Character... args)
    {
        for(Character e:args)
        {
            printnb(e+" ");
        }
        print();
    }
    void f_(int... args)
    {
        for(int e:args)
        {
            printnb(e+" ");
        }
        print();
    }
    void g_(char... args)
    {
        for(char e:args)
        {
            printnb(e+" ");
        }
        print();
    }
    public static void main(String[] args)
    {
        H haha=new H();
        haha.f(new Integer(1),2,3);
        haha.f(1,2,3,4);
        haha.f(new Integer(1),new Integer(2),new Integer(3),new Integer(4),new Integer(5));

        haha.g('a','b');
        haha.g(new Character('a'),'b','c');
        haha.g(new Character('a'),new Character('b'),new Character('c'),new Character('d'));

        haha.f_(1,new Integer(2));
        haha.g_('a',new Character('b'));

    }

}  

输出：

1   2   3   
1   2   3   4   
1   2   3   4   5   
a   b   
a   b   c   
a   b   c   d   
1   2   
a   b   

//以下几段代码告诉我们的是：  类型... 名字 这种参数形式在函数重载时容易产生麻烦
//本书作者给您的警告是：在函数重载时，最多只有一个函数使用 ：类型 ... 名字这种形式。也就是不定个数的参数表的形式。
//关于产生怎样的麻烦：下面这段代码使用a()报错 因为编译器不知道该调用哪个a()函数

public class H
{
    void a(Integer... args)
    {
        printnb("a:  ");
        for(Integer e:args)
        {
            printnb(e+"   ");
        }
        print();
    }

    void a(Character... args)
    {
        printnb("b:  ");
        for(Character e:args)
        {
            printnb(e+"   ");
        }
        print();
    }
    void a(Long... args)
    {
        printnb("c:   ");
        for(Long e:args)
        {
            printnb(e+"   ");
        }
        print();
    }
    public static void main(String[] args)
    {
        H haha=new H();
        haha.a(1,2);
        haha.a(11L);
        haha.a('c');
        //haha.a(args);//报错。编译器不知道该调用哪个a()函数
    }

}   

输出：

a:  1   2   
c:   11   
b:  c