分类 Java 下的文章

情人节html5玫瑰花源码

情人节html5玫瑰花源码

玫瑰花

玫瑰花

<html>
<head></head>
<body>
<iframe width="1200px" scrolling="no" height="820px" frameborder="0" noresize="noresize" src="javascript:'
<!doctype html>n<html>nt<head>ntt<title>JS1k, 1k demo submission [1022]</title>ntt<meta charset=&quot;utf-8&quot;
/>nt</head>nt<body>ntt<canvas id=&quot;c&quot;></canvas>ntt<script>ntttvar b =
document.body;ntttvar c = document.getElementsByTagName('canvas')[0];ntttvar a = c.getContext
('2d');ntttdocument.body.clientWidth; // fix bug in webkit: http://qfox.nl/weblog/218
ntt</script>ntt<script>n// start of submission //nwith(m=Math)
C=cos,S=sin,P=pow,R=random;c.width=c.height=f=500;h=-250;function p(a,b,c){if(c>60)return[S(a*7)*(13+5/(.2+P
(b*4,4)))-S(b)*50,b*f+50,625+C(a*7)*(13+5/(.2+P(b*4,4)))+b*400,a*1-b/2,a];A=a*2-1;B=b*2-1;if(A*A+B*B<1){if(c>37){n=
(j=c&1)%3F6:4;o=.5/(a+.01)+C(b*125)*3-a*300;w=b*h;return[o*C(n)+w*S(n)+j*610-390,o*S(n)-w*C(n)+550-j*350,1180+C
(B+A)*99-j*300,.4-a*.1+P(1-B*B,-h*6)*.15-a*b*.4+C(a+b)/5+P(C((o*(a+1)+(B>0%3Fw:-w))/25),30)*.1*(1-B*B),o/1e3+.7-
o*w*3e-6]}if(c>32){c=c*1.16-.15;o=a*45-20;w=b*b*h;z=o*S(c)+w*C(c)+620;return[o*C(c)-w*S(c),28+C(B*.5)*99-b*b*b*60-
z/2-h,z,(b*b*.3+P((1-(A*A)),7)*.15+.3)*b,b*.7]}o=A*(2-b)*(80-c*2);w=99-C(A)*120-C(b)*(-h-c*4.9)+C(P(1-b,7))
*50+c*2;z=o*S(c)+w*C(c)+700;return[o*C(c)-w*S(c),B*99-C(P(b, 7))*50-c/3-z/1.35+450,z,(1-b/1.2)*.9+a*.1, P((1-
b),20)/4+.05]}}setInterval('for(i=0;i<1e4;i++)if(s=p(R(),R(),i%2546/.74)){z=s[2];x=~~(s[0]*f/z-h);y=~~(s[1]*f/z-
h);if(!m[q=y*f+x]|m[q]>z)m[q]=z,a.fillStyle=&quot;rgb(&quot;+~(s[3]*h)+&quot;,&quot;+~(s[4]*h)+&quot;,&quot;+~(s[3]
*s[3]*-80)+&quot;)&quot;,a.fillRect(x,y,1,1)}',0)n// end of submission //
ntt</script>nt</body>n</html>'"></iframe>
</body>
</html>

Java程序员进化为架构师掌握的知识

