java杂记-static
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java杂记-static相关的知识,希望对你有一定的参考价值。
首先是static的概念
借鉴 http://lavasoft.blog.51cto.com/62575/18771/ (好吧,都是复制这个的。写的很好,所以我就复制了)
static表示“全局”或者“静态”的意思,用来修饰成员变量和成员方法,也可以形成静态static代码块,java中无全局概念。
被static修饰的成员变量和成员方法独立于该类的任何对象,也就是说,它不依赖类特定的实例,被类的所有实例共享。只要这个类被加载,Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此,static对象可以在它的任何对象创建之前访问,无需引用任何对象。
用public修饰的static成员变量和成员方法本质是全局变量和全局方法,当声明它类的对象市,不生成static变量的副本,而是类的所有实例共享同一个static变量。
static变量前可以有private修饰,表示这个变量可以在类的静态代码块中,或者类的其他静态成员方法中使用(当然也可以在非静态成员方法中使用--废话),但是不能在其他类中通过类名来直接引用,这一点很重要。实际上你需要搞明白,private是访问权限限定,static表示不要实例化就可以使用,这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。
static修饰的成员变量和成员方法习惯上称为静态变量和静态方法,可以直接通过类名来访问,访问语法为:
类名.静态方法名(参数列表...)
类名.静态变量名
用static修饰的代码块表示静态代码块,当Java虚拟机(JVM)加载类时,就会执行该代码块(用处非常大,呵呵)。
1、static变量 按照是否静态的对类成员变量进行分类可分两种:一种是被static修饰的变量,叫静态变量或类变量;另一种是没有被static修饰的变量,叫实例变量。 两者的区别是: 对于静态变量在内存中只有一个拷贝(节省内存),JVM只为静态分配一次内存,在加载类的过程中完成静态变量的内存分配,可用类名直接访问(方便),当然也可以通过对象来访问(但是这是不推荐的)。 对于实例变量,没创建一个实例,就会为实例变量分配一次内存,实例变量可以在内存中有多个拷贝,互不影响(灵活)。 所以一般在需要实现以下两个功能时使用静态变量: 在对象之间共享值时 方便访问变量时 2、静态方法 静态方法可以直接通过类名调用,任何的实例也都可以调用, 因此静态方法中不能用this和super关键字,不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法),只能访问所属类的静态成员变量和成员方法。 因为实例成员与特定的对象关联!这个需要去理解,想明白其中的道理,不是记忆!!! 因为static方法独立于任何实例,因此static方法必须被实现,而不能是抽象的abstract。 例如为了方便方法的调用,Java API中的Math类中所有的方法都是静态的,而一般类内部的static方法也是方便其它类对该方法的调用。 静态方法是类内部的一类特殊方法,只有在需要时才将对应的方法声明成静态的,一个类内部的方法一般都是非静态的 3、static代码块 static代码块也叫静态代码块,是在类中独立于类成员的static语句块,可以有多个,位置可以随便放,它不在任何的方法体内,JVM加载类时会执行这些静态的代码块,如果static代码块有多个,JVM将按照它们在类中出现的先后顺序依次执行它们,每个代码块只会被执行一次。例如:
4、static和final一块用表示什么 static final用来修饰成员变量和成员方法,可简单理解为“全局常量”! 对于变量,表示一旦给值就不可修改,并且通过类名可以访问。 对于方法,表示不可覆盖,并且可以通过类名直接访问。 有时你希望定义一个类成员,使它的使用完全独立于该类的任何对象。通常情况下,类成员必须通过它的类的对象访问,但是可以创建这样一个成员,它能够被它自己使用,而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static,它就能够在它的类的任何对象创建之前被访问,而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ,所以它被声明为static。 声明为static的变量实质上就是全局变量。当声明一个对象时,并不产生static变量的拷贝,而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制: 它们仅能调用其他的static 方法。 它们只能访问static数据。 它们不能以任何方式引用this 或super。 如果你需要通过计算来初始化你的static变量,你可以声明一个static块,Static 块仅在该类被加载时执行一次。下面的 例子显示的类有一个static方法,一些static变量,以及一个static 初始化块: 调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说,静态方法常常为应用程序中的其它类提供一些实用工具所用,在Java的类库中大量的静态方法正是出于此目的而定义的。 如果你需要通过计算来初始化你的static变量,你可以声明一个static块,Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法,一些static变量,以及一个static 初始化块: class Value3 { static int c = 0; Value3() { c = 15; } Value3(int i) { c = i; } static void inc() { c++; } } public class Count { public static void prt(String s) { System.out.println(s); } Value3 v = new Value3(10); static Value3 v1, v2; static {//此即为static块 prt("v1.c=" + v1.c + " v2.c=" + v2.c); v1 = new Value3(27); prt("v1.c=" + v1.c + " v2.c=" + v2.c); v2 = new Value3(15); prt("v1.c=" + v1.c + " v2.c=" + v2.c); } public static void main(String[] args) { Count ct = new Count(); prt("ct.c=" + ct.v.c); prt("v1.c=" + v1.c + " v2.c=" + v2.c); v1.inc(); prt("v1.c=" + v1.c + " v2.c=" + v2.c); prt("ct.c=" + ct.v.c); } } 结果为:v1.c=0 v2.c=0 v1.c=27 v2.c=27 v1.c=15 v2.c=15 ct.c=10 v1.c=10 v2.c=10 v1.c=11 v2.c=11 ct.c=11 static定义的变量会优先于任何其它非static变量,不论其出现的顺序如何。正如在程序中所表现的,虽然v出现在v1和v2的前面,但是结果却是v1和v2的初始化在v的前面。在static{后面跟着一段代码,这是用来进行显式的静态变量初始化,这段代码只会初始化一次,且在类被第一次装载时。如果你能读懂并理解这段代码,会帮助你对static关键字的认识。在涉及到继承的时候,会先初始化父类的static变量,然后是子类的,依次类推。 参考: 类的运行机制 main进入,执行程序,结束后释放内存。 一个java文件从被加载到被卸载这个生命过程,总共要经历4个阶段: 加载(即生成Class对象)->链接(验证+准备+解析)(即相当于jvm编译,会给类静态变量默认值)->初始化(使用前的准备,也是部分初始化JAVA代码开始,如构造函数,和类静态变量的初始值)->使用->卸载 其中加载(除了自定义加载)+链接的过程是完全由jvm负责的,什么时候要对类进行初始化工作(加载+链接在此之前已经完成了),jvm有严格的规定(四种情况): 1.遇到new,getstatic,putstatic,invokestatic这4条字节码指令时,加入类还没进行初始化,则马上对其进行初始化工作。 其实就是3种情况: a .用new实例化一个类时 b.读取或者设置类的静态字段时(不包括被final修饰的静态字段,因为他们已经被塞进常量池了) 特殊情况:public static final int A = 4 + new Random().nextInt(10);//静态final变量在编译时不定的情况 c.以及执行静态方法的时候。 2.使用java.lang.reflect.*的方法对类进行反射调用的时候,如果类还没有进行过初始化,马上对其进行。 3.初始化一个类的时候,如果他的父亲还没有被初始化,则先去初始化其父亲。(不同于子类的构造方法,默认包含Super()方法一样。) 4.当jvm启动时,用户需要指定一个要执行的主类(包含static void main(String[] args)的那个类),则jvm会先去初始化这个类。 以上4种预处理称为对一个类进行主动的引用,其余的其他情况,称为被动引用,都不会触发类的初始化。下面也举了些被动引用的例子: * 被动引用情景1 * 通过子类引用父类的静态字段,不会导致子类的初始化 * @author volador * */class SuperClass{ static{ System.out.println("super class init."); } public static int value=123; }class SubClass extends SuperClass{ static{ System.out.println("sub class init."); } }public class test{ public static void main(String[]args){ System.out.println(SubClass.value); } } 输出结果是:super class init。 被动引用情景2 * 通过数组引用来引用类,不会触发此类的初始化 * @author volador * */public class test{ public static void main(String[] args){ SuperClass s_list=new SuperClass[10]; } } 输出结果:没输出 /* 被动引用情景3 * 常量在编译阶段会被存入调用类的常量池中,本质上并没有引用到定义常量类类,所以自然不会触发定义常量的类的初始化 * @author root * */class ConstClass{ static{ System.out.println("ConstClass init."); } public final static String value="hello"; }public class test{ public static void main(String[] args){ System.out.println(ConstClass.value); } } 输出结果:hello(tip:在编译的时候,ConstClass.value已经被转变成hello常量放进test类的常量池里面了) 1. Classloader的作用,概括来说就是将编译后的class装载、加载到机器内存中,为了以后的程序的执行提供前提条件。 package test01; class Singleton { public static Singleton singleton = new Singleton(); public static int a; public static int b = 0; private Singleton() { super(); a++; b++; } public static Singleton GetInstence() { return singleton; } } public class MyTest { /** * @param args */ public static void main(String[] args) { Singleton mysingleton = Singleton.GetInstence(); System.out.println(mysingleton.a); System.out.println(mysingleton.b); } } 一般不假思索的结论就是,a=1,b=1。给出的原因是:a、b都是静态变量,在构造函数调用的时候已经对a和b都加1了。答案就都是1。但是运行完后答案却是a=1,b=0。 下面我们将代码稍微变一下 Java代码 public static Singleton singleton = new Singleton(); public static int a; public static int b = 0; 的代码部分替换成 Java代码 public static int a; public static int b = 0; public static Singleton singleton = new Singleton(); 效果就是刚才预期的a=1,b=1。 为什么呢,这3句无非就是静态变量的声明、初始化,值的变化和声明的顺序还有关系吗?Java不是面向对象的吗?怎么和结构化的语言似地,顺序还有关系。这个就是和Java虚拟机JVM加载类的原理有着直接的关系。 1. 类在JVM中的工作原理 要想使用一个Java类为自己工作,必须经过以下几个过程 1):类加载load:从字节码二进制文件——.class文件将类加载到内存,从而达到类的从硬盘上到内存上的一个迁移,所有的程序必须加载到内存才能工作。将内存中的class放到运行时数据区的方法区内,之后在堆区建立一个java.lang.Class对象,用来封装方法区的数据结构。这个时候就体现出了万事万物皆对象了,干什么事情都得有个对象。就是到了最底层究竟是鸡生蛋,还是蛋生鸡呢?类加载的最终产物就是堆中的一个java.lang.Class对象。 2):连接:连接又分为以下小步骤 验证:出于安全性的考虑,验证内存中的字节码是否符合JVM的规范,类的结构规范、语义检查、字节码操作是否合法、这个是为了防止用户自己建立一个非法的XX.class文件就进行工作了,或者是JVM版本冲突的问题,比如在JDK6下面编译通过的class(其中包含注解特性的类),是不能在JDK1.4的JVM下运行的。 准备:将类的静态变量进行分配内存空间、初始化默认值。(对象还没生成呢,所以这个时候没有实例变量什么事情) 新分配的空间中,所有的原始类型将被置0(int类型为0,boolean类型为false等等),引用类型将被置成null;所以singleton 也是一个属性,也被默认值为null 这阶段会为类变量(指那些静态变量)分配内存并设置类比那辆初始值的阶段,这些内存在方法区中进行分配。这里要说明一下,这一步只会给那些静态变量设置一个初始的值,而那些实例变量是在实例化对象时进行分配的。这里的给类变量设初始值跟类变量的赋值有点不同,比如下面: public static int value=123; 在这一阶段,value的值将会是0,而不是123,因为这个时候还没开始执行任何java代码,123还是不可见的,而我们所看到的把123赋值给value的putstatic指令是程序被编译后存在于<clinit>(),所以,给value赋值为123是在初始化的时候才会执行的。 这里也有个例外: public static final int value=123; 这里在准备阶段value的值就会初始化为123了。这个是说,在编译期,javac(还是JVM?答案:http://blog.csdn.net/cutesource/article/details/5904542)会为这个特殊的value生成一个ConstantValue属性,并在准备阶段jm就会根据这个ConstantValue的值来为value赋值了。即编译的时候,就将该值或者是对象放入常量池。 注:java程序要运行需要两次编译,一次是javac,而次是jvm。第一次也是过程中就包含常量池。 解析:把类的符号引用转为直接引用(保留) 3):类的初始化: 将类的静态变量赋予正确的初始值,这个初始值是开发者自己定义时赋予的初始值,而不是默认值。 2. 类的主动使用与被动使用 以下是视为主动使用一个类,其他情况均视为被动使用! 1):初学者最为常用的new一个类的实例对象(声明不叫主动使用) 2):对类的静态变量进行读取、赋值操作的。(静态,final且值确定是常量,是编译时确定的,调用的时候直接用,不会加载对应的类) 3):直接调用类的静态方法。 4):反射调用一个类的方法。 5):初始化一个类的子类的时候,父类也相当于被程序主动调用了(如果调用子类的静态变量是从父类继承过来并没有复写的,那么也就相当于只用到了父类的东东,和子类无关,所以这个时候子类不需要进行类初始化)。 6):直接运行一个main函数入口的类。 所有的JVM实现(不同的厂商有不同的实现,有人就说IBM的实现比Sun的要好……)在首次主动调用类和接口的时候才会初始化他们。 1. 类的加载方式 1):本地编译好的class中直接加载 2):网络加载:java.net.URLClassLoader可以加载url指定的类(即网络下载字节码,并加载) 3):从jar、zip等等压缩文件加载类,自动解析jar文件找到class文件去加载util类 4):从java源代码文件动态编译成为class文件(动态生成字节码) 2. 类加载器 JVM自带的默认加载器 1):根类加载器:bootstrap,由C++编写,所有Java程序无法获得。 2):扩展类加载器:由Java编写。 3):系统类、应用类加载器:由Java编写。 用户自定义的类加载器:java.lang.ClassLoader的子类,用户可以定制类的加载方式。每一个类都包含了加载他的ClassLoader的一个引用——getClass().getClassLoader()。如果返回的是null,证明加载他的ClassLoader是根加载器bootstrap。 1. 回顾那个诡异的代码 从入口开始看 Singleton mysingleton = Singleton.GetInstence(); 是根据内部类的静态方法要一个Singleton实例。 这个时候就属于主动调用Singleton类了。 之后内存开始加载Singleton类 1):对Singleton的所有的静态变量分配空间,赋默认的值,所以在这个时候,singleton=null、a=0、b=0。注意b的0是默认值,并不是咱们手工为其赋予的的那个0值。 2):之后对静态变量赋值,这个时候的赋值就是我们在程序里手工初始化的那个值了。此时singleton = new Singleton();调用了构造方法。构造方法里面a=1、b=1。之后接着顺序往下执行。 3): public static int a; public static int b = 0; a没有赋值,保持原状a=1。b被赋值了,b原先的1值被覆盖了,b=0。所以结果就是这么来的。类中的静态块static块也是顺序地从上到下执行的。 2. 编译时常量、非编译时常量的静态变量 如下代码 Java代码 package test01; class FinalStatic { public static final int A = 4 + 4; static { System.out.println("如果执行了,证明类初始化了……"); } } public class MyTest03 { /** * @param args */ public static void main(String[] args) { System.out.println(FinalStatic.A); } } 结果是只打印出了8,证明类并没有初始化。反编译源码发现class里面的内容是 public static final int A = 8; 也就是说编译器很智能的、在编译的时候自己就能算出4+4是8,是一个固定的数字。没有什么未知的因素在里面。 将代码稍微改一下 public static final int A = 4 + new Random().nextInt(10);//静态final变量在编译时不定的情况 //思考 什么是常量? 什么样的静态变量被放进常量池? //java文件编译成class 再编译成本机可执行的代码。 同时分析下 : 用final修饰就是代表常量,当常量被设定后,一般情况下就不允许再进行更改 public static final int A = 4 + new Random().nextInt(10);(变量,类常亮)(JVM编译阶段,不会进入常量池) public final int A = 4 + new Random().nextInt(10);(变量,对象常量)(JVM编译阶段,不会进入常量池) public final int A = 4 + 4;(恒量,无论程序运行多少次,。值都不变)(JVM编译阶段,会进入常量池) 这个时候静态块就执行了,证明类初始化了。在静态final变量在编译时不定的情况下。如果客户程序这个时候访问了该类的静态变量,那就会对类进行初始化,所以尽量静态final变量尽量没什么可变因素在里面1,否则性能会有所下降。
本文出自 “追逐吧!” 博客,请务必保留此出处http://4034702.blog.51cto.com/4024702/1903947
以上是关于java杂记-static的主要内容,如果未能解决你的问题,请参考以下文章
杂记:Django和static,Nginx配置路径,json_schema