静态方法（static method）

先从一道笔试题说起

关于Java中的静态方法，下列说法哪些是正确的（）
A：静态方法是一个属于类而不属于对象(实例)的方法。（√）

静态方法可以在没有创建对象实例的情况下调用，其是可以通过类名引用。

B：静态方法只能访问静态数据。无法访问非静态数据(实例变量)。（√）

它这边的意思是不能直接访问非静态数据（实例变量），因为非静态数据是属于对象属性的，其只有在对象存在的时候才能引用。

C：静态方法只能调用其他静态方法，不能从中调用非静态方法。（√）

这里也是不能直接调用非静态方法，因为非静态方法是属于某个对象的，不先实例化对象，通过对象引用，那么将无法判断具体调用哪个对象（实例）的非静态方法。

D：静态方法不能通过类名直接访问，也不需要任何对象。（×） 静态方法可以直接用类名访问。

类名.静态方法名() 这种方式是可以的，所以静态方法可以直接通过类名进行访问。

简单总结

先总结：

• （1）静态方法中不可以直接引用实例方法（非静态方法）或实例成员变量（非静态变量）；

静态方法中引用实例方法、实例变量，须先实例化对象，然后通过 对象名.实例变量名 和 对象名.实例方法名( )

• （2）静态方法、实例方法（非静态方法）都可以引用静态变量、静态方法；
  • 如果在不同类中，则是通过 类名.静态变量名 和 类名.静态方法名( ) 的方式引用；
  • 如果是在同一个类中，则可以省略类名；

当然，要想其他类能引用其静态变量、静态方法，则其不能将这些变量、方法设置为private。

• （3）实例方法（非静态方法）中引用实例变量、其他实例方法；
  • 如果在不同类中，则需要先实例化对象，通过对象进行引用；
  • 如果在同一个类中，则直接引用即可；
• （4）引用（调用）静态方法的方式有两种：
  • 类名.静态方法名( )
  • 先实例化一个对象，然后通过 对象名.静态方法名( )

• （5）静态方法中不能使用 this 和 super ，而实例方法可以；

具体案例

通过下面的案例，可以对上面所述内容有个更加清晰的认识。

StaticMethodTest1

package com.yuan.test;

public class StaticMethodTest1 {
    private static int staticVariable;//静态成员变量
    public static int publicStaticVariable;
    protected static int protectedStaticVariable;
    private int instanceVariable;//实例成员变量（非静态成员变量）

    public static void staticMethod1(){
        staticVariable = 166;//静态方法中引用静态变量
        publicStaticVariable = 101;
        protectedStaticVariable = 102;
        System.out.println("StaticMethodTest1's staticVariable ="+staticVariable);
        /*
        Non-static field 'instanceVariable' cannot be referenced from a static context
        不能从静态上下文中引用非静态变量
         */
        //instanceVariable = 555;

        /*
        Non-static method 'instanceMethod()' cannot be referenced from a static context
        不能从静态上下文中引用非静态方法（实例方法）的
         */
        //instanceMethod1();

        staticMethod2();//在当前类中的静态方法中调用当前类的其它静态方法（可省略类名）
    }

    public void instanceMethod1(){
        // 实例方法（非静态方法）中是可以引用非静态变量（实例成员变量）的
        instanceVariable = 100;
        // 实例方法也可以引用静态变量
        staticVariable = 177;
    }

    public static void staticMethod2(){
        staticVariable = 188;
    }

    public static void main(String[] args){
        StaticMethodTest1 staticMethodTest1 = new StaticMethodTest1();
        staticMethodTest1.instanceMethod1();
        // main方法是典型的静态方法，所以引用实例变量须通过实例对象
        System.out.println(staticMethodTest1.instanceVariable);
        System.out.println(staticVariable);

        staticMethod1();//在当前类中调用静态方法，可以省略类名
        System.out.println(staticVariable);
        System.out.println(publicStaticVariable);
        System.out.println(protectedStaticVariable);
    }
}

运行后结果为：

100
177
StaticMethodTest1's staticVariable =166
188
101
102

StaticMethodTest2

package com.yuan.test;

public class StaticMethodTest2 {
    private static int staticVariable;
    public static int publicStaticVariable;

    public static void staticMethod1(){
        // 通过类名直接引用StaticMethodTest1类的静态方法staticMethod1
        // 引用其他类的静态方法（类名.静态方法名()）
        StaticMethodTest1.staticMethod1();
        // 修改当前类中的静态变量，可以省略类名
        staticVariable = 222;
        publicStaticVariable = 221;
        // 修改其它类中的静态变量（类名.静态变量名），注意：其它类的静态变量不能是private的
        StaticMethodTest1.publicStaticVariable = 201;
        StaticMethodTest1.protectedStaticVariable = 202;
        // 除了可以使用类名直接调用静态方法，还可以通过实例对象调用静态方法
        StaticMethodTest1 staticMethodTest1 = new StaticMethodTest1();
        staticMethodTest1.staticMethod1();//会将其publicStaticVariable、protectedStaticVariable 的值又改回101、102 
    }