一:Java知识
1、进制转换
2、Java基本数据类型
面向对象相关知识
3、类、接口、抽象类
this关键字、static关键字、final关键字
方法的参数传递机制
Java垃圾回收机制
四种内部类的实现方式
方法重写(override)与重载(overload)的联系与区别通过多态实现程序代码的松耦合
Java 异常体系详解(checked exception 与 unchecked exception)
JDK 5.0 新特性(泛型、枚举、可变参数、增强的 for 循环、静态导入等)
Java Annotation(使用系统内置 Annotation、自定义Annotation、Annotation的继承等)
Java多线程机制详解(锁、synchronized关键字、sleep()方法、wait()方法、notify()
、notifyAll()方法的意义与联系)
Java线程池的内部实现
Java定时任务内部实现
Java I/O编程(装饰模式详解)
Java网络编程基础知识(Socket、URL、URLConnection、ServerSocket等)
TCP与 UDP的联系与区别
Java Collection API(Collection、List、Set、Map、ArrayList、LinkedList、 Vector、 HashSet、
TreeSet、 HashMap与TreeMap等)区别,适用场景
常用设计模式(工厂方法模式、观察者模式、策略模式、装饰模式、模板方法模式、命令模式等的原理与
应用)
Java NIO详解
java.util.concurrent 并发包的应用(ConcurrentHashMap核心源代码分析、ThreadPoolExecutor、Future
Task、Semaphore、Condition、ReentrantReadWriteLock等接口与类的深度分析)
基于 JDK 1.4 锁的并发机制与基于 JDK 5.0并发包的同步与并发机制的比较与分析
序列化与反序列化
正则表达式的应用
Java动态代理与反射机制
Java代码的执行机制
源代码编译机制
类加载与执行机制
JVM内存管理(内存空间、内存分配、内存回收)
使用 JConsole、JVisualVM及 JMap等查看内存的使用状况
分析程序执行的过程
JVM线程资源同步及交互机制
线程交互机制与状态分析
Java文件操作相关,递归删除,递归读取
JDBC相关知识,步骤,连接操作,数据库连接池(详解 Apache DBCP数据库连接池)
移位操作 (左移n位==乘以2的n次幂) (右移n位==除以2的n次幂)
二、算法
各种排序算法:快速排序、归并排序、插入排序等等
斐波切纳函数
二分查找
全排列
二叉树的遍历
定义栈的数据结构,要求添加一个min函数,能够得到栈的最小元素。要求函数min、push以及pop的时
间复杂度都是O(1)
字符串反转
前缀树
最大堆,最小堆
Hash算法及HashMap算法
ConcurrentLinkedHashMap(LRU)
BloomFilter
LIRS算法 LIRS的基本思想是对访问的数据块进行分类,一部分为hot数据块,一部分为cold数据块。对于
hot数据块我们可以分配90%以上的cache给它们。而对于cold数据块给它们分配10%。
从LIRS算法的描述来看,可以理解为两个LRU队列的组合,利用cold缓冲区来保护Hot缓冲区,提高了进
入hot缓冲区的门槛,阻止hot缓冲区频繁地变化。
三、数据库
mysql存储引擎
mysql优化
mysql HA解决方案
sql语句优化
NoSQL相关
四、文件系统
Linux主流文件系统
EXT3与EXT4文件系统
主流分布式文件系统分析与对比
分布式文件系统
五、系统相关
共享内存实现机制
mmap的实现原理与机制
copy on write技术
zero copy技术
六、网络相关
OSI七层网络模型
TCP/IP交互流程
HTTP访问流程
七、大型网站架构
负载均衡技术及其原理
智能DNS解析,原理,实现方案
squid web加速及缓存技术
网页静态化
 

如何修改java class文件

工具:
Java Class File Editor 下载地址:https://sourceforge.net/projects/classeditor/
jd-gui.exe 下载地址:http://jd.benow.ca/
其中Java Class File Editor是用来修改class内容的,而jd-gui.exe是在修改前和修改后查看代码的。
下载工具ce2.23 .tar.gz,解压,打开window的cmd
进入文件夹 运行java -jar ce.jar就可以看到界面,

class editor

class editor


jd-gui.exe查看源代码,在editor里查找要修改的地方,修改,保存,然后用jd-gui.exe查看修改后是否生效。
查看class文件

查看class文件

AngularJS开发的理念

