首先要说明的是，java里不能直接使用synchronized声明一个变量，而是使用synchronized去修饰一个代码块或一个方法。
目前创新互联已为上千的企业提供了网站建设、域名、虚拟空间、网站托管维护、企业网站设计、华池网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。
详细说明如下：
synchronized用来修饰一个方法或者一个代码块，它用来保证在同一时刻最多只有一个线程执行该段代码。
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
五、以上规则对其它对象锁同样适用。
示例代码：
public class Thread1 implements Runnable {
public void run() {
synchronized(this) {
for (int i = 0; i 5; i++) {
System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
}
}
}
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t1, "B");
ta.start();
tb.start();
}
}
结果：
A synchronized loop 0
A synchronized loop 1
A synchronized loop 2
A synchronized loop 3
A synchronized loop 4
B synchronized loop 0
B synchronized loop 1
B synchronized loop 2
B synchronized loop 3
B synchronized loop 4
个人的总结
1 静态变量只有一份被类的所有实例共享
2 静态变量的声明在编译时已经明确了内存的位置
3 延迟初始化是改变静态变量的值
引用
Java静态变量的初始化（static块的本质）
在网上看到了下面的一段代码：
1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i = 10;
6.
7. public static void main(String[] args) {
8. System.out.println(_i);
9. }
10. }
public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }
上述代码会打印出什么结果来呢？10还是20？本文将以此代码为引子，着重讨论一下静态变量的初始化问题。 楼主可以找组织先记下175再来记下161最后填写984就会出现扣裙问题1：静态变量如何初始化
Java类中可以定义一个static块，用于静态变量的初始化。如：
1. public class Test {
2. public static int _i;
3. static {
4. _i = 10;
5. }
6. }
public class Test { public static int _i; static { _i = 10; } }
当然最常用的初始化静态变量的操作是在声明变量时直接进行赋值操作。如：
1. public class Test {
2. public static int _i = 10;
3. }
public class Test { public static int _i = 10; }
那么上述两例在本质上有什么区别吗？回答是没有区别。两例代码编译之后的字节码完全一致，通过 “javap -c”查看到的字节码如下：
public class Test extends java.lang.Object{
public static int _i;
public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."init":()V
4: return
static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: return
}
通过字节码还可以看出，当类的定义中不含有static块时，编译器会为该类提供一个默认的static块。当然这是在含有静态变量初始化操作的前 提下。如果静态变量没有初始化操作，则编译器不会为之提供默认的static块。如：
1. public class Test {
2. public static int _i;
3. }
public class Test { public static int _i; }
其字节码的表现形式为：
public class Test extends java.lang.Object{
public static int _i;
public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."init":()V
4: return
}
由于静态变量是通过赋值操作进行初始化的，因此可以通过静态函数返回值的方式为其初始化。如：
1. public class Test {
2. public static int _i = init();
3.
4. private static int init() {
5. return 10;
6. }
7. }
public class Test { public static int _i = init(); private static int init() { return 10; } }
其本质与下面的代码相同：
1. public class Test {
2. public static int _i;
3. static {
4. _i = init();
5. }
6.
7. private static int init() {
8. return 10;
9. }
10. }
public class Test { public static int _i; static { _i = init(); } private static int init() { return 10; } }
问题2：JDK如何处理static块
类定义中可以存在多个static块吗？回答是可以。如：
1. public class Test {
2. public static int _i;
3. static {
4. _i = 10;
5. }
6.
7. public static void main(String[] args) {
8. }
9.
10. static {
11. _i = 20;
12. }
13. }
public class Test { public static int _i; static { _i = 10; } public static void main(String[] args) { } static { _i = 20; } }
此类编译之后的字节码为：
public class Test extends java.lang.Object{
public static int _i;
public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."init":()V
4: return
public static void main(java.lang.String[]);
Code:
0: return
static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: bipush 20
7: putstatic #2; //Field _i:I
10: return
}
观察static{}部分可以看出，上例的代码与下面的代码效果一致：
1. public class Test {
2. public static int _i;
3.
4. public static void main(String[] args) {
5. }
6.
7. static {
8. _i = 10;
9. _i = 20;
10. }
11. }
public class Test { public static int _i; public static void main(String[] args) { } static { _i = 10; _i = 20; } }
此例可以证明，不仅类定义中可以有多个static块，而且在编译时编译器会将多个static块按照代码的前后位置重新组合成一个static 块。
问题3：如何看待静态变量的声明
静态变量存放在常量池之中。如何证明呢？如：
1. public class Test {
2. public static int _i = 10;
3. }
public class Test { public static int _i = 10; }
使用“javap -c -verbose”查看其字节码的内容如下：
public class Test extends java.lang.Object
SourceFile: "Test.java"
minor version: 0
major version: 49
Constant pool:
const #1 = Method #4.#14; // java/lang/Object."init":()V
const #2 = Field #3.#15; // Test._i:I
const #3 = class #16; // Test
const #4 = class #17; // java/lang/Object
const #5 = Asciz _i;
const #6 = Asciz I;
const #7 = Asciz init;
const #8 = Asciz ()V;
const #9 = Asciz Code;
const #10 = Asciz LineNumberTable;
const #11 = Asciz clinit;
const #12 = Asciz SourceFile;
const #13 = Asciz Test.java;
const #14 = NameAndType #7:#8;// "init":()V
const #15 = NameAndType #5:#6;// _i:I
const #16 = Asciz Test;
const #17 = Asciz java/lang/Object;
{
public static int _i;
public Test();
Code:
Stack=1, Locals=1, Args_size=1
0: aload_0
1: invokespecial #1; //Method java/lang/Object."init":()V
4: return
LineNumberTable:
line 2: 0
static {};
Code:
Stack=1, Locals=0, Args_size=0
0: bipush 10
2: putstatic #2; //Field _i:I
5: return
LineNumberTable:
line 3: 0
}
我们看到，常量池中const #2指向的就是Test._i，也就是静态变量。静态变量被保存到常量池中的工作原理这里不深入讨论。在此需要注意的是：
* 静态变量的声明与初始化是两个不同的操作；
* 静态变量的声明在编译时已经明确了内存的位置。
如：
1. public class Test {
2. public static int _i = 10;
3. }
public class Test { public static int _i = 10; }
上述代码的本质可以视为：
1. public class Test {
2. // 静态变量的声明
3. public static int _i;
4.
5. // 静态变量的初始化
6. static {
7. _i = 10;
8. }
9. }
public class Test { // 静态变量的声明 public static int _i; // 静态变量的初始化 static { _i = 10; } }
由于静态变量的声明在编译时已经明确，所以静态变量的声明与初始化在编码顺序上可以颠倒。也就是说可以先编写初始化的代码，再编写声明代码。如：
1. public class Test {
2. // 静态变量的初始化
3. static {
4. _i = 10;
5. }
6.
7. // 静态变量的声明
8. public static int _i;
9. }
public class Test { // 静态变量的初始化 static { _i = 10; } // 静态变量的声明 public static int _i; }
对初始问题的解答
解答了上述三个问题，让我们再来看看开篇提到的问题。代码如下：
1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i = 10;
6.
7. public static void main(String[] args) {
8. System.out.println(_i);
9. }
10. }
public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }
其本质可以用下面的代码表示：
1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i;
6. static {
7. _i = 10;
8. }
9.
10. public static void main(String[] args) {
11. System.out.println(_i);
12. }
13. }
public class Test { static { _i = 20; } public static int _i; static { _i = 10; } public static void main(String[] args) { System.out.println(_i); } }
再简化一下，可以表示为：
1. public class Test {
2. public static int _i;
3.
4. static {
5. _i = 20;
6. _i = 10;
7. }
8.
9. public static void main(String[] args) {
10. System.out.println(_i);
11. }
12. }
public class Test { public static int _i; static { _i = 20; _i = 10; } public static void main(String[] args) { System.out.println(_i); } }
至此，代码已经明确告诉我们打印结果是什么了！
很简单.就和普通使用一样哦
你要导入这个类所在的包
%@ page import="java.util.Date" %
%@ page import="java.text.*" %
这是调api的包
也可以这样写
%@ page import="java.util.Date, java.text.*" %
使用时
h2使用 java.util.Date 显示目前时间/h2
%
Date date = new Date();
out.println("现在时间："+date);
%
记住java代码一定要加% %写在这里面
当然你只要依样画葫芦就可以了
如果说怎么使用javaBean
我简单的写写吧
jsp:useBean id="user" scope="page" class="user"
中id要于属性的名字关联,范围是指该User的使用范围,类就是你的Bean所在的包了
如果你的User在model包内,就这么写
class="model.User"
具体的你可以参考一下JSP设计这本书
因为布署好的项目一般类都是放在WEB-INFO/CLASSES目录下
所以你只要把编译好的类,带包放进去,然后把包路径一定要写上,肯定是可以的,JAVABEANS还是蛮不错的.建议你下些电子书看看。
把泛型加在修饰符的前面，具体代码如下：
public T void show(T t) {
// do someing
}
备注：一般泛型方法的参数也是泛型的，否则这个泛型方法没有意义，
Java中，我们应该知道最基本的就是定义变量和声明变量了，那么定义与声明这两者有没有区别呢?具体的区别又是哪些呢?下面学习啦小编来告诉你定义与声明的区别。
定义和声明的定义区别
1、一种是需要建立存储空间的。例如：int a 在声明的时候就已经建立了存储空间。
2、另一种是不需要建立存储空间的。 例如：extern int a 其中变量a是在别的文件中定义的。
声明是向编译器介绍名字--标识符。它告诉编译器“这个函数或变量在某处可找到，它的模样象什么”。
而定义是说：“在这里建立变量”或“在这里建立函数”。它为名字分配存储空间。无论定义的是函数还是变量，编译器都要为它们在定义点分配存储空间。
对于变量，编译器确定变量的大小，然后在内存中开辟空间来保存其数据，对于函数，编译器会生成代码，这些代码最终也要占用一定的内存。
总之就是：把建立空间的声明成为“定义”，把不需要建立存储空间的成为“声明”。
基本类型变量的声明和定义(初始化)是同时产生的;而对于对象来说，声明和定义是分开的。
下面小编给大家举个例子说明一下。
例如：类A
如果A a;就是一个声明，告诉编译器a是A类的一个对象变量，但是不进行初始化;
如果以后a=new A();这就是初始化，分配了空间。
需要注意的是我们声明的最终目的是为了提前使用，即在定义之前使用，如果不需要提前使用就没有单独声明的必要，变量是如此，函数也是如此，所以声明不会分配存储空间，只有定义时才会分配存储空间。
用static来声明一个变量的作用有二：
(1)对于局部变量用static声明，则是为该变量分配的空间在整个程序的执行期内都始终存在。
(2)外部变量用static来声明，则该变量的作用只限于本文件模块。
定义和声明的具体区别
所谓定义就是(编译器)创建一个对象，为这个对象分配一块内存，并给它取上一个名字，这个名字就是就是我们经常所说的变量名或对象名。
声明有2重含义：
(1) 告诉编译器，这个名字已经匹配到一块内存上，下面的代码用到变量或者对象是在别的地方定义的。声明可以出现多次。
(2) 告诉编译器，这个名字已经被预定了，别的地方再也不能用它来作为变量名或对象名。
定义和声明最重要区别
定义创建对象并为这个对象分配了内存，声明没有分配内存。