服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|JAVA教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|JavaScript|易语言|

服务器之家 - 编程语言 - JAVA教程 - java关键字static学习心得

java关键字static学习心得

2021-03-25 10:07铜雀春深锁二乔 JAVA教程

本篇文章给大家分享一篇关于java关键字static的学习心得,有这方面需要的朋友学习下吧。

staticjava中又一重要的关键字,在一定环境下使用,可以提高程序的运行性能,优化程序的结构。其主要应用有以下几方面:

1.static修饰的成员变量,称为类变量/静态变量,以实现所有对象对该成员的共享。

2.static修饰的成员方法,称为类方法/静态方法,可直接通过类名调用,无需创建对象。

3.形成静态代码块,优化程序性能。

4.静态导包,一般将类的方法直接导入到当前类中,从而直接使用方法名即可调用类方法,更加方便。

5.修饰内部类,无需实例化外部类就可以调用内部类。

下面一附代码说明:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Student {
    String name;
    static int age;
    public String toString() {
      return "Name:" + name + ", Age:" + age;
    }
    public static void main(String[] args) {
     Student s1 = new Student();
      s1.name="张三";
      s1.age=20;
      Student s2 = new Student();
      s2.name="李四";
      s2.age=10;
      System.out.println(s1);
      System.out.println(s2);
    }
}
/**输出结果
Name:张三, Age:10
Name:李四, Age:10
*/

如上述代码,s1和s2两个对象分别存储在内存中堆区域的不同地址中,所以他们之间相互不会干扰。然而static关键字修饰了成员变量age,让其变成类的所属,而不是对象的所属,任何该类实例的对象都可以共享使用它。所以,输出的age均是最终赋给的10。如果去掉static,显然对象之间互不影响,输出如下:

?
1
2
Name:张三, Age:20
Name:李四, Age:10

java关键字static学习心得

如上述代码,out1调用out2时出错。由此代码可得,静态方法不能调用非静态的成员变量和成员方法。非静态方法可以调用静态的成员变量和成员方法。注意,static不影响成员的访问权限,Java中能够影响到访问权限的关键词是private、public、protected,default。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Test extends Base{
  static{
    System.out.println("static静态块1");
  }
  public Test(){
    System.out.println("test构造器");
  
  public static void main(String[] args) {
    new Test();
  }
}
class Base{
  static{
    System.out.println("static静态块2");
  }
  public Base(){
    System.out.println("base构造器");
  }
}

如上述代码,记住两句话,static代码块随类的加载一起加载。static修饰的变量方法比其他变量方法优先加载,且只加载一次。加载子类时,会首先加载父类。由此可以分析:在执行开始,先要寻找到main方法,因为main方法是程序的入口,但是在执行main方法之前,必须先加载Test类,而在加载Test类的时候发现Test类继承自Base类,因此会转去先加载Base类,在加载Base类的时候,发现有static块,便执行了static块。在Base类加载完成之后,便继续加载Test类,然后发现Test类中也有static块,便执行static块。在加载完所需的类之后,便开始执行main方法。在main方法中执行new Test()的时候会先调用父类的构造器,然后再调用自身的构造器。因此,运行结果如下:

?
1
2
3
4
static静态块2
static静态块1
base构造器
test构造器
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* A.java文件 */
package com.dogo.test;
public class A {
  public static void outWord(Object o){
    System.out.println(o);
  }
}
/* B.java文件 */
import static com.dogo.test.A.*;
public class B
{
  public static void main( String[] args )
  {
    outWord("Hello World!");
  }
  /**输出
   * Hello World!
   */
}

如上述代码,A.java中包含一个简单的静态方法,在B.java中我们用static关键字将A类导入,由此,便无需使用“类名.方法名”的方法去调用类方法了,直接可以采用"方法名"去调用类方法,就好像是该类自己的方法一样。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*Outer.java*/
public class Outer {
  static {
    System.out.println("Outer静态块");
  }
  public Outer(){
    System.out.println("Outer构造器");
  }
  static class Inner{
    static{
      System.out.println("Inner静态块");
    }
    
    public Inner(){
      System.out.println("Inner构造器");
    }
  }
}
/*Test.java*/
public class Test{
  public static void main(String[] args) {
    new Outer.Inner();
  }
}

如上述代码,记住,用static修饰内部类,外部类可以直接调用内部类,因为static修饰的的内部类是在加载外部类的同时加载的,所以,并不要实例化外部类就能直接调用静态内部类。例子中,在进入Test的main方法之前,加载Test类,然后执行new Outer.Inner();这里需要注意:因为Inner是静态的,所以这里并不需要加载外部类和实例化外部类,可以直接加载Inner并实例化。运行结果如下:

?
1
2
Inner静态块
Inner构造器

大乔注:static另一个很重要的应用就是实现单例设计模式。单利模式的特点是该类只能有一个实例,为了实现这一功能,必须隐藏类的构造函数,即把构造函数声明为private,并提供一个创建对象的方法,由于构造对象被声明为private,外界无法直接创建这个类型的对象,只能通过该类提供的方法来获取类的对象,于是只能把创建对象的方法声明为static,程序实例如下:

?
1
2
3
4
5
6
7
8
9
10
class SingleDemo{
    private static SingleDemo ins=null;
    private SingleDemo(){}
    public static SingleDemo getIns(){
      if(ins==null){
        ins=new SingleDemo();
      }
      return ins;
    }
  }

原文链接:https://www.cnblogs.com/hellohellozxb/p/8318626.html

延伸 · 阅读

精彩推荐