Angular信奉的是,当组建视图(UI)同时又要写软件逻辑时,声明式的代码会比命令式的代码好得多,尽管命令式的代码非常适合用来表述业务逻辑
将DOM操作和应用逻辑解耦是一种非常好的思路,它能大大改善代码的可调性;
将测试和开发同等看待是一种非常非常好的思路,测试的难度在很大程度上取决于代码的结构;
将客户端和服务器端解耦是一种特别好的做法,它能使两边并行开发,并且使两边代码都能实现重用;
如果框架能够在整个开发流程里都引导着开发者:从设计UI,到编写业务逻辑,再到测试,那对开发者将是极大的帮助;
“化繁为简,化简为零”总是好的。
AngularJS能将你从以下的噩梦中解脱出来:
使用回调:回调的使用会打乱你的代码的可读性,让你的代码变得支离破碎,很难看清本来的业务逻辑。移除一些常见的代码,例如回调,是件好事。大幅度地减少你因为JavaScript这门语言的设计而不得不写的代码,能让你把自己应用的逻辑看得更清楚。
手动编写操作DOM元素的代码:操作DOM是AJAX应用很基础的一部分,但它也总是很“笨重”并且容易出错。用声明的方式描述的UI界面可随着应用状态的改变而变化,能让你从编写低级的DOM操作代码中解脱出来。绝大部分用AngularJS写的应用里,开发者都不用再自己去写操作DOM的代码,不过如果你想的话还是可以去写。
对UI界面读写数据:AJAX应用的很大一部是CRUD操作。一个经典的流程是把服务端的数据组建成内部对象,再把对象编成HTML表单,用户修改表单后再验证表单,如果有错再显示错误,然后将数据重新组建成内部对象,再返回给服务器。这个流程里有太多太多要重复写的代码,使得代码看起来总是在描述应用的全部执行流程,而不是具体的业务逻辑和业务细节。
前得写大量的基础性的代码:通常你需要写很多的基础性的代码才能实现一个“Hello World”的应用。用AngularJS的话,它会提供一些服务让你很容易地正式开始写你的应用,而这些服务都是以一种Guice-like dependency-injection式的依赖注入自动加入到你的应用中去的,这让你能很快的进入你应用的具体开发。特别的是,你还能全盘掌握自动化测试的初始化过程。

Java异常处理步骤

Java异常处理步骤:
第一句一般是总的,告诉你哪里错了,错误就在caused by后面的语句提示里面,或者是自己写的类里面。异常信息是从上往下抛(大概的说法)的,因为下面是调用上面的方法,也就是说第一行是最终抛出异常的方法,而最后一行最上层调用的方法
异常链是一种机制,异常转译时,保存原来的异常,这样当这个异常再被转译时,还会被保存,于是就成了一条链了,包含了所有的异常,所以你可以看到这样的异常打印:

org.apache.phoenix.exception.PhoenixIOException: org.apache.phoenix.exception.PhoenixIOException: 系统找不到指定的路径。
	at org.apache.phoenix.util.ServerUtil.parseServerException(ServerUtil.java:107)
	at org.apache.phoenix.iterate.ParallelIterators.getIterators(ParallelIterators.java:527)
	at org.apache.phoenix.iterate.MergeSortResultIterator.getIterators(MergeSortResultIterator.java:48)
	at org.apache.phoenix.iterate.MergeSortResultIterator.minIterator(MergeSortResultIterator.java:63)
	at org.apache.phoenix.iterate.MergeSortResultIterator.next(MergeSortResultIterator.java:90)
	at org.apache.phoenix.jdbc.PhoenixResultSet.next(PhoenixResultSet.java:734)
	at com.youku.service.VideoFingerprintServiceNew.getSimlarVideoMD5(VideoFingerprintServiceNew.java:111)
	at com.youku.service.VideoFingerprintServiceNew.excute(VideoFingerprintServiceNew.java:50)
	at com.youku.service.AbstractHttpImpl.getResponseModel(AbstractHttpImpl.java:22)
	at com.youku.web.servlet.CommonHttpServlet.doPost(CommonHttpServlet.java:79)
	at com.youku.web.servlet.CommonHttpServlet.doGet(CommonHttpServlet.java:41)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:617)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:723)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:290)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
	at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:233)
	at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:191)
	at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:127)
	at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:103)
	at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:109)
	at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:293)
	at org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:861)
	at org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.process(Http11Protocol.java:612)
	at org.apache.tomcat.util.net.JIoEndpoint$Worker.run(JIoEndpoint.java:503)
	at java.lang.Thread.run(Thread.java:745)
