Java中static的作用

本文详细阐述了Java中静态(static)属性与方法的概念、作用及应用场景,包括静态代码块的优先执行特性,并通过实例代码展示如何在不同情况下使用静态属性。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1、static表示“全局”或者“静态”的意思,用来修饰成员变量和成员方法,也可以形成静态static代码块,被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说,它不依赖类特定的实例,被类的所有实例共享(因此可以用來统计一个类有多少个实例化对象),所以有些属性希望被所有对象共享,则必须将其声明为static属性,被static声明的属性成为全局属性。

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

3、类中定义的静态代码块会优先于构造块先执行,而且不管有多少个对象,静态代码块只执行一次

例1:

class PersonE{
 private String name;
 private int age;
 private static String country = "A城";
 public PersonE(String name,int age){
  this.name = name;
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public static String getCountry() {
  return country;
 }
 public static void setCountry(String country) {
  PersonE.country = country;
 }
 public void info(){
  System.out.println("姓名:"+this.getName()+","+"年龄:"+this.getAge()+","+"城市:"+country);
 }
}
public class StaticUse {
 public static void main(String[] args){
  PersonE per1 = new PersonE("张三",20);
  PersonE per2 = new PersonE("李四",22);
  System.out.println("---------修改之前--------");
  per1.info();
  per2.info();
  System.out.println("---------修改之後---------");
  PersonE.setCountry("B城");
  per1.info();
  per2.info();
 }
}

例2:

public class StaticUse{
 private static int s;
 public StaticUse(){
  System.out.println("Creat new Class");
 }
 static{
  System.out.println("static block initialized");
 }
 public static int getS() {
  return s;
 }
 public static void setS(int s) {
  StaticUse.s = s;
 }
 public static void main(String[] args){
  StaticUse classA = new StaticUse();
  StaticUse classB = new StaticUse();
  System.out.println("classA.s ="+classA.getS()+";classB.s ="+classB.getS());
  classA.setS(10);
  System.out.println("classA.s ="+classA.getS()+";classB.s ="+classB.getS());
  classB.setS(classB.getS()+10);
  System.out.println("classA.s ="+classA.getS()+";classB.s ="+classB.getS());
 }
}

例子3、

class PersonE{
 private static int count = 0;
 public PersonE(){
  count++;
  System.out.println("产生了"+count+"个对象");
 }
}
public class StaticUse{
 public static void main(String[] args){
  new PersonE();
  new PersonE();
 }
}

例子4:

class PersonE{
 {
  System.out.println("1、构造块。");
 }
 static{
  System.out.println("0,静态代码块。");
 }
 public PersonE(){
  System.out.println("2、构造方法。");
 }
}
public class StaticUse{
 static{
  System.out.println("在主方法所在的类中定义的代码块。");
 }
 public static void main(String[] args){
  new PersonE();
  new PersonE();
 }
}

<think>首先,用户的问题是:“我想理解JAVAstatic关键字的作用和用法 请问Javastatic关键字的作用是什么”。我需要基于系统级指令和用户可见层的要求来回答。 系统级指令关键点: - 所有行内数学表达式使用 $...$ 格式,但这里可能不涉及数学表达式,因为主题是Javastatic关键字。 - 独立公式使用 $$...$$ 格式,但同样,可能不适用。 - LaTeX语法正确:确保任何数学部分正确,但这里可能没有。 - 使用中文回答:整个回答必须用中文。 - 生成相关问题:在回答后,添加相关问题部分。 - 引用段落末尾添加引用标识:例如 [^1],但用户提供了引用,我需要参考它们。 用户可见层: - 回答结构清晰,帮助用户逐步解决问题。 - 尽量保证回答真实可靠。 - 参考站内引用:用户提供了引用 [^1] 到 [^5],我需要基于这些引用构建回答,但引用是给定的,我应该整合它们。 用户提供的引用: - [^1]: static用于形成静态代码块优化性能。 - [^2]: static修饰类成员,属于类本身,共享内存。 - [^3]: static不影响作用域,只影响访问权限。 - [^4]: static变量或方法独立于对象实例,被所有对象共享。 - [^5]: static用于静态变量、静态方法、静态块、静态导入、静态内部类。 我的回答需要覆盖static关键字的主要作用和用法: 1. 静态变量:被所有实例共享。 2. 静态方法:属于类,可直接通过类名调用。 3. 静态块:在类加载时执行一次。 4. 静态导入:导入静态成员。 5. 静态内部类:不依赖外部类实例。 结构: - 逐步解释:先介绍static是什么,然后分点说明作用。 - 确保清晰:使用列表或分段。 - 最后生成相关问题。 回答结构: 1. 引言:简要介绍static关键字。 2. 主要作用:分点列出。 - 静态变量 - 静态方法 - 静态块 - 静态导入 - 静态内部类 3. 示例:提供简单代码示例(如Python示例,但这里是Java,所以用Java代码)。 4. 引用:在相关段落末尾添加引用标识。 5. 相关问题:结尾添加相关问题。 代码示例:由于用户提供了Python示例,我应该提供Java代码示例来展示static的用法。 相关问题: - 基于主题生成几个相关问题。 最终输出格式: - 回答部分用中文。 - 代码块使用markdown格式。 - 相关问题部分以“§§相关问题§§”开头。 现在,规划内容: - 引言:static关键字在Java中用于表示类级别的成员,而不是实例级别的。 - 作用: - 静态变量:所有对象共享同一份拷贝。例如,static int count; 被所有实例共享。 - 静态方法:可直接通过类名调用,如Math.sqrt()。不能访问非静态成员。 - 静态块:用于初始化静态变量,在类加载时执行一次。 - 静态导入:简化静态成员的访问,如import static java.lang.Math.*;。 - 静态内部类:可以独立实例化。 - 引用:在解释时,引用相关部分。例如,当谈到静态块时,引用 [^1];当谈到共享时,引用 [^2] 等。 确保引用自然添加:在段落末尾,如“静态块在类加载时执行一次 [^1]”。 相关问题: 1. static变量和实例变量有什么区别? 2. 如何正确使用static方法? 3. static块在Java中有什么实际应用? 4. 静态导入有什么优点和缺点? 5. 静态内部类和普通内部类有何不同? 现在,撰写回答。</think>### Javastatic关键字的作用和用法 在Java编程中,`static`关键字是一个核心概念,它用于修饰类的成员(如变量、方法、代码块等),使其成为类级别的成员,而不是实例级别的成员。这意味着`static`成员属于类本身,而不是类的任何一个具体对象。理解`static`的作用和用法,有助于编写更高效、结构清晰的代码。下面我将逐步解释其主要作用和具体用法。 #### 1. **静态变量(Static Variables)** - **作用**:静态变量被所有类的实例共享,而不是每个实例拥有自己的拷贝。无论创建多少个对象,静态变量只分配一次内存空间,所有对象访问的是同一个值。 - **用法**:声明变量时添加`static`关键字。常用于存储类级别的数据,如计数器或共享配置。 - **示例**: ```java public class Counter { static int count = 0; // 静态变量,所有实例共享 public Counter() { count++; // 每次创建对象时,count增加 } } ``` - 使用:`Counter c1 = new Counter(); Counter c2 = new Counter();` 后,`Counter.count` 值为2,因为两个对象共享同一个`count`。 - **引用**:静态变量被所有实例对象共享,而不是每个对象独立拥有 [^4]。 #### 2. **静态方法(Static Methods)** - **作用**:静态方法属于类本身,而不是任何对象实例。它可以直接通过类名调用,无需创建对象。静态方法不能直接访问非静态成员(如实例变量),只能访问静态成员。 - **用法**:声明方法时添加`static`关键字。常用于工具类方法,如`Math.sqrt()`。 - **示例**: ```java public class MathUtils { public static int add(int a, int b) { return a + b; // 静态方法,可直接调用 } } ``` - 使用:`MathUtils.add(5, 3)` 返回8,无需实例化`MathUtils`对象。 - **引用**:静态方法可以通过类名直接访问,不需要创建对象 [^2]。 #### 3. **静态块(Static Blocks)** - **作用**:静态块用于在类加载时执行初始化操作,如初始化静态变量或加载资源。它只执行一次,且早于任何对象创建。 - **用法**:在类中定义`static { ... }`块。一个类可以有多个静态块,它们按顺序执行。 - **示例**: ```java public class ConfigLoader { static String config; // 静态变量 static { config = loadConfig(); // 类加载时执行一次 } private static String loadConfig() { // 模拟加载配置 return "default_config"; } } ``` - 使用:当`ConfigLoader`类首次被加载时,静态块自动执行,初始化`config`。 - **引用**:静态块在类初次加载时执行,用于优化程序性能 [^1]。 #### 4. **静态导入(Static Import)** - **作用**:简化静态成员的访问,允许直接使用静态成员(如变量或方法)而无需类名前缀。 - **用法**:使用`import static`语句导入特定静态成员或所有成员(`*`)。 - **示例**: ```java import static java.lang.Math.*; // 静态导入Math类所有成员 public class Calculator { public double calculate() { return sqrt(25); // 直接使用sqrt,无需Math.sqrt() } } ``` - 优点:代码更简洁;缺点:可能引起命名冲突,需谨慎使用。 - **引用**:静态导入使得在使用静态成员时不需要通过类名来限定 [^5]。 #### 5. **静态内部类(Static Inner Classes)** - **作用**:静态内部类是独立的类,不依赖于外部类的实例。它可以被直接实例化,而无需先创建外部类对象。 - **用法**:在内部类声明时添加`static`关键字。常用于封装相关功能。 - **示例**: ```java public class Outer { static class Inner { // 静态内部类 void display() { System.out.println("Static inner class"); } } } ``` - 使用:`Outer.Inner inner = new Outer.Inner(); inner.display();` 直接实例化内部类。 - **引用**:静态内部类不需要依赖于外部类的实例而被实例化 [^5]。 #### 关键注意事项 - **作用域与访问权限**:`static`关键字不影响变量或方法的作用域(如public/private),只决定成员是否属于类级别 [^3]。 - **内存效率**:由于静态成员只加载一次,减少了内存开销,适合共享数据场景。 - **限制**:静态方法不能访问非静态成员,因为非静态成员依赖于对象实例。同样,非静态方法可以直接访问静态成员。 - **最佳实践**:避免过度使用`static`,因为它可能导致全局状态问题;优先用于工具类、常量或单例模式。 通过以上解释,您应该对Java中`static`关键字的作用和用法有了清晰的理解。如果您有具体代码场景,我可以进一步提供示例。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值