本章内容:

1.static静态关键字概述
2.静态变量
3.静态方法
4.总结

1.static静态关键字概述

关于 static 关键字的使用,它可以用来修饰的成员变量和成员方法,被修饰的成员是属于类的,而不是单单是属 于某个对象的。也就是说,既然属于类,就可以不靠创建对象来调用了。

在一个类中,有变量和方法,而变量有成员变量,静态变量;而方法有成员方法和静态方法之分(只要带static关键字就代表静态变量或方法)

如何区分我们什么时候使用static关键字呢?


从上述图中我们可以看出在学生类中,我们new三个学生对象,每一个对象除了姓名,年龄,学号不同之外,每一个学生对象的所在教室完全一样。
对于姓名,年龄,学号来说,每一个对象都有自己独立的数据。但对于所在的教室来说,这应该是多个对象共享同一份数据才对。
一旦使用了static关键字,那么这样的内容不在属于对象自己,而是属于类的,所以凡是本类的对象,都共享同一份

我们来实现这个图片展示的功能(以标准的类的创建方式):

1
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
58
59
60
61
62
63
64
65
66
67
68
69
package com.bytedance;

public class staticDemo {
public static void main(String[] args) {
// 静态static常量赋初值(类名称.变量名)
Student1.room = "101教室";

Student1 one = new Student1("郭靖", 20);
System.out.println("one的姓名:" + one.getName());
System.out.println("one的年龄:" + one.getAge());
System.out.println("one的教室:" + Student1.room);
System.out.println("============");

Student1 two = new Student1("黄蓉", 18);
System.out.println("two的姓名:" + two.getName());
System.out.println("two的年龄:" + two.getAge());
System.out.println("two的教室:" + Student1.room);

myMethod() // 本类中的静态方法直接调用
}
// 本类中的静态方法,调用时可以省略类名称,直接调用
public static void myMethod() {
System.out.println("自己的方法!");
}
}


class Student1 {

private int id; // 学号
private String name; // 姓名
private int age; // 年龄
static String room; // 所在教室
private static int idCounter = 0; // 学号计数器,每当new了一个新对象的时候,计数器++

public Student1() {
this.id = ++idCounter;
}

public Student1(String name, int age) {
this.name = name;
this.age = age;
this.id = ++idCounter;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}

2.静态变量

静态变量 : static 数据类型 变量名 (static int numberID)

      比如说,基础班新班开班,学员报到。现在想为每一位新来报到的同学编学号(sid),从第一名同学开始,sid为 1,以此类推。学号必须是唯一的,连续的,并且与班级的人数相符,这样以便知道,要分配给下一名新同学的学 号是多少。这样我们就需要一个变量,与单独的每一个学生对象无关,而是与整个班级同学数量有关

1
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
package com.bytedance;

public class staticDemo {
public static void main(String[] args) {
Student1 s1 = new Student1("迪丽热巴",18);
Student1 s2 = new Student1("古力娜扎",20);
Student1 s3 = new Student1("马尔扎哈",33);
s1.show(); // Student : name=迪丽热巴, age=18, 学生编号=1
s2.show(); // Student : name=古力娜扎, age=20, 学生编号=2
s3.show(); // Student : name=马尔扎哈, age=33, 学生编号=3
}
}


class Student1{
// 成员变量
private String name;
private int age;
// 学生的id
private int id;
// 静态变量,记录学生数量,分配学号
public static int numberNo = 0;

public Student1(String name,int age){
this.name = name;
this.age = age;
// 表示每创建一个Student1对象,id就会自动加一
this.id = ++ numberNo;
}
// 打印属性值   
public void show() {
System.out.println("Student : name="+this.name+", age="+this.age+", 学生编号="+this.id);
}
}

3.静态方法

使用格式: 修饰符 static 返回值类型 方法名 (参数列表){ // 执行语句代码块 }

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员,原因即多个对象均属 于一个类,共享使用同一个静态成员,但是不建议,会出现警告信息。

1
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
package com.bytedance;

public class staticDemo {
public static void main(String[] args) {
MyClass obj = new MyClass(); // 首先创建对象
obj.num = 18;
MyClass.numStatic = 20;

// 创建对象之后,然后才能使用没有static关键字的内容
obj.method();

// 对于静态方法来说,可以通过对象名进行调用,也可以直接通过类名称来调用。
obj.methodStatic(); // 正确,不推荐,这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”

MyClass.methodStatic(); // 正确,推荐

// 对于本类当中的静态方法,可以省略类名称
myMethod();
staticDemo.myMethod(); // 对于本类中的静态方法,myMethod()与staticDemo.myMethod()完全等效,可以省略类名称
}

public static void myMethod() {
System.out.println("自己的方法!");
}
}


class MyClass {
int num; // 成员变量
static int numStatic; // 静态变量

// 成员方法
public void method() {
System.out.println("这是一个成员方法。");
// 成员方法可以访问成员变量
System.out.println(num);
// 成员方法可以访问静态变量
System.out.println(numStatic);
}

// 静态方法
public static void methodStatic() {
System.out.println("这是一个静态方法。");
// 静态方法可以访问静态变量
System.out.println(numStatic);
// 静态不能直接访问非静态【重点】
// System.out.println(num); // 错误写法!

// 静态方法中不能使用this关键字。
// System.out.println(this); // 错误写法!
}}

4. 总结

一旦使用static修饰成员方法,那么这就成为了静态方法。静态方法不属于对象,而是属于类的。

如果没有static关键字,那么必须首先创建对象,然后通过对象才能使用它。
如果有了static关键字,那么不需要创建对象,直接就能通过类名称来使用它。

无论是成员变量,还是成员方法。如果有了static,都推荐使用类名称进行调用
静态变量\:类名称.静态变量
静态方法\:类名称.静态方法()

静态常量赋初始值的方法:类名称.静态变量名 = 初始值

注意事项:

  1. 静态方法只能访问静态成员,实例方法可以访问静态和实例成员。反之,成员方法可以直接访问类变量或静态方法
    原因:因为在内存当中是【先】有的静态内容,【后】有的非静态内容。
    “先人不知道后人,但是后人知道先人。”

  2. 静态方法当中不能用this。
    原因:this代表当前对象,通过谁调用的方法,谁就是当前对象。

  3. 对于本类当中的静态方法,调用时可以省略类名称

参考文献


 评论

联系我 | Contact with me

Copyright © 2019-2020 谁知你知我,我知你知深。此恨经年深,比情度日久

博客内容遵循 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议