Caused by: java.util.concurrent.ExecutionException: org.apache.phoenix.exception.PhoenixIOException: 系统找不到指定的路径。
	at java.util.concurrent.FutureTask.report(FutureTask.java:122)
	at java.util.concurrent.FutureTask.get(FutureTask.java:202)
	at org.apache.phoenix.iterate.ParallelIterators.getIterators(ParallelIterators.java:523)
	... 23 more
Caused by: org.apache.phoenix.exception.PhoenixIOException: 系统找不到指定的路径。
	at org.apache.phoenix.util.ServerUtil.parseServerException(ServerUtil.java:107)
	at org.apache.phoenix.iterate.SpoolingResultIterator.(SpoolingResultIterator.java:129)
	at org.apache.phoenix.iterate.SpoolingResultIterator.(SpoolingResultIterator.java:74)
	at org.apache.phoenix.iterate.SpoolingResultIterator$SpoolingResultIteratorFactory.newIterator(SpoolingResultIterator.java:68)
	at org.apache.phoenix.iterate.ChunkedResultIterator.(ChunkedResultIterator.java:90)
	at org.apache.phoenix.iterate.ChunkedResultIterator$ChunkedResultIteratorFactory.newIterator(ChunkedResultIterator.java:70)
	at org.apache.phoenix.iterate.ParallelIterators$2.call(ParallelIterators.java:631)
	at org.apache.phoenix.iterate.ParallelIterators$2.call(ParallelIterators.java:622)
	at java.util.concurrent.FutureTask.run(FutureTask.java:262)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
	... 1 more

这个异常链中就是包含了两个异常,最前面是顶级异常,后面再打印一个Cause by,然后再打印低一层异常,直到打印完所有的异常。
异常链,在JDK1.4以后版本中,Throwable类支持异常链机制。Throwable 包含了其线程创建时线程执行堆栈的快照。它还包含了给出有关错误更多信息的消息字符串。最后,它还可以包含 cause(原因):另一个导致此 throwable 抛出的 throwable。它也称为异常链 设施,因为 cause 自身也会有 cause,依此类推,就形成了异常链,每个异常都是由另一个异常引起的。
通俗的说,异常链就是把原始的异常包装为新的异常类,并在新的异常类中封装了原始异常类,这样做的目的在于找到异常的根本原因。
这篇文章很好:http://my.oschina.net/yanquan345/blog/204498
在我查过的资料中,以《Effective Java》书中对异常处理设计的研究得最系统,本文很多思想来自于它,下面我把其中的几条原则翻译(非直译)并贴上:
第57条:只对异常情况使用异常。(说明:即不要用异常处理控制正常程序流)。
第58条:对可恢复异常使用编译时异常,对编程错误使用运行时异常。
第59条:应避免不必要的编译时异常:如果调用者即使合理的使用API也不能避免异常的发生,并且调用者可以对捕获的异常做出有意义的处理,才使用编译时异常。
第60条:应偏好使用自带异常
第61条:抛出的异常应适合本层抽象(就是上面说的转译)
第62条:把方法可能抛的所有异常写入文档,包括运行时异常
第63条:用异常类记录的信息要包含失败时的数据
第64条:力求失败是原子化的(解释:就是如果调用一个方法发生了异常,就应该使对象返回调用前的状态)
第65条:不要忽略异常

angular开发相关资料

