Java——静态成员

于 2024-11-08 11:00:00 发布
阅读量2.1k 收藏 24
点赞数 12
分类专栏： # Java SE 文章标签： 1024程序员节 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/stewie6/article/details/143212177
版权

一、静态变量（Static Variables）

1、静态变量是什么

静态变量，又被称为类变量，它使用 static 关键字修饰。静态变量是类级别的变量，在类加载时初始化。

2、静态变量的特点

类级别共享：静态变量在所有实例间共享，所有对象访问的是同一个静态变量。

内存管理：生命周期与类一致，从类加载到类卸载。静态变量在类加载时分配内存，直到程序结束才释放。

可以通过类名直接访问：静态变量是属于整个类的，所以它不需要实例就可以访问，直接使用类名进行访问。例如 ClassName.staticVariable。

类级别共享：静态变量在所有实例间共享，所有对象访问的是同一个静态变量。

3、静态变量的定义与声明

public class MyClass {
    public static int staticVar = 0; // 静态变量
    public int instanceVar = 0;      // 实例变量
}

4、静态变量的使用场景

1）计数器

用于记录类被实例化的次数。

public class Counter {
    public static int count = 0;

    public Counter() {
        count++;
    }
}

2）共享资源

例如在工具类中共享某些资源或配置。

public class Utility {
	private static Scanner input = new Scanner(System.in);
    // 静态变量，用于工具类的共享

	public static char readAChar(char[] validChars) {
        //...
	}
}

3）定义常量

常用static final组合来定义常量。定义全局常量，如数学常数、配置信息等。

public class Constants {
    public static final double PI = 3.141592653589793;
}

5、静态变量的存储位置

在JDK 8，Java对内存管理进行了变更。

方法区被移除，取而代之的是元空间 (Metaspace)。对于方法区是在JVM中的，而对于元空间，则是位于本地内存中的。

因此，静态变量和常量池不再存储在永久代（永久代是方法区的实现）中，而是迁移到了堆内存中。这些改变是为了改善内存管理，避免永久代的内存限制问题。

所以说：

  1. JDK 8 之前：

    静态变量存储在方法区中。

  2. JDK 8 及之后：

    永久代被元空间取代。静态变量迁移到堆内存中。元空间用于存储类的元数据，位于本地内存中而非JVM堆中。

二、静态方法（Static Methods）

1、静态方法是什么

静态方法（又叫类方法）是使用static关键字声明的方法。它们属于类本身，可以在无需创建类实例的情况下调用。

Math.random();

我们可以想到调用 Math 类中的 random() 方法，直接使用类名就可以调用这个方法，所以这个方法是静态方法。

2、静态方法特点

1）特点

无需实例化：可以通过类名直接调用静态方法。

访问限制：静态方法只能直接访问其他静态成员（变量和方法），不能访问实例成员。

不能使用this和super关键字：因为静态方法不属于任何实例。

多态性限制：静态方法不支持运行时多态，只能进行静态绑定。静态方法不能被重写，因为静态方法是与类相关联的，不依赖于具体实例。因此，不能通过子类的实例来覆盖父类的静态方法。

2）补充

如果在子类中定义了与父类静态方法同名的方法，这不是重写，而称为方法隐藏。调用时，方法的选择取决于引用变量的类型（也就是说取决于编译时类型，所以这就是静态绑定），而不是对象的实际类型（运行时类型）。

public class Example {
	public static void main(String[] args) {
		SuperClass sc = new SubClass();
		sc.staticMethod();
	}
}

class SuperClass {
	public static void staticMethod() {
		System.out.println("SuperClass staticMethod~");
	}
}

class SubClass extends SuperClass{
	public static void staticMethod() {
		System.out.println("SubClass staticMethod~");
	}
}

运行结果：

3、静态方法的最佳实践

1）工具类方法

如java.lang.Math类的方法，提供数学运算功能。

double result = Math.sqrt(25.0); // 调用静态方法

不仅是Math这种标准库中提供的方法类，我们自己实现的方法类中的方法一般也是使用静态方法。

2）工厂方法

返回类的实例的静态方法。

public class Factory {
    public static MyClass createInstance() {
        return new MyClass();
    }
}

3）主方法

Java程序的入口点是静态方法main。

public static void main(String[] args) {
    // 程序入口
}

三、main 方法详解

1、main 方法介绍

在Java中，main方法是程序的入口点。它是一个特殊的方法，Java虚拟机（JVM）在运行程序时会首先调用它。

