java的学习记录5

来源：互联网发布：淘宝授权书查询真假编辑：程序博客网时间：2024/05/29 06:39

import java.util.*;

public class rt{
        public static void main(String[] args){
                int[] array;
                Random rand=new Random();
                int h=rand.nextInt(5);
                array=new int[h];
                System.out.println("the length of array="+array.length);
                System.out.println(Arrays.toString(array));
        }
}

结果：

the length of array=3
[0, 0, 0]

或者

the length of array=0
[]

等

分析：数组的大小通过rand.nextInt(5)决定，方法Arrays.toString()将一维数组打印。

eg:Integer是一个类，可以作为数组元素。

import java.util.*;

public class rt{
        public static void main(String[] args){
                Random rand=new Random();
                int r=rand.nextInt(5);
                Integer[] array=new Integer[r];
                System.out.println("the length of array="+array.length);
                for(int i=0;i<array.length;i++)
                  array[i]=rand.nextInt(999);
                System.out.println(Arrays.toString(array));
        }
}

结果;

the length of array=4
[794, 136, 355, 545]
或者：

the length of array=0
[]

等

分析：数组在定义的时候同时进行初始化。

import java.util.*;

public class rt{
        public static void main(String[] args){
                Integer[] a={new Integer(1),new Integer(2),new Integer(3)};
                Integer[] b={new Integer(4),new Integer(5),new Integer(6)};
                System.out.println(Arrays.toString(a)+"\n"+Arrays.toString(b));
        }
}

结果：

[1, 2, 3]
[4, 5, 6]

import java.util.*;

class test{
        public static void main(String[] args){
                for(String s:args)
                  System.out.println(s);
        }
}

public class rt{
        public static void main(String[] args){
                String[] s={"1","2","3"};
                test.main(s);
                test.main(new String[]{"3","4","5"});
        }
}

结果：

1
2
3
3
4
5

分析：在main（）函数中创建并初始化数组，在调用其它类test中的main方法，打印每一个数组元素。

eg:在java中一切都是对象，所有的类都直接或间接继承Object类，当让可以创建以Object数组为参数的方法。

import java.util.*;

public class rt{
        static void printarray(Object[] args){
                for(Object o:args)
                  System.out.println(o);
        }
        public static void main(String[] args){
                Object[] array={new Integer(1),new Integer(2),new Integer(3)};
                printarray(array);
        }
}

结果：

1
2
3

