java中static关键字的作用(java中static关键字的作用)

╰+哭是因爲堅強的太久メ 2023-09-25 08:31 106阅读 0赞

## 关键字static的作用是什么? ##

在Java语言中，static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。

static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用(当然也可以在非静态成员方法中使用)，但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：

类名.静态方法名(参数列表...)

类名.静态变量名

用static修饰的代码块表示静态代码块，当Java虚拟机(JVM)加载类时，就会执行该代码块(用处非常大)。

static在Java语言中的使用有四种：(变量、方法、代码块、内部类)

1、static变量

按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类

变量；另一种是没有被static修饰的变量，叫实例变量。

两者的区别是：

对于静态变量在内存中只有一个拷贝(节省内存)，JVM只为静态分配一次内存，在加载类的过

程中完成静态变量的内存分配，可用类名直接访问(方便)，当然也可以通过对象来访问(但是这是不推荐的)。

对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响(灵活)。

2、静态方法

静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！

因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

3、static代码块

static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

// -- Java code example :)

public class Test5 \{

private static int a;

private int b;

static \{

Test5.a = 3 ;

System.out.println(a);

Test5 t = new Test5();

t.f();

t.b = 1000 ;

System.out.println(t.b);

static \{

Test5.a = 4 ;

System.out.println(a);

public static void main(String\[\] args) \{

// TODO 自动生成方法存根

// -- static代码块的位置可以随便放置！

static \{

Test5.a = 5 ;

System.out.println(a);

public void f()\{

System.out.println( " hhahhahah " );

运行结果：

hhahhahah

利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。

4. 静态内部类(Inner Class)

为正确理解static在应用于内部类时的含义，必须记住内部类的对象默认持有创建它的那个封装类的一个对象的句柄。然而，假如我们说一个内部类是static的，这种说法却是不成立的。

static内部类意味着：

(1) 为创建一个static内部类的对象，我们不需要一个外部类对象。

(2) 不能从static内部类的一个对象中访问一个外部类对象。

但在存在一些限制：由于static成员只能位于一个类的外部级别，所以内部类不可拥有static数据或static内部类。

倘若为了创建内部类的对象而不需要创建外部类的一个对象，那么可将所有东西都设为static。为了能正常工作，同时也必须将内部类设为static。如下所示：

//: Parcel10.Java

// Static inner classes

package c07.parcel10;

abstract class Contents \{

abstract public int value();

interface Destination \{

String readLabel();

public class Parcel10 \{

private static class PContents

extends Contents \{

private int i = 11;

public int value() \{ return i; \}

protected static class PDestination

implements Destination \{

private String label;

private PDestination(String whereTo) \{

label = whereTo;

public String readLabel() \{ return label; \}

public static Destination dest(String s) \{

return new PDestination(s);

public static Contents cont() \{

return new PContents();

public static void main(String\[\] args) \{

Contents c = cont();

Destination d = dest("Tanzania");

\} ///:~

在main()中，我们不需要Parcel10的对象；相反，我们用常规的语法来选择一个static成员，以便调用将句柄返回Contents和Destination的方法。

通常，我们不在一个接口里设置任何代码，但static内部类可以成为接口的一部分。由于类是“静态”的，所以它不会违反接口的规则——static内部类只位于接口的命名空间内部：

//: IInterface.java// Static inner classes inside interfaces

interface IInterface \{

static class Inner \{

int i, j, k;

public Inner() \{\}

void f() \{\}

\} ///:~

建议大家在每个类里都设置一个main()，将其作为那个类的测试床使用。但这样做的一个缺点就是额外代码的数量太多。若不愿如此，可考虑用一个static内部类容纳自己的测试代码。如下所示：

//: TestBed.java// Putting test code in a static inner class

class TestBed \{

TestBed() \{\}

void f() \{ System.out.println("f()"); \}

public static class Tester \{

public static void main(String\[\] args) \{

TestBed t = new TestBed();

t.f();

\} ///:~

这样便生成一个独立的、名为TestBed$Tester的类(为运行程序，请使用“java TestBed$Tester”命令)。可将这个类用于测试，但不需在自己的最终发行版本中包含它。

PS: 静态内部类--代码示例

Java中我们经常会使用到内部类(inner classes)，如果没有Static的内部类，它的instance的创建是依赖于其元类的。这样的关系似乎比较难表达，让我们直接看下面的代码：

1: public class Outer \{

2:int var;

4:void outerHoge() \{

5:System.out.println("hogehoge");

6:\}

8:void outerHote2() \{

10:Inner i = new Inner();

11:staticHoge sh = new StaticHoge();

13:

17: //Inner i2 = new this.Inner();

18:\}

20:

21:class Inner \{

22:void innerHoge() \{

23:

26:var = 1;

27:outerHoge();

28:\}

29:\}

31:static class StaticHoge() \{

32:void methodHoge() \{

33:

36: //var = 10;

37: //outerHoge();

38: //Inner inner = new Inner();

39:\}

40:\}

41: \}

static的内部类的使用，我们可以像Package一样用它：

1: public class Outer2 \{

2:public static class StaticHoge1 \{

3://...

4:\}

5:public static class StaticHoge2 \{

6://...

7:\}

可以像下面这样使用：

1: Outer2.StaticHoge1 sh1 = new Outer2.StaticHoge1();

2: Outer2.StaticHoge2 sh2 = new Outer2.StaticHoge2();声明为static的变量实质上就是全局变量。声明为static的方法有以下几条限制：

它们仅能调用其他的static 方法。

它们只能访问static数据。

它们不能以任何方式引用this 或super

如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。

## java中static怎么用 ##

static 属于全局，也就是类的属性 和方法，换句话说 一个类，不管有多少个实例，却只有一个全局变量

class B \{static int a=0;\}

B b1=new B();..................；B bn=new B();

b1~bn 都是类B的实例，每个实例都共享 变量a，a是全局变量，属于类B的属性，每个实例都能引用变量a,

加入执行b1.a=1;后 那么b2.a,b3.a,b4.a......bn.a 都等于1了，

static 方法也是类似的

需要注意的是 静态属性和方法属于类方法，加载类后，就已经存在静态属性和方法，实例是需要用new构造出来后 才会有引用

根据先后顺序，就有以下两条规则

1、非静态的方法可以调用静态的或者非静态的属性和方法；

2、静态的方法不可以调用非静态的属性和方法，因为非静态的还不一定存在，只能先构造出来后，再通过实例引用

例如 在main方法中 可以直接调用static 的方法，调用非static方法 需要先构造出类的实例，通过实例才能调用方法1、static 关键字：可以用于修饰属性，也可以用于修饰方法，还可以用于修饰类。

2、static 修饰属性：无论一个类生成了多少个对象，所有这些对象共同使用唯一一份静态的成员变量；一个对象对该静态成员变量进行了修改，其他对象的该静态成员变量的值也会随之发生变化。如果一个成员变量是static 的，那么我们可以通过 类名 .成员变量名 成员变量名 成员变量名 的方式来使用它 的方式来使用它 (推荐使用这种方式) 。

3、static修饰方法： static 修饰的方法叫做静态。 对于静态方法来说，可以 使用 类名 .方法名的方式来访问。

4、静态方法只能继承，不重写(Override)

5、不能在静态方法中访问非静态成员变量；

6、不能在静态方法中使用this关键字。上面的回答很好，补充一些，在修饰类时，注意要在同一个包下的类中才可以直接 类名.方法()\\属性！不需要实例化！static关键字

在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说，static成员变量只有一份。

用static声明的方法是静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员

\#\#静态方法不再是针对于某个对象调用，所以不能访问非静态成员

可以通过对象引用或类名(不需要实例化)访问静态成员

如果某些成员函数只访问静态数据成员，那么最好把他们声明为静态的成员函数，因为这样不需要特定的对象就可以访问这些成员变量了。