2、main 方法的定义格式

public static void main(String[] args)

这是 main 方法的定义格式，但是，它的定义格式为什么是这样的呢？

  1. public: 访问修饰符，表示该方法可以被任何地方调用。因为JVM需要调用main方法，因此必须是public。

  2. static: 静态修饰符，意味着该方法属于类而不是类的实例。JVM无需创建类的对象即可调用main方法。

  3. void: 返回类型，main方法不返回任何值。

  4. main: 方法名，必须是main，因为这是JVM识别的入口点。

  5. String[] args: 参数，args是一个String数组，用于接收命令行参数。用户可以在运行程序时向main方法传递参数。

3、main 方法的参数

我们可以通过命令行传递参数给 main 方法，我们先写一段程序：

public class Arguments {
    public static void main(String[] args) {
        for(String arg : args) {
            System.out.println("Argument: " + arg);
        }
    }
}

然后我们在命令行中编译这个代码：

然后运行程序，同时传入几个参数，可以看到运行结果是：

这里我们给 main 方法传入了三个参数：

Hello World !

三个字符串。然后这三个字符串通过我们在 main 方法中写的遍历参数数组的语句被打印出来。

4、在 IDEA 中给 main 方法传参

运行结果：

三、代码块（Block）

1、代码块介绍

1）代码块是什么

在Java中，代码块又称为初始化块，有些情况下初始化比较复杂，需要将其封装在代码块中。他没有名字，不能通过对象或者类名调用。一般是加载类时或者创建对象时隐式调用。

代码块分为实例代码块和静态代码块。它们用于在特定情况下执行特定的初始化操作。

2）代码块定义格式

    // 前面可以有修饰符可选，但也仅限 static 修饰符
    [static]{
        // 语句
    }

2、实例代码块（Instance block）

1）介绍

实例代码块在创建对象时执行。每次创建对象时，都会执行实例代码块的内容。如果只是使用类的静态成员，实例代码块并不会执行。

实例代码块中可以访问实例成员，也可以访问静态成员。

  1. 执行时机：在每次创建对象时执行，优先于构造函数执行。
  2. 使用场景：可以用于所有构造函数中共享的初始化代码，避免代码重复。所以可以将实例代码块理解成构造器的补充机制，用来辅助构造器来初始化对象。

2）示例

public class Block {
	public static void main(String[] args) {
		new Test();
		new Test(1);
	}
}

class Test {
	private int x;

	{
		System.out.print("实例代码块：x被初始化为 ");
	}

	public Test() {
		this.x = 0;
		System.out.println(this.x);
		System.out.println("Test()构造器");
	}

	public Test(int x) {
		this.x = x;
		System.out.println(this.x);
		System.out.println("Test(int x)构造器");
	}
}

运行结果：

3、静态代码块（Static block）

1）介绍

静态代码块用于初始化静态变量，只在类加载时执行一次。可以用于复杂的静态变量初始化或执行需要的配置信息。

静态代码块只能访问静态成员。

特点：

  • 类加载时执行：静态代码块在类首次加载到JVM时执行，且只执行一次。

  • 顺序执行：如果有多个静态代码块，按照在类中出现的顺序依次执行。

用途：

  • 静态变量复杂初始化：当静态变量的初始化不只是简单的赋值时，可以使用静态代码块。

  • 加载资源或配置：在类加载时执行一次性操作，如加载配置文件。

2）类的加载

在Java中，一个类在一次程序运行中通常只会被加载一次。类加载的具体机制由类加载器管理，确保每个类在运行期间仅加载一次。

类的加载会由以下行为触发：

  1. 创建类的实例：使用 new 关键字创建对象时。

  2. 访问类的静态成员（静态变量或静态方法）：此时类会被加载，以便访问这些静态成员。例如包含 main 方法的类在程序启动时加载。因为程序启动时，JVM 会调用静态方法 main 方法。

  3. 通过反射机制：使用 Class.forName() 或其他反射API。

  4. 初始化子类：当子类被初始化时，父类也会被加载和初始化。

如果程序中没有触发这些行为，类就不会被加载。

3）示例

public class Block {
	public static void main(String[] args) {
		System.out.println("Example.staticVar = " + Example.staticVar);
	}
}

class Example {
	public static int staticVar;

	static {
		System.out.println("静态代码块");
	}
}

运行结果：

4、代码块的执行顺序

