1 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter.DEFAULT;

 2 

 3 

 4 public class test {

 5 

 6     /

 7       ＠param args

 8      /

 9     public static void main（String[] args） {

10         // TODO Auto-generated method stub    

11         /

12           一维数组:

13           

14           数组的语法：

15            数据类型[] 数组名 = new 数据类型[长度]

16            或者

17            数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3}

18            数据类型[] 数组名 = {元素1，元素2，元素3};

19            重视:这三种办法同一个数组不克不及同时应用

20           静态初始化:

21                由我们给数组赋值，数组的长度由体系决意

22          /

23         int[] tests1 = new int[]{1，2，3，4，5};

24         int[] tests2 = {1，2，3，4，5，};    

25         /

26           动态初始化:

27                       由我们给数组定义长度，体系主动为数组赋初始值 和全局变量一样

28                       然则我们也可以经由过程数组的下标给数组赋值的.....

29          /

30         int[] tests3 = new int[4];

31         tests3[0]=1;

32         tests3[1]=2;//赋值

33         System.out.println（tests2[0]）;  //接见数组的成果是:1

34         System.out.println（tests2.length）;//经由过程数组length属性获得数组长度

35             

36         /

37           二维数组:     

38           懂得为:多行多列、数据类型雷同的凑集   

39           数组的语法；

40           数据类型[][] 数组名 = new 数据类型[长度][长度]

41            或者

42            数据类型[][] 数组名 = new 数据类型[][]{  {元素1} ， {元素2} ，{元素3} }

43            数据类型[][] 数组名 = {{元素1}，{元素2}，{元素3}};

44            

45            静态初始化:

46                和一维数组一样，都是由我们给数组赋值，数组的长度由体系决意

47          /

48         int[][] arr1=new int[][] {  {1，2} ， {3，4} };

49         int[][] arr2={  {1，2} ， {3，4} };

50         /

51           注：大的花括号里面的每一对小的花括号可以看做一维数组

52           

53           动态初始化:

54                   和一维数组一样，都是由我们给数组定义长度，体系主动为数组赋初始值 和全局变量一样

55                   然则我们也可以经由过程数组的下标给数组赋值的.....

56          /

57         int[][] arr3=new int[2][2]; 

58         /

59              这两个中括号是什么意思呢？可以懂得为2行2列。

60              也可以懂得为:第一个中括号是代表有2个一维数组，第二个中括号代表一个一维数组里面有2个元素

61          /

62         arr3[0][0]=1;   //赋值，取长度的话和一维数组一样的。。

63         System.out.println（arr3.length）;//获取数组的长度

64         System.out.println（arr3[0][0]）;//这里是获取数组里面的元素，成果为:1

65         

66         

67         /

68           记住:接见数组的时辰下标不成以跨越   数组长度-1  不然会数组越界错误

69           还有的就是每个数组的下标都是从0开端的

70          /

71         

72     }

73 }

 1 / 

 2           《同类中调用办法》

 3           前面已经写了如何编写办法，那么写了必然是要用的，如何去调用它呢？

 4           调用办法的话，直接写   办法名（）;  或者    办法名（参数1，参数2）. 

 5           有参数的话就要往括号里丢参数，若是没有就直接括号就了事

 6           如下:

 7          /

 8         int a=5;int b=10;

 9         //调用带参办法

10         swap（a，b）;

11         //调用无参办法

12         swap（）;

13         //  这两个办法形成了重载关系

14     }

15     public static void swap（int a，int b）

16     {

17         System.out.println（有参数的办法体）;

18     }

19     public static void swap（）

20     {

21         System.out.println（无参数的办法体）;

22     }

1 public class A 

2 {

3     public void b（）

4     {

5         System.out.println（对象A的b办法）;

6     }

7 }

 1 public class test {

 2 

 3     /

 4       ＠param args

 5      /

 6     public static void main（String[] args） {

 7         // TODO Auto-generated method stub    

 8         /

 9           非同类中调用办法:

10           不是同类的话那么就必必要实例化对象才干调用办法...

11           那么如何实例化呢？这些如今临时不须要知道，只知道如何调用办法就够了，后面会慢慢讲解

12           实例化后经由过程    对象名.办法名（）; 就可以调用了 。 如下:

13          /

14         A a=new A（）;

15         a.b（）;

16         //输出成果为:对象A的b办法。

17     }

18 }