java 静态类例子_java 静态类的简单介绍

1、Java静态类：静态方法、静态变量、静态代码块、静态内部类

静态类，即定义了静态方法、静态变量、静态代码块的类，或静态内部类，这些静态方法、静态变量不需要实例化即可直接引用，而静态代码块则是用在系统初始化时。

静态类与非静态类的区别

先看代码：

````

public class HelloWorld{

Public static void main(String[] args){

System.out.println(“Hello,world!”);

}

}

````

这段简单的代码定义了一个静态的方法名为main，这个就意味着告诉Java编译器，这个 方法不需要创建一个此类的对象即可使用。 它只输出简单的”Hello , world”,然而，它却展示了static关键字的主要用法.

静态类，即定义了静态方法、静态变量、静态代码块的类，或静态内部类。静态类和非静态类的区别如下：

静态类不能被实例化，类的成员主要是静态成员和静态方法

非静态类一般需要实例化后才可以操作，不过接口和抽象类不能直接实例化。

静态的类都是在运行时静态地加载到内存中(一开始运行首先从静态的类开始)，所以 也不需要对它们进行初始化，也没有实例，因此在类的内部也不能用this

如果是静态内部类的话，静态内部类不能操作访问外部数据，静态内部类的实例生成不需要从外部生成相关类。

静态方法：

通常，在一个类中定义一个方法为static，那就是说，无须本类的对象即可调用此方法。调用一个静态方法就是“类名.方法名”，静态方法的使用很简单。

例如：

````

public class StaticClass {

//定义一个静态方法

public static void inc(String str){

System.out.println(str);

}

public static void main(String[] args) {

StaticClass.inc(“这就一个静态类！”); //引用静态类

}

}

````

一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。

静态变量：

静态变量与静态方法类似。所有此类实共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控引块存储空间。

例如：

````

public class StaticClass {

//定义静态变量

public static int i = 0 ;

//定义静态方法

public static void inc(){

i++;

}

}

//测试静态类，修改静态变量

public class StaticTest {

public static void main(String[] args) {

StaticClass v1,v2;

v1 = new StaticClass();

v2 = new StaticClass();

System.out.println(“v1.i=”+v1.i+“ v2.i=”+v2.i);

v1.inc();

System.out.println(“v1.i=”+v1.i+“ v2.i=”+v2.i);

}

}

````

运行结果：

v1.i=0  v2.i=0

v1.i=1  v2.i=1

由此可见，在调用了v1.inc()方法后，修改了静态变量i的值，同时v2变量的i值也发生了变化。这个说明每位共享一块存储区。

静态代码块:

Static变量有点类似于C中的全局变量的概念，值得探讨的是静态变量的初始化问题。修改上面的程序：

例如

````

public class StaticClass {

// 定义静态变量

public static int i = 0;

public StaticClass() {

i = 15;

}

public StaticClass(int n) {

i = n;

}

// 定义静态方法

public static void inc() {

i++;

}

}

//测试静态类，修改静态变量

public class StaticTest {

// 初始化静态构造函数

StaticClass v = new StaticClass(10);

// 访问静态类

static StaticClass v1, v2;

// 静态代码块

static {

System.out.println(“初始化：v1.c=” + v1.i + “ v2.i=” + v2.i);

v1 = new StaticClass(27);

System.out.println(“初始化：v1.c=” + v1.i + “ v2.i=” + v2.i);

v1 = new StaticClass(15);

System.out.println(“初始化：v1.c=” + v1.i + “ v2.i=” + v2.i);

}

public static void main(String[] args) {

StaticTest test = new StaticTest();

System.out.println(“test.i=” + test.v.i);

System.out.println(“v1.i=” + v1.i + “ v2.i=” + v2.i);

v1.inc();

System.out.println(“v1.i=” + v1.i + “ v2.i=” + v2.i);

System.out.println(“test.i=” + test.v.i);

}

}

````

从输出的结果可以看出，静态代码块在系统启动时就执行了输出。在static\{ 后面跟着一段代码，这是用来显式地初始化静态变量，这段代码只会初始化一次，且在类被第一次装载时\}

另外，static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。例子中v是在v1和v2的前面，但结果却是v1和v2的初始化在v前面。在涉及到继承的时候，会先初始化父类的static变量，然后是子类。

静态内部类：

Static在类的内部定义静态变量、静态方法和静态代码块的使用情形，除此之外，它还可以修饰class的定义。

通常一个普通类不允许声明为静态的，只有一个内部类可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需要实例化一个外部类。

例如：

````

public class Tests {

//定义一个静态内部类

public static class InnerClass{

//静态内部类构造函数

InnerClass(){

System.out.println(“InnerClass”);

}

//静态内部定义的方法

public void print(String string){

System.out.println(string);

}

}

public static void main(String[] args) {

Tests.InnerClass ci = new Tests.InnerClass();//应用静态内部类

ci.print(“this is String”);

}

}

````

输出结果：

InnerClass

this is String

静态内部类和普通类的用法是一样的