static关键字
static关键字
static关键字
static是一个修饰符,用于修饰成员(包括成员变量,成员函数),当几个对象有相同的元素,就可以将其static;当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外,还可以被类名调用:类名.静态成员;
static修饰的成员变量和函数存在于方法区(或者叫做数据区,共享区);
1.static修饰的成员的特点
1.static修饰的成员随着类的加载而加载,随着类的消失而消失,说明生命周期很长;
2.优先于对象存在,静态是先存在的,对象是后存在的;
3.可以直接被类名所调用;
4.被所有对象所共享
2.实例变量和类变量的区别
1.存放位置
类变量随着类的加载而存在于方法区;
实例变量随着对象的家里而存在于堆内存中;
2.生命周期
类变量生命周期最长,随着类的消失而消失;
实例变量声明周期随着对象的消失而消失;
3.使用静态的注意事项
1.静态方法只能访问静态变量和方法;
2.非静态方法可以访问静态和非静态//静态成员优于对象存在,所以可以使用;
3.静态方法不能定义this,super关键字,因为静态优先于对象存在,所以静态方法中不可以出现this;
4.主函数是静态的;
4.静态成员的利弊
利:对对象的共享数据进行单独空间的存储,节省空间;
弊:声明周期很长,访问出现局限;
5.静态的使用
什么时候使用静态变量
1.当对象中出现共享数据时,该数据被静态所修饰;
什么时候使用静态函数
1.当功能内部没有访问到非静态数据,(即没有访问到特有数据时)那么该功能可以被定义成静态的;
6.在编程的过程中原则:
1.能私有化的尽量私有化;
2.能创建类的尽量创建类;
3.能static的尽量static;
7.静态的一个应用–工具类
每个应用程序中,都有共性功能,可以将这些功能进行抽取独立封装,以便复用
在一般工具类中,里面没有其他成员变量了,全只有方法,所以这些方法全定义成static,同时为了程序的严谨性,可以将
构造函数定义成private,这样就不用new了,而直接(类名.方法)来调用,不占更多的内存
8.程序实例
1./*
2.这里我们发现当建立new ArrayTool这个对象时,该对象并没有封装特有数据,
3.里面操作数组的方法并没有用该对象里面任何的特有数据,
4.所以我们考虑程序更严谨,这里并不需要对象,我们可以将ArrayTool中的方法静态化static,
5.直接用类名调用即可
6.*/
7.
8./*
9.将这些方法都静态后,但该类还是可以被其他程序建立对象,
10.因为类中还默认为该类建立了空参数的构造函数,ArrayTool(){},
11.所以为了让程序更严谨,强制让该类不能建立对象,
12.可以通过将构造函数私有化完成.通过:private ArrayTool(){},
13.这样我们就可以在外面建立这个对象,只能调用里面的方法
14.*/
15.
16./*
17.这种工具类,一般里面都定义成静态方法
18.*/
19.class ArrayToolDemo
20.{
21. public static void main(String[] args)
22. {
23. int[] arr={3,2,5,77,55,66,41,21};
24. /*
25. ArrayTool tool=new ArrayTool();
26. System.out.println(tool.getMax(arr));
27. tool.printArray(arr);
28. tool.selectSort(arr);
29. tool.printArray(arr);
30. int[] arr2={2,5,6,87,77,54};
31. tool.selectSort(arr2);
32. tool.printArray(arr2);
33. */
34. System.out.println(ArrayTool.getMax(arr));
35. ArrayTool.printArray(arr);
36. ArrayTool.selectSort(arr);
37. ArrayTool.printArray(arr);
38. int[] arr2={2,5,6,87,77,54};
39. ArrayTool.selectSort(arr2);
40. ArrayTool.printArray(arr2);
41.
42. }
43.}
44.
45.
46./*
47.下面是ArrayTool的代码:
48.class ArrayTool
49.{
50. private ArrayTool()
51. {
52. }
53. public static int getMax(int[] arr)
54. {
55. int max=0;
56. for (int i=0;i<arr.length ;i++ )
57. {
58. if (arr[i]>arr[max])
59. {
60. max=i;
61. }
62. }
63. return arr[max];
64. }
65. public static int getMin(int[] arr)
66. {
67. int min=0;
68. for (int i=0;i<arr.length ;i++ )
69. {
70. if (arr[i]<arr[min])
71. {
72. min=i;
73. }
74. }
75. return arr[min];
76.
77. }
78. public static void selectSort(int[] arr)
79. {
80. for (int i=0;i<arr.length ;i++ )
81. {
82. for (int j=i+1;j<arr.length ;j++ )
83. {
84. if (arr[i]>arr[j])
85. {
86. swap(arr,i,j);
87. }
88. }
89. }
90. }
91. //因为swap不用给外部提供,只需要内部使用,所以私有化private
92. private static void swap(int[] arr,int x,int y)
93. {
94. int temp=arr[x];
95. arr[x]=arr[y];
96. arr[y]=temp;
97. }
98. public static void printArray(int[] arr)
99. {
100. System.out.print("[");
101. for (int i=0;i<arr.length ;i++ )
102. {
103. if (i!=arr.length-1)
104. {
105. System.out.print(arr[i]+",");
106. }else
107. {
108. System.out.print(arr[i]+"]");
109. }
110. }
111. }
112.}
113.
114.*/
9.静态代码块
1.格式
1.static
2.{
3. 执行代码
4.}
2.特点
-
随着类的加载而执行,只执行一次,最先执行
-
用于给类进行初始化
-
类的加载可以通过直接调用类中的静态方法或者new对象来实现类的加载
3.下面的一个程序来说明程序执行顺序
1./*
2.上面程序的执行顺序是:
3. new对象 --> 类中的静态代码块 --> 构造函数代码块 --> 对应对象的构造函数
4.加载Test1类 --> 对类进行初始化 --> 对所有对象初始化--> 对对应对象初始化
5.*/
6.class TestDemo
7.{
8. public static void main(String[] args)
9. {
10. new Test1();
11. }
12.}
13.class Test1
14.{
15. static
16. {
17. System.out.println("a");//静态代码块
18. }
19. {
20. System.out.println("b");//构造代码块
21. }
22. Test1()
23. {
24. System.out.println("c");//构造函数
25. }
26.}
