static关键字有什么作用

Posted 2023-04-08 纳什1

目录

static关键字有什么作用  

（1） static 成员变量

(2)static成员方法

（3） static 代码块

（4）static内部类

引申：

1.什么是实例变量？什么是局部变量？什么是类变量？什么是 final 变量？

2.static 与 final 结合使用表示什么意思？

---

static关键字有什么作用  

      static 关键字主要有两种作用：第一，为某特定数据类型或对象分配单一的存储空间，而
与创建对象的个数无关。第二，实现某个方法或属性与类而不是对象关联在一起，也就是说,
在不创建对象的情况下就可以通过类来直接调用方法或使用类的属性。具体而言，在 Java语
言中，static 主要有 4 种使用情况：成员变量、成员方法、代码块和内部类。

（1） static 成员变量

虽然 Java 语言中没有全局的概念，但可以通过 statie 关键字来达到全局的效果。Java 类提
供了两种类型的变量：用 static 关键字修饰的静态变量和不用 static 关键字修饰的实例变量。
静态变量属于类，在内存中只有一个复制（所有实例都指向同一个内存地址)，只要静态变量
所在的类被加载，这个静态变量就会被分配空间，因此就可以被使用了。对静态变量的引用有
两种方式，分别为“类.静态变量”和“对象.静态变量”。
        实例变量属于对象，只有对象被创建后，实例变量才会被分配空间，才能被使用，它在内
存中存在多个复制。只能用“对象.实例变量”的方式来引用。以下是静态变量与实例变量的使用示例。

public class demo1 
    public static int staticInt = 0;
    public int  nonStaticInt= 0;
    public static void main(String[] args) 
        demo1 d = new demo1();
        System.out.println("d.staticInt="+d.staticInt);
        System.out.println("demo1.staticInt="+demo1.staticInt);
        System.out.println("d.nonStaticInt=" + d.nonStaticInt);
        System.out.println("对静态变量和实例变量分别+1");
        d.staticInt++;
        d.nonStaticInt++;
        demo1 d1=new demo1();
        System.out.println("d1.staticInt="+d1.staticInt);
        System.out.println("demo1.staticInt="+demo1.staticInt);
        System.out.println("d1.nonStaticInt=" + d1.nonStaticInt);

    

运行结果;

d.staticInt=0
demo1.staticInt=0
d.nonStaticInt=0
对静态变量和实例变量分别+1
d1.staticInt=1
demo1.staticInt=1
d1.nonStaticInt=0

        从上例可以看出，静态变量只有一个，被类拥有，所有对象都共享这个静态变量，而实例
对象是与具体对象相关的。需要注意的是，与C ++语言不同的是，在 Java 语言中，不能在方
法体中定义 static 变量。

(2)static成员方法

        与变量类似，Java 类同时也提供了 static 方法与非 static 方法。static 方法是类的方法，不
需要创建对象就可以被调用，而非 static 方法是对象的方法，只有对象被创建出来后才可以被
使用。
        static 方法中不能使用 this 和 super 关键字，不能调用非 static 方法，只能访问所属类的静
态成员变量和成员方法，因为当 static 方法被调用时，这个类的对象可能还没被创建，即使已
经被创建了，也无法确定调用哪个对象的方法。同理，static 方法也不能访问非 static 类型的
变量。
        static 一个很重要的用途是实现单例模式。单例模式的特点是该类只能有一个实例，为了
实现这一功能，必须隐藏类的构造函数，即把构造函数声明为 private，并提供一个创建对象的
方法，由于构造对象被声明为 private，外界无法直接创建这个类型的对象，只能通过该类提供
的方法来获取类的对象，要达到这样的目的只能把创建对象的方法声明为 static，程序示例
如下：

class Singleton
    private static Singleton instance=null;
    private Singleton()
    public static Singleton getInstance()
        if(instance==null)
            instance=new Singleton();
        
        return  instance;
    

        用 public 修饰的 static 变量和方法本质上都是全局的，若在 statie 变量前用 private 修饰，
则表示这个变量可以在类的静态代码块或者类的其他静态成员方法中使用，但是不能在其他类
中通过类名来直接引用。

（3） static 代码块

        static 代码块（静态代码块）在类中是独立于成员变量和成员函数的代码块的。它不在任
何一个方法体内，JVM 在加载类时会执行 static 代码块，如果有多个 static代码块，JVM 将会
按顺序来执行。static 代码块经常被用来初始化静态变量。需要注意的是，这些 static 代码块只
会被执行一次，示例如下：

public class demo1 
    private static int a;
    static 
        demo1.a=4;
        System.out.println(a);
        System.out.println("static block is called");
    
    public static void main(String[] args) 

    

