java static 详解

Posted 2023-03-31 春风化作秋雨

1、static目的 

java中的static关键字主要用于内存管理。

2、static范围

使用范围：java static关键字可以用在变量、方法、代码块和嵌套类伤。

作用范围：static关键字属于类，而不是类的实例。

静态(static)修饰如下：

1. 变量：称为类变量、静态变量
2. 方法：称为类方法、静态方法
3. 代码块：称为静态代码块
4. 嵌套类：称为静态内部类

---

3、静态变量

类的成员变量可以分为以下两种：

1. 静态变量（或称为类变量），指被 static 修饰的成员变量。
2. 实例变量，指没有被 static 修饰的成员变量。

静态变量与实例变量的区别如下：
1）静态变量

1. 运行时，Java 虚拟机只为静态变量分配一次内存，加载类过程中完成静态变量的内存分配。
2. 在类的内部，可以在任何方法内直接访问静态变量。
3. 在其他类中，可以通过类名访问该类中的静态变量。

2）实例变量

1. 每创建一个实例，Java 虚拟机就会为实例变量分配一次内存。
2. 在类的内部，可以在非静态方法中直接访问实例变量。
3. 在本类的静态方法或其他类中则需要通过类的实例对象进行访问。

静态变量在类中的作用如下：

1. 静态变量可以被类的所有实例共享，因此静态变量可以作为实例之间的共享数据，增加实例之间的交互性。
2. 如果类的所有实例都包含一个相同的常量属性，则可以把这个属性定义为静态常量类型，从而节省内存空间。例如，在类中定义一个静态常量 PI。

静态变量的好处：它能使程序存储器高效(即它节省内存)。

class Student8 
    int rollno;
    String name;
    static String college = "ITS";

    Student8(int r, String n) 
        rollno = r;
        name = n;
    

    void display() 
        System.out.println(rollno + " " + name + " " + college);
    

    public static void main(String args[]) 
        Student8 s1 = new Student8(111, "Karan");
        Student8 s2 = new Student8(222, "Aryan");

        s1.display();
        s2.display();
    
//原文出自【易百教程】，商业转载请联系作者获得授权，非商业请保留原文链接：https://www.yiibai.com/java/static-keyword-in-java.html

4、静态方法

同成员变量，成员方法也可以分为以下两种：

1. 静态方法（或称为类方法），指被 static 修饰的成员方法。
2. 实例方法，指没有被 static 修饰的成员方法。

静态方法与实例方法的区别：

1. 静态方法，属于类，而不属于类的对象。
   1）它通过类直接被调用，无需创建类的对象。
   2）静态方法中，不能使用 this 关键字，也不能直接访问所属类的实例变量和实例方法；
   3）静态方法中，可以直接访问所属类的静态变量和静态方法。
   4）同this 关键字，super 关键字也与类的实例相关，静态方法中不能使用 super 关键字。
2. 实例方法，可直接访问所属类的静态变量、静态方法、实例变量和实例方法。

静态方法与静态变量好处：

1. 属于类级别，无需创建对象就即可直接使用，使用方便。

2. 全局唯一，内存中唯一，静态变量可以唯一标识某些状态。

3. 类加载时候初始化，常驻在内存，调用快捷方便。

静态方法与静态变量缺点：

1. 静态方法不能调用非静态的方法和变量。

2.不能使用this和super关键字。

静态方法与静态变量适用场景：

1. 静态方法，最适合工具类中方法的定义；比如文件操作，日期处理方法等。

2.静态方法，适合入口方法定义；比如单例模式，因从外部拿不到构造函数，所以定义一个静态的方法获取对象非常有必要。

3.静态变量适合全局变量的定义；举例：用一个布尔型静态成员变量做控制标志。

5、静态代码块

定义：静态代码块，是 Java 类中的 static 修饰的代码。

作用：用于类初始化时，为类的静态变量赋初始值，提升程序性能。
静态代码块的特点如下：

1. 静态代码块，有点类似于一个方法，但不可以存在于任何方法体内。
2. 静态代码块，可以置于类中的任何地方，类中可以有多个静态初始化块。 
3. Java 虚拟机在加载类时执行，将只需要进行一次初始化的操作放在 static 代码块。
4. 类中含多个静态代码块，Java虚拟机将按它们在类中出现的顺序依次执行，且都执行一次。
5. 同静态代码块与静态，不能直接访问类的实例变量和实例方法，需通过类的对象访问。

