关闭

静态方法

385人阅读 评论(0) 收藏 举报

 

3.7  静 态 方 法

前面已经介绍过,成员变量分为实例变量和静态变量。其中实例变量属于某一个具体的实例,必须在类实例化后才真正存在,不同的对象拥有不同的实例变量。而静态变量被该类所有的对象公有(相当于全局变量),不需要实例化就已经存在。

方法也可分为实例方法和静态方法。其中,实例方法必须在类实例化之后通过对象来调用,而静态方法可以在类实例化之前就使用。与成员变量不同的是:无论哪种方法,在内存中只有一份——无论该类有多少个实例,都共用同一个方法。

本节以前的例子中,除了main()方法,其余的方法都是实例方法,而main()则是一个静态方法,所以它才能够被系统直接调用。

3.7.1  静态方法的声明和定义

定义一个静态方法和定义一个实例方法,在形式上并没有什么区别,只是在声明的头部,需要加上一个关键字static。它的一般语法形式如下:

[访问权限修饰符] static [返回值类型] 方法名([参数列表]){

   语句序列

}

例如下面是一个静态的方法:

public  static  void stFun(){

     System.out.println("这是一个静态方法");

}

3.7.2  静态方法和实例方法的区别

静态方法和实例方法的区别主要体现在两个方面:

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

  ●     静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量和静态方法),而不允许访问实例成员变量和实例方法;实例方法则无此限制。

下面几个例子展示了这一区别。

【例3.23】 调用静态方法示例。

//-----------文件名hasStaticMethod.java,程序编号3.35-----------------

public class hasStaticMethod{

   //定义一个静态方法

   public static void callMe(){

    System.out.println("This is a static method.");

  }

}

下面这个程序使用两种形式来调用静态方法。

//-----------文件名invokeStaticMethod.java,程序编号3.36-----------------

public class invokeStaticMethod{

  public static void main(String args[]){

    hasStaticMethod.callMe();        //不创建对象,直接调用静态方法   

    hasStaticMethod oa = new hasStaticMethod();   //创建一个对象

    oa.callMe();                     //利用对象来调用静态方法

  }

}

程序3.36两次调用静态方法,都是允许的,程序的输出如下:

This is a static method.

This is a static method.

允许不创建对象而调用静态方法,是Java为了减少程序员调用某些常用方法时的麻烦,而允许程序员按照传统的C语言中使用函数的方式来使用方法。典型的例子是前面某些程序中使用“Math.ramdon()”来获取随机数。

【例3.24】 静态方法访问成员变量示例。

//-----------文件名accessMember.java,程序编号3.37-----------------

class accessMember{

  private static int sa; //定义一个静态成员变量

  private         int ia;     //定义一个实例成员变量

  //下面定义一个静态方法

   static void statMethod(){

     int i = 0;              //正确,可以有自己的局部变量

         sa = 10;        //正确,静态方法可以使用静态变量

         otherStat();    //正确,可以调用静态方法

         ia = 20;        //错误,不能使用实例变量

         insMethod();    //错误,不能调用实例方法

    }

   static void otherStat(){

   }

   //下面定义一个实例方法

   void  insMethod(){

     int i = 0;              //正确,可以有自己的局部变量

       sa = 15;              //正确,可以使用静态变量

       ia = 30;              //正确,可以使用实例变量

      statMethod();          //正确,可以调用静态方法

  }

}

本例其实可以概括成一句话:静态方法只能访问静态成员,实例方法可以访问静态和实例成员。之所以不允许静态方法访问实例成员变量,是因为实例成员变量是属于某个对象的,而静态方法在执行时,并不一定存在对象。同样,因为实例方法可以访问实例成员变量,如果允许静态方法调用实例方法,将间接地允许它使用实例成员变量,所以它也不能调用实例方法。基于同样的道理,静态方法中也不能使用关键字this

main()方法是一个典型的静态方法,它同样遵循一般静态方法的规则,所以它可以由系统在创建对象之前就调用。下面这个程序有个错误,请读者仔细查看。

public class hasError{

  int insVar = 100;

  public static void main(String args[]){

    System.out.println("insVar = " + insVar);

  }

}

3.7.3  静态代码块

在类中,可以将某一块代码声明为静态的,这样的程序块叫静态初始化段。静态代码块的一般形式如下:

static {

  语句序列

}

  ●     静态代码块只能定义在类里面,它独立于任何方法,不能定义在方法里面。

  ●     静态代码块里面的变量都是局部变量,只在本块内有效。

  ●     静态代码块会在类被加载时自动执行,而无论加载者是JVM还是其他的类。

  ●     一个类中允许定义多个静态代码块,执行的顺序根据定义的顺序进行。

  ●     静态代码块只能访问类的静态成员,而不允许访问实例成员。

【例3.25】 静态代码块运行示例1

//-----------文件名staticBlock.java,程序编号3.38-----------------

public class staticBlock{

  //定义一个普通的main()方法

  public static void main(String args[]){

    System.out.println("This is main method."); 

  }

  //定义一个静态代码块