1）静态、实例代码块和构造器的执行顺序

在一个类没有加载时，创建此类的第一个对象的调用顺序是：

  1. 调用静态代码块和静态属性初始化。（静态代码块和静态属性初始化执行的优先级是一样的，如果有多个静态代码块和多个静态属性初始化，则按照它们定义的顺序执行）
  2. 调用实例代码块和实例属性初始化。（普通代码块和普通属性初始化的执行优先级也是一样的，如果有多个实例代码块和多个实例属性初始化，则按照它们定义的顺序执行）
  3. 调用构造方法。

示例：

public class Example {
	public static void main(String[] args) {
		new Test();
	}
}

class Test {
	private static int staticVar1 = initStaticVar1();

	static {
		System.out.println("静态代码块 1");
	}

	static {
		System.out.println("静态代码块 2");
	}

	private static int staticVar2 = initStaticVar2();

	private int instanceVar1 = initInstanceVar1();

	{
		System.out.println("实例代码块 1");
	}

	{
		System.out.println("实例代码块 2");
	}
	
	private int instanceVar2 = initInstanceVar2();
	
	public Test() {
		System.out.println("构造器");
	}

	public static int initStaticVar1() {
		System.out.println("staticVar1 被初始化");
		return 10;
	}

	public static int initStaticVar2() {
		System.out.println("staticVar2 被初始化");
		return 10;
	}

	public int initInstanceVar1() {
		System.out.println("instanceVar1 被初始化");
		return 20;
	}

	public int initInstanceVar2() {
		System.out.println("instanceVar2 被初始化");
		return 20;
	}
}

运行结果：

可以看到执行顺序与我们前面提到的一致，优先级一样的执行顺序由它的定义的顺序决定。

2）构造器中的执行顺序

对于一个类的构造器，它首应当是显示或者隐式调用 super() 也就是父类的构造器，然后就是执行子类的实例代码块，然后才是子类构造器的主体。

  1. 调用父类构造器：创建子类对象时，首先调用父类构造器（通过隐式或显式的 super() 调用）。

  2. 执行实例代码块：在父类构造器执行完成后，子类的实例代码块被执行。实例代码块的执行并不依赖于构造器的显式调用，而是自动插入在父类构造器调用后和子类构造器主体执行前。

  3. 执行构造器：最后，执行子类的构造器主体。

示例：

public class Example {
	public static void main(String[] args) {
		new SubClass();
	}
}

class SuperClass {
	public SuperClass() {
		System.out.println("父类构造器");
	}
}

class SubClass extends SuperClass{
	{
		System.out.println("实例代码块");
	}

	public SubClass() {
		// super(); 首先调用父类构造器
		// 执行实例代码块
		System.out.println("子类构造器");
	}
}

运行结果：

3）创建一个子类的执行顺序

在子类和父类都没有加载时，创建第一个子类对象，执行顺序为：

  1. 父类的静态代码块和静态属性初始化。（优先级一样，按定义的顺序执行）
  2. 子类的静态代码块和静态属性初始化。（优先级一样，按定义的顺序执行）
  3. 父类的实例代码块和实例属性初始化。（优先级一样，按定义的顺序执行）
  4. 父类的构造器。（取决于子类调用的是哪一个）
  5. 子类的实例代码块和实例属性初始化。（优先级一样，按定义的顺序执行）
  6. 子类的构造器。

示例：

public class Example {
	public static void main(String[] args) {
		new SubClass();
	}
}

class SuperClass {
	static {
		System.out.println("父类的静态代码块");
	}

	{
		System.out.println("父类的实例代码块");
	}

	public SuperClass() {
		System.out.println("父类的构造器");
	}
}

class SubClass extends SuperClass {
	static {
		System.out.println("子类的静态代码块");
	}

	{
		System.out.println("子类的实例代码块");
	}

	public SubClass() {
		System.out.println("子类的构造器");
	}
}

运行结果：

可以看到运行结果与我们上面提到的执行顺序一致。

参考资料：

Java学习笔记9---类静态成员变量的存储位置及JVM的内存划分_jdk8静态变量放在jvm哪里-优快云博客

