java static定义的变脸可以更改吗

一.定义:

一种 表示静态属性的 关键字 / 修饰符

二.作用

1.作用:共用、共享

意思就是被静态修饰的内容，可以被所有对象所共享.直接说"共用、共享"可能比较抽象.我们通过例子来说明:

比如
姓名：张三 国籍：中国
姓名：李四 国籍：中国

就可以把国籍使用static进行修饰

2.原因

能有此作用的原因分析：

• Java中，任何变量 / 代码存储时，都是 在编译时 由系统自动分配内存;
• 在静态变量编译后，所分配的内存会一直存在，直到程序退出内存才会释放这个空间;
• 类加载时，JVM会把静态变量放到 方法区，被本类 & 本类的所有实例所共用;

三.使用

static静态修饰符可应用于：类、代码块、方法 & 变量

1.静态类

• 使用 static关键字 修饰、定义 为 静态的 内部类

即：
静态类又名为：静态内部类
该类独立存在，形式上与外部类有内外关系，实际上则没有，本质是为了隐藏自身

• 具体使用&相关规则

/**
 * 1. 静态类的方法 = 静态 / 非静态
 *    (静态方法可在外层通过静态类调用，而非静态方法必须要创建类的对象后才能调用)
 * 2. 只能引用外部类的静态变量（static，即类变量）
 * 3. 注：
 *       a. 默认不持有外部类引用、使用不依赖于外部类（与外层类无绑定）：即使无创建外层类的对象，它一样存在
 *       b. 若一个内部类不是被定义成静态内部类，那么其成员变量 / 方法不能被定义成静态
 *       c. 静态内部类 & 非静态内部类在创建时有区别，下面会详细说明
 */

// 外部类
public class A {  
    // 静态内部类
    public static class B{  
    }  
    // 非静态内部类（即 普通）
    class C{  
    }  
}  

// 静态内部类b & 非静态内部类c   创建时的区别：
A a=new A(); 
A.B b=new A.B(); 
A.C c=a.new C();

• 静态内部类 与 内部类的区别

• 特别注意
  a. 加载一个类时，其内部类不会同时被加载。
  b. 一个类被加载时刻为: 当且仅当其某个静态成员被调用时（静态域、构造器、静态方法等）

2.静态代码块

• 定义:
  类加载器加载类的最后1步（类初始化）时，执行类构造器()里需执行的一组语句

额外说明

①类初始化 = 真正开始执行类中定义Java程序代码 = 执行类构造器()
②() = 由编译器自动收集类中所有类变量的赋值动作&静态语句块中的语句合并产生的
③与类构造函数（即实例构造器()）不同，()不需显式地调用父类构造器，虚拟机会保证子类的()执行前，父类的()已执行完毕

• 特点:
  静态代码块是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。在静态方法里面只能直接调用同类中其他的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。因为对于非静态的方法和变量，需要先创建类的实例对象后方可使用，而静态方法在使用前不用创建任何对象。
• 具体使用 & 相关规则

/**
 * 1. 代码块 使用 Static修饰
 * 2. 静态块只会在类加载到内存中时执行1次
 *    a. 若有多个static代码块，JVM将按照它们在类中出现的先后顺序依次执行
 *    b. 静态语句块中只能访问定义在静态语句块之前的变量，定义在它之后的变量可以赋值，但不能访问。如下实例所示
 */

 public class Test { 

     // 使用静态修饰的静态代码块
     static{ 
         i=0;  // 給变量赋值，可通过编译. 如果这里改成 int i=0; 下一行代码也是可以通过编译的
         System.out.print(i); // 非法， 提示：“非法向前引用” 
     } 

     static int i=1; 
  
 }

• 非静态代码块
  与静态代码块相对应的一个概念是 非静态代码块.

非静态代码块的执行顺序在构造方法执行之前，类每new一次都会执行。

声明方式：不加任何修饰符

{
          //do something
 }

3.静态方法

• 定义: 使用 static关键字 修饰、定义为静态的成员方法 (也称 类方法)
• 具体使用 & 相关规则

/**
 * 1. 可直接通过类名调用，也可通过对象实例调用
 *    （属于类，不属于实例）
 * 2. 任何的实例都可调用（方便共享、公用）
 * 3. 只能访问所属类的静态成员变量 & 方法、不能使用this、super关键字
 *   （this = 调用该函数的对象、但由于静态方法可以直接使用类名调用（即可能还没创建对象），所以不可使用this）
 */

// 静态方法的申明
public static void a(int param) {

}

4.静态变量

• 定义: 使用 static关键字 修饰、定义为静态的成员变量 (也称 类变量、全局变量)
• 特点:
  被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
• 具体使用 & 相关规则

/**
 * 1. 静态变量在内存中只有1个拷贝：JVM只为静态分配1次内存
 *   a. 全部对象共用这个static关键字修饰的成员变量，方便对象间共享，节省内存
 *   b. 未被static 修饰的成员变量 = 实例变量：每创建1个实例，JVM就会为实例变量分配1次内存，实例变量在内存中可以有多个拷贝（但互相不影响，更加灵活）
 * 2. 可用类名直接访问：在加载类的过程中完成静态变量的内存分配，（也可通过对象实例访问）
 *  （属于类，不属于实例）
 * 3. 非线程安全：因静态变量被类的所有实例共用
 * 4. 局部变量也能被声明为static
 */

// 静态方法的申明
public class A {  

