很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。
static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。
1）static方法
static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。
2）static变量
static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
static成员变量的初始化顺序按照定义的顺序进行初始化。
1. Java类中可以定义一个static块，用于静态变量的初始化。如：
- public class Test {
- public static int _i;
- static {
- _i = 10;
- }
- }
当然最常用的初始化静态变量的操作是在声明变量时直接进行赋值操作。如：
- public class Test {
- public static int _i = 10;
- }
2. 由于静态变量是通过赋值操作进行初始化的，因此可以通过静态函数返回值的方式为其初始化。如：
- public class Test {
- public static int _i = init();
- private static int init() {
- return 10;
- }
- }
其本质与下面的代码相同：
- public class Test {
- public static int _i;
- static {
- _i = init();
- }
- private static int init() {
- return 10;
- }
- }
3. 类定义中可以存在多个static块吗？回答是可以。如：
- public class Test {
- public static int _i;
- static {
- _i = 10;
- }
- public static void main(String[] args) {
- }
- static {
- _i = 20;
- }
- }
- public class Test {
- public static int _i;
- public static void main(String[] args) {
- }
- static {
- _i = 10;
- _i = 20;
- }
- }
- public class Test {
- public static int _i = 10;
- }
- 静态变量的声明与初始化是两个不同的操作；
- 静态变量的声明在编译时已经明确了内存的位置。
如：
- public class Test {
- public static int _i = 10;
- }
上述代码的本质可以视为：
- public class Test {
- // 静态变量的声明
- public static int _i;
- // 静态变量的初始化
- static {
- _i = 10;
- }
- }
由于静态变量的声明在编译时已经明确，所以静态变量的声明与初始化在编码顺序上可以颠倒。也就是说可以先编写初始化的代码，再编写声明代码。如：
- public class Test {
- // 静态变量的初始化
- static {
- _i = 10;
- }
- // 静态变量的声明
- public static int _i;
- }
1.static关键字会改变类中成员的访问权限吗？
有些初学的朋友会将java中的static与C/C++中的static关键字的功能混淆了。在这里只需要记住一点：与C/C++中的static不同，Java中的static关键字不会影响到变量或者方法的作用域。在Java中能够影响到访问权限的只有private、public、protected（包括包访问权限）这几个关键字。看下面的例子就明白了：
提示错误"Person.age 不可视"，这说明static关键字并不会改变变量和方法的访问权限。
2.能通过this访问静态成员变量吗？
虽然对于静态方法来说没有this，那么在非静态方法中能够通过this访问静态成员变量吗？先看下面的一个例子，这段代码输出的结果是什么？
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public
class
Main {
static
int
value =
33
;
public
static
void
main(String[] args)
throws
Exception{
new
Main().printValue();
}
private
void
printValue(){
int
value =
3
;
System.out.println(
this
.value);
}
}
|
33
这里面主要考察队this和static的理解。this代表什么？this代表当前对象，那么通过new Main()来调用printValue的话，当前对象就是通过new Main()生成的对象。而static变量是被对象所享有的，因此在printValue中的this.value的值毫无疑问是33。在printValue方法内部的value是局部变量，根本不可能与this关联，所以输出结果是33。在这里永远要记住一点：静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。
3.static能作用于局部变量么？
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
|
public
class
Test
extends
Base{
static
{
System.out.println(
"test static"
);
}
public
Test(){
System.out.println(
"test constructor"
);
}
public
static
void
main(String[] args) {
new
Test();
}
}
class
Base{
static
{
System.out.println(
"base static"
);
}
public
Base(){
System.out.println(
"base constructor"
);
}
}
|
base static test static base constructor test constructor
至于为什么是这个结果，我们先不讨论，先来想一下这段代码具体的执行过程，在执行开始，先要寻找到main方法，因为main方法是程序的入口，但是在执行main方法之前，必须先加载Test类，而在加载Test类的时候发现Test类继承自Base类，因此会转去先加载Base类，在加载Base类的时候，发现有static块，便执行了static块。在Base类加载完成之后，便继续加载Test类，然后发现Test类中也有static块，便执行static块。在加载完所需的类之后，便开始执行main方法。在main方法中执行new Test()的时候会先调用父类的构造器，然后再调用自身的构造器。因此，便出现了上面的输出结果。
2.这段代码的输出结果是什么？
|
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
|
public
class
Test {
Person person =
new
Person(
"Test"
);
static
{
System.out.println(
"test static"
);
}
public
Test() {
System.out.println(
"test constructor"
);
}
public
static
void
main(String[] args) {
new
MyClass();
}
}
class
Person{
static
{
System.out.println(
"person static"
);
}
public
Person(String str) {
System.out.println(
"person "
+str);
}
}
class
MyClass
extends
Test {
Person person =
new
Person(
"MyClass"
);
static
{
System.out.println(
"myclass static"
);
}
public
MyClass() {
System.out.println(
"myclass constructor"
);
}
}
|
test static myclass static person static person Test test constructor person MyClass myclass constructor
类似地，我们还是来想一下这段代码的具体执行过程。首先加载Test类，因此会执行Test类中的static块。接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。
3.这段代码的输出结果是什么？
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public
class
Test {
static
{
System.out.println(
"test static 1"
);
}
public
static
void
main(String[] args) {
}
static
{
System.out.println(
"test static 2"
);
}
}
|
test static 1 test static 2
- public class Test {
- static {
- _i = 20;
- }
- public static int _i = 10;
- public static void main(String[] args) {
- System.out.println(_i);
- }
- }
其本质可以用下面的代码表示：
- public class Test {
- static {
- _i = 20;
- }
- public static int _i;
- static {
- _i = 10;
- }
- public static void main(String[] args) {
- System.out.println(_i);
- }
- }
再简化一下，可以表示为：
- public class Test {
- public static int _i;
- static {
- _i = 20;
- _i = 10;
- }
- public static void main(String[] args) {
- System.out.println(_i);
- }
- }
扫一扫
214
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