Java基础——静态内部类
qq_52519008的博客
10-04 1011
在非静态内部类中不可以声明静态成员。如现在在一个student类中定义了一个内部类Age，如果没有将这个类利用static关键字修饰，即没有定义为静态类，那么在这个内部类中如果要利用static关键字来修饰某个成员方法或者成员变量是不允许的。在编译的时候就通不过。故程序开发人员需要注意，只有静态内部类才能够定义静态的成员变量与成员方法。
Java基础——非静态内部类的实例必须依赖外部类的实例存在
qq_45321679的博客
04-23 745
非静态内部类的示例必须依赖外部类的实例存在
java笔记静态成员
04-19
java基础的几个例题包括静态成员，booblean数据类型的介绍
JAVA中的静态成员
weixin_34377065的博客
08-22 146
//Java中的静态成员 /* *静态的成员变量是属于类的，不属于某个对象,是共享的。 * 访问时可以用类名.静态属性直接访问，也可以用对象.访问，后者不提倡。 * 静态的成员方法只能访问静态的成员 */ class Point{ static int age ; //所有人共用age static int diqiu ; static...
【Java基础】static成员
m0_67872788的博客
07-12 1505
static是Java中的一个关键字，表示静态的。在Java中，被static修饰的成员叫做静态成员。静态成员 不属于某个具体的对象，而是属于 类，因此也可以称之为 类成员。
java中static的用法（一）静态成员变量
热门推荐
baiyelove的专栏
05-14 2万+
static可以修饰成员变量、方法、游离块、内部类。     static修饰的成员变量：static修饰的成员变量也叫类变量或全局变量，在类被加载时static修饰的成员变量被初始化，与类关联，只要类存在，static变量就存在。一个static变量单独划分一块存储空间，不与具体的对象绑定在一起，该存储空间被类的各个对象所共享。也就是说当声明一个对象时，并不产生static变量的拷贝，而是该
JAVA静态成员变量
RAVEEE的博客
06-28 464
静态成员变量 定义:静态成员变量只初始化一次   package test30; //关于静态成员什么时候调用的问题 public class meiju { private static long a=0; private static long i=getIt(); public static void main(String[] args) { Syste...
浅谈Java内部类——静态内部类
08-24
静态内部类是Java中的一种内部类，它可以独立存在和实例化，访问外部类的静态成员变量和静态方法。但是，它不能访问外部类的非静态成员变量和方法。静态内部类适用于需要在外部类中定义一个独立的类，但不需要访问...
浅析Java内部类——成员内部类
08-24
浅析Java内部类——成员内部类 Java内部类是Java语言中的一种特殊的类结构，它可以定义在类内部，而不是独立的类。今天，我们将主要介绍Java成员内部类的相关知识。 什么是内部类 内部类是定义在类内部的类，它...
JAVA OOP——静态变量、常量和方法、可见性修饰符、数据域封装
m0_46156900的博客
08-08 350
栏目： Java静态变量和静态方法:static variables、methods1.静态变量2.静态方法UML图：3.小结常量：Constants可见性修饰符:Visibility Modifiers1.最经典：public 修饰符2. 没有修饰符3.private 修饰符4.protected 修饰符小结数据域封装:data field encapsulation 静态变量和静态方法:static variables、methods 要点： A static variable is shared
JAVA静态成员
yutiannj的专栏
08-17 1340
/** * 对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新； 静态数据成员存储在全局数据区。静态
关于static静态修饰符
weixin_53106294的博客
08-28 211
静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性。被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中。既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问。静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。4. 静态方法中不能调用任何非静态方法，因为非静态方法有。静态成员一般是通过 静态方法来访问的。1. 不属于某个具体的对象，是类方法。...
静态成员 java_JAVA中的静态成员
weixin_39637285的博客
02-20 278
//Java中的静态成员/**静态的成员变量是属于类的，不属于某个对象,是共享的。* 访问时可以用类名.静态属性直接访问，也可以用对象.访问，后者不提倡。* 静态的成员方法只能访问静态的成员*/class Point{static int age ; //所有人共用agestatic int diqiu ;static { //定义静态初始化块 ， 静态块属于类，只有一份，只需加载一次diqi...
Java中的static成员
ting_happy的博客
05-16 2571
一、static修饰成员变量 static修饰的成员变量，称为静态成员变量（类变量），静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。（static修饰的变量是存储于方法区的）可以通过类名直接访问，也可以通过对象来访问，但是更推荐前者。 二、static修饰成员方法 被static修饰的成员方法，是类的方法，不是某个对象所特有的。静态成员一般通过静态方法来访问（大部分是因为访问限定符） 注意： 1.静态方法和静态成员一样，不属于某个具体的对象，是类方法。 2.可以通过对象调用，
Java中静态成员变量
xiaoge132的专栏
04-07 1717
package com.mingrisoft; public class TransferProperty { int i=47; //定义成员变量 public void call(){ //定义成员方法 System.out.println("调用call()方法"); for(i=0;i System.out.print(i+" "); if(i==2){ Sy
java静态成员
Limingmingaa的博客
05-10 349
静态成员 Java中类似静态构造方法的结构，称之为：静态初始化代码块，与之对应的是实例初始化代码块，见下例： 1 public class Program { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 System.out.println(Point.getValue()); 8 System.out.p
Java中静态成员
第十七签
03-03 1569
静态成员是一组比较特殊的成员，它不属于某个特定的类实例，而是属于一个类所有，这个类的所有实例共享它们。 类的静态成员，指的是用static修饰的成员，主要有三种：静态变量，静态方法和静态代码块，特点如下： 1、在类加载时，就会进行自动的创建和初始化或执行代码 2、它们对于一个类来说，都只有一份 3、类的所有实例都可以访问到它们 对于静态成员变量，指的是用static关键字修饰的成员变量，它会在类加载
Java static关键字（静态变量和静态方法）
qq_45532748的博客
07-22 1328
使用static修饰符修饰的属性为静态变量（类变量），方法称为静态方法，统称为静态成员，归整个类所有。static修饰的变量不需要依赖对象访问。
Java中的static变量
m0_58914004的博客
09-28 1352
与之相对应的是在运行时只暂时存在的自动变量（即局部变量）与以“动态分配”方式获取存储空间的一些对象，其中自动变量的存储空间在调用栈上分配与释放。计算机编程领域指在程序执行前系统就为之“静态分配”（也即在运行时中不再改变分配情况）存储空间的一类变量。方法：void set_one(int x){不同的对象的类变量都分配给相同的一处内存空间，对象共享类变量。那么以最后一次调用修改方法赋给类变量的值为最后答案。不同的对象的实例变量都将被分配不同的内存空间。static变量又称（静态变量，类变量）
Java静态
最新发布
03-11
### Java 中静态变量和静态方法详解 #### 静态变量的特点 静态变量的生命周期始于类加载之时，并于类卸载时结束。这类变量存放在内存的方法区内，无论是创建多少个对象实例，静态变量仅存在单一副本供所有实例共享[^1]。 对于如下代码片段： ```java class Example { static int staticVar; } ``` 这段定义表明`staticVar`是一个属于整个`Example`类而非特定对象的成员变量，在程序运行期间只要该类被加载到JVM中，则此静态变量即存在于内存之中直至应用终止或者显式地卸载对应的类为止。 #### 初始化过程与执行顺序 如果在同一个类内部既声明了静态变量又包含了用于初始化这些变量的静态代码块，那么它们之间的执行遵循书写次序原则——先写入的部分优先被执行。因此，若尝试在一个尚未声明之前就被使用的静态变量上操作将会引发编译错误[^2]。 考虑下面的例子： ```java class Example { static { staticVar = 10; // 这里假设staticVar已经在前面某处正确定义过 } static int staticVar; // 上述情况下由于静态代码块位于变量定义前，所以会导致编译失败 } ``` 上述情形下，因为静态代码块试图给还未正式引入作用域内的`staticVar`赋值而导致语法不合法；正确的做法应该是确保任何对静态字段的操作都发生在其实际声明之后。 #### 访问方式及其局限性 一旦某个类已经成功装载至虚拟机环境中，即使没有任何具体对象被构建出来也能借助“类名.属性/函数”的形式直接获取或修改其中公开可访问级别的静态成分[^4]。然而值得注意的是，尽管可以通过这种方式触及静态资源，却不能反过来经由已有的实体引用去接触那些专属于类别层面的数据项或是行为逻辑[^3]。 例如： ```java public class TestStaticAccess { public static void main(String[] args) { System.out.println(Example.staticVar); // 下面这行会触发编译期错误，因为n1不是静态成员 //System.out.println(b.n1); // 正确的方式是使用类名来访问静态成员 System.out.println(B.n2); System.out.println(C.address); } } // 假设其他部分保持不变... class B { public int n1 = 100; public static int n2 = 200; } class C { public static String address = "北京"; } ``` 在此基础上进一步探讨Kotlin如何处理来自Java库里的静态特性也是有意义的话题之一[^5]，不过当前讨论主要聚焦于纯Java环境下的概念解释。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值