angular开发相关资料
bootstrap::UI组件      弹出层
http://angular-ui.github.io/bootstrap/
jquery easyUI:UI组件     表格
http://www.zi-han.net/case/easyui/
angular api文档:
http://docs.angularjs.org/api/
angular的依赖注入需要注意,必须参数名称一致,否则依赖注入失败,会提示找不到“提供者”,

Error: $injector:unpr
Unknown Provider

意思是:找不到被注入的内容,确认是否定义或者拼写是否正确。(make sure the dependency is defined and spelled correctl)
参看:http://docs.angularjs.org/error/$injector/unpr
而且bootstrap这个组件里的Modal的open方法也是支持angular的依赖注入的,必须查看资料才能找到各种参数是干什么用的:
声明controller:

controller - a controller for a modal instance - it can initialize scope used by modal. A controller can be injected with $modalInstance

声明参数:

resolve - members that will be resolved and passed to the controller as locals; it is equivalent of the resolve property for AngularJS routes

参看:http://angular-ui.github.io/bootstrap/
最后追查到确实是controller中参数定义名称和resolve中的参数名称不符合,导致依赖注入失败。

javascript基本语法

改变 HTML 属性
如需改变 HTML 元素的属性,请使用这个语法:

document.getElementById(id).attribute=new value

本例改变了 元素的 src 属性:

<img id="image" src="smiley.gif" alt="" />
<script type="text/javascript">
document.getElementById("image").src="landscape.jpg";
</script>

改变 HTML 样式
如需改变 HTML 元素的样式,请使用这个语法:

document.getElementById(id).style.property=new style

下面的例子会改变
元素的样式:

Hello World!
<script type="text/javascript">
document.getElementById("p2").style.color="blue";
</script>

JavaScript变量

局部 JavaScript 变量
在 JavaScript 函数内部声明的变量(使用 var)是局部变量,所以只能在函数内部访问它。(该变量的作用域是局部的)。
您可以在不同的函数中使用名称相同的局部变量,因为只有声明过该变量的函数才能识别出该变量。
只要函数运行完毕,本地变量就会被删除。
全局 JavaScript 变量
在函数外声明的变量是全局变量,网页上的所有脚本和函数都能访问它。
JavaScript 变量的生存期
JavaScript 变量的生命期从它们被声明的时间开始。
局部变量会在函数运行以后被删除。
全局变量会在页面关闭后被删除。
向未声明的 JavaScript 变量来分配值
如果您把值赋给尚未声明的变量,该变量将被自动作为全局变量声明。
这条语句:

carname="Volvo";

将声明一个全局变量 carname,即使它在函数内执行。

跨域问题

Uncaught SecurityError: Blocked a frame with origin “http://click.youku.com” from accessing a frame with origin “http://index.youku.com”. The frame requesting access set “document.domain” to “youku.com”, but the frame being accessed did not. Both must set “document.domain” to the same value to allow access.
还是跨域问题,父页面和子页面没有明确指出在同一个域下
在子页面中加入如下代码,显示声明:

<script>
        document.domain='youku.com';
</script>

Java对象初始化详解

在Java中,一个对象在可以被使用之前必须要被正确地初始化,这一点是Java规范规定的。本文试图对Java如何执行对象的初始化做一个详细深入地介绍(与对象初始化相同,类在被加载之后也是需要初始化的,本文在最后也会对类的初始化进行介绍,相对于对象初始化来说,类的初始化要相对简单一些)。
1.Java对象何时被初始化
Java对象在其被创建时初始化,在Java代码中,有两种行为可以引起对象的创建。其中比较直观的一种,也就是通常所说的显式对象创建,就是通过new关键字来调用一个类的构造函数,通过构造函数来创建一个对象,这种方式在java规范中被称为“由执行类实例创建表达式而引起的对象创建”。
当然,除了显式地创建对象,以下的几种行为也会引起对象的创建,但是并不是通过new关键字来完成的,因此被称作隐式对象创建,他们分别是:
● 加载一个包含String字面量的类或者接口会引起一个新的String对象被创建,除非包含相同字面量的String对象已经存在与虚拟机内了(JVM会在内存中会为所有碰到String字面量维护一份列表,程序中使用的相同字面量都会指向同一个String对象),比如,