    public static void main(String[] args){
        staticMethod1();
        // 引用其他类的静态变量（类名.静态变量名）
        System.out.println(StaticMethodTest1.publicStaticVariable);
        System.out.println(StaticMethodTest1.protectedStaticVariable);
        // 引用当前类的静态变量
        System.out.println(publicStaticVariable);
    }

}

运行结果为：

StaticMethodTest1's staticVariable =166
StaticMethodTest1's staticVariable =166
101
102
221

如果错误，欢迎指正！谢谢！

参考：
java 调用静态方法和实例（对象）方法的区别

一、静态变量和静态方法

1、静态变量和静态方法都属于类的静态成员，它们与普通的成员变量和成员方法不同，静态变量和静态方法只属于定义它们的类，而不属于某一个对象。
2、静态变量和静态方法都可以通过类名和对象进行访问。

二、静态变量示例

class StaticMenthod:
count = 0 #静态变量，不需要显示的声明

def __init__(self):
    StaticMenthod.count += 1

def __del__(self):
    StaticMenthod.count -= 1

sMenthod = StaticMenthod() #创建对象实例

sMenthod.count += 1 #通过对象实例操作静态变量
print(“sMenthod:%d”%(sMenthod.count)) #通过对象实例调用静态变量
print(“StaticMenthod:%d”%(StaticMenthod.count)) #通过类名调用静态变量

运行结果如下：

通过上面的测试结果可以看出通过对象实例访问静态变量和通过类名访问静态变量的结果是不一样的，由此也证明了通过对象访问实例和通过类名访问实例是互相不干扰的。

三、静态方法

1、静态方法相关描述
1》、静态方法中不需要传入self参数，因此无法访问在静态方法中访问静态实例变量。
2》、静态方法中不可以直接访问类的静态变量，但可以通过类名引用静态变量。
3》、可以通过装饰符定义静态变量。

2、静态方法示例

class StaticFunc:
str = “this is static variable!”

@staticmethod
def static_func():
    print("this is static function!")

StaticFunc.static_func()

sFunc = StaticFunc() sFunc.static_func()

print(StaticFunc.str)

运行结果如下：

通过结果分析可以知道：通过对象名调用静态方法和通过类名调用静态方法的结果是没有什么区别的。

说明：如有错误，欢迎指正。。。

变量名首写字母使用小写，如果由多个单词组成，从第2个单词开始的其他单词的首写字母使用大写。

如果局部变量的名字和成员变量的名字相同， 要想在该方法中使用成员变量，必须使用关键字this

输出结果：

成员变量和局部变量的区别

       成员变量：

          1、成员变量定义在类中，在整个类中都可以被访问。

          2、成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。

          3、成员变量有默认初始化值。

      局部变量：

          1、局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

          2、局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。

          3、局部变量没有默认初始化值 

      在使用变量时需要遵循的原则为：就近原则

      首先在局部范围找，有就使用；接着在成员位置找。

成员变量和类变量的区别

由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。

不同的对象的实例变量将被分配不同的内存空间， 如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量，也就是说对象共享类变量。

输出结果：

成员变量和类变量的区别：

   1、两个变量的生命周期不同

      成员变量随着对象的创建而存在，随着对象的回收而释放。

      静态变量随着类的加载而存在，随着类的消失而消失。

   2、调用方式不同

      成员变量只能被对象调用。

      静态变量可以被对象调用，还可以被类名调用。

   3、别名不同

      成员变量也称为实例变量。

      静态变量也称为类变量。

   4、数据存储位置不同

      成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

      静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

static：★★★ 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。

   特点：

   1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

   2、被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。

    3、静态随着类的加载而加载。而且优先于对象存在。

 

弊端：

   1、有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。

   2、静态方法只能访问静态成员，不可以访问非静态成员。

      因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。

   3、静态方法中不能使用this，super关键字。

      因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

 

什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？

成员分两种：

   1、成员变量。（数据共享时静态化）

      该成员变量的数据是否是所有对象都一样：

      如果是，那么该变量需要被静态修饰，因为是共享的数据。 

      如果不是，那么就说这是对象的特有数据，要存储到对象中。 

   2、成员函数。（方法中没有调用特有数据时就定义成静态）

      如果判断成员函数是否需要被静态修饰呢？

      只要参考，该函数内是否访问了对象中的特有数据：

      如果有访问特有数据，那方法不能被静态修饰。

      如果没有访问过特有数据，那么这个方法需要被静态修饰。

成员变量和静态变量的区别：

   1、成员变量所属于对象。所以也称为实例变量。

      静态变量所属于类。所以也称为类变量。

   2、成员变量存在于堆内存中。

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

   3、成员变量随着对象创建而存在。随着对象被回收而消失。

      静态变量随着类的加载而存在。随着类的消失而消失。

   4、成员变量只能被对象所调用 。

      静态变量可以被对象调用，也可以被类名调用。

   所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。