java中static详解

最新推荐文章于 2025-06-24 19:36:25 发布

战血石LoveYY

最新推荐文章于 2025-06-24 19:36:25 发布

阅读量222

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Java

本文链接：https://blog.youkuaiyun.com/qq_35129986/article/details/84754519

Java 专栏收录该内容

13 篇文章

订阅专栏

今天在看《Thinking in Java》时，看到文章介绍静态。

就想再深入钻研一下，记几个注意事项：

首先，static 是Java中的一个关键字，我们不能声明普通外层类或者包为静态的

1.静态变量：静态变量是属于类的，而不是属于类创建的对象或实例（当然，类对象实例也可以调用静态变量，效果和直接类.变量一样）。因为静态变量被类的所有实例共用，所以非线程安全的。通常静态变量还和关键字final一起用，作为所有对象共用的资源或常量

2.静态方法：静态方法只能访问类的静态变量，或调用类的静态方法。当然静态方法可以在自己内部定义非静态变量和对象

public static int add() {

Properties p=new Properties();

//intA是静态变量
           intA++;
           int intB=10;
           intB++;

           return intB;
       }

3.静态类:我们对嵌套类使用static关键字，static不能用于最外层的类。

4.静态块：静态块就是类加载器加载对象时，要执行的处理语句。通常用于类加载的时候创建静态资源。我们在静态块中不能访问非静态变量。（当然静态块可以在自己内部定义非静态变量和对象）

在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。

静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。

内部类创建

静态内部类：

不能和外部类有相同的名字。

　　被编译成一个完全独立的.class文件，名称为OuterClass$InnerClass.class的形式。

　　只可以访问外部类的静态成员和静态方法，包括了私有的静态成员和方法。

静态内部类与普通内部类的区别在于,静态内部类的对象是不指向与某个具体的外部类对象,所以在创建对象时不需要创建外部类对象。并且在new的时候是通过 new Parent.Inner()方式,而不是Parent.new Inner()。不要和内部类的实例化搞混了。class的声明和内部类是一样的,都是Parent.Inner

public class OutInnerStatic {
   private int intA=10;
   private static int intB=20;
   static class StaticInnerClass{
       void draw() {
           System.out.println(intA);//报错，只能访问外部类的静态成员
           System.out.println(intB);
       }
   }
}

　　生成静态内部类对象的方式为：

　　　　OuterClass.InnerClass inner = new OuterClass.InnerClass();

例：

OutInnerStatic.StaticInnerClass scic=new OutInnerStatic.StaticInnerClass();

成员内部类：

成员内部类可以直接使用外部类的所有成员和方法，即使是private修饰的。而外部类要访问内部类的所有成员变量和方法，需要通过内部类的对象来获取。成员内部类不能含有static的变量和方法。因为成员内部类需要先创建了外部类，才能创建它自己的。它可以访问它的外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。

public class OuterClass {
   private int intA=10;
   private int intB=25;
   private static int intC=35;
   class InnerClass{
       private int intA=11;
       static final int intC=36;
       public void draw() {

System.out.println(OuterClass.this.intA);//10
           System.out.println(intA);//11
           System.out.println(intB);//25
           System.out.println(intC);//36

       }
   }
}

在外部类之外创建内部类的实例（必须通过外部类的实例去创建）：

　　　　(new Outerclass()).new Innerclass();

例：

       OuterClass oc=new OuterClass();
       OuterClass.InnerClass ic=oc.new InnerClass();
       ic.draw();

成员内部类引用外部类变量时的方法是：外部类名.this.变量名；静态内部类引用时的方法是：外部类名.变量

在引用成员内部类自己的定义的成员时最好也使用this关键字，以加以区别

方法内部类：

方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

局部类访问局部变量，变量必须加上final

public class MethodInnerClass {
   public void Method1() {
       int intA=10;
       final int intB=20;
       class InnerClass{
           public void get() {
               intA++;//报错
               int intC=intB+1;
           }
       }
   }
}

匿名内部类:

匿名内部类不能定义任何静态成员、方法。

匿名内部类中的方法不能是抽象的；

匿名内部类必须实现接口或抽象父类的所有抽象方法。

匿名内部类访问的外部类成员变量或成员方法必须用static修饰；

格式如下：

new 父类构造器（参数列表）|实现接口（）
{
//匿名内部类的类体部分
}

new Thread() {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("a");
}
}
}.start();

静态方法是属于类的，即静态方法是随着类的加载而加载的，在加载类时，程序就会为静态方法在方法区中分配内存，而非静态方法是属于对象的，对象是在类加载之后创建的，也就是说静态方法先于对象存在，当你创建一个对象时，程序为其在堆中分配内存，一般是通过this指针来指向该对象。静态方法不依赖于对象的调用，它是通过‘类名.静态方法名’这样的方式来调用的。而对于非静态方法，在对象创建的时候程序才会为其分配内存，然后通过类的对象去访问非静态方法。因此在对象未存在时非静态方法也不存在，静态方法自然不能调用一个不存在的方法。