class StringLiteral {
    private String str = "literal";
    private static String sstr = "s_literal";
}

● 自动装箱机制可能会引起一个原子类型的包装类对象被创建,比如,

class PrimitiveWrapper {
    private Integer iWrapper = 1;
}

● String连接符也可能会引起新的String或者StringBuilder对象被创建,同时还可能引起原子类型的包装对象被创建,比如(本人试了下,在mac ox下1.6.0_29版本的javac,对待下面的代码会通过StringBuilder来完成字符串的连接,并没有将i包装成Integer,因为StringBuilder的append方法有一个重载,其方法参数是int),

public class StringConcatenation {
    private static int i = 1;
    public static void main(String... args) {
        System.out.println("literal" + i);
    }
}

2.Java如何初始化对象
当一个对象被创建之后,虚拟机会为其分配内存,主要用来存放对象的实例变量及其从超类继承过来的实例变量(即使这些从超类继承过来的实例变量有可能被隐藏也会被分配空间)。在为这些实例变量分配内存的同时,这些实例变量也会被赋予默认值。
引用
关于实例变量隐藏

class Foo {
    int i = 0;
}
class Bar extends Foo {
    int i = 1;
    public static void main(String... args) {
        Foo foo = new Bar();
        System.out.println(foo.i);
    }
}

上面的代码中,Foo和Bar中都定义了变量i,在main方法中,我们用Foo引用一个Bar对象,如果实例变量与方法一样,允许被覆盖,那么打印的结果应该是1,但是实际的结果确是0。
但是如果我们在Bar的方法中直接使用i,那么用的会是Bar对象自己定义的实例变量i,这就是隐藏,Bar对象中的i把Foo对象中的i给隐藏了,这条规则对于静态变量同样适用。
在内存分配完成之后,java的虚拟机就会开始对新创建的对象执行初始化操作,因为java规范要求在一个对象的引用可见之前需要对其进行初始化。在Java中,三种执行对象初始化的结构,分别是实例初始化器、实例变量初始化器以及构造函数。
2.1. Java的构造函数
每一个Java中的对象都至少会有一个构造函数,如果我们没有显式定义构造函数,那么Java编译器会为我们自动生成一个构造函数。构造函数与类中定义的其他方法基本一样,除了构造函数没有返回值,名字与类名一样之外。在生成的字节码中,这些构造函数会被命名成方法,参数列表与Java语言书写的构造函数的参数列表相同(这样的方法名在Java语言中是非法的,但是对于JVM来说,是合法的)。另外,构造函数也可以被重载。
Java要求一个对象被初始化之前,其超类也必须被初始化,这一点是在构造函数中保证的。Java强制要求Object对象(Object是Java的顶层对象,没有超类)之外的所有对象构造函数的第一条语句必须是超类构造函数的调用语句或者是类中定义的其他的构造函数,如果我们即没有调用其他的构造函数,也没有显式调用超类的构造函数,那么编译器会为我们自动生成一个对超类构造函数的调用指令,比如,

public class ConstructorExample {
}

对于上面代码中定义的类,如果观察编译之后的字节码,我们会发现编译器为我们生成一个构造函数,如下,

aload_0
invokespecial    #8; //Method java/lang/Object."<init>":()V
return

上面代码的第二行就是调用Object对象的默认构造函数的指令。
正因为如此,如果我们显式调用超类的构造函数,那么调用指令必须放在构造函数所有代码的最前面,是构造函数的第一条指令。这么做才可以保证一个对象在初始化之前其所有的超类都被初始化完成。
如果我们在一个构造函数中调用另外一个构造函数,如下所示,

public class ConstructorExample {
    private int i;
    ConstructorExample() {
        this(1);
        ....
    }
    ConstructorExample(int i) {
        ....
        this.i = i;
        ....
    }
}

