`
ddzero
  • 浏览: 7379 次
  • 性别: Icon_minigender_1
  • 来自: 厦门
最近访客 更多访客>>
lengjing
文章分类
社区版块
存档分类
最新评论

static解析

JDBC编程SUN 
阅读更多
今天在某个代码里看到静态域的使用，出于学习的目的，专门对static相关的内容(静态类、方法、变量、域，以及非静态的)进行测试

废话不多说，上代码：


主类 StaticTest.java 
public class StaticTest extends fatherClass{
	//初始化时，可以直接调用静态成员，以及同类的非静态成员
	
	//静态变量初始化时不能引用非静态成员
	public static int staticVar=new AssistClass().getNum2();
	
	//静态域与静态变量初始化具有相同的优先级
	static{
		staticVar++;
		System.out.println("static block");
		
		//域中可以定义变量以及类，不能定义方法，并且只是在域中使用
		//不能带有public\protected\private标示符
		int var2=3;
		class NSC2{
			int i=2;
		}
//		System.out.println(new NSC2().i);
		
		//不允许定义静态变量和静态类
//!			static int staticVar2;
//!			static class SC2{}
		
	}
	public int var=new AssistClass().getNum();
	public int var2=fun3();
	
	public StaticTest(){
		System.out.println("constructor");
	}
	
	//非静态域与非静态变量初始化具有相同的优先级
	{
		//静态域可以访问所属类的静态
		var++;
		staticVar++;
		System.out.println("not static block");
		
	}
	
	public void fun(){//非静态方法可以直接调用静态和非静态成员
		staticVar=1;
		staticFun();
		fun2();
	}
	
	public void fun2(){
		
	}
	public int fun3(){
		return 3;
	}
	
	public static void staticFun(){
		//静态方法不能直接调用非静态成员
		//需要：1.实例化	2.改为静态
//!		fun2();
		System.out.println("sattic method");
		
	}
	
	public static int staticFun2(){
		System.out.println("static field init");
		return 2;
	}
	
	public static int staticFun3(){
		System.out.println("not static field init");
		return 3;
	}
	
	/**
	 * @param args
	 */
	
	//静态方法在第一次执行时会先执行静态初始化和静态域
	//构造方法可以认为是静态方法
	//每次实例化都会执行一次非静态初始化和非静态域
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		staticFun();
		
//		new StaticTest();
		new StaticTest();
		
//		System.out.println(st.var+"&"+st.var2+"&"+staticVar);
	}

	//结论：静态成员可以被直接调用，非静态成员则需经实例化(但可以被同类的非静态成员调用)
}


辅助类 AssistClass.java 
public class AssistClass{
	int i=1;
	
	public int getNum(){
		System.out.println("not static field init");
		return 4;
	}
	
	public int getNum2(){
		System.out.println("static field init");
		return 5;
	}
	
	public int getNum3(){
		System.out.println("father static field init");
		return 5;
	}
	
	public int getNum4(){
		System.out.println("father not static field init");
		return 5;
	}

       public static void main(String[] args){
		//静态方法在第一次执行时会先执行静态初始化和静态域
		//构造方法可以认为是静态方法
		//每次实例化都会执行一次非静态初始化和非静态域
		new StaticTest();
		new StaticTest();
	}
}


父类 FatherClass.java 
public class fatherClass{
	//同静态时，父类的变量初始化/域先于子类执行
	static int fatherVar=new AssistClass().getNum3();
	
	static{
		System.out.println("father static block");
	}
	
	//同非静态时，父类的变量初始化/域先于子类执行
	{
		System.out.println("father not static block");
	}
	
	int fatherVar2=new AssistClass().getNum4();
}


关于静态成员与非静态成员之间的调用关系，这里不赘述，因为这是语法问题，各位只要写一写代码就了解了

执行StaticTest类的main方法，输出结果：

引用
father static field init
father static block
static field init
static block
father not static block
father not static field init
not static field init
not static block
constructor


要是改变初始化与域的位置，输出结果也会有相应改变，同样静态(或非静态)的初始化和域，基本按照先后顺序执行。

结论是：

1）静态元素（变量、方法、域、内部类）不能直接调用非静态元素 ，需要对非静态元素所属类实例化，特别是调用非静态内部类时，需要对其外部类实例化，然后获取非静态内部类的实例对象。
 
2）不管位置如何，静态初始化 / 域先于非静态初始化 / 域，父类的初始化 / 域先于子类的初始化 / 域，变量的初始化以及域先于构造方法执行。即：
      a） 先初始化 / 域，后构造方法；
      b） 先“静态”后“非静态”；
      c） 先父后子。
其他静态 / 非静态方法均需调用才能执行

这里请注意次序排列的先后顺序，比如静态非静态的区分先于父子类的区分，即子类的静态初始化比父类的非静态初始化优先的。

3）静态方法在第一次被执行时，会先执行静态的初始化和域，如所属类的main方法，构造方法虽没有static标示符，但也可以认为是静态方法。而在构造方法执行（即实例化）时，除了执行静态初始化和域，接着又会执行非静态的初始化和域。

当然非静态在每次实例化都会执行一次。


关于域，那是不归于方法封装的执行代码，即它是可以主动执行（静态在定义时，非静态在实例化时进行）的，而不必通过方法调用，应该有点类似C吧。

4）域中可以定义变量和类，但不能是静态变量和静态类（因为不需要共享），并且变量和类都只是域内部使用，因此不需要public/protected/private标识符。

补充： 谢谢各位的支持，另外应logic的要求，对静态类进行了测试
请看代码：
StaticTest2.java 
public class StaticTest2 {
	static int staticVar;
	int var;
	static class StaticClass{
		//静态类中可以定义静态、非静态的成员、域
		//静态类中可以调用外部类的静态成员
		public static int S2Var=staticVar;
		//静态类中需要对外部类实例化，才能调用外部类的非静态类成员
		public int NS2Var=new StaticTest().var;
		
		static{
			System.out.println("static Class > static block");
		}
		
		{
			System.out.println("static class > not static block");
		}
		
		class NS2Class{}
		
		static class S2Class{public static int S2var;}
		
		public static void staticFun(){
			System.out.println("this is static class");
		}
		
		public void fun(){
			System.out.println("this is static class");
		}
	}
	
	class NotStaticClass{
		//非静态内部类不能定义静态域
		//提示错误：Cannot define static initializer in inner type StaticTest2.NotStaticClass
//!		static { System.out.println("not static Class > static block"); }
		
		{
			System.out.println("not static class > not static block");
		}
		
		//非静态内部类中不能定义静态变量
		//提示错误：The field var cannot be declared static; static fields can only be declared in static or top level types
//!		static int var;
		
		//非静态内部类中不能定义静态方法
		//提示错误：The method staticFun cannot be declared static; static methods can only be declared in a static or top level type
//!		public static void staticFun(){}
		
		class NS2Class{}
		
		//非静态内部类中不能定义静态类
		//提示错误：The member type S2Class cannot be declared static; static types can only be declared in static or top level types
//！		static class S2Class{}
		
		public void fun(){
			System.out.println("this is not static class");
		}
	}
	
	static{
		System.out.println("static block");
	}
	
	{
		System.out.println("not static block");
	}
	
	public NotStaticClass getNSC(){
		return new NotStaticClass();
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("............hua li de fen ge xian..............");
		StaticTest2.StaticClass.staticFun();
		new StaticClass().fun();
		//等同于
//		new StaticTest2.StaticClass().fun();
		
		//外部类（即StaticTest2）需经实例化，
		//设法获取静态内部类的实例（如getNSC()），才能调用非静态内部类的非静态成员
		(new StaticTest2()).getNSC().fun();
//!		new NotStaticClass().fun();
	}
}


AnnotherTest.java 
public class AnnotherTest{
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		System.out.println("外部类测试：");
		
		//外部类初始化时，会执行其静态变量初始化和静态域，但不会涉及其静态类
		new StaticTest2();
		
		System.out.println("静态类测试：");
		
		/*
		 * 静态类测试
		 */	
		//静态类调用其成员，静态类的外部类不需要经实例化
		//静态类调用其静态成员，此时不会执行其外部类（StaticTest2）的静态变量初始化和静态域
		StaticTest2.StaticClass.staticFun();
//		System.out.println( StaticTest2.StaticClass.S2Class.S2var );
		
		//静态类调用其非静态成员
//		new StaticTest2.StaticClass().fun();
		
		System.out.println("非静态内部类测试：");
		/*
		 * 非静态内部类测试
		 */
		//StaticTest2.NotStaticClass只能调用class元素
		System.out.println(StaticTest2.NotStaticClass.class);
		
		//非静态内部类中不能定义静态元素
		//外部类（即StaticTest2）需经实例化，
		//设法获取静态内部类的实例（如getNSC()），才能调用非静态内部类的非静态成员
		(new StaticTest2()).getNSC().fun();
		
		//以下代码会编译错误，需先实例化外部类
//!		new StaticTest2.NotStaticClass().fun();
		
	}
}


重点在AnnotherTest的测试结果：

引用
外部类测试：
static block
not static block
静态类测试：
static Class > static block
this is static class
非静态内部类测试：
class defaultPackage.StaticTest2$NotStaticClass
not static block
not static class > not static block
this is not static class


结论是：
5）静态类首先是内部类，静态类当中可以定义静态元素和非静态元素（包括内部类、变量、方法、域），而非静态内部类只能定义非静态元素。静态类可以直接调用外部类的静态元素，非静态内部类可以直接调用外部类的静态和非静态元素。

6）外部类在执行变量初始化和域（包括静态和非静态）时，不会涉及其内部类的变量初始化和域。相对的，内部类（包括静态类和非静态内部类）在执行自己的变量初始化和域时，也不会执行静态类所属外部类的变量初始化和域。

当然，非静态内部类必须通过其外部类的实例对象来调用，因此会先执行外部类的构造方法，于是该发生的还是会发生。


写的很乱，这是我的第二篇博文，欢迎各位拍砖。
分享到：
| HibernateTemplate与HibernateDaoSupport ...
评论
23 楼 wangxuehui 2011-03-08  
ddzero 写道
今天在某个代码里看到静态域的使用，出于学习的目的，专门对static相关的内容(静态类、方法、变量、域，以及非静态的)进行测试

废话不多说，上代码：


主类 StaticTest.java 
public class StaticTest extends fatherClass{
	//初始化时，可以直接调用静态成员，以及同类的非静态成员
	
	//静态变量初始化时不能引用非静态成员
	public static int staticVar=new AssistClass().getNum2();
	
	//静态域与静态变量初始化具有相同的优先级
	static{
		staticVar++;
		System.out.println("static block");
		
		//域中可以定义变量以及类，不能定义方法，并且只是在域中使用
		//不能带有public\protected\private标示符
		int var2=3;
		class NSC2{
			int i=2;
		}
//		System.out.println(new NSC2().i);
		
		//不允许定义静态变量和静态类
//!			static int staticVar2;
//!			static class SC2{}
		
	}
	public int var=new AssistClass().getNum();
	public int var2=fun3();
	
	public StaticTest(){
		System.out.println("constructor");
	}
	
	//非静态域与非静态变量初始化具有相同的优先级
	{
		//静态域可以访问所属类的静态
		var++;
		staticVar++;
		System.out.println("not static block");
		
	}
	
	public void fun(){//非静态方法可以直接调用静态和非静态成员
		staticVar=1;
		staticFun();
		fun2();
	}
	
	public void fun2(){
		
	}
	public int fun3(){
		return 3;
	}
	
	public static void staticFun(){
		//静态方法不能直接调用非静态成员
		//需要：1.实例化	2.改为静态
//!		fun2();
		System.out.println("sattic method");
		
	}
	
	public static int staticFun2(){
		System.out.println("static field init");
		return 2;
	}
	
	public static int staticFun3(){
		System.out.println("not static field init");
		return 3;
	}
	
	/**
	 * @param args
	 */
	
	//静态方法在第一次执行时会先执行静态初始化和静态域
	//构造方法可以认为是静态方法
	//每次实例化都会执行一次非静态初始化和非静态域
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		staticFun();
		
//		new StaticTest();
		new StaticTest();
		
//		System.out.println(st.var+"&"+st.var2+"&"+staticVar);
	}

	//结论：静态成员可以被直接调用，非静态成员则需经实例化(但可以被同类的非静态成员调用)
}


辅助类 AssistClass.java 
public class AssistClass{
	int i=1;
	
	public int getNum(){
		System.out.println("not static field init");
		return 4;
	}
	
	public int getNum2(){
		System.out.println("static field init");
		return 5;
	}
	
	public int getNum3(){
		System.out.println("father static field init");
		return 5;
	}
	
	public int getNum4(){
		System.out.println("father not static field init");
		return 5;
	}

       public static void main(String[] args){
		//静态方法在第一次执行时会先执行静态初始化和静态域
		//构造方法可以认为是静态方法
		//每次实例化都会执行一次非静态初始化和非静态域
		new StaticTest();
		new StaticTest();
	}
}


父类 FatherClass.java 
public class fatherClass{
	//同静态时，父类的变量初始化/域先于子类执行
	static int fatherVar=new AssistClass().getNum3();
	
	static{
		System.out.println("father static block");
	}
	
	//同非静态时，父类的变量初始化/域先于子类执行
	{
		System.out.println("father not static block");
	}
	
	int fatherVar2=new AssistClass().getNum4();
}


关于静态成员与非静态成员之间的调用关系，这里不赘述，因为这是语法问题，各位只要写一写代码就了解了

执行StaticTest类的main方法，输出结果：

引用
father static field init
father static block
static field init
static block
father not static block
father not static field init
not static field init
not static block
constructor


要是改变初始化与域的位置，输出结果也会有相应改变，同样静态(或非静态)的初始化和域，基本按照先后顺序执行。

结论是：

1）静态元素（变量、方法、域、内部类）不能直接调用非静态元素 ，需要对非静态元素所属类实例化，特别是调用非静态内部类时，需要对其外部类实例化，然后获取非静态内部类的实例对象。
 
2）不管位置如何，静态初始化 / 域先于非静态初始化 / 域，父类的初始化 / 域先于子类的初始化 / 域，变量的初始化以及域先于构造方法执行。即：
      a） 先初始化 / 域，后构造方法；
      b） 先“静态”后“非静态”；
      c） 先父后子。
其他静态 / 非静态方法均需调用才能执行

这里请注意次序排列的先后顺序，比如静态非静态的区分先于父子类的区分，即子类的静态初始化比父类的非静态初始化优先的。

3）静态方法在第一次被执行时，会先执行静态的初始化和域，如所属类的main方法，构造方法虽没有static标示符，但也可以认为是静态方法。而在构造方法执行（即实例化）时，除了执行静态初始化和域，接着又会执行非静态的初始化和域。

当然非静态在每次实例化都会执行一次。


关于域，那是不归于方法封装的执行代码，即它是可以主动执行（静态在定义时，非静态在实例化时进行）的，而不必通过方法调用，应该有点类似C吧。

4）域中可以定义变量和类，但不能是静态变量和静态类（因为不需要共享），并且变量和类都只是域内部使用，因此不需要public/protected/private标识符。

补充： 谢谢各位的支持，另外应logic的要求，对静态类进行了测试
请看代码：
StaticTest2.java 
public class StaticTest2 {
	static int staticVar;
	int var;
	static class StaticClass{
		//静态类中可以定义静态、非静态的成员、域
		//静态类中可以调用外部类的静态成员
		public static int S2Var=staticVar;
		//静态类中需要对外部类实例化，才能调用外部类的非静态类成员
		public int NS2Var=new StaticTest().var;
		
		static{
			System.out.println("static Class > static block");
		}
		
		{
			System.out.println("static class > not static block");
		}
		
		class NS2Class{}
		
		static class S2Class{public static int S2var;}
		
		public static void staticFun(){
			System.out.println("this is static class");
		}
		
		public void fun(){
			System.out.println("this is static class");
		}
	}
	
	class NotStaticClass{
		//非静态内部类不能定义静态域
		//提示错误：Cannot define static initializer in inner type StaticTest2.NotStaticClass
//!		static { System.out.println("not static Class > static block"); }
		
		{
			System.out.println("not static class > not static block");
		}
		
		//非静态内部类中不能定义静态变量
		//提示错误：The field var cannot be declared static; static fields can only be declared in static or top level types
//!		static int var;
		
		//非静态内部类中不能定义静态方法
		//提示错误：The method staticFun cannot be declared static; static methods can only be declared in a static or top level type
//!		public static void staticFun(){}
		
		class NS2Class{}
		
		//非静态内部类中不能定义静态类
		//提示错误：The member type S2Class cannot be declared static; static types can only be declared in static or top level types
//！		static class S2Class{}
		
		public void fun(){
			System.out.println("this is not static class");
		}
	}
	
	static{
		System.out.println("static block");
	}
	
	{
		System.out.println("not static block");
	}
	
	public NotStaticClass getNSC(){
		return new NotStaticClass();
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("............hua li de fen ge xian..............");
		StaticTest2.StaticClass.staticFun();
		new StaticClass().fun();
		//等同于
//		new StaticTest2.StaticClass().fun();
		
		//外部类（即StaticTest2）需经实例化，
		//设法获取静态内部类的实例（如getNSC()），才能调用非静态内部类的非静态成员
		(new StaticTest2()).getNSC().fun();
//!		new NotStaticClass().fun();
	}
}


AnnotherTest.java 
public class AnnotherTest{
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		System.out.println("外部类测试：");
		
		//外部类初始化时，会执行其静态变量初始化和静态域，但不会涉及其静态类
		new StaticTest2();
		
		System.out.println("静态类测试：");
		
		/*
		 * 静态类测试
		 */	
		//静态类调用其成员，静态类的外部类不需要经实例化
		//静态类调用其静态成员，此时不会执行其外部类（StaticTest2）的静态变量初始化和静态域
		StaticTest2.StaticClass.staticFun();
//		System.out.println( StaticTest2.StaticClass.S2Class.S2var );
		
		//静态类调用其非静态成员
//		new StaticTest2.StaticClass().fun();
		
		System.out.println("非静态内部类测试：");
		/*
		 * 非静态内部类测试
		 */
		//StaticTest2.NotStaticClass只能调用class元素
		System.out.println(StaticTest2.NotStaticClass.class);
		
		//非静态内部类中不能定义静态元素
		//外部类（即StaticTest2）需经实例化，
		//设法获取静态内部类的实例（如getNSC()），才能调用非静态内部类的非静态成员
		(new StaticTest2()).getNSC().fun();
		
		//以下代码会编译错误，需先实例化外部类
//!		new StaticTest2.NotStaticClass().fun();
		
	}
}


重点在AnnotherTest的测试结果：

引用
外部类测试：
static block
not static block
静态类测试：
static Class > static block
this is static class
非静态内部类测试：
class defaultPackage.StaticTest2$NotStaticClass
not static block
not static class > not static block
this is not static class


结论是：
5）静态类首先是内部类，静态类当中可以定义静态元素和非静态元素（包括内部类、变量、方法、域），而非静态内部类只能定义非静态元素。静态类可以直接调用外部类的静态元素，非静态内部类可以直接调用外部类的静态和非静态元素。

6）外部类在执行变量初始化和域（包括静态和非静态）时，不会涉及其内部类的变量初始化和域。相对的，内部类（包括静态类和非静态内部类）在执行自己的变量初始化和域时，也不会执行静态类所属外部类的变量初始化和域。

当然，非静态内部类必须通过其外部类的实例对象来调用，因此会先执行外部类的构造方法，于是该发生的还是会发生。


写的很乱，这是我的第二篇博文，欢迎各位拍砖。

22 楼 fsk215 2011-03-02  
这里请注意次序排列的先后顺序，比如静态非静态的区分先于父子类的区分，即子类的静态初始化比父类的非静态初始化优先的。

这个有异议，父类的静态初始化应该高于子类的静态初始化，而父类的非静态初始化落后于子类的静态初始化；

补充一点直接用子类调用其中的静态方法 只初始化子类的静态成员而不初始化父类的静态成员（和父类无关）；
21 楼 mercyblitz 2010-08-09  
Firklaag 写道
请问为什么可以在非静态内部类中定义 比如
static final int i= 0；
这类的属性？



字段定义，和类是不是静态没有关系。


static和非static是生命周期和作用域不同。
20 楼 beneo 2010-08-09  
Firklaag 写道
请问为什么可以在非静态内部类中定义 比如
static final int i= 0；
这类的属性？


jls 写的很清楚

http://java.sun.com/docs/books/jls/third_edition/html/classes.html#8.1.3

19 楼 Firklaag 2010-08-09  
请问为什么可以在非静态内部类中定义 比如
static final int i= 0；
这类的属性？
18 楼 javamore 2010-06-16  
java基础 http://java.afity.com
17 楼 beneo 2010-06-16  
ddzero 写道
beneo 写道

2. 道理跟1一样，静态类是属于object的，你其他的 no static 属性or方法也是属于object的，没有实例化，都不能访问

静态类应该是属于class的吧


my mistake, thanks

static inner class 是属于 class 的，你其他的 no static 属性or方法是属于object的
16 楼 ddzero 2010-06-15  
beneo 写道

2. 道理跟1一样，静态类是属于object的，你其他的 no static 属性or方法也是属于object的，没有实例化，都不能访问

静态类应该是属于class的吧
15 楼 logic 2010-06-15  
beneo 写道
logic 写道
首先，很感谢楼主对静态类的补充，谢谢。
但如果能够把以下两个问题的答案补充到静态类中去，就可以说完美了。

1，非静态类中为什么不能定义静态(static)的属性or方法?
2，静态类中为什么不能访问外部类的非静态(no static)的属性or方法?


1. 首先我想你问的是 non static inner class，对吧。

官方的说明是，non-static inner class 不是属于 class ，而是属于 object ，所以你得实例化外部，才能实例化里面。 如果 non - static inner class 属于 object, 你在里面又申明了一个属于 class 的 static 变量，岂不是矛盾。

此外，从语义上面还有一层解释。

2. 道理跟1一样，静态类是属于object的，你其他的 no static 属性or方法也是属于object的，没有实例化，都不能访问

谢谢楼上的解答，完全能够理解了，建议楼主一块总结到static解析里面去。
14 楼 beneo 2010-06-15  
logic 写道
首先，很感谢楼主对静态类的补充，谢谢。
但如果能够把以下两个问题的答案补充到静态类中去，就可以说完美了。

1，非静态类中为什么不能定义静态(static)的属性or方法?
2，静态类中为什么不能访问外部类的非静态(no static)的属性or方法?


1. 首先我想你问的是 non static inner class，对吧。

官方的说明是，non-static inner class 不是属于 class ，而是属于 object ，所以你得实例化外部，才能实例化里面。 如果 non - static inner class 属于 object, 你在里面又申明了一个属于 class 的 static 变量，岂不是矛盾。

此外，从语义上面还有一层解释。

2. 道理跟1一样，静态类是属于object的，你其他的 no static 属性or方法也是属于object的，没有实例化，都不能访问
13 楼 beneo 2010-06-15  
参加一次scjp考试，一切都明白了
12 楼 ddzero 2010-06-14  
logic 写道
首先，很感谢楼主对静态类的补充，谢谢。
但如果能够把以下两个问题的答案补充到静态类中去，就可以说完美了。

1，非静态类中为什么不能定义静态(static)的属性or方法?
2，静态类中为什么不能访问外部类的非静态(no static)的属性or方法?


关于第二个问题：就像静态方法要调用非静态成员一样，静态类如果想访问外部类的非静态成员，需要对外部类实例化。
11 楼 angel243fly 2010-06-14  
ddzero 写道
huangyuanmu 写道
静态块有的时候还是蛮有用的，在类被第一次引用时执行一次。这种应用的典型就是jdbc驱动，还记得jdbc编程中著名的那句Class.forName("XXXX")吗？

域，或者称为块，可以认为是一种行为上的初始化，与变量初始化具有相同的优先级。静态亦即共享，静态域可以在第一次引用时执行，主要作用就是进行某些共享性的操作，比如你说的JDBC。至于非静态域，其实可以用构造方法代替。

正解！！！
我只用过静态域来加载jdbc驱动
10 楼 logic 2010-06-14  
首先，很感谢楼主对静态类的补充，谢谢。
但如果能够把以下两个问题的答案补充到静态类中去，就可以说完美了。

1，非静态类中为什么不能定义静态(static)的属性or方法?
2，静态类中为什么不能访问外部类的非静态(no static)的属性or方法?
9 楼 ddzero 2010-06-14  
logic 写道
能否对静态类进行详细分析和测试一下，谢谢。

已添加静态类的分析，请看补充部分
8 楼 345161974 2010-06-14  
<<Thinking in java>>上面讲解的更详细。
7 楼 刘琛颖 2010-06-14  
有收获。写得有针对性。
6 楼 sesen2010 2010-06-14  
谢谢了楼主....
5 楼 ddzero 2010-06-14  
huangyuanmu 写道
静态块有的时候还是蛮有用的，在类被第一次引用时执行一次。这种应用的典型就是jdbc驱动，还记得jdbc编程中著名的那句Class.forName("XXXX")吗？

域，或者称为块，可以认为是一种行为上的初始化，与变量初始化具有相同的优先级。静态亦即共享，静态域可以在第一次引用时执行，主要作用就是进行某些共享性的操作，比如你说的JDBC。至于非静态域，其实可以用构造方法代替。
4 楼 logic 2010-06-14  
能否对静态类进行详细分析和测试一下，谢谢。
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    static解析并显示html

    在这个特定的情景中，"static解析并显示html"指的是利用MFC中的CStatic控件来显示HTML内容。CStatic是MFC中用于创建静态文本、图像或自定义控件的类，通常用来展示不可编辑的信息。 当我们想要在MFC应用中显示HTML...

    Qt 5.12.10 mingw73_static.7z 静态编译包

    **二、mingw73_static解析** mingw73_static是指MinGW-w64的静态编译版本，MinGW-w64是一个为Windows平台提供GCC编译器的项目，它包含了针对不同体系结构（如x86和x64）的编译器和运行时库。"static"表示这个编译器...

    java 面试题

    解析：接口中的所有成员默认都是public，不能用private、protected或static修饰。 5. 下列正确的有？ 正确答案：A．call by value不会改变实际参数的数值；D．call by reference能改变实际参数的内容 解析：Java...

    java选择题_115.doc

    解析：在Java中，静态（static）关键字用于声明类方法或类变量。类方法属于类本身，而不是类的任何实例，可以直接通过类名调用。 2. 术语“类变量”是哪个的同义词？ (a) 只读变量 (b) 私有数据字段 (c) 静态数据...

    实例解析Java关于static的作用

    Java中的`static`关键字在编程中扮演着至关重要的角色，它是Java面向对象特性的一个关键组成部分。`static`关键字用于修饰变量、方法以及嵌套类，它使得这些元素可以在不创建对象的情况下被访问。 首先，我们来看...

    Java中的static关键字

    Java 中的 static 关键字 ...在 Java 中，类装载器把一个类装入 Java 虚拟机中，要经过三个步骤来完成：装载、链接和初始化，其中链接又可以分成校验、准备和解析三步，除了解析外，其它步骤是严格按照顺序完成的。

    c++解析html并显示的static控件

    在C++编程中，开发一个能够解析HTML并将其内容显示在静态控件（Static Control）中的功能是一项常见的需求，尤其是在创建自定义用户界面时。在这个项目中，我们看到的是一组源代码文件，它们可能构成了一个小型库或...

    C语言static的用法

    本文将从不同角度对`static`在C语言中的应用进行深入解析，并结合具体的示例来帮助理解其背后的逻辑。 #### 一、`static`变量的基本概念与特性 1. **局部静态变量**： - 当在一个函数内部定义了一个`static`变量...

    Java中的static关键字全面解析

    本文将全面解析`static`关键字的用途、常见误区以及在面试和笔试中可能出现的相关问题。 首先，`static`关键字主要用于声明类级别的成员，包括静态方法（`static` methods）、静态变量（`static` variables）以及...

    Java语言中static关键词应用解析.zip

    本资料主要解析了`static`关键字的各种应用，帮助开发者深入理解其工作原理和用法。 首先，`static`关键字用于声明类级别的变量和方法，这意味着它们属于类本身，而不是类的任何实例。当类被加载时，静态变量和静态...

    java地址解析和反向地址解析

    public static void main(String[] args) throws NamingException { String ipAddress = "8.8.8.8"; // Google DNS server's IP InitialContext context = new InitialContext(); javax.naming.directory....

    Java static关键字解析

    Java static关键字解析静态内部类（默认指外部类的内部类）静态方法静态变量静态语句块 范围：只围绕外部类进行讨论，例如内部类的内部类这种多层套娃式的暂不进行讨论 jdk版本： jdk8 静态内部类（默认指外部类的...

    Java中的Static块与静态方法

    本文将深入探讨Java中的静态块与静态方法，解析它们的区别、联系以及执行顺序，帮助读者更全面地理解`static`关键字在Java中的运用。 ### 静态方法 静态方法是通过`static`关键字声明的，它属于类而不属于类的任何...

    Java语言中static关键词应用解析.pdf

    在Java编程语言中，static关键字是一个非常重要的概念，它用于定义类的成员变量和成员方法，使其成为静态的，即属于类本身而非类的任何特定对象。这种成员变量和方法被所有对象共享，它们的生命周期与类的生命周期...

    C++关键字之static的基本用法

    静态数据成员必须在类外进行初始化，且初始化语句不加作用域解析运算符`::`。例如： ```cpp class MyClass { public: static int count; }; int MyClass::count = 0; // 初始化静态成员 ``` 6. **C++11引入...

    java中final与static的用法

    下面将详细解析这两个关键字的用法及其在Java中的重要性。 ### 一、`final`关键字 `final`关键字在Java中有多种用途，它可以用来修饰类、方法和变量，其主要目的是确保被修饰的对象具有不可变性或只读性。 #### 1...

    继承与static精选例题

    ### 继承与Static知识点详解 #### 一、继承与Static的基本概念 在Java中，继承是一种类之间的关系，允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，可以实现代码复用，提高程序的可维护性。 `...

    yaml文件解析(java)

    public static void main(String[] args) { // 加载YAML文件 InputStream inputStream = YamlParser.class.getResourceAsStream("/config.yaml"); // 创建Yaml实例 Yaml yaml = new Yaml(); // 解析YAML...

Magicbox
Global site tag (gtag.js) - Google Analytics