  static{

     System.out.println("This is static block.");

     int stVar = 0;   //这是一个局部变量,只在本块内有效

  }

}

编译通过后,用java命令加载本程序,会得到如下输出:

This is static block.

This is main method.

从以上输出结果中可以看出,静态代码块甚至在main方法之前就被执行。在main()方法中可以完成的任务在静态代码块中都可以完成。但是二者在执行上仍然有一些区别,请看下例。

【例3.26】 静态代码块和main()方法的区别。

这里仍然使用例3.25中的staticBlock类,然后新定义一个类来使用它。

//-----------文件名useStaticBlock.java,程序编号3.39-----------------

public class useStaticBolck{

  public static void main(String args[]){

     new staticBlock();  //创建一个staticBlock的对象

  }

}

本程序没有像以前的程序那样,在创建对象时使用一个变量来接收对象,因为这个程序在后面并不需要用到这个变量。程序的输出如下:

This is static block.

这一次,只执行了静态代码块,main()方法在这种情况下是不会被执行的。

最后来写一个复杂一点的静态代码块的例子,它综合体现了静态代码块的使用方法,请读者注意注释说明。

【例3.27】 静态代码块使用示例2

//-----------文件名staticBlock.java,程序编号3.40-----------------

public class staticBlock{

  static int stMember = 100;            //定义静态成员变量

  public static void main(String args[]){

    System.out.println("This is main method.");

  }

  //第一个静态代码块

  static{

     System.out.println("This is first static block.");

     stMember  = 200;                        //访问静态成员变量

     staticBlock oa = new staticBlock(); //创建对象

     System.out.println("stMember = " + oa.stMember);

     statFun();                              //调用静态方法

  }

  //定义一个静态方法

  static void statFun(){

     System.out.println("This is a static method.");

  }

  //第二个静态代码块

  static{

     System.out.println("This is second static block.");

  }

}

程序运行的结果如下:

This is first static block.

stMember = 200

This is a static method.

This is second static block.

This is main method.

3.7.4  再论静态成员变量

在前面的3.3.3节中已经介绍过静态成员变量,不过那里的静态成员变量都是一些基本类型。Java允许以类作为静态成员变量的类型,那么静态成员变量就是一个对象。

如果是基本数据类型的静态成员变量,在类的外部可以不必创建对象就直接使用。但如果静态成员是对象,问题就要复杂得多。因为对象所属的类,既可能有静态成员,也可能有实例成员。而其中的实例成员必须要在对象实例化后才能使用,问题的核心在于:系统是否会为静态的类变量创建实例。

【例3.28】 对象作为静态成员使用示例。

//-----------文件名supplyTest.java,程序编号3.41-----------------

public class supplyTest{

  //定义一个静态方法供测试用

  public static void statShow(){

     System.out.println("这是静态方法");

  }

  //定义一个实例方法供测试用

  public void  instShow(){

      System.out.println("这是实例方法");

  }

}

下面这个程序中,定义了一个supplyTest类型的变量,作为静态成员,没有显示地实例化它。

//-----------文件名hasStatMember.java,程序编号3.42-----------------

public class hasStatMember{

  static  supplyTest  stVar;     //定义一个静态成员

  public static void main(String args[]){

     stVar.statShow();           //调用静态方法

     stVar.instShow();           //调用实例方法

  }

}

这个程序可以编译通过,但它运行的结果如下:

这是静态方法

Exception in thread "main" java.lang.NullPointerException

        at hasStatMember.main(hasStatMember.java:5)

从运行结果中可以看出,静态方法被正常执行,但实例方法不能执行,原因是未创建对象实例。这说明尽管stVar被声明成static类型,系统仍然不会自动为它创建对象,所以程序3.42必须改成如下内容才能正常运行:

//-----------文件名hasStatMember.java,程序编号3.42-----------------

public class hasStatMember{

  static supplyTest stVar = new supplyTest();     //定义一个静态成员并实例化它

  public static void main(String args[]){

     stVar.statShow();                             //调用静态方法

     stVar.instShow();                             //调用实例方法

  }

}

程序的输出结果是:

这是静态方法

这是实例方法

从输出结果中可以看出,stVar的实例化是在定义时完成的,这意味着在hasStatMember类的外部可以像在内部一样使用它。下面这个程序演示了对stVar的使用形式。

//-----------文件名useStVar.java,程序编号3.43-----------------

public class useStVar{

  public static void main(String args[]){   

     hasStatMember.stVar.statShow();     //调用静态方法

     hasStatMember.stVar.instShow();     //调用实例方法

  }

}

程序的输出结果如下:

这是静态方法

这是实例方法

无论是静态方法还是实例方法,都是通过类名.静态变量名.方法名的形式来使用的。读者可能会觉得这种形式有点眼熟。确实如此,前面大量使用的“System.out.println”就是这种形式。其中,System是系统预定义好的一个类,out是它的一个静态成员,printlnout的一个实例方法。

 

 

 

 

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:14436次
    • 积分:340
    • 等级:
    • 排名:千里之外
    • 原创:17篇
    • 转载:11篇
    • 译文:1篇
    • 评论:0条
    文章存档