静态语句块有什么用

java的，举个例子

public class Test {
private Test(){}
private static int num;
static {
//可能你的这个类是单例的，外界没办法调用构造方法，而你需要给num赋值，而又不是简单的赋值，需要从数据库中查询再赋值，就可以在这里做了
String sql = "select count(*) from table";
....

num = rs.getInt(1);
}
}

1.static的用法： static用于修饰：属性，方法，语句块，内部内 语句块：在类内直接有大括号{}，括号内有语句 内部类：类内有另外的类 作用：如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象，声明为static的变量实质上就是全局变量，所以对象共享。(类相关：类属性，类方法) 内存池：常驻内存，反复利用(数据库连接池常用) 静态池：static属性 class A{ static int b = 0; } A a1 = new A(); A a2 = new A(); 内存图：栈：a1，a2，分别指向堆内的两个对象 堆：new A()，new A()，分别指向静态池中的静态值0 静态池：0 静态的属性/方法可以按照以下两种方式调用： a.new 对象(), 对象. 调用 b.不创建对象，直接用类名.调用 静态的属性/方法是在类加载时完成处理的，静态语句块仅在类加载时调用一次，非静态语句块在对象创建时调用。加载发生的条件：new 对象(声明不加载类，也不创建对象) 类名.调用属性/方法 静态方法的特征： 类名.调用 静态方法不能使用非静态变量，也不能调用非静态方法，反之可以 父类静态方法只能被子类静态方法重写，发生多态时，静态方法调用父类重写前的 例子1：父类静态方法只能被子类静态方法重写，发生多态时，静态方法调用父类重写前的 public class Super { public static void test(){ System.out.println("super"); } public static void main(String[] args) { Super s = new Sub(); s.test(); //发生多态是调用重写前的，得super，相当于Super.test(); } } class Sub extends Super{ public static void test(){ //只能被子类静态方法重写 System.out.println("sub"); } } 例子2：静态语句块仅在类加载时调用一次，非静态语句块在对象创建时调用，加载发生的条件：new 对象， 类名.调用属性/方法，声明不加载类，也不创建对象 public class TestBlock { static int i; static{ //静态语句块 System.out.println("classLoading..."); } { //非静态语句块 System.out.println("instance"); } } public class Test { public static void main(String[] args) { System.out.println("begin"); TestBlock tb; //声明既不加载类，也不创建对象 System.out.println("declear"); tb = new TestBlock(); //new对象,加载类，并创建对象 System.out.println("over"); TestBlock.i = 9; System.out.println(TestBlock.i); } } 所以打印的结果：begin declear classLoading... instance over 9 但是以下将main方法和类写在一起，所得结果注意： public class TestBlock { static int i; static{ System.out.println("classLoading..."); } { System.out.println("instance"); } public static void main(String[] args) { System.out.println("begin"); TestBlock tb; System.out.println("declear"); tb = new TestBlock(); System.out.println("over"); TestBlock.i = 9; System.out.println(TestBlock.i); } } 所以打印的结果：classLoading... begin declear instance over 9 例子3： 静态方法不能使用非静态变量，也不能调用非静态方法，反之可以 public class TestMethod { int i1 = 0; static int i2 = 0; public void test1(){ i1 = 0; //非静态方法可以使用非静态变量 i2 = 0; //非静态方法也可以使用静态变量 System.out.println("no static"); } public static void test2(){ //i1 = 0; //静态方法不能使用非静态变量 i2 = 0; //静态方法可以使用静态变量 System.out.println("static"); } public static void main(String[] args) { TestMethod.test2(); //静态方法可以直接用类名.调用 //TestMethod.test1(); //非静态方法不能直接调用，需要new对象来调用 } } 例子4：static变量是全局变量，每个对象共享 public class TestField { static int i1 = 0; //类变量 int i2 = 0; //实例变量 public TestField(){ i1++; i2++; } public static void main(String[] args){ System.out.println(TestField.i1); //0 TestField tf1 = new TestField(); TestField tf2 = new TestField(); System.out.println(tf1.i1); //2 System.out.println(tf2.i1); //2 System.out.println(tf1.i2); //1 System.out.println(tf2.i2); //1 } } 需要说明的是：类名.调用的时候，只类加载，不创建对象，所以不执行构造器中的代码，所以结果为0 i1为全局变量,每次创建对像的时候，执行构造器中的代码，数据更新一次，所以结果为2 i2为实例变量，每个用户访问数据都不变，只执行一次构造器中的代码，所以结果为1 例子5：Singleton 单例设计模式：类外只能有一个对象 私有构造：private 构造 提供一个static方法，返回本类对象 单例的目的：保证一个类只有单一的实例，也就是说你无法通过new来创建这个类的一个新实例。 单例的好处：当一个对象在程序内部只能有一个实例的时候，它可以保证我们不会重复创建，而是始终指向同一个对象 代码： 第一种：在声明变量时实例化(也叫饿汉式单例模式)，代码如下： public class Singleton { private static Singleton instance = new Singleton(); private Singleton(){} public static Singleton getInstance() { return instance; } } 第二种：把对象的创建放到方法里面去(也叫懒汉式单例模式)，代码如下： public class Singleton { private static Singleton instance = null; private Singleton(){} public static synchronized Singleton getInstance() { //也可以这样写：synchronized public static Singleton getInstance() { if (instance == null){ instance = new Singleton(); } return instance; } } 各自的优缺点： 第一种饿汉式： 优点：在类加载初始化的时候就创建对象，调用getInstance的时候，没有同步方法，运行时性能较高。 缺点：类加载速度慢，占用太多大的资源空间。 第二种懒汉式： 优点：避免了第一种方式的缺点， 同时，可以在多线程下运行安全。 缺点：因为他使用了锁，在运行中效率慢。 测试： public class Test { public static void main(String[] args) { Singleton s1 = Singleton.getInstance(); Singleton s3 = Singleton.getInstance(); System.out.println(s1==s3); } } 运行的结果：true 2.final的用法： final用于修饰：类，方法，变量(包括成员变量和局部变量) final的类无法继承，例：String/System类不可继承 final的方法无法重写/覆盖，final类中所有方法都无法重写，因为final类无法继承 final的变量必须显示赋值一次(only one) 父类中非final的方法可以在子类中重写为final的方法 final的属性没有set方法，可以有get方法，赋值可以直接赋，也可以在构造中赋 只用final修饰的不是常量，因为final只管一层 常量： 用static+final修饰的属性变量必须声明的同时赋初值，而且访问权限为public public static final int LIMIT = 9999; 常量名所有字母都大写，不同单词之间用下划线隔开 例子1： public class Super { public void test(){} } class Sub extends Super{ public final void test(){} }