对于这种情况,Java只允许在ConstructorExample(int i)内出现调用超类的构造函数,也就是说,下面的代码编译是无法通过的,

public class ConstructorExample {
    private int i;
    ConstructorExample() {
        super();
        this(1);
        ....
    }
    ConstructorExample(int i) {
        ....
        this.i = i;
        ....
    }
}

或者,

public class ConstructorExample {
    private int i;
    ConstructorExample() {
        this(1);
        super();
        ....
    }
    ConstructorExample(int i) {
        ....
        this.i = i;
        ....
    }
}

Java对构造函数作出这种限制,目的是为了要保证一个类中的实例变量在被使用之前已经被正确地初始化,不会导致程序执行过程中的错误。但是,与C或者C++不同,Java执行构造函数的过程与执行其他方法并没有什么区别,因此,如果我们不小心,有可能会导致在对象的构建过程中使用了没有被正确初始化的实例变量,如下所示,

class Foo {
    int i;
    Foo() {
        i = 1;
        int x = getValue();
        System.out.println(x);
    }
    protected int getValue() {
        return i;
    }
}
class Bar extends Foo {
    int j;
    Bar() {
        j = 2;
    }
    @Override
    protected int getValue() {
        return j;
    }
}
public class ConstructorExample {
    public static void main(String... args) {
        Bar bar = new Bar();
    }
}

如果运行上面这段代码,会发现打印出来的结果既不是1,也不是2,而是0。根本原因就是Bar重载了Foo中的getValue方法。在执行Bar的构造函数是,编译器会为我们在Bar构造函数开头插入调用Foo的构造函数的代码,而在Foo的构造函数中调用了getValue方法。由于Java对构造函数的执行没有做特殊处理,因此这个getValue方法是被Bar重载的那个getValue方法,而在调用Bar的getValue方法时,Bar的构造函数还没有被执行,这个时候j的值还是默认值0,因此我们就看到了打印出来的0。
2.2. 实例变量初始化器与实例初始化器
我们可以在定义实例变量的同时,对实例变量进行赋值,赋值语句就时实例变量初始化器了,比如,

public class InstanceVariableInitializer {
    private int i = 1;
    private int j = i + 1;
}

如果我们以这种方式为实例变量赋值,那么在构造函数执行之前会先完成这些初始化操作。
我们还可以通过实例初始化器来执行对象的初始化操作,比如,

public class InstanceInitializer {
    private int i = 1;
    private int j;
    {
        j = 2;
    }
}

上面代码中花括号内代码,在Java中就被称作实例初始化器,其中的代码同样会先于构造函数被执行。
如果我们定义了实例变量初始化器与实例初始化器,那么编译器会将其中的代码放到类的构造函数中去,这些代码会被放在对超类构造函数的调用语句之后(还记得吗?Java要求构造函数的第一条语句必须是超类构造函数的调用语句),构造函数本身的代码之前。我们来看下下面这段Java代码被编译之后的字节码,Java代码如下,

public class InstanceInitializer {
    private int i = 1;
    private int j;
    {
        j = 2;
    }
    public InstanceInitializer() {
        i = 3;
        j = 4;
    }
}

编译之后的字节码如下,

aload_0
invokespecial    #11; //Method java/lang/Object."<init>":()V
aload_0
iconst_1
putfield #13; //Field i:I
aload_0
iconst_2
putfield #15; //Field j:I
aload_0
iconst_3
putfield #13; //Field i:I
aload_0
iconst_4
putfield #15; //Field j:I
return

上面的字节码,第4,5行是执行的是源代码中i=1的操作,第6,7行执行的源代码中j=2的操作,第8-11行才是构造函数中i=3和j=4的操作。
Java是按照编程顺序来执行实例变量初始化器和实例初始化器中的代码的,并且不允许顺序靠前的实例初始化器或者实例变量初始化器使用在其后被定义和初始化的实例变量,比如,