    private static int count = 0;  //静态变量的申明
   
}

• 静态变量与实例变量的区别
  (点击图片可以方法查看)

四 补充说明:

1.很多时候,使用静态,是因为无法变量名. 调用,只能使用类名.调用,比如 单例设计模式 )

2.当成员被静态修饰时，就多了一种调用方式。除了可以被对象调用外，还可以直接被类名调用。格式为： 类名.静态成员

3.静态修饰的内容,在方法区(有的书翻译成 共享区、数据区),不在堆内存中

4.static的特点:

• 随着类的加载而加载
• 优先于对象存在
• 被所有的对象所共享
• 可以直接使用类名.调用

5.静态有利有弊:

优点:
对对象的共享数据进行单独空间的存储,节约空间.没有必要每一个对象中都存储一份.可以直接被类名.调用

缺点:
生命周期过长.
访问存在局限.静态只能访问静态.

6.什么时候定义静态方法?
答:当功能内部没有访问到非静态数据(对象的特有数据),那么该功能就可以被定义为静态的.

class Person
{
	String name;//成员变量，实例变量。
	
	public void show()
	{
		System.out.println("::::");
	}
	
}

class  StaticDemo
{
	public static void main(String[] args) 
	{
		Person p = new Person();
		p.show();
		
		Person.show();
	}
}

比如上述Person的show()方法,没有访问到非静态数据.
这次就可以直接写成Person.show();

但如果show()方法改成:

public static void show()
	{
		System.out.println(name+"::::");
	}

show()方法中访问了非静态字段name,所以建议直接写成:

Person p = new Person();
		p.show();

五.举例夯实

下面一个例子在面试的笔试环节经常容易出现,可以考察大家对静态的理解.通过整个例子,大家也可以进一步加深理解:

package staticblock;
 
public class Parent
{
	//静态代码块，只在类装载的时候执行
	static
	{
		System.out.println("parent static block");
	}
	
	//非静态代码块，每new一次都会执行
	{
		System.out.println("parent non-static block");
	}
	
	public  Parent()
	{
		System.out.println("parent constractor block");
	}
}

package staticblock;
 
public class Child extends Parent
{
	//子类静态代码块
	static
	{
		System.out.println("child static block");
	}
	
	//子类非静态代码块
	{
		System.out.println("child non-static block");
	}
	
	//子类构造方法
	public Child()
	{
		System.out.println("child constractor block");
	}
	
	//静态方法需要在调用 的时候才执行
	public  static void get()
	{
		System.out.println("this is a static method!");
	}
	
	public static void main(String[] args)
	{
		new Child();
		System.out.println("------------------");
		new Child();
		Child.get();
	}
}

执行后打印结果如下:

parent static block
child static block
parent non-static block
parent constractor block
child non-static block
child constractor block
------------------
parent non-static block
parent constractor block
child non-static block
child constractor block
this is a static method!

说明:

我们看到静态代码块在执行中只执行了1次，而非静态代码块执行了两次，静态方法需要调用才会执行。执行顺序是先执行父类的静态代码块，然后执行子类的静态代码块；然后执行父类的非静态代码块，再执行父类的构造方法；之后再执行子类的非静态代码块，再执行子类的构造方法。执行顺序：静态代码块 > 非静态代码块 > 构造方法。

六.Android中慎用static

在前面提到了static的缺点是 生命周期太长,下面就这个问题进行谈论.

1.使用静态static静态变量潜在性问题：

(1)占用内存，并且内存一般不会释放；

(2)在系统不够内存情况下会自动回收静态内存，这样就会引起访问全局静态错误。

(3)不能将activity作为static静态对象，这样使activity的所有组件对象都存入全局内存中，并且不会被回收；

2.静态变量的生命周期：

(1) 类在什么时候被加载？

当我们启动一个app的时候，系统会创建一个进程，此进程会加载一个Dalvik VM的实例，然后代码就运行在DVM之上，类的加载和卸载，垃圾回收等事情都由DVM负责。也就是说在进程启动的时候，类被加载，静态变量被分配内存。

(2) 静态变量在类被卸载的时候销毁。

类在什么时候被卸载？

在进程结束的时候。

说明：一般情况下，所有的类都是默认的ClassLoader加载的，只要ClassLoader存在，类就不会被卸载，而默认的ClassLoader生命周期是与进程一致的，本文讨论一般情况。

(3) Android中的进程什么时候结束

这个是Android对进程和内存管理不同于PC的核心——如果资源足够，Android不会杀掉任何进程，另一个意思就是进程随时可能会被杀掉。而Android会在资源够的时候，重启被杀掉的进程。也就是说静态变量的值，如果不做处理，是不可靠的，可以说内存中的一切都不可靠。如果要可靠，还是得保存到Nand或SD卡中去，在重启的时候恢复回来。

另一种情况就是不能把退出所有Activity等同于进程的退出，所以在用户点击图标启动应用的时候，以前存放于静态变量中的值，有可能还存在，因此要视具体情况给予清空操作。

(4)Application也是一样不可靠

Application其实是一个单例对象，也是放在内存中的，当进程被杀掉，就全清空了，只不过Android系统会帮重建Application，而我们存放在Application的数据自然就没有了，还是得自己处理。

(5)静态引用的对象不会被垃圾回收

只要静态变量没有被销毁也没有置null，其对象一直被保持引用，也即引用计数不可能是0，因此不会被垃圾回收。因此，单例对象在运行时不会被回收。