Question

静态语句块有什么用

java的，举个例子

Answer 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 /*final*/ class Super {
public /*final*/ void test(){}
}
class Sub extends Super{
public final void test(){}
}

Answer 2

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

num = rs.getInt(1);
}
}