public class InstanceInitializer {
    {
        j = i;
    }
    private int i = 1;
    private int j;
}
public class InstanceInitializer {
    private int j = i;
    private int i = 1;
}

上面的这些代码都是无法通过编译的,编译器会抱怨说我们使用了一个未经定义的变量。之所以要这么做,是为了保证一个变量在被使用之前已经被正确地初始化。但是我们仍然有办法绕过这种检查,比如,

public class InstanceInitializer {
    private int j = getI();
    private int i = 1;
    public InstanceInitializer() {
        i = 2;
    }
    private int getI() {
        return i;
    }
    public static void main(String[] args) {
        InstanceInitializer ii = new InstanceInitializer();
        System.out.println(ii.j);
    }
}

如果我们执行上面这段代码,那么会发现打印的结果是0。因此我们可以确信,变量j被赋予了i的默认值0,而不是经过实例变量初始化器和构造函数初始化之后的值。
引用
一个实例变量在对象初始化的过程中会被赋值几次?
在本文的前面部分,我们提到过,JVM在为一个对象分配完内存之后,会给每一个实例变量赋予默认值,这个时候实例变量被第一次赋值,这个赋值过程是没有办法避免的。
如果我们在实例变量初始化器中对某个实例x变量做了初始化操作,那么这个时候,这个实例变量就被第二次赋值了。
如果我们在实例初始化器中,又对变量x做了初始化操作,那么这个时候,这个实例变量就被第三次赋值了。
如果我们在类的构造函数中,也对变量x做了初始化操作,那么这个时候,变量x就被第四次赋值。
也就是说,一个实例变量,在Java的对象初始化过程中,最多可以被初始化4次。
2.3. 总结
通过上面的介绍,我们对Java中初始化对象的几种方式以及通过何种方式执行初始化代码有了了解,同时也对何种情况下我们可能会使用到未经初始化的变量进行了介绍。在对这些问题有了详细的了解之后,就可以在编码中规避一些风险,保证一个对象在可见之前是完全被初始化的。
3.关于类的初始化
Java规范中关于类在何时被初始化有详细的介绍,在3.0规范中的12.4.1节可以找到,这里就不再多说了。简单来说,就是当类被第一次使用的时候会被初始化,而且只会被一个线程初始化一次。我们可以通过静态初始化器和静态变量初始化器来完成对类变量的初始化工作,比如,

public class StaticInitializer {
    static int i = 1;
    static {
        i = 2;
    }
}

上面通过两种方式对类变量i进行了赋值操作,分别通过静态变量初始化器(代码第2行)以及静态初始化器(代码第5-6行)完成。
静态变量初始化器和静态初始化器基本同实例变量初始化器和实例初始化器相同,也有相同的限制(按照编码顺序被执行,不能引用后定义和初始化的类变量)。静态变量初始化器和静态初始化器中的代码会被编译器放到一个名为static的方法中(static是Java语言的关键字,因此不能被用作方法名,但是JVM却没有这个限制),在类被第一次使用时,这个static方法就会被执行。上面的Java代码编译之后的字节码如下,我们看到其中的static方法,

static {};
  Code:
   Stack=1, Locals=0, Args_size=0
   iconst_1
   putstatic    #10; //Field i:I
   iconst_2
   putstatic    #10; //Field i:I
   return

在第2节中,我们介绍了可以通过特殊的方式来使用未经初始化的实例变量,对于类变量也同样适用,比如,

public class StaticInitializer {
    static int j = getI();
    static int i = 1;
    static int getI () {
        return i;
    }
    public static void main(String[] args) {
        System.out.println(StaticInitializer.j);
    }
}

上面这段代码的打印结果是0,类变量的值是i的默认值0。但是,由于静态方法是不能被覆写的,因此第2节中关于构造函数调用被覆写方法引起的问题不会在此出现。
http://blog.jobbole.com/23939/