运行结果：

4
static block is called

（4）static内部类

        static 内部类是指被声明为 static 的内部类，它可以不依赖于外部类实例对象而被实例化，
而通常的内部类需要在外部类实例化后才能实例化。静态内部类不能与外部类有相同的名字，
不能访问外部类的普通成员变量，只能访问外部类中的静态成员和静态方法（包括私有类
型)示例如下：

public class Outer 
    static int n=5;
    static class Inner
        void accessAttrFromOuter()
            System.out.println("Inner:Outer.n="+n);
        
    
    public static void main(String[] args) 
        Outer.Inner nest = new Outer.Inner();
        nest.accessAttrFromOuter();
    

运行结果：

Inner:Outer.n=5

需要注意的是,只有内部类才能被定义为static。

引申：

1.什么是实例变量？什么是局部变量？什么是类变量？什么是 final 变量？

实例变量：变量归对象所有（只有在实例化对象后才可以)。每当实例化一个对象时，会
创建一个副本并初始化，如果没有显示初始化，那么会初始化一个默认值。各个对象中的实例
变量互不影响。
局部变量：在方法中定义的变量，在使用前必须初始化。
类变量：用 static 可修饰的属性、变量归类所有，只要类被加载，这个变量就可以被使用
(类名.变量名）。所有实例化的对象共享类变量。
final 变量：表示这个变量为常量，不能被修改。

2.static 与 final 结合使用表示什么意思？

        在 Java 语言中，static 关键字常与 final 关键字结合使用，用来修饰成员变量与成员
有点类似于 C/C ++语言中的“全局常量”。对于变量，若使用 statie final 修饰，则表示一
值，就不可修改，并且通过类名可以访问。对于方法，若使用 statie final 修饰，则表示该
不可覆盖，并且可以通过类名直接访问。

特别注意：在Java语言中，不能在成员函数内部定义static变量

java定义静态变量的作用 static关键字

我们知道类中的静态变量在程序运行期间，其内存空间对所有该类的对象实例而言是共享的，为了节省系统内存开销、共享资源，应该将一些变量声明为静态变量。通过下面的例子，你就会发现有什么不同。

代码一：

public class MemoryTest   
     static class Data  
         private int week;  
         private String name;  
         Data(int i, String s)  
             week = i;  
             name = s;  
           
       
       
     Data weeks[] =   
             new Data(1,"monday"),  
             new Data(2,"Tuesday"),  
             new Data(3,"Wednesday"),  
             new Data(4,"Thursday"),  
             new Data(5,"Friday"),  
             new Data(6,"Saturday"),  
             new Data(7,"Sunday")  
     ;  
       
     public static void main(String[] args)   
         final int N = 20000;  
         MemoryTest test = null;  
         for (int i = 0; i <=N; i++)   
            test = new MemoryTest();  
           
         System.out.println(test.weeks.length);  
       
  

代码二：

public class MemoryTest   
      static class Data  
          private int week;  
          private String name;  
          Data(int i, String s)  
              week = i;  
              name = s;  
            
        
       
     static Data weeks[] =   
             new Data(1,"monday"),  
             new Data(2,"Tuesday"),  
             new Data(3,"Wednesday"),  
             new Data(4,"Thursday"),  
             new Data(5,"Friday"),  
             new Data(6,"Saturday"),  
             new Data(7,"Sunday")  
     ;  
       
     public static void main(String[] args)   
         final int N = 20000;  
         MemoryTest test = null;  
         for (int i = 0; i <=N; i++)   
             test = new MemoryTest();  
           
         System.out.println(test.weeks.length);  
       
   

我想大家应该发现上面那两个类的区别了吧！

 Data weeks[] 与  static Data weeks[] 

代码一会在内存中保存20000个weeks的副本，而代码二则在内存中保存1个weeks的副本，然后共享该副本，这样的话就不会造成内存的浪费。

虽然 静态的变量能节约大量的内存，但是并不是所有的地方都适合用，建议大家在下列条件都符合的情况下，尽量用静态变量：

（1）变量所包含的对象体积较大，占用内存较多。

（2）变量所包含的对象生命周期较长。

（3）变量所包含的对象数据稳定。

（4）该类的对象实例有对该变量所包含的对象的共享需求。

如果变量不具备上述特点，建议不要轻易使用静态变量，以免弄巧成拙。

最后，再提一点内存的优化，就是有关对象的重用，比如：对象池和数据库连接池等。那样的话，是很节约内存空间的，不过，在用的时候要考虑各个方面，比如：运行环境的内存资源的限制等。为了防止对象池中的对象过多，要记得清除。

开发者涨薪指南 48位大咖的思考法则、工作方式、逻辑体系