public class StaticCode 
    public static int count = 0;
    
        count++;
        System.out.println("非静态代码块 count=" + count);
    
    static 
        count++;
        System.out.println("静态代码块1 count=" + count);
    
    static 
        count++;
        System.out.println("静态代码块2 count=" + count);
    

    public static void main(String[] args) 
        System.out.println("*************** StaticCode1 执行 ***************");
        StaticCode sct1 = new StaticCode();
        System.out.println("*************** StaticCode2 执行 ***************");
        StaticCode sct2 = new StaticCode();
    

6、静态类

 java中一个类要被声明为static的，只有一种情况，就是静态内部类（内嵌类）。如在外部类声明为static的，程序会编译都不会通过。

1、静态内部类，跟静态方法一样，只能访问静态成员变量和方法，不能访问非静态方法和属性。

2、普通内部类，可以访问任意外部类的成员变量和方法。

3、静态内部类，可以声明普通成员变量和方法，而普通内部类不能声明static成员变量和方法。

4、静态内部类，可以单独初始化。

Inner i = new Outer.Inner();

 普通内部类初始化：

Outer o = new Outer();
Inner i = o.new Inner();

适用场景：当外部类需要使用内部类，而内部类无需外部类资源，并且内部类可以单独创建时，考虑采用静态内部类的设计，在知道如何初始化静态内部类。

public class Outer 
    private String name;
    private int age;

    public static class Builder 
        private String name;
        private int age;

        public Builder(int age) 
            this.age = age;
        

        public Builder withName(String name) 
            this.name = name;
            return this;
        

        public Builder withAge(int age) 
            this.age = age;
            return this;
        

        public Outer build() 
            return new Outer(this);
        
    

    private Outer(Builder b) 
        this.age = b.age;
        this.name = b.name;
    

静态内部类，调用外部类的构造函数来构造外部类；静态内部类可被单独初始化，于是在外部就可以有下面的实现：

public Outer getOuter()

    Outer outer = new Outer.Builder(2).withName("Yang Liu").build();
    return outer;

静态类总结：

1.如果类的构造器或静态工厂中有多个参数，设计这样类时，最好使用Builder模式，特别是当大多数参数都是可选的时候。

2.如果现在不能确定参数的个数，最好一开始就使用构建器即Builder模式。

参考：

Java static关键字（静态变量和静态方法）

Java static关键字 -Java教程™

Java静态类 - Facilitate - 博客园

java中static作用详解

有要详解,那我找资料给你吧

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

被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。

只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

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

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

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

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

1、static变量
　按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。

两者的区别是：
　对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
　对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

所以一般在需要实现以下两个功能时使用静态变量：
 在对象之间共享值时
 方便访问变量时

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

例如为了方便方法的调用，Java API中的Math类中所有的方法都是静态的，而一般类内部的static方法也是方便其它类对该方法的调用。

静态方法是类内部的一类特殊方法，只有在需要时才将对应的方法声明成静态的，一个类内部的方法一般都是非静态的

3、static代码块

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

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
Test5.a=5;
System.out.println(a);

public void f()
System.out.println("hhahhahah");



运行结果：
3
hhahhahah
1000
4
5

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

4、static和final一块用表示什么
static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字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
在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式：

classname.method( )

这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。

下面是一个例子。在main() 中，static方法callme() 和static 变量b在它们的类之外被访问。

class StaticDemo
static int a = 42;
static int b = 99;
static void callme()

System.out.println("a = " + a);



class StaticByName

public static void main(String args[])
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);



下面是该程序的输出：

a = 42
b = 99

static成员是不能被其所在class创建的实例访问的。

如果不加static修饰的成员是对象成员，也就是归每个对象所有的。

加static修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的 参考技术A

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

被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。

只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

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

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

Java是由Sun Microsystems公司推出的Java面向对象程序设计语言（以下简称Java语言）和Java平台的总称。

Java由James Gosling和同事们共同研发，并在1995年正式推出。Java最初被称为Oak，是1991年为消费类电子产品的嵌入式芯片而设计的。1995年更名为Java，并重新设计用于开发Internet应用程序。

用Java实现的HotJava浏览器（支持Java applet）显示了Java的魅力：跨平台、动态Web、Internet计算。从此，Java被广泛接受并推动了Web的迅速发展，常用的浏览器均支持Javaapplet。另一方面，Java技术也不断更新。Java自面世后就非常流行，发展迅速，对C++语言形成有力冲击。

在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。2010年Oracle公司收购Sun Microsystems。

参考技术B 　　大家都知道，我们可以基于一个类创建多个该类的对象，每个对象都拥有自己的成员，互相独立。然而在某些时候，我们更希望该类所有的对象共享同一个成员。此时就是 static 大显身手的时候了！

    Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问

　　使用 static 可以修饰变量、方法和代码块。

　　例如，我们在类中定义了一个 静态变量 hobby ，操作代码如下所示：

运行结果：

要注意哦：静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收！

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