javastatic,javastatic关键字

发布时间：2023-01-09

本文目录一览：

  1. java中static是什么意思？能不能通俗的讲下，让我这个菜鸟好理解一点
  2. java中的static到底有什么作用?
  3. [java static有什么好处](#java static有什么好处)
  4. java中static怎么用
  5. Java中static的作用?
  6. [java static是什么意思？](#java static是什么意思？)

java中static是什么意思？能不能通俗的讲下，让我这个菜鸟好理解一点

static 英文是静态的意思，所以它在 Java 中也是这么用的，是一个修饰词。在定义数据前面加上它是说这个数据是静态不变的，在方法名前面加上它是说这个方法是静态的。一般就是这些用处。

java中的static到底有什么作用?

static 表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态 static 代码块，但是 Java 语言中没有全局变量的概念。被 static 修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。 static 变量前可以有 private 修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private 是访问权限限定，static 表示不要实例化就可以使用，这样就容易理解多了。static 前面加上其它访问权限关键字的效果也以此类推。

java static有什么好处

作用

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字 static（静态的）就能创建这样的成员。如果一个成员被声明为 static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为 static。static 成员的最常见的例子是 main()。因为在程序开始执行时必须调用 main()，所以它被声明为 static。 声明为 static 的变量实质上就是全局变量。当声明一个对象时，并不产生 static 变量的拷贝，而是该类所有的实例变量共同拥有一个 static 变量。声明为 static 的方法有以下几条限制：

  • 它们仅能调用其他的 static 方法。
  • 它们只能访问 static 数据。
  • 它们不能以任何方式引用 this 或 super（关键字 super 与继承有关）。

举例

如果你需要通过计算来初始化你的 static 变量，你可以声明一个 static 块。static 块仅在该类被加载时执行一次。下面的例子显示的类有一个 static 方法，一些 static 变量，以及一个 static 初始化块：

// Demonstrate static variables，methods，and blocks.
class UseStatic {
    static int a = 3;
    static int b;
    static void meth(int x) {
        System.out.println("x = " + x);
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
    static {
        System.out.println("Static block initialized.");
        b = a * 4;
    }
    public static void main(String args[]) {
        meth(42);
    }
}

一旦 UseStatic 类被装载，所有的 static 语句被运行。首先，a 被设置为 3，接着 static 块执行（打印一条消息），最后，b 被初始化为 a * 4 或 12。然后调用 main()，main() 调用 meth()，把值 42 传递给 x。3 个 println() 语句引用两个 static 变量 a 和 b，以及局部变量 x。 注意：在一个 static 方法中引用任何实例变量都是非法的。 下面是该程序的输出：

Static block initialized.
x = 42
a = 3
b = 12

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 方法需要先构造出类的实例，通过实例才能调用方法。

Java中static的作用?

1. static 成员变量

在类中一个成员变量可用 static 关键字来修饰，这样的成员变量称为 static 成员变量，或静态成员变量。而没有用 static 关键字修饰的成员变量称为非静态成员变量。 静态成员变量是属于类的，也就是说，该成员变量并不属于某个对象，即使有多个该类的对象实例，静态成员变量也只有一个。只要静态成员变量所在的类被加载，这个静态成员变量就会被分配内存空间。因此在引用该静态成员变量时，通常不需要生成该类的对象，而是通过类名直接引用。引用的方法是“类名.静态变量名”。当然仍然可以通过“对象名.静态变量名”的方式引用该静态成员变量。相对应的非静态成员变量则属于对象而非类，只有在内存中构建该类对象时，非静态成员变量才被分配内存空间。

2. static 成员方法

Java 中也支持用 static 关键字修饰的成员方法，即静态成员方法。与此相对应的没有用 static 修饰的成员方法称为非静态成员方法。 与静态成员变量类似，静态成员方法是类方法，它属于类本身而不属于某个对象。因此静态成员方法不需要创建对象就可以被调用，而非静态成员方法则需要通过对象来调用。 特别需要注意的是，在静态成员方法中不能使用 this、super 关键字，也不能调用非静态成员方法，同时不能引用非静态成员变量。这个道理是显而易见的，因为静态成员方法属于类而不属于某个对象，而 this、super 都是对象的引用，非静态成员方法和成员变量也都属于对象。所以当某个静态成员方法被调用时，该类的对象可能还没有被创建，那么在静态成员方法中调用对象属性的方法或成员变量显然是不合适的。即使该类的对象已经被创建，也是无法确定它究竟是调用哪个对象的方法，或是哪个对象中的成员变量的。所以在这里特别强调这一点。

3. static 代码块

static 代码块又称为静态代码块，或静态初始化器。它是在类中独立于成员函数的代码块。static 代码块不需要程序主动调用，在 JVM 加载类时系统会执行 static 代码块，因此在 static 代码块中可以做一些类成员变量的初始化工作。如果一个类中有多个 static 代码块，JVM 将会按顺序依次执行。需要注意的是，所有的 static 代码块只能在 JVM 加载类时被执行一次。

4. static 内部类

在 Java 中还支持用 static 修饰的内部类，称为静态内部类。静态成员内部类的特点主要是它本身是类相关的内部类，所以它可以不依赖于外部类实例而被实例化。静态内部类不能访问其外部类的实例成员（包括普通的成员变量和方法），只能访问外部类的类成员（包括静态成员变量和静态方法）。即使是静态内部类的实例方法（非静态成员方法）也不能访问其外部类的实例成员。

java static是什么意思？

是静态修饰符，什么叫静态修饰符呢？大家都知道，在程序中任何变量或者代码都是在编译时由系统自动分配内存来存储的，而所谓静态就是指在编译后所分配的内存会一直存在，直到程序退出内存才会释放这个空间，也就是只要程序在运行，那么这块内存就会一直存在。这样做有什么意义呢？ 在 Java 程序里面，所有的东西都是对象，而对象的抽象就是类，对于一个类而言，如果要使用他的成员，那么普通情况下必须先实例化对象后，通过对象的引用才能够访问这些成员，但是有种情况例外，就是该成员是用 static 声明的（在这里所讲排除了类的访问控制），例如：

未声明为 static

class ClassA {
    int b;
    public void ex1() {
        ...
    }
}
class ClassB {
    void ex2() {
        int i;
        ClassA a = new ClassA();
        i = a.b; // 这里通过对象引用访问成员变量b
        a.ex1(); // 这里通过对象引用访问成员函数ex1
    }
}

声明为 static

class ClassA {
    static int b;
    static void ex1() {
        ...
    }
}
class ClassB {
    void ex2() {
        int i;
        i = ClassA.b; // 这里通过类名访问成员变量b
        ClassA.ex1(); // 这里通过类名访问成员函数ex1
    }
}

通过以上两种比较，就可以知道 static 用来修饰类成员的主要作用了，在 Java 类库当中有很多类成员都声明为 static，可以让用户不需要实例化对象就可以引用成员，最基本的有 Integer.parseInt()、Float.parseFloat() 等等用来把对象转换为所需要的基本数据类型。这样的变量和方法我们又叫做类变量和类方法。 接下来讲一下被 static 修饰后的变量的值的问题，刚才在前面讲过，被 static 修饰后的成员，在编译时由内存分配一块内存空间，直到程序停止运行才会释放，那么就是说该类的所有对象都会共享这块内存空间，看一下下面这个例子：

class TStatic {
    static int i;
    public TStatic() {
        i = 4;
    }
    public TStatic(int j) {
        i = j;
    }
    public static void main(String args[]) {
        TStatic t = new TStatic(5); // 声明对象引用，并实例化
        TStatic tt = new TStatic(); // 同上
        System.out.println(t.i);
        System.out.println(tt.i);
        System.out.println(t.i);
    }
}

这段代码里面 Tstatic 类有一个 static 的 int 变量 i，有两个构造函数，第一个用于初始化 i 为 4，第二个用于初始化 i 为传进函数的值，在 main 中所传的值是 5，程序首先声明对象的引用 t，然后调用带参数的构造函数实例化对象，此时对象 t 的成员变量 i 的值为 5，接着声明对象 tt，调用无参数的构造函数，那么就把对象 tt 的成员变量 i 的值初始化为 4 了，注意了，在这里 i 是 static，那就是说该类的所有对象都共享该内存，那也就是说在实例化对象 tt 的时候改变了 i 的值，那么实际上对象 t 的 i 值也变了，因为实际上它们引用的是同一个成员变量。最后打印的结果是三个 4。

推荐文章