分析：main(）函数中定义数组array，printarray方法中用foreach打印数组。

import java.util.*;

class aa{};

public class rt{
        static void printarray(Object[] args){
                for(Object o:args)
                        System.out.print(o+" ");
                        System.out.println();
        }
        public static void main(String[] args){
                Object[] array=new Object[]{new Integer(1)};
                printarray(array);
                printarray(new Object[]{"2","22","222"});
                printarray(new Object[]{new aa(),new aa(),new aa()});
                printarray((Object[])new Integer[]{111,222,333});
        }
}

结果：

1
2 22 222
aa@fd13b5 aa@118f375 aa@117a8bd
111 222 333

分析：如果Object数组中是对象，那么答应出来的是对象的名字和地址。强制转换，将Integer数组转化为Object数组。

eg:

public class rt{
        static void f(int mark,String... trailing){
                System.out.print("required:"+mark+"****** ");
                for(String s:trailing)
                  System.out.print(s+" ");
                System.out.println();
        }
        public static void main(String[] args){
                f(1,"one");
                f(2,"two","three");
                f(0);
        }
}

结果：

required:1****** one
required:2****** two three
required:0******

分析：可以在参数列表中传入0个元素，例如f(0)中，trailing数组元素为空，注意，mark元素不能为空。

public class rt{
        static void function(Character... args){
                System.out.print(args.getClass());
                System.out.println("length"+args.length);
        }
        static void func(int... args){
                System.out.print(args.getClass());
                System.out.println("LENGTH"+args.length);
        }
        public static void main(String[] args){
                function('1');
                function();
                func(1);
                func();
                System.out.println("int[]:"+new int[0].getClass());
        }
}

结果：

class [Ljava.lang.Character;length1
class [Ljava.lang.Character;length0
class [ILENGTH1
class [ILENGTH0
int[]:class [I

分析：方法getClass()属于Object,用来产生对象的类，并在打印类时，可以看到该类类型的编码字符串。[表示这是一个后面紧随的类型的数组，而后的 I表示是基本类型int。

public class rt{
        static void function(Integer... args){
                for(Integer i:args)
                        System.out.print(i+" ");
                        System.out.println();
                }
                public static void main(String[] args){
                        function(new Integer(122),new Integer(233));
                        function(1,22,333);
                        function(1,new Integer(22),333);
                }
        }

结果：

122 233
1 22 333
1 22 333

分析：在参数列表中，自动包装机制会进行类型转化，例如int型转化为Integer型。我们可以在在一个参数列表运用多个类型。

eg:可变参数列表

public class rt{
        static void function(Character... args){
                for(Character c:args)
                  System.out.print(c+" ");
                System.out.println();
        }
        static void function(Integer... args){
                for(Integer i:args)
                  System.out.print(i+" ");
                System.out.println();
        }
        static void function(double... args){
                for(double d:args)
                  System.out.print(d+" ");
                System.out.println();
        }
        public static void main(String[] args){
                function('a','b','c');
                function(1,2,3);
                function(1.00,2.00,3.00);
        }
}

报错：

rt.java:19: 错误: 对function的引用不明确, rt中的方法 function(Character...)和rt中的方法 function(double...)都匹配
                function('a','b','c');
                ^
jart.java:20: 错误: 对function的引用不明确, rt中的方法 function(Integer...)和rt中的方法 function(double...)都匹配
                function(1,2,3);
                ^
2 个错误

分析：

因为java存在默认的类型转换，so 。

原文：

public class rt{
        static void function(Character... args){
                for(Character c:args)
                  System.out.print("Character:"+c+" ");
                System.out.println();
        }
        static void function(Integer... args){
                for(Integer i:args)
                  System.out.print("Integer:"+i+" ");
                System.out.println();
        }
        static void function(Long... args){
                  System.out.println("third ");
        }
        public static void main(String[] args){
                function('a','b','c');
                function(1,2,3);
                function(0);
                function(0L);
        }
}

结果：

Character:a Character:b Character:c
Integer:1 Integer:2 Integer:3
Integer:0
third

分析：如果主函数加入function()，将不能编译，因为编译器不知道调用哪一个方法。

当让，我们可以在方法中加入一个非可变参数来进行明显的区分。

public class rt{
        static void function(int i,Character... args){
                for(Character c:args)
                  System.out.print(c+" ");
        }
        static void function(Character... args){
                for(Character c:args)
                  System.out.print("second");
        }
        public static void main(String[] args){
                function(1,'a','b');
                function('a','b','c');
        }
}

报错：

rt.java:12: 错误: 对function的引用不明确, rt中的方法 function(int,Character...)和rt中的方法 function(Character...)都匹配
function('a','b','c');
^
1 个错误

分析：可知两个方法都必须加入区别参数。

public class rt{
        static void function(int i,Character... args){
                for(Character c:args)
                  System.out.print(c+" ");
        }
        static void function(char cc,Character... args){
                for(Character c:args)
                  System.out.print("second");
        }
        public static void main(String[] args){
                function(1,'a','b');
                function('a','b','c');
        }
}

结果：a b secondsecond

分析：char和character区别 - 必应 Bing

char是基本类型没错，但是String不是，String是对象，不是基本类型

char是基本类型的数据,Charater是封装成的类；他们的关系就像int和Integer之间的关系.

涉及装箱拆箱

http://bbs.csdn.net/topics/260068056

0 0