JAVA之旅（五）——this，static，关键字，main函数，封装工具类，生成javadoc说明书，静态代码块
一.this关键字
用于区分局部变量和成员变量同名的情况
this的特点
this就代表本类对象这在我们的set方法里面是有的
2
3
4
2 this.name = name;
3 }
4
this代表他所在的函数对属对象的引用
现在我们这里有这么一个需求
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5 /**
6 * 需求：给人定义一个用于比较年龄相同的功能，也就是是否是同龄人
7 */
8 Person p1 = new Person(20);
9 Person p2 = new Person(25);
10 boolean b = p1.compare(p2);
11 System.out.println(b);
12
13 }
14
15}
16
17class Person {
18
19 private int age;
20
21 // 一初始化就有年龄
22 public Person(int age) {
23 this.age = age;
24
25 }
26
27 public int getAge() {
28 return age;
29 }
30
31 public void setAge(int age) {
32 this.age = age;
33 }
34
35 public boolean compare(Person p) {
36
37 return this.age == p.age;
38 }
39
40}
41
42
得到的结果肯定是false啦
可以知道，当定义类中的功能时，该函数内部要用到该函数的对象时，这时用this来表示，但凡本类功能内部使用到了本类对象，都用this表示
我们再来看个小知识点，我们看一个需求
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5
6 // 构造函数间只能用this语句
7 }
8
9}
10
11class Person {
12
13 private int age;
14 private String name;
15
16 public Person(int age) {
17 this.age = age;
18 }
19
20 public Person(int age, String name) {
21 this(age); // 代表p的age
22 this.name = name;
23 }
24
25}
26
27
this()函数的引用，这里我们要注意，this语句只能放在构造函数的第一行对对象进行初始化
二.static关键字
静态，我们来看一个小例子
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5
6 Person p = new Person();
7 p.age = 18;
8 p.show();
9 }
10
11}
12
13class Person {
14
15 int age;
16 String name = "lgl";
17 static String country = "cn";
18
19 public void show() {
20 System.out
21 .println("你的名字:" + name + "今年:" + age + "岁" + "国籍：" + country);
22 }
23
24}
25
26
static是一个修饰符，是一个修饰成员变量，成员函数的关键字，被静态修饰之后，他就不在内存中了，被单独提取出来，每个人都能访问，静态修饰内容被对象所共享
当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用外，还可以直接被类名调用：类名.静态成员
2
2
一样可以
这样，我们可以总结一下static的特点
- 1.随着类的加载而加载
所谓随着类的加载而加载，Person这个类你一使用的时候，静态就已经存在了
- 2.优先于对象存在
明确一点，静态时先存在的，参照1
- 3.被所有对象所共享
- 4.可以直接被类名所调用
实例变量和类变量的区别：
-
存放位置
-
类变量随着类的加载而存在于方法区中，随着类的消失而消失
- 实例变量随着对象的建立而存在于堆内存中
-
生命周期
-
类变量生命周期最长，随着类的消失而消失
- 实例变量的生命周期随着对象的消失而消失
静态变量的使用注意事项
-
静态方法只能访问静态成员
-
非静态方法方法即可以访问静态也可以访问非静态
-
静态方法中不可以定义this，super关键字，因为静态优先于对象存在，所在静态方法中不可以出现他们
-
主函数是静态
静态有利有弊
- 利：对对象的共享数据进行单独控件的存储，节省空间，没必要每个对象都存储一遍，也可以直接被类名调用
- 弊：生命周期过长，访问出现局限性（静态虽好，只能访问静态）
这里要说一个小知识点：
main函数
主函数大家应该都很熟悉了
主函数是一个特殊的函数，可以被JVM调用，作为程序的入口
- public:代表的该访问权限是最大的
- static:代表主函数随着类的加载而存在
- void：主函数没有具体的返回值
- main:不是关键字，但是是一个特殊的单词，可以被jvm识别
- 函数的参数：参数类型是一个数组，该数组中的元素是字符串，字符串类型的数组
主函数的格式是固定的，jvm识别
OK，了解了主函数，我们回到静态，什么时候使用static?
要从两方面下手，因为静态修饰的内容有成员变量和函数
- 什时候定义静态变量
当对象中出现共享数据时，该数据被静态修饰，对象中的特有数据，定义成非静态，存在于堆内存中
- 什么时候定义静态函数
当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义为静态
封装工具类
我们可以看我们是怎么求最大值的
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5
6 int[] arr = { 0, 9, 0, 6, 2, 8 };
7 int max = getMa(arr);
8 System.out.println("最大值：" + max);
9
10 }
11
12 /**
13 * 求一个数组的最大值
14 * @param arr
15 * @return
16 */
17 public static int getMa(int[] arr) {
18 int max = 0;
19 for (int i = 0; i < arr.length; i++) {
20 if (arr[i] > arr[max]) {
21 max = i;
22 }
23 }
24 return arr[max];
25 }
26}
27
28
我们把这个方法提取出来，确实很方便，但是，要是其他的类也有数组需要求最大值呢？这个时候我们就可以封装成一个工具类了
-
每一个应用程序都有共性的部分，可以将这些功能抽取，独立封装，以便使用，所以我们可以这样写：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
2 * 数组工具
3 *
4 * @author LGL
5 *
6 */
7public class ArrayTools {
8
9 /**
10 * 求一个数组的最大值
11 *
12 * @param arr
13 * @return
14 */
15 public static int getMax(int[] arr) {
16 int max = 0;
17 for (int i = 0; i < arr.length; i++) {
18 if (arr[i] > arr[max]) {
19 max = i;
20 }
21 }
22 return arr[max];
23 }
24
25 /**
26 * 求一个数组的最小值
27 *
28 * @param arr
29 * @return
30 */
31 public static int getMin(int[] arr) {
32 int min = 0;
33 for (int i = 0; i < arr.length; i++) {
34 if (arr[i] < arr[min]) {
35 min = i;
36 }
37 }
38 return arr[min];
39 }
40
41}
42
43
把获取最大值和最小值的方法都封装起来，用static去修饰，这样
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5
6 int[] arr = { 0, 9, 1, 6, 2, 8 };
7
8 int max = ArrayTools.getMax(arr);
9 int min = ArrayTools.getMin(arr);
10
11 System.out.println("最大值：" + max);
12 System.out.println("最小值：" + min);
13
14 }
15
16}
17
18
我们就可以直接去获取
虽然我们可以通过ArrayTools的对象使用这些方法，对数组进行操作，但是，会存在一些问题‘’
- 对象是用来封装数据的，可是ArrayTools 对象病没有封装特有的数据
- 操作一个数组的每个方法都没有用到ArrayTools 对象中的特有数据
这个时候我们可以考虑，让程序更加的严谨，不需要对象，可以将ArrayTools 的方法都定义成静态的，直接通过类名调用即可
生成javadoc说明书
当我们写好一个工具类的时候，是可用广为流传的，但是，人家也不知道呢写了啥呀，所以，我们写个说明书是必须的，首先回到我们的工具类
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
2 * 数组工具
3 *
4 * @author LGL
5 *
6 */
7public class ArrayTools {
8
9 /**
10 * 求一个数组的最大值
11 *
12 * @param arr
13 * 接收到数组
14 * @return
15 */
16 public static int getMax(int[] arr) {
17 int max = 0;
18 for (int i = 0; i < arr.length; i++) {
19 /**
20 * 两数比较
21 */
22 if (arr[i] > arr[max]) {
23 max = i;
24 }
25 }
26 /**
27 * 返回最大值
28 */
29 return arr[max];
30 }
31
32 /**
33 * 求一个数组的最小值
34 *
35 * @param arr
36 * 接收到数组
37 * @return
38 */
39 public static int getMin(int[] arr) {
40 int min = 0;
41 for (int i = 0; i < arr.length; i++) {
42 /**
43 * 两数比较
44 */
45 if (arr[i] < arr[min]) {
46 min = i;
47 }
48 }
49 /**
50 * 返回最小值
51 */
52 return arr[min];
53 }
54
55}
56
57
你可以看到，我们添加了很多的注释，现在我们可以去生成了，我们在jdk安装目录的bin文件下看到一个文件叫做javadoc,我们就需要他，我们可以在java类目录下
2
3
2javadoc -d myhelp -author ArrayTools.java
3
生成之后我们打开index.html
静态代码块
我们讲一个小知识点静态代码快，我们先看一下格式
2
3
4
5
6
2 static {
3 //静态代码快
4 }
5}
6
静态代码块的特点：随着类的加载而执行，只执行一次
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
2public class HelloJJAVA {
3 static {
4 // 静态代码快
5 System.err.println("b");
6 }
7
8 // 公共的 静态 无返回值 main方法 数组
9 public static void main(String[] str) {
10 new StaticDemo();
11 System.out.println("over");
12 }
13
14 static {
15 // 静态代码快
16 System.err.println("c");
17 }
18
19}
20
21class StaticDemo {
22 static {
23 // 静态代码快
24 System.err.println("a");
25 }
26}
27
我们可以猜猜看，执行的顺序是什么？静态方法是从上往下执行优先于mian方法的，所以是b,然